Update data-centre nameplates to v2: 31 fields, 55 equipment types, extraction benchmark

README.md

@@ -8,6 +8,7 @@ tags:
   - ocr
   - document-ai
   - information-extraction
+  - key-information-extraction
   - nameplate
   - nameplate-ocr
   - equipment-nameplate
@@ -17,6 +18,7 @@ tags:
   - mission-critical
   - mep
   - electrical
+  - mechanical
   - equipment-schedule
   - schedule-verification
   - asset-register
@@ -34,6 +36,7 @@ tags:
   - crac
   - chiller
   - cooling
+  - server-rack
   - construction
   - aec
   - edge-ai
@@ -43,139 +46,187 @@ tags:
   - browser
 ---
 
-# Data Centre Nameplates — equipment-nameplate OCR checked against the schedule
+# Data Centre Nameplates — equipment-nameplate OCR checked against the equipment schedule
 
 **Read an equipment nameplate and know if it is the unit the schedule asked for.** Point a phone at the
-nameplate of a UPS, PDU, switchgear, generator, transformer, busway, battery, CRAH or chiller; the model returns
-the plate's fields — manufacturer, model, serial, voltage, phase, Hz, kVA, kW, amps, MCA, MOCP, refrigerant,
-manufacture date — and **checks each one against the equipment schedule**, flagging a mismatch instead of a
-silent pass. It builds an asset register and exports it to CSV.
+nameplate of a UPS, PDU, switchgear, generator, transformer, busway, battery, CRAH, chiller — or a **server
+rack** — and the engine returns the plate's fields (31 of them, grouped Identification / Electrical / Cooling /
+Server racks / Mechanical) and **checks each one against the equipment schedule**, flagging a mismatch instead
+of a silent pass. It builds an asset register and exports it to CSV.
 
 Built for the part of a data-centre job where the gear *is* the job. The expensive mistakes are a unit
 delivered at the wrong voltage or rating, or one that quietly never makes it onto the asset register.
 
-> **Runs on the device.** OCR and matching run in the browser (or Node) with no server and no upload. A
-> nameplate photo of live infrastructure never leaves the phone that took it.
+> **Runs on the device.** OCR, extraction and matching run in the browser (or Node) with no server and no
+> upload. A nameplate photo of live infrastructure never leaves the phone that took it — no GPU, no key, no
+> data egress.
 
-**▶ Try it live:** [huggingface.co/spaces/constructelligence/data-centre-nameplates](https://huggingface.co/spaces/constructelligence/data-centre-nameplates) — a browser demo with a sample schedule and a sample plate.
+**▶ Try it live:** [huggingface.co/spaces/constructelligence/data-centre-nameplates](https://huggingface.co/spaces/constructelligence/data-centre-nameplates) — a browser demo with a sample schedule and sample plates.
 
 | | |
 |---|---|
 | **Task** | Image → structured nameplate fields → schedule verification |
-| **Fields** | 13 (manufacturer, model, serial, voltage, phase, Hz, kVA, kW, amps, MCA, MOCP, refrigerant, mfg date) |
-| **Equipment** | 13 types (UPS, generator, ATS/STS, switchgear, transformer, PDU/RPP, panelboard, busway, battery, CDU, chiller, CRAH/CRAC, pump) |
+| **Fields** | **31**, in five groups (Identification, Electrical, Cooling, Server racks/IT, Mechanical) |
+| **Equipment** | **55 types**, device wording ranked above family (see below) |
 | **OCR** | Tesseract.js 5 (English LSTM), pretrained — no fine-tuning |
-| **Extraction** | Deterministic labelled-field parser with an OCR error model |
+| **Extraction** | Deterministic labelled-field parser + OCR error model + numeric range guards |
+| **Matching** | Code folding (`O/0`, `I/L/1`, `S/5`, `B/8`, `Z/2`) + voltage-compatibility signal |
+| **Quality gate** | Advisory photo check (blur, glare, darkness, resolution) before OCR |
 | **Runtime** | Browser · Node · edge — no GPU, no server, no data egress |
+| **Field accuracy** | **99.8%** clean / **80.0%** under character-error stress (extraction benchmark) |
 | **Licence** | Apache-2.0 |
 
 ---
 
 ## Why this exists
 
-General OCR reads the text on a nameplate. A data-centre commissioning or QA team needs the text to answer a
-narrower question: **is this the right unit, and does it match what was specified?** That means three things a
-plain OCR call does not do:
+General OCR reads the text on a nameplate. A commissioning or QA team needs the text to answer a narrower
+question: **is this the right unit, and does it match what was specified?** That means three things a plain
+OCR call does not do:
 
 1. **Turn plate text into fields, not paragraphs.** "INPUT: 480Y/277 VAC 3 PH 60 HZ" becomes
    `voltage=480Y/277 V`, `phase=3`, `hz=60`; "RATING: 750 KVA / 675 KW" becomes `kva=750`, `kw=675`.
 2. **Survive the way OCR misreads plate lettering.** Serifed `V`→`Vv`, `K`→`X` (`XVA`), `HZ`→`Hw`, codes split
-   after their punctuation (`NPX- 750- 480`). The parser repairs these before matching.
-3. **Compare to the schedule the way codes actually differ.** Model and serial codes are compared with `O/0`,
-   `I/L/1`, `S/5`, `B/8`, `Z/2` folded and punctuation ignored, so a misread is not a false mismatch, while a
-   genuine voltage variant (`NPX-750-415` vs `NPX-750-480`) still fails.
+   after their punctuation (`NPX- 750- 480`). The parser repairs these before matching, and rejects
+   out-of-range noise (`0 KVA`, a stray `0` amp) rather than recording it.
+3. **Compare to the schedule the way codes actually differ.** Model and serial codes are compared with
+   `O/0`, `I/L/1`, `S/5`, `B/8`, `Z/2` folded and punctuation ignored, so a misread is not a false mismatch,
+   while a genuine voltage variant (`NPX-750-415` vs `NPX-750-480`) still fails. A voltage a plate and a
+   schedule row share is a positive signal; the equipment **type** still wins ties, so a 415 V UPS plate is not
+   matched to a same-voltage PDU.
 
 The result is a pass/mismatch verdict per plate, with the fields that disagree named.
 
 ## How it works
 
 ```
- photo ──► OCR (Tesseract.js) ──► field parser ──► schedule matcher ──► verdict + asset register CSV
-             │                        │                    │
-      lines + confidence        labelled-value rules   code folding, tolerance checks
+ photo ─► photo check ─► OCR (Tesseract.js) ─► field parser ─► equipment typing ─► schedule matcher ─► verdict + CSV
+            blur/glare      lines + confidence   labelled rules   maker line excluded   code folding, voltage signal
 ```
 
-1. **OCR** (`tesseract.js@5`, English) returns lines with a per-line confidence.
-2. **Field parser** scans lines for labelled values (`MODEL`, `S/N`, `MVA`, `MCA`, `MOCP`, `FLA`, `VOLTS`,
-   `REFRIGERANT`, `MFG DATE`), reading voltages as `480Y/277`, `13.8 kV`, `208/120`, and rejecting look-alikes
-   (`480/277` with no voltage word is not a voltage; `R-513A` and a charge weight are not amps). Lines OCR
-   scored near zero (brushed metal, background texture) are dropped before parsing.
-3. **Equipment typing** recognises the family from plate wording (UPS, genset, ATS, switchgear, transformer,
-   PDU/RPP, panelboard, busway, battery, CDU, chiller, CRAH/CRAC, pump).
-4. **Schedule matcher** ranks candidate tags — a serial match wins outright; otherwise model similarity
-   dominates, with manufacturer and equipment type as tie-breakers. Data halls repeat, so among equal matches
-   the first **unscanned** tag is offered.
-5. **Field checks** compare the reading to the chosen row and return `ok`, `mismatch` or `unread` per field, and
+1. **Photo check** — an advisory blur/glare/darkness/resolution read before OCR; the shot can be retaken
+   before a bad read.
+2. **OCR** (`tesseract.js@5`, English) returns lines with a per-line confidence; two page-segmentation passes
+   are merged field by field when the first is weak.
+3. **Field parser** scans lines for labelled values (`MODEL`, `S/N`, `MVA`, `MCA`, `MOCP`, `FLA`, `VOLTS`,
+   `REFRIGERANT`, `MFG DATE`, …), reading voltages as `480Y/277`, `13.8 kV`, `208/120`, and rejecting
+   look-alikes. Numeric fields are range-guarded. Lines OCR scored near zero are dropped first.
+4. **Equipment typing** recognises **55 families** and ranks the specific device above its family (flywheel
+   before UPS; paralleling gear before generator; dry cooler before chiller; rack before server). The **maker
+   line is excluded** from typing, so a vendor called “…Transformer Corp” cannot type a chiller plate.
+5. **Schedule matcher** ranks candidate tags — a serial match wins outright; otherwise model similarity
+   dominates, with manufacturer, equipment type and a compatible voltage as signals. Among equal matches the
+   first **unscanned** tag is offered.
+6. **Field checks** compare the reading to the chosen row (`ok` / `mismatch` / `unread` per field) and return
    an overall status: `verified`, `partial`, `mismatch`, `unmatched` or `missing` (scheduled but not scanned).
 
-## Fields extracted
+## Fields extracted (31)
+
+**Identification** — `manufacturer`, `model`, `serial`, `mfgDate`
+
+**Electrical**
 
 | Field | Example | Notes |
 |---|---|---|
-| `manufacturer` | Northline Power Systems | ~44 data-centre makers recognised as whole words; otherwise the company-looking line |
-| `model` | NPX-750-480 | `MODEL`, `MOD.`, `M/N`, `CAT. NO.`, `P/N`, `PART NO.` |
-| `serial` | NL26A01937 | `SERIAL`, `SER.`, `S/N`, `5/N`, `SN` |
-| `voltage` | 480Y/277 V | every voltage on the plate (transformers and UPSes carry more than one) |
-| `phase` | 3 | `1`/`3`, `PH`, `PHASE`, `Ø` |
-| `hz` | 60 | 50 or 60, `HZ`/`FREQUENCY` |
-| `kva` | 750 | thousands separators handled (`3,750`); European decimals too |
-| `kw` | 675 | `KW` / `EKW` |
-| `amps` | 1002 | labelled (`FLA`, `RLA`, `CURRENT`, `AMPS`) first |
-| `mca` | 612 | minimum circuit ampacity |
-| `mocp` | 800 | `MOCP` / `MAX FUSE` / `MAX BREAKER` |
-| `refrigerant` | R-513A | R-410A, 134A, 1234ZE, 1234YF, 513A, 514A, 1233ZD, 454B, 407C, 32, 22 |
-| `mfgDate` | 03/2026 | `MFG`, `MANUFACTURED`, `MFD`, `BUILD`, `PRODUCTION` |
-
-## Equipment types recognised
-
-`ups` · `generator` · `ats` (also STS) · `switchgear` · `transformer` · `pdu` (also RPP) · `panelboard` ·
-`busway` · `battery` · `cdu` · `chiller` · `crah` (also CRAC) · `pump`
-
-Manufacturers recognised include Schneider Electric, Square D, APC, Eaton, ABB, Siemens, Vertiv, Liebert,
-Caterpillar, Cummins, Kohler, Rolls-Royce, MTU, Generac, Trane, Carrier, Daikin, York, Johnson Controls,
-Stulz, Munters, nVent, Legrand, Mitsubishi Electric, Toshiba, General Electric, Hubbell, Socomec, Piller,
-Starline, Raritan, Server Technology, Emerson, Russelectric, ASCO, Hitachi, Riello, Rittal, Motivair, CoolIT,
-Hitec, EnerSys, Leclanché and Samsung SDI.
-
-## Results — OCR and extraction, end to end
-
-Six drawn plates (UPS, diesel genset, chiller, dry-type transformer, PDU, CRAH), each pushed through the
-degradations a phone photo actually has, then run through the app's own OCR + parser and scored **field by
-field**. **56 checks per condition** (six plates × their fields), 13 conditions.
-
-| Condition | Field accuracy | ms/plate |
-|---|:---:|---:|
-| clean | **100%** (56/56) | 1236 |
-| small (640 px) | **100%** (56/56) | 897 |
-| blur | **100%** (56/56) | 540 |
-| noise | **100%** (56/56) | 748 |
-| low contrast | **100%** (56/56) | 557 |
-| glare | **100%** (56/56) | 532 |
-| tilt (7°) | **100%** (56/56) | 612 |
-| keystone | **100%** (56/56) | 474 |
-| dark anodised plate | **100%** (56/56) | 808 |
-| JPEG | **100%** (56/56) | 524 |
-| plate small in a cluttered scene | **100%** (56/56) | 895 |
-| sideways | **100%** (56/56) | 554 |
-| phone (blur + glare + noise + tilt + scene + JPEG) | **98.2%** (55/56) | 1607 |
-| **Overall** | **99.9% (727/728)** | **768** |
-
-The single miss is one `hz` value on the hardest "phone" composite. The benchmark measures what **OCR** loses,
-not parser coverage: the ground truth is the parser's own reading of the clean plate text, so every reduction
-is an OCR failure the parser could not repair. Reproduce it with `node tests/nameplates-bench.mjs`.
-
-**Read this honestly.** These are crisp, machine-drawn plates. A real nameplate photographed on a live unit is
-harder: cast shadows, embossed lettering, print over brushed metal, a plate half out of frame. Expect the
-degradation suite, not the clean row, and treat every low-confidence field as one a person must confirm.
+| `voltage` | 480Y/277 V | every voltage on the plate; `13.8 kV`, `208/120`, `480` |
+| `phase` / `hz` | 3 / 60 | `PH`/`PHASE`/`Ø`; 50 or 60 Hz |
+| `kva` / `kw` | 750 / 675 | `kVA`, `KW`, `EKW`; thousands separators |
+| `amps` | 1002 | labelled `FLA`/`RLA`/`CURRENT`/`AMPS` first |
+| `pf` | 0.8 | power factor, 0–1 |
+| `mca` / `mocp` | 612 / 800 | min circuit ampacity; max overcurrent protection |
+| `sccr` | 65 | short-circuit / interrupting rating (kAIC) |
+| `enclosure` | NEMA 3R | NEMA type or IEC IP code |
+| `standards` | UL 1989 | UL / IEC / ANSI / IEEE / NFPA / CSA / EN listings |
+| `batteryType` | VRLA | VRLA, AGM, Gel, Flooded, Li-ion, LiFePO4, NiCd, Lead-acid |
+| `batteryAh` / `cells` | 500 / 48 | amp-hours; cell count |
+
+**Cooling** — `refrigerant`, `charge`, `tons`, `btu`, `cfm`, `gpm`
+
+**Server racks / IT** — `uHeight` (rack U), `powerW`, `outlets`, `ports`
+
+**Mechanical** — `rpm`, `weight` (normalised to kg)
+
+## Equipment types recognised (55)
+
+Power: flywheel · UPS · STS · ATS · rectifier/DC · inverter · BESS · nitrogen generator · paralleling gear ·
+generator · fuel system · switchgear/switchboard · MCC · metering/CT · protective relay · transformer/DGA monitor ·
+SPD · capacitor/PFC · neutral grounding resistor · VFD · busway · panelboard · PDU/RPP · battery · load bank
+
+Cooling & mechanical: heat pump · pump · cooling tower · thermal storage · chiller · dry cooler/condenser · CDU ·
+CRAH/CRAC · AHU · heat exchanger · expansion tank · air separator · boiler · humidifier · water treatment ·
+air dryer · compressor · fan coil · rooftop unit · makeup air · economizer
+
+Fire, safety & controls: fire suppression · fire alarm · leak/gas detection · BMS/EPMS/DCIM
+
+IT & white space: **rack** · **server/storage** · network gear · KVM/console
+
+## Server racks — a first-class subsection
+
+Racks, rack PDUs, switches and in-row cooling are what the electrical and cooling design actually serves, so
+they are treated as data-centre equipment, not an afterthought: `Rack U`, `Power (W)`, `PDU outlets` and
+`Ports` are extracted and checked like any other field, and the equipment set covers rack/enclosure, server,
+network, KVM and rack PDU. Sample plates include a PowerEdge-class server and a rack PDU.
 
+## Results
+
+### Extraction benchmark — labelled plates, field by field
+
+A generated corpus of plates with **by-construction** ground truth (not the parser's own reading), rendered
+with wording variety. `clean` isolates the extractor + matcher; `ocr` adds the character errors OCR makes on
+plate lettering. n = 1000. Reproduce with `node tests/nameplates-extraction-bench.mjs --n=1000`.
+
+| Condition | Exact plate | Micro-F1 | ms/plate |
+|---|:---:|:---:|---:|
+| clean | **94.1%** | **99.7%** | 0.49 |
+| ocr (character-error stress) | 1.1% | **79.9%** | 0.49 |
+
+Per-field F1 is 100% for manufacturer, type, model, serial, kVA, phase, Hz, MCA, MOCP, refrigerant,
+pf, cfm, uHeight, sccr and enclosure in the clean condition; the residual clean misses are a small number of
+voltage and `mfgDate` cases. The `ocr` condition is deliberately harsh (per-character flips); low-confidence
+fields are surfaced for a human rather than trusted. Per-field tables: `eval/extraction-bench.json`.
+
+### OCR benchmark — drawn plates through phone-photo degradations
+
+Plates drawn for several equipment types, each pushed through real-photo degradations (small, blurred, noisy,
+low-contrast, glare, tilted, keystoned, dark anodised, JPEG, plate-small-in-scene, sideways, and a "phone"
+composite), then run through the app's own OCR + parser and scored field by field. An earlier run over six
+plate types and 13 conditions scored **99.9% overall (727/728)**; the harness now draws more plate types and
+is re-run on release. Run it with `node tests/nameplates-bench.mjs` (needs a browser for Tesseract.js).
+
+**Read this honestly.** These are machine-drawn plates. A real plate on a live unit is harder: cast shadows,
+embossed lettering, print over brushed metal, a plate half out of frame. Expect the degradation suite, not the
+clean row, and treat every low-confidence field as one a person must confirm.
+
+## Comparison with related models
+
+Nameplate extraction has no shared public benchmark — FUNSD/CORD measure invoices and forms, not equipment
+plates. These are the closest published reference points, on **their own** datasets; they are context, not a
+head-to-head. The only directly comparable scores are ones produced by the corpus in
+`ml/nameplates/bench/`.
+
+| Model / method | Task & dataset | Reported |
+|---|---|---|
+| **This engine** | **named-field extraction, own labelled plate corpus** | **99.7% micro-F1 (clean)** |
+| LayoutLMv3 (base) | entity extraction, FUNSD | 92.08 F1 |
+| LiLT | entity extraction, FUNSD | 88.41 F1 |
+| Donut | field extraction, CORD | 84.1 F1 |
+| CTPN + Transformer | power-equipment nameplate detection / recognition | 88.7% det F1 · 92.3% char acc |
+| PP-OCRv4 (TL-DREN) | electricity nameplate detection / recognition | 0.524 det F1 · 0.82 rec acc |
+| RNN nameplate OCR | power-equipment nameplate chars (zh + alnum) | 99.9% zh · 99.3% alnum |
+| OCR-free VLM (e.g. Qwen2.5-VL-7B) | document KIE, zero-shot | varies; strong but large |
+
+What is different here: the engine is **small, deterministic, on-device, and schedule-aware**. It does not
+just transcribe a plate — it decides `verified` / `mismatch` against a schedule and names the fields that
+disagree, which no general document model does out of the box.
 
 ## Fine-tuning — the higher-accuracy server model
 
-The engine above is the on-device path. Alongside it, a **Donut** model
+Alongside the on-device path, a **Donut** model
 ([`naver-clova-ix/donut-base`](https://huggingface.co/naver-clova-ix/donut-base)) is fine-tuned to read a plate
 **straight into fields** (`<s_nameplate><s_type>ups</s_type><s_manufacturer>…`) for a server / endpoint where
-the browser engine falls short. Training data is synthetic plates with real-photo degradations, plus corrected
-real plates from the field. Once trained, the weights are published in a sibling repository and linked here.
+the browser engine falls short. Training data is synthetic plates with real-photo degradations plus corrected
+real plates; best checkpoints are selected by **field accuracy**, using the same OCR-aware comparison the app
+uses. The corpus in `ml/nameplates/bench/` scores it on the same test set as the on-device engine.
 
 Nothing on this page claims the accuracy of that model yet — it is the roadmap, not a result.
 
@@ -191,16 +242,16 @@ Nothing on this page claims the accuracy of that model yet — it is the roadmap
 
 - **Safety, code compliance or energisation decisions.** It reads a plate; it does not verify that a unit is
   safe to energise, correctly protected, or code-compliant.
-- **An as-built or a legal record on its own.** OCR misreads happen; low-confidence fields are highlighted for a
-  person to check, and any field that disagrees with the schedule must be confirmed by eye.
-- **Serial-number evidence in a dispute** without human verification. Two plates can share a misread serial;
-  the register flags duplicate serials but cannot tell a repeated plate from a copied number.
+- **An as-built or a legal record on its own.** OCR misreads happen; low-confidence fields are highlighted and
+  any field that disagrees with the schedule must be confirmed by eye.
+- **Serial-number evidence in a dispute** without human verification; the register flags duplicate serials but
+  cannot tell a repeated plate from a copied number.
 
 ## Limitations
 
 - **English nameplates**, Latin script. Non-Latin or handwritten plates are out of scope.
-- **Glare, blur and angle degrade OCR.** The parser repairs common misreads, but a plate that is small in the
-  frame, badly glared or very low contrast will lose fields (those fields come back `unread`, not invented).
+- **Glare, blur and angle degrade OCR.** The parser repairs common misreads, but a badly glared or very
+  low-contrast plate will lose fields (those come back `unread`, not invented).
 - **Deterministic parser, not a language model.** It reports only what it can match to a rule; it will not
   infer a missing digit.
 - **The schedule must be structured** (CSV with a Tag or Model column). Free-form schedule PDFs are not parsed
@@ -214,7 +265,6 @@ The engine is plain ES modules with no build step. `nameplate-model.js` is the e
 ```js
 import { parseNameplate, parseEquipmentSchedule, candidatesFor, checkAgainst, statusOf } from './nameplate-model.js';
 
-// 1. Parse plate text (from Tesseract, or typed by hand)
 const reading = parseNameplate(`NORTHLINE POWER SYSTEMS
 UNINTERRUPTIBLE POWER SUPPLY
 MODEL NO: NPX-750-480
@@ -227,24 +277,24 @@ MFG DATE: 03/2026`);
 console.log(reading.type);            // 'ups'
 console.log(reading.fields.voltage);  // { value: '480Y/277 V', values: [480, 277], conf, line }
 
-// 2. Match against the equipment schedule and check each field
 const { items } = parseEquipmentSchedule(scheduleCsv);
 const [best] = candidatesFor(reading, items);
-const checks = checkAgainst(reading, best.item);
-console.log(statusOf(checks, best.item.tag)); // 'verified' | 'partial' | 'mismatch' | ...
+console.log(statusOf(checkAgainst(reading, best.item), best.item.tag)); // 'verified' | 'partial' | 'mismatch' | …
 ```
 
-In a browser, feed Tesseract's `data.lines` (`[{ text, confidence, bbox }]`) straight into `parseNameplate`
-to keep OCR confidence and the plate line each value came from.
+In a browser, feed Tesseract's `data.lines` (`[{ text, confidence, bbox }]`) straight into `parseNameplate` to
+keep OCR confidence and the plate line each value came from.
 
-## Evaluation
+## Evaluation & reproducibility
 
-- **Extraction/verification logic:** 12 unit tests over the parser, voltage reader, code folding, schedule
-  parsing, candidate ranking and mismatch detection — all passing (`node --test tests/nameplate-model.test.mjs`).
-- **OCR end-to-end:** a field-by-field benchmark draws plates for six equipment types and puts each through the
-  degradations real phone photos have — small, blurred, noisy, low-contrast, glare, tilt, keystone, dark
-  anodised plate, JPEG, plate-small-in-scene and sideways — then scores the app's own OCR + parsing pipeline
-  field by field. Run it with `node tests/nameplates-bench.mjs`.
+- **Extraction:** `node tests/nameplates-extraction-bench.mjs --n=1000 --json=…` — labelled corpus, per-field
+  precision/recall/F1, whole-plate exact match, ms/plate. Corpus dump for other models:
+  `… --dump=…/extraction-corpus.jsonl`. Method and comparator: `ml/nameplates/bench/README.md`.
+- **Unit tests:** the parser, voltage reader, code folding, schedule parsing, candidate ranking, mismatch
+  detection, range guards and the matcher — `node --test tests/nameplate-model.test.mjs` (all passing).
+- **OCR end-to-end:** `node tests/nameplates-bench.mjs` — drawn plates through phone-photo degradations.
+- **Fine-tuned reader:** `ml/nameplates/cloud/eval_donut.py` scores the Donut model field by field on the
+  held-out split.
 
 ## Repository contents
 
@@ -254,9 +304,9 @@ to keep OCR confidence and the plate line each value came from.
 | `schedule-import.js` | the CSV schedule reader it depends on |
 | `progress-project.js` | a helper the schedule reader imports |
 | `sample_schedule.csv` | a 10-row data-centre equipment schedule |
-| `sample_plates.json` | two sample plates: one that verifies, one flagged on model and voltage |
-| `eval/` | the OCR benchmark harness output |
-| `config.json` | machine-readable fields, types and statuses |
+| `sample_plates.json` | sample plates: a match, a flagged mismatch, a switchboard, a server |
+| `eval/` | OCR benchmark output, extraction benchmark output and corpus |
+| `config.json` | machine-readable fields, groups, types and statuses |
 
 ## Provenance
 
@@ -275,8 +325,8 @@ acting on it.
 ## Licence and trademarks
 
 Code released under **Apache-2.0**. Brand and product names (Schneider Electric, Eaton, Vertiv, Caterpillar,
-Trane, …) are trademarks of their owners and are matched only to identify user-supplied plates; this project is
-independent and not affiliated with or endorsed by them.
+Trane, Dell, Cisco, …) are trademarks of their owners and are matched only to identify user-supplied plates;
+this project is independent and not affiliated with or endorsed by them.
 
 ## Citation
 

bench/README.md

@@ -0,0 +1,69 @@
+# Benchmark: nameplate field extraction
+
+One labelled corpus, one metric, so this engine and any other model (Donut, LayoutLMv3, a VLM, a
+cloud document-AI API) can be compared on the **same** data.
+
+```sh
+# Run the deterministic engine and write the numbers + the corpus
+node tests/nameplates-extraction-bench.mjs \
+  --n=1000 \
+  --json=ml/nameplates/hf/data-centre-nameplates/eval/extraction-bench.json \
+  --dump=ml/nameplates/hf/data-centre-nameplates/eval/extraction-corpus.jsonl \
+  --dumpN=200
+```
+
+## What it measures
+
+Each item is generated from **constructed** field values (so the ground truth is not the parser's own
+reading), rendered with the wording variety real plates use, and scored field by field:
+
+- **clean** — measures the extractor + matcher alone (no OCR loss).
+- **ocr** — the same plate text pushed through the character errors OCR actually makes on plate
+  lettering (`O/0`, `I/L/1`, `S/5`, `B/8`, `Z/2`, `HZ→Hw`, `KVA→XVA`, dropped/split characters).
+
+Reported: per-field precision / recall / F1, whole-plate exact match (no missed and no spurious field),
+and ms/plate. Code similarity uses the same `O/0`, `I/L/1`, `S/5`, `B/8`, `Z/2` folding the app uses.
+
+## Scoring another model on the same corpus
+
+`--dump` writes JSONL, one item per line:
+
+```json
+{"id":0,"type":"transformer","clean":"<plate text>","ocr":"<corrupted text>","truth":{"manufacturer":"…","model":"…","voltage":[4160,480,277],"kva":1500,…}}
+```
+
+Two ways to use it:
+
+1. **Text in / fields out** (LayoutLM, an LLM/VLM over OCR text, a cloud KIE API): feed `ocr`, parse
+   the model's fields, and compare to `truth` with the same normalisers. This isolates extraction.
+2. **Image in / fields out** (Donut, TrOCR+KIE, a VLM): render `clean`/`ocr` text to an image with the
+   project's plate drawer (`window.__nameplates.samplePlate` in `nameplates-app.js`, or
+   `ml/nameplates/synth/generate.py`), run the model, compare to `truth`. This folds OCR into the score.
+
+Use the project's own comparator so the rules are identical:
+
+```js
+import { codeSimilarity } from '@constructelligence/nameplate-model'; // or '../nameplate-model.js'
+const codeOk = (want, got) => codeSimilarity(want, got) >= 0.85;        // model / serial
+const numOk  = (want, got) => got != null && Math.abs(+got - +want) < 1e-6;
+const voltOk = (want, got) => want.values.every(v => got.values.includes(v));
+```
+
+## Reference points (published, different datasets — not directly comparable)
+
+These are reported by their authors on their own benchmarks. They are context for the task, not a
+head-to-head; the only numbers comparable to each other are ones produced by the corpus above.
+
+| Model | Task / dataset | Reported |
+|---|---|---|
+| LayoutLMv3 (base) | entity extraction, FUNSD | 92.08 F1 |
+| LiLT | entity extraction, FUNSD | 88.41 F1 |
+| Donut | field extraction, CORD | 84.1 F1 |
+| LayoutLMv3-large | information extraction, FUNSD | ~92 F1 |
+| CTPN + Transformer | power-equipment nameplate detection / recognition | 88.7% det F1 · 92.3% char acc |
+| PP-OCRv4 (TL-DREN) | electricity nameplate detection / recognition | 0.524 det F1 · 0.82 rec acc |
+| RNN nameplate OCR | power-equipment nameplate chars (zh + alnum) | 99.9% zh · 99.3% alnum |
+
+Nameplate extraction is a small field with no shared public benchmark — FUNSD/CORD measure invoices and
+forms, not equipment plates. That is exactly why this corpus is published: to give the task a
+reproducible, domain-specific test set.

config.json

@@ -1,23 +1,38 @@
 {
   "name": "data-centre-nameplates",
-  "version": "1.0",
+  "version": "2.0",
   "task": "image-to-text",
   "modality": "image",
   "language": ["en"],
-  "summary": "Reads an equipment nameplate (OCR) and checks it against an equipment schedule for data-centre MEP gear: UPS, PDU, switchgear, generators, ATS, transformers, busway, batteries, CRAH/CRAC, chillers, CDUs and pumps.",
+  "summary": "Reads an equipment nameplate (OCR) and checks it against an equipment schedule for data-centre MEP and IT gear across 55 equipment types, including a server-rack subsection (rack U height, power, PDU outlets, network ports).",
   "engine": {
     "ocr": "tesseract.js 5 (LSTM English)",
-    "extraction": "deterministic labelled-field parser + OCR error model",
-    "matching": "code-similarity (O/0, I/L/1, S/5, B/8, Z/2 folding) + schedule field checks",
+    "extraction": "deterministic labelled-field parser + OCR error model + numeric range guards",
+    "matching": "code-similarity (O/0, I/L/1, S/5, B/8, Z/2 folding), voltage-compatibility signal + schedule field checks",
+    "quality": "advisory photo check (blur, glare, darkness, resolution) before OCR",
     "runtime": "browser / Node, no server, no upload"
   },
+  "field_groups": {
+    "id": ["manufacturer", "model", "serial", "mfgDate"],
+    "electrical": ["voltage", "phase", "hz", "kva", "kw", "amps", "pf", "mca", "mocp", "sccr", "enclosure", "standards", "batteryType", "batteryAh", "cells"],
+    "cooling": ["refrigerant", "charge", "tons", "btu", "cfm", "gpm"],
+    "rack": ["uHeight", "powerW", "outlets", "ports"],
+    "mechanical": ["rpm", "weight"]
+  },
   "fields": [
-    "manufacturer", "model", "serial", "voltage", "phase", "hz",
-    "kva", "kw", "amps", "mca", "mocp", "refrigerant", "mfgDate"
+    "manufacturer", "model", "serial", "mfgDate",
+    "voltage", "phase", "hz", "kva", "kw", "amps", "pf", "mca", "mocp", "sccr", "enclosure", "standards", "batteryType", "batteryAh", "cells",
+    "refrigerant", "charge", "tons", "btu", "cfm", "gpm",
+    "uHeight", "powerW", "outlets", "ports",
+    "rpm", "weight"
   ],
   "equipment_types": [
-    "ups", "generator", "ats", "switchgear", "transformer", "pdu",
-    "panelboard", "busway", "battery", "cdu", "chiller", "crah", "pump"
+    "flywheel", "ups", "sts", "ats", "rectifier", "inverter", "bess", "nitrogen", "paralleling", "generator",
+    "fueltank", "switchgear", "mcc", "metering", "relay", "tmonitor", "transformer", "spd", "capacitor", "ngr",
+    "vfd", "busway", "panelboard", "pdu", "battery", "loadbank", "heatpump", "pump", "coolingtower", "thermalstorage",
+    "chiller", "condenser", "cdu", "crah", "ahu", "heatexchanger", "expansiontank", "airseparator", "boiler", "humidifier",
+    "watertreatment", "dryer", "compressor", "fcu", "rtu", "mua", "economizer", "firesuppression", "firealarm", "leakdetection",
+    "bms", "kvm", "rack", "server", "network"
   ],
   "statuses": ["verified", "partial", "mismatch", "unmatched", "missing"],
   "license": "apache-2.0",

eval/extraction-bench.json

@@ -0,0 +1,296 @@
+{
+  "clean": {
+    "condition": "clean",
+    "n": 1000,
+    "exactPlate": 0.941,
+    "microF1": 0.997,
+    "msPerPlate": 0.48,
+    "fields": {
+      "manufacturer": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 1000
+      },
+      "type": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 1000
+      },
+      "voltage": {
+        "precision": 1,
+        "recall": 0.958,
+        "f1": 0.979,
+        "support": 1000
+      },
+      "kva": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 563
+      },
+      "phase": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 867
+      },
+      "hz": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 867
+      },
+      "model": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 1000
+      },
+      "serial": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 1000
+      },
+      "mfgDate": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 867
+      },
+      "batteryType": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 133
+      },
+      "cells": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 133
+      },
+      "batteryAh": {
+        "precision": 0.993,
+        "recall": 1,
+        "f1": 0.996,
+        "support": 133
+      },
+      "kw": {
+        "precision": 0.992,
+        "recall": 0.996,
+        "f1": 0.994,
+        "support": 235
+      },
+      "amps": {
+        "precision": 0.991,
+        "recall": 0.998,
+        "f1": 0.994,
+        "support": 428
+      },
+      "mca": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 204
+      },
+      "mocp": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 204
+      },
+      "refrigerant": {
+        "precision": 0.991,
+        "recall": 1,
+        "f1": 0.996,
+        "support": 111
+      },
+      "pf": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 108
+      },
+      "cfm": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 193
+      },
+      "uHeight": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 100
+      },
+      "powerW": {
+        "precision": 0.943,
+        "recall": 0.99,
+        "f1": 0.966,
+        "support": 100
+      },
+      "sccr": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 111
+      },
+      "enclosure": {
+        "precision": 1,
+        "recall": 1,
+        "f1": 1,
+        "support": 111
+      }
+    }
+  },
+  "ocr": {
+    "condition": "ocr",
+    "n": 1000,
+    "exactPlate": 0.011,
+    "microF1": 0.799,
+    "msPerPlate": 0.49,
+    "fields": {
+      "manufacturer": {
+        "precision": 1,
+        "recall": 0.72,
+        "f1": 0.837,
+        "support": 1000
+      },
+      "type": {
+        "precision": 1,
+        "recall": 0.518,
+        "f1": 0.682,
+        "support": 1000
+      },
+      "voltage": {
+        "precision": 1,
+        "recall": 0.675,
+        "f1": 0.806,
+        "support": 1000
+      },
+      "kva": {
+        "precision": 1,
+        "recall": 0.622,
+        "f1": 0.767,
+        "support": 555
+      },
+      "phase": {
+        "precision": 1,
+        "recall": 0.94,
+        "f1": 0.969,
+        "support": 878
+      },
+      "hz": {
+        "precision": 1,
+        "recall": 0.786,
+        "f1": 0.88,
+        "support": 878
+      },
+      "model": {
+        "precision": 1,
+        "recall": 0.6,
+        "f1": 0.75,
+        "support": 1000
+      },
+      "serial": {
+        "precision": 1,
+        "recall": 0.627,
+        "f1": 0.771,
+        "support": 1000
+      },
+      "mfgDate": {
+        "precision": 1,
+        "recall": 0.321,
+        "f1": 0.486,
+        "support": 878
+      },
+      "uHeight": {
+        "precision": 0.974,
+        "recall": 0.958,
+        "f1": 0.966,
+        "support": 118
+      },
+      "powerW": {
+        "precision": 0.849,
+        "recall": 0.619,
+        "f1": 0.716,
+        "support": 118
+      },
+      "cfm": {
+        "precision": 1,
+        "recall": 0.653,
+        "f1": 0.79,
+        "support": 225
+      },
+      "amps": {
+        "precision": 0.94,
+        "recall": 0.809,
+        "f1": 0.87,
+        "support": 446
+      },
+      "sccr": {
+        "precision": 1,
+        "recall": 0.847,
+        "f1": 0.917,
+        "support": 124
+      },
+      "enclosure": {
+        "precision": 1,
+        "recall": 0.815,
+        "f1": 0.898,
+        "support": 124
+      },
+      "kw": {
+        "precision": 0.994,
+        "recall": 0.719,
+        "f1": 0.835,
+        "support": 221
+      },
+      "pf": {
+        "precision": 1,
+        "recall": 0.946,
+        "f1": 0.972,
+        "support": 112
+      },
+      "mca": {
+        "precision": 1,
+        "recall": 0.834,
+        "f1": 0.91,
+        "support": 205
+      },
+      "mocp": {
+        "precision": 1,
+        "recall": 0.707,
+        "f1": 0.829,
+        "support": 205
+      },
+      "refrigerant": {
+        "precision": 0.973,
+        "recall": 0.735,
+        "f1": 0.837,
+        "support": 98
+      },
+      "batteryType": {
+        "precision": 1,
+        "recall": 0.656,
+        "f1": 0.792,
+        "support": 122
+      },
+      "cells": {
+        "precision": 1,
+        "recall": 0.459,
+        "f1": 0.629,
+        "support": 122
+      },
+      "batteryAh": {
+        "precision": 0.965,
+        "recall": 0.672,
+        "f1": 0.792,
+        "support": 122
+      }
+    }
+  }
+}

eval/extraction-bench.log

@@ -0,0 +1,50 @@
+
+CLEAN  n=1000  exact-plate 94.1%  micro-F1 99.7%  0.49 ms/plate
+  powerW        P  94.3  R  99.0  F1  96.6  (100)
+  voltage       P 100.0  R  95.8  F1  97.9  (1000)
+  kw            P  99.2  R  99.6  F1  99.4  (235)
+  amps          P  99.1  R  99.8  F1  99.4  (428)
+  batteryAh     P  99.3  R 100.0  F1  99.6  (133)
+  refrigerant   P  99.1  R 100.0  F1  99.6  (111)
+  manufacturer  P 100.0  R 100.0  F1 100.0  (1000)
+  type          P 100.0  R 100.0  F1 100.0  (1000)
+  kva           P 100.0  R 100.0  F1 100.0  (563)
+  phase         P 100.0  R 100.0  F1 100.0  (867)
+  hz            P 100.0  R 100.0  F1 100.0  (867)
+  model         P 100.0  R 100.0  F1 100.0  (1000)
+  serial        P 100.0  R 100.0  F1 100.0  (1000)
+  mfgDate       P 100.0  R 100.0  F1 100.0  (867)
+  batteryType   P 100.0  R 100.0  F1 100.0  (133)
+  cells         P 100.0  R 100.0  F1 100.0  (133)
+  mca           P 100.0  R 100.0  F1 100.0  (204)
+  mocp          P 100.0  R 100.0  F1 100.0  (204)
+  pf            P 100.0  R 100.0  F1 100.0  (108)
+  cfm           P 100.0  R 100.0  F1 100.0  (193)
+  uHeight       P 100.0  R 100.0  F1 100.0  (100)
+  sccr          P 100.0  R 100.0  F1 100.0  (111)
+  enclosure     P 100.0  R 100.0  F1 100.0  (111)
+
+OCR  n=1000  exact-plate 1.1%  micro-F1 79.9%  0.49 ms/plate
+  mfgDate       P 100.0  R  32.1  F1  48.6  (878)
+  cells         P 100.0  R  45.9  F1  62.9  (122)
+  type          P 100.0  R  51.8  F1  68.2  (1000)
+  powerW        P  84.9  R  61.9  F1  71.6  (118)
+  model         P 100.0  R  60.0  F1  75.0  (1000)
+  kva           P 100.0  R  62.2  F1  76.7  (555)
+  serial        P 100.0  R  62.7  F1  77.1  (1000)
+  cfm           P 100.0  R  65.3  F1  79.0  (225)
+  batteryType   P 100.0  R  65.6  F1  79.2  (122)
+  batteryAh     P  96.5  R  67.2  F1  79.2  (122)
+  voltage       P 100.0  R  67.5  F1  80.6  (1000)
+  mocp          P 100.0  R  70.7  F1  82.9  (205)
+  kw            P  99.4  R  71.9  F1  83.5  (221)
+  manufacturer  P 100.0  R  72.0  F1  83.7  (1000)
+  refrigerant   P  97.3  R  73.5  F1  83.7  (98)
+  amps          P  94.0  R  80.9  F1  87.0  (446)
+  hz            P 100.0  R  78.6  F1  88.0  (878)
+  enclosure     P 100.0  R  81.5  F1  89.8  (124)
+  mca           P 100.0  R  83.4  F1  91.0  (205)
+  sccr          P 100.0  R  84.7  F1  91.7  (124)
+  uHeight       P  97.4  R  95.8  F1  96.6  (118)
+  phase         P 100.0  R  94.0  F1  96.9  (878)
+  pf            P 100.0  R  94.6  F1  97.2  (112)

nameplate-model.js

@@ -11,41 +11,130 @@
 import { parseCsv } from './schedule-import.js';
 
 export const FIELDS = [
-  ['manufacturer', 'Manufacturer'], ['model', 'Model'], ['serial', 'Serial'], ['voltage', 'Voltage'],
-  ['phase', 'Phase'], ['hz', 'Hz'], ['kva', 'kVA'], ['kw', 'kW'], ['amps', 'Amps'], ['mca', 'MCA'], ['mocp', 'MOCP'],
-  ['refrigerant', 'Refrigerant'], ['mfgDate', 'Mfg date'],
+  // Identification.
+  ['manufacturer', 'Manufacturer', 'id'], ['model', 'Model', 'id'], ['serial', 'Serial', 'id'], ['mfgDate', 'Mfg date', 'id'],
+  // Electrical.
+  ['voltage', 'Voltage', 'electrical'], ['phase', 'Phase', 'electrical'], ['hz', 'Hz', 'electrical'],
+  ['kva', 'kVA', 'electrical'], ['kw', 'kW', 'electrical'], ['amps', 'Amps', 'electrical'], ['pf', 'Power factor', 'electrical'],
+  ['mca', 'MCA', 'electrical'], ['mocp', 'MOCP', 'electrical'], ['sccr', 'SCCR (kA)', 'electrical'],
+  ['enclosure', 'Enclosure', 'electrical'], ['standards', 'Listings', 'electrical'], ['batteryType', 'Battery type', 'electrical'],
+  ['batteryAh', 'Battery Ah', 'electrical'], ['cells', 'Battery cells', 'electrical'],
+  // Cooling.
+  ['refrigerant', 'Refrigerant', 'cooling'], ['charge', 'Refrigerant charge', 'cooling'], ['tons', 'Cooling (tons)', 'cooling'],
+  ['btu', 'Cooling (BTU/h)', 'cooling'], ['cfm', 'Airflow (CFM)', 'cooling'], ['gpm', 'Flow (GPM)', 'cooling'],
+  // Server racks and IT.
+  ['uHeight', 'Rack U', 'rack'], ['powerW', 'Power (W)', 'rack'], ['outlets', 'PDU outlets', 'rack'], ['ports', 'Ports', 'rack'],
+  // Mechanical.
+  ['rpm', 'Speed (RPM)', 'mechanical'], ['weight', 'Weight (kg)', 'mechanical'],
 ];
 
+// Field groups for the reading panel; keys match the third element of FIELDS.
+export const FIELD_GROUPS = [['id', 'Identification'], ['electrical', 'Electrical'], ['cooling', 'Cooling'], ['rack', 'Server racks / IT'], ['mechanical', 'Mechanical']];
+
+// Data centre equipment types. Order is the whole game: the first pattern that
+// matches a plate wins, so device-specific wording comes before the families it
+// belongs to (flywheel before UPS, paralleling gear before generator, heat pump
+// and pumps before the cooling families, metering before transformer, controls
+// before racks).
 export const EQUIPMENT_TYPES = [
+  // Power conversion and transfer.
+  ['flywheel', 'Flywheel UPS', /FLYWHEEL/],
   ['ups', 'UPS', /\bUPS\b|UNINTERRUPTIBLE/],
-  ['generator', 'Generator', /GENERATOR|GENSET|\bEKW\b|STANDBY POWER|PRIME POWER/],
-  ['ats', 'Transfer switch', /TRANSFER SWITCH|\bATS\b|\bSTS\b/],
-  ['switchgear', 'Switchgear / switchboard', /SWITCHGEAR|SWITCHBOARD/],
-  ['transformer', 'Transformer', /TRANSFORMER|\bXFMR\b|PRIMARY.*SECONDARY/],
+  ['sts', 'Static transfer switch', /STATIC TRANSFER|STATIC BYPASS|\bSTS\b|RACK[-\s]?ATS/],
+  ['ats', 'Automatic transfer switch', /TRANSFER SWITCH|\bATS\b|\bATSE\b/],
+  ['rectifier', 'Rectifier / DC power', /RECTIFIER|BATTERY CHARGER|DC POWER SYSTEM/],
+  ['inverter', 'Inverter', /\bINVERTER\b|POWER CONVERSION SYSTEM/],
+  ['bess', 'Battery energy storage', /BATTERY ENERGY STORAGE|\bBESS\b|ENERGY STORAGE/],
+  // Prime power and distribution.
+  ['nitrogen', 'Nitrogen generator', /NITROGEN GENERATOR|\bN2\s?GENERATOR\b/],
+  ['paralleling', 'Paralleling gear', /PARALLELING|GENERATOR CONTROL|SYNCHRONIS|BUS TIE/],
+  ['generator', 'Generator', /GENERATOR|GENSET|\bEKW\b|STANDBY POWER|PRIME POWER|DIESEL ENGINE/],
+  ['fueltank', 'Fuel system', /FUEL TANK|DAY TANK|DIESEL TANK|FUEL OIL|FUEL POLISH|BULK FUEL/],
+  ['switchgear', 'Switchgear / switchboard', /SWITCHGEAR|SWITCHBOARD|DISTRIBUTION BOARD|\bMDP\b|MAIN DISTRIBUTION/],
+  ['mcc', 'Motor control centre', /MOTOR CONTROL|\bMCC\b/],
+  ['metering', 'Metering / CT cabinet', /METERING|POWER METER|KWH METER|ELECTRIC METER|CT CABINET/],
+  ['relay', 'Protective relay', /PROTECTIVE RELAY|PROTECTION RELAY|FEEDER RELAY|POWER SYSTEM RELAY|\bANSI\s?(?:50|51|27|59|81|87)\b/],
+  ['tmonitor', 'Transformer / DGA monitor', /TRANSFORMER MONITOR|DISSOLVED GAS|\bDGA\b|TRANSFORMER MONITORING/],
+  ['transformer', 'Transformer', /TRANSFORMER|\bXFMR\b|PRIMARY.*SECONDARY|DRY TYPE|ISOLATION TRANSFORMER|K[-\s]?RATED/],
+  ['spd', 'Surge protection', /SURGE PROTECT|\bSPD\b|\bTVSS\b|TRANSIENT VOLTAGE/],
+  ['capacitor', 'Power factor / filter', /CAPACITOR|POWER FACTOR|HARMONIC FILTER|\bPFC\b/],
+  ['ngr', 'Neutral grounding resistor', /NEUTRAL GROUNDING|GROUNDING RESISTOR|\bNGR\b/],
+  ['vfd', 'Variable frequency drive', /VARIABLE FREQUENCY|VARIABLE SPEED|\bVFD\b|\bVSD\b|\bAFD\b/],
+  ['busway', 'Busway', /BUSWAY|BUS PLUG|BUS DUCT|ISOLATED PHASE BUS|PHASE BUS/],
+  ['panelboard', 'Panelboard', /PANELBOARD|PANEL BOARD|LOAD CENTER/],
   ['pdu', 'PDU / RPP', /POWER DISTRIBUTION UNIT|\bPDU\b|\bRPP\b|REMOTE POWER PANEL/],
-  ['panelboard', 'Panelboard', /PANELBOARD/],
-  ['busway', 'Busway', /BUSWAY|BUS PLUG|BUS DUCT/],
-  ['battery', 'Battery cabinet', /BATTERY|\bVRLA\b|LITHIUM/],
-  ['cdu', 'Coolant distribution unit', /COOLANT DISTRIBUTION|\bCDU\b/],
-  ['chiller', 'Chiller', /CHILLER/],
-  ['crah', 'CRAH / CRAC', /\bCRAH\b|\bCRAC\b|COMPUTER ROOM AIR|AIR HANDL/],
+  ['battery', 'Battery / battery cabinet', /\bBATTERY\b|VRLA|LITHIUM|LEAD ACID/],
+  ['loadbank', 'Load bank', /LOAD BANK|LOADBANK|RESISTIVE LOAD/],
+  // Pumps come before the cooling families: a "condenser water pump" or a
+  // "chilled water pump" is a pump, not the machine it serves; "heat pump" is
+  // matched first so the compressor word inside it does not win.
+  ['heatpump', 'Heat pump', /HEAT PUMP/],
   ['pump', 'Pump', /\bPUMP\b/],
+  // Cooling and mechanical.
+  ['coolingtower', 'Cooling tower', /COOLING TOWER|COOLING TWR|EVAPORATIVE CONDENSER/],
+  ['thermalstorage', 'Thermal storage', /THERMAL STORAGE|CHILLED WATER STORAGE|ICE STORAGE/],
+  ['chiller', 'Chiller', /\bCHILLER\b/],
+  ['condenser', 'Dry cooler / condenser', /DRY COOLER|FLUID COOLER|EVAPORATIVE COOLER|REMOTE CONDENSER|AIR[-\s]?COOLED CONDENSER|ADIABATIC|CONDENSER/],
+  ['cdu', 'CDU / liquid cooling', /COOLANT DISTRIBUTION|\bCDU\b|LIQUID COOLING|IMMERSION|DIRECT TO CHIP|COOLANT MANIFOLD|REAR DOOR/],
+  ['crah', 'CRAH / CRAC', /\bCRAH\b|\bCRAC\b|COMPUTER ROOM AIR/],
+  ['ahu', 'Air handling unit', /\bAHU\b|AIR HANDLING|AIR HANDLER/],
+  ['heatexchanger', 'Heat exchanger', /HEAT EXCHANGER|PLATE HEAT|PLATE AND FRAME/],
+  ['expansiontank', 'Expansion tank', /EXPANSION TANK|HYDROPNEUMATIC/],
+  ['airseparator', 'Air separator', /AIR SEPARATOR|AIR SEPARATION|\bAIR SCOOP\b/],
+  ['boiler', 'Boiler', /\bBOILER\b/],
+  ['humidifier', 'Humidifier / dehumidifier', /HUMIDIFIER|HUMIDIFICATION|DEHUMIDIFIER/],
+  ['watertreatment', 'Water treatment', /WATER TREATMENT|WATER SOFTENER|REVERSE OSMOSIS|\bRO SYSTEM\b|CHEMICAL DOSING|SIDE STREAM FILTER|SAND FILTER|CARBON FILTER|WATER FILTER/],
+  ['dryer', 'Air dryer', /AIR DRYER|DESICCANT|REFRIGERATED DRYER/],
+  ['compressor', 'Compressor', /\bCOMPRESSOR\b/],
+  ['fcu', 'Fan coil / fan wall', /\bFCU\b|FAN COIL|FAN WALL|EXHAUST FAN|SUPPLY FAN|RETURN FAN/],
+  ['rtu', 'Rooftop unit', /ROOFTOP UNIT|\bRTU\b|PACKAGED UNIT|PACKAGE UNIT/],
+  ['mua', 'Makeup air unit', /MAKEUP AIR|MAKE-UP AIR|\bMUA\b/],
+  ['economizer', 'Economizer', /ECONOMIZER/],
+  // Fire, safety and controls.
+  ['firesuppression', 'Fire suppression', /FIRE SUPPRESSION|CLEAN AGENT|\bFM[-\s]?200\b|NOVEC|INERT GAS|SPRINKLER|PRE[-\s]?ACTION|\bCO2\b|AEROSOL/],
+  ['firealarm', 'Fire alarm', /FIRE ALARM|\bVESDA\b|SMOKE DETECT|ASPIRATING|HEAT DETECT/],
+  ['leakdetection', 'Leak / gas detection', /LEAK DETECT|WATER DETECT|REFRIGERANT MONITOR|GAS DETECT/],
+  ['bms', 'BMS / controls', /\bBMS\b|\bEPMS\b|\bDCIM\b|BUILDING MANAGEMENT|\bBAS\b|CONTROL PANEL|CONTROL CABINET|\bPLC\b|CONTROLLER/],
+  // IT and white space. Rack before server so "server rack / enclosure" is a
+  // rack; KVM before server so "console server" is a console.
+  ['kvm', 'KVM / console', /\bKVM\b|CONSOLE SERVER/],
+  ['rack', 'Rack / enclosure', /EQUIPMENT RACK|\bRACK\b|ENCLOSURE|\bCABINET\b/],
+  ['server', 'Server / storage', /\bSERVER\b|BLADE|STORAGE ARRAY|\bSAN\b|\bNAS\b|HCI NODE/],
+  ['network', 'Network gear', /NETWORK SWITCH|ETHERNET SWITCH|\bROUTER\b|PATCH PANEL|FIREWALL|LOAD BALANCER/],
 ];
 
-// Makers common on data centre electrical and cooling packages. Matched as
-// whole words; anything else falls back to a line that reads like a company.
+// Makers common on data centre electrical, cooling, IT and fire packages.
+// Matched as whole words; anything else falls back to a line that reads like a
+// company. Longer names precede the shorter names they contain.
 const MAKERS = [
   'Schneider Electric', 'Square D', 'APC', 'Eaton', 'ABB', 'Siemens', 'Vertiv', 'Liebert', 'Caterpillar', 'Cummins',
-  'Kohler', 'Rolls-Royce', 'MTU', 'Generac', 'Trane', 'Carrier', 'Daikin', 'York', 'Johnson Controls', 'Stulz',
-  'Munters', 'nVent', 'Legrand', 'Mitsubishi Electric', 'Toshiba', 'General Electric', 'Hubbell', 'Socomec', 'Piller',
-  'Starline', 'Raritan', 'Server Technology', 'Emerson', 'Russelectric', 'ASCO', 'Hitachi', 'Riello',
-  'Rittal', 'Motivair', 'CoolIT', 'Hitec', 'EnerSys', 'Leclanché', 'Samsung SDI',
+  'Kohler', 'Rolls-Royce Power Systems', 'Rolls-Royce', 'MTU', 'Generac', 'Trane', 'Carrier', 'Daikin', 'York',
+  'Johnson Controls', 'Stulz', 'Munters', 'nVent', 'Legrand', 'Mitsubishi Electric', 'Toshiba', 'General Electric',
+  'Hubbell', 'Socomec', 'Piller', 'Starline', 'Raritan', 'Server Technology', 'Emerson', 'Russelectric', 'ASCO',
+  'Hitachi', 'Riello', 'Rittal', 'Motivair', 'CoolIT', 'Hitec', 'EnerSys', 'Leclanché', 'Samsung SDI',
+  // Cooling and mechanical.
+  'Airedale', 'Uniflair', 'Climaveneta', 'Aermec', 'FläktGroup', 'FlaktGroup', 'Systemair', 'ebm-papst', 'Danfoss',
+  'Grundfos', 'Wilo', 'Xylem', 'Bell & Gossett', 'Armstrong', 'Taco', 'Flowserve', 'SPX', 'Baltimore Aircoil',
+  'Evapco', 'Marley', 'LU-VE', 'Alfa Laval', 'SWEP', 'Tranter', 'Boyd', 'Asetek',
+  // Power distribution, switchgear and batteries.
+  'PDI', 'Power Distribution Inc', 'Anord Mardix', 'Mardix', 'Universal Electric', 'Hammond', 'Hoffman',
+  'Exide', 'C&D Technologies', 'GS Yuasa', 'FIAMM', 'NorthStar', 'Saft', 'Hoppecke', 'LG Energy', 'CATL', 'Fluence',
+  'Aggreko', 'Himoinsa', 'Perkins', 'Volvo Penta', 'Deutz', 'Wartsila',
+  // IT and network.
+  'Dell', 'HPE', 'Hewlett Packard', 'Cisco', 'Juniper', 'Arista', 'Lenovo', 'Supermicro', 'IBM', 'Fujitsu', 'NetApp',
+  'Pure Storage', 'Aten', 'Avocent',
+  // Fire, detection and controls.
+  'Fike', 'Kidde', 'Tyco', 'Viking', 'Victaulic', 'Hochiki', 'Xtralis', 'VESDA', 'Notifier', 'Honeywell',
+  'Delta Controls', 'Distech', 'Automated Logic', 'Tridium',
 ];
-const COMPANY_LINE = /\b(INC|CORP|CORPORATION|LTD|LLC|GMBH|CO\.|COMPANY|SYSTEMS|ELECTRIC|POWER|TECHNOLOGIES|INDUSTRIES)\b/;
+const COMPANY_LINE = /\b(INC|CORP|CORPORATION|LTD|LLC|GMBH|CO\.|COMPANY|SYSTEMS|ELECTRIC|POWER|TECHNOLOGIES|INDUSTRIES|ENGINEERING|INTERNATIONAL|GROUP|AG|SA|BV|NV|PTY|WORKS|THERMAL|CONTROLS|SOLUTIONS|MANUFACTURING)\b/;
 
 const NUM = '(\\d{1,5}(?:[.,]\\d+)?)';
 // "1,002" is a thousands separator on a US plate; "2,5" is a European decimal.
 const num = s => (s == null ? null : parseFloat(/^\d{1,3},\d{3}$/.test(String(s)) ? String(s).replace(',', '') : String(s).replace(',', '.')));
+// Range guards: a rating of 0, or an absurd value, is an OCR artefact, not a field.
+const positive = v => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : null);
+const inRange = (v, lo, hi) => (typeof v === 'number' && Number.isFinite(v) && v >= lo && v <= hi ? v : null);
 
 /**
  * Nameplate fields from OCR output: a string, or lines as [{ text, confidence }]
@@ -71,11 +160,11 @@ export function parseNameplate(input) {
   const CODE = '([A-Z0-9][A-Z0-9\\-\\/\\.]{2,})';
   scan('model', new RegExp(`(?:\\bMODEL\\b|\\bMOD\\.|\\bM\\/N\\b|\\bCAT(?:ALOG)?\\.?\\s*(?:NO\\b\\.?|#|NUMBER)|\\bP\\/N\\b|\\bPART\\s*(?:NO\\b\\.?|#|NUMBER))\\s*(?:NO\\b\\.?|NUMBER\\b|#)?\\s*[:#.]?\\s*${CODE}`), m => cleanCode(m[1]));
   scan('serial', new RegExp(`(?:\\bSERIAL\\b|\\bSER\\.|\\bS\\/N\\b|\\b5\\/N\\b|\\bSN\\b)\\s*(?:NO\\b\\.?|NUMBER\\b|#)?\\s*[:#.]?\\s*([A-Z0-9][A-Z0-9\\-]{3,})`), m => cleanCode(m[1]));
-  scan('refrigerant', /\bR[-\s]?(410A|134A|1234ZE|1234YF|513A|514A|1233ZD|454B|407C|32|22)\b/, m => `R-${m[1]}`);
+  scan('refrigerant', /\bR[-\s]?(410A|134A|1234ZE|1234YF|1233ZD|513A|514A|515B|454B|468A|449A|407C|452A|455A|245FA|123|32|22|717|744|290|128|503|508B)\b/, m => `R-${m[1]}`);
   scan('hz', /\b(50|60)\s*HZ\b|\bHZ\s*[:]?\s*(50|60)\b|\bFREQ(?:UENCY)?\.?\s*[:]?\s*(50|60)\b/, m => +(m[1] || m[2] || m[3]));
   scan('phase', /\b([13])\s*-?\s*(?:PH|PHASE|Ø|Φ)\b|\bPH(?:ASE)?\s*[:]?\s*([13])\b/, m => +(m[1] || m[2]));
-  scan('kva', new RegExp(`${NUM}\\s*KVA\\b|\\bKVA\\s*[:]?\\s*${NUM}`), m => num(m[1] || m[2]));
-  scan('kw', new RegExp(`${NUM}\\s*E?KW\\b|\\bE?KW\\s*[:]?\\s*${NUM}`), m => num(m[1] || m[2]));
+  scan('kva', new RegExp(`${NUM}\\s*KVA\\b|\\bKVA\\s*[:]?\\s*${NUM}`), m => positive(num(m[1] || m[2])));
+  scan('kw', new RegExp(`${NUM}\\s*E?KW\\b|\\bE?KW\\s*[:]?\\s*${NUM}`), m => positive(num(m[1] || m[2])));
   scan('mfgDate', /\b(?:MFG\.?|MANUFACTURED|MFD\.?|BUILD|PROD(?:UCTION)?\.?)\s*(?:DATE)?\s*[:]?\s*(\d{1,2}[/-]\d{2,4}|\d{4}[/-]\d{1,2}(?:[/-]\d{1,2})?|\d{1,2}[/-]\d{1,2}[/-]\d{2,4})/, m => m[1]);
 
   // Voltage: every voltage on the plate (a transformer or UPS carries more than one).
@@ -91,24 +180,55 @@ export function parseNameplate(input) {
   if (volts.length) fields.voltage = { value: voltLine.text, conf: voltLine.conf, line: voltLine.line, values: volts };
 
   // Amps: a labelled rated current first, then any bare "1002 A". Refrigerants (R-410A) are not amps.
-  scan('amps', new RegExp(`(?:\\bFLA\\b|\\bRLA\\b|\\bCURRENT\\b|\\bAMPS?\\b|\\bAMPERES\\b)\\s*[:]?\\s*${NUM}`), m => num(m[1]));
-  if (!fields.amps) scan('amps', new RegExp(`(?<![-\\d.R])${NUM}\\s*(?:A|AMPS?)\\b`), m => num(m[1]));
-  scan('mca', new RegExp(`\\bMCA\\b\\s*[:]?\\s*${NUM}`), m => num(m[1]));
-  scan('mocp', new RegExp(`(?:\\bMOCP\\b|\\bMAX\\.?\\s*(?:FUSE|BREAKER|OCP))\\s*(?:SIZE)?\\s*[:]?\\s*${NUM}`), m => num(m[1]));
+  scan('amps', new RegExp(`(?:\\bFLA\\b|\\bRLA\\b|\\bCURRENT\\b|\\bAMPS?\\b|\\bAMPERES\\b)\\s*[:]?\\s*${NUM}`), m => positive(num(m[1])));
+  if (!fields.amps) scan('amps', new RegExp(`(?<![-\\d.R])${NUM}\\s*(?:A|AMPS?)\\b`), m => positive(num(m[1])));
+  scan('mca', new RegExp(`\\bMCA\\b\\s*[:]?\\s*${NUM}`), m => positive(num(m[1])));
+  scan('mocp', new RegExp(`(?:\\bMOCP\\b|\\bMAX\\.?\\s*(?:FUSE|BREAKER|OCP))\\s*(?:SIZE)?\\s*[:]?\\s*${NUM}`), m => positive(num(m[1])));
+
+  // Data centre electrical: power factor and short-circuit/interrupting rating.
+  scan('pf', /(?:POWER\s*FACTOR|\bP\.?F\b)\s*[:=]?\s*(0?[.,]\d{1,3}|1(?:[.,]0+)?)\b|(0?[.,]\d{1,3})\s*P\.?F\b/, m => inRange(num(m[1] || m[2]), 0.01, 1));
+  scan('sccr', new RegExp(`${NUM}\\s*KAIC\\b|(?:\\bSCCR\\b|SHORT[\\s-]?CIRCUIT|WITHSTAND|INTERRUPTING RATING|\\bKAIC\\b)[^0-9]{0,12}${NUM}\\s*(?:KA|K)?\\b`), m => inRange(num(m[1] || m[2]), 0.1, 1000));
+
+  // Enclosure rating: NEMA type or IEC IP code.
+  scan('enclosure', /\bNEMA\s*(?:TYPE\s*)?(\d{1,2}[A-Z]?)\b|\bIP\s*(\d{2}[A-Z]{0,2})\b/, m => (m[1] ? `NEMA ${m[1]}` : `IP ${m[2]}`));
+
+  // Mechanical / cooling nameplates: refrigerant charge, capacity, airflow and flow.
+  scan('charge', new RegExp(`CHARGE\\s*(?:WEIGHT)?\\s*[:]?\\s*${NUM}\\s*(?:LBS?|KG|KGS?|OZ)?\\b`), m => positive(num(m[1])));
+  scan('tons', new RegExp(`${NUM}\\s*TONS?\\b|\\bTONS?\\s*[:]?\\s*${NUM}`), m => positive(num(m[1] || m[2])));
+  scan('btu', new RegExp(`${NUM}\\s*(?:BTU\\/?H?R?|BTUH)\\b|\\bBTU\\/?H?R?\\s*[:]?\\s*${NUM}`), m => positive(num(m[1] || m[2])));
+  scan('cfm', new RegExp(`${NUM}\\s*CFM\\b|\\bCFM\\s*[:]?\\s*${NUM}`), m => positive(num(m[1] || m[2])));
+  scan('gpm', new RegExp(`${NUM}\\s*(?:GPM|LPM|L\\/S|M3\\/H)\\b|\\bGPM\\s*[:]?\\s*${NUM}`), m => positive(num(m[1] || m[2])));
+  scan('batteryAh', new RegExp(`${NUM}\\s*(?:AH|AMP[\\s-]?HOURS?)\\b`), m => positive(num(m[1])));
+
+  // Battery chemistry, cell count, rotating speed, rigging weight and listing marks.
+  scan('batteryType', /\b(VRLA|AGM|GEL|FLOODED|LITHIUM[-\s]?ION|LI[-\s]?ION|LIFEPO4|NICD|NI[-\s]?CD|LEAD[-\s]?ACID|NICKEL[-\s]?CADMIUM|VALVE[-\s]?REGULATED)\b/, m => batteryTypeName(m[1]));
+  scan('cells', new RegExp(`(?:CELLS?|CELL\\s*COUNT)\\s*[:]?\\s*${NUM}\\b|${NUM}\\s*CELLS?\\b`), m => inRange(num(m[1] || m[2]), 1, 1000));
+  scan('rpm', new RegExp(`${NUM}\\s*RPM\\b|\\bRPM\\s*[:]?\\s*${NUM}`), m => inRange(num(m[1] || m[2]), 1, 200000));
+  scan('weight', new RegExp(`(?:WEIGHT|NET\\s?WEIGHT|NET\\s?WT|MASS)\\s*[:]?\\s*${NUM}\\s*(LBS?|LB|KGS?|KG|TONS?)?\\b`), m => positive(weightKg(num(m[1]), m[2])));
+  scan('standards', /\b(UL\s?\d{3,5}[A-Z]?|IEC\s?\d{4,5}|ANSI\s?[A-Z]{1,3}[-\s]?\d{1,4}|IEEE\s?\d{1,4}|NFPA\s?\d{1,3}|CSA\s?[A-Z]?\d{1,4}|EN\s?\d{4,5})\b/, m => m[1].replace(/\s+/g, ' ').trim());
+
+  // Server racks: rack-unit height, IT power draw, PDU outlets and network ports.
+  scan('uHeight', /\b(\d{1,2})\s*U\b/, m => { const v = +m[1]; return v >= 1 && v <= 60 ? v : null; });
+  scan('powerW', new RegExp(`(?:POWER|INPUT POWER|RATED POWER)\\s*[:]?\\s*${NUM}\\s*W\\b|(?<![KE])${NUM}\\s*W\\b`), m => positive(num(m[1] || m[2])));
+  scan('outlets', new RegExp(`${NUM}\\s*(?:OUTLETS?|RECEPTACLES?)\\b|\\bOUTLETS?\\s*[:]?\\s*${NUM}`), m => inRange(num(m[1] || m[2]), 1, 10000));
+  scan('ports', new RegExp(`\\b(\\d{1,3})\\s*-?\\s*PORTS?\\b|\\bPORTS?\\s*[:]?\\s*${NUM}`), m => inRange(num(m[1] || m[2]), 1, 10000));
 
   // Manufacturer: a known maker anywhere, else a line that reads like a company name.
+  let makerLine = -1;
   for (const [i, l] of lines.entries()) {
     // "New York" on a supplier's address is not York the maker.
     const t = up(l.text).replace(/NEW YORK/g, '');
     const maker = MAKERS.find(mk => new RegExp(`\\b${escapeRe(up(mk))}\\b`).test(t));
-    if (maker) { set('manufacturer', maker, l.conf, i); break; }
+    if (maker) { set('manufacturer', maker, l.conf, i); makerLine = i; break; }
   }
   if (!fields.manufacturer) {
     const i = lines.findIndex(x => COMPANY_LINE.test(up(x.text)) && !/\d{3}/.test(x.text) && x.text.length <= 48);
-    if (i >= 0) set('manufacturer', titleCase(lines[i].text.replace(/[^A-Za-z0-9&.,\- ]/g, '').trim()), lines[i].conf, i);
+    if (i >= 0) { set('manufacturer', titleCase(lines[i].text.replace(/[^A-Za-z0-9&.,\- ]/g, '').trim()), lines[i].conf, i); makerLine = i; }
   }
 
-  const all = up(lines.map(l => l.text).join('\n'));
+  // Equipment type from plate text, excluding the maker line: a vendor called
+  // "…Transformer Corp" or "…Switchgear Ltd" must not type a chiller plate.
+  const all = up(lines.filter((_, i) => i !== makerLine).map(l => l.text).join('\n'));
   const type = (EQUIPMENT_TYPES.find(([, , re]) => re.test(all)) || [null])[0];
   const conf = lines.length ? Math.round(lines.reduce((s, l) => s + l.conf, 0) / lines.length) : 0;
   return { fields, type, conf, text: lines.map(l => l.text).join('\n'), lines: lines.map(l => ({ text: l.text, conf: l.conf, bbox: l.bbox })) };
@@ -174,9 +294,27 @@ const HEADERS = {
   kva: /^(kva|rating \(kva\)|kva rating|capacity \(kva\))$/i,
   kw: /^(kw|ekw|rating \(kw\)|kw rating|capacity \(kw\))$/i,
   amps: /^(amps|a|amperage|fla|rated current|current)$/i,
+  pf: /^(pf|power factor)$/i,
   mca: /^(mca|min\.? circuit amp(s|acity)?|minimum circuit ampacity)$/i,
   mocp: /^(mocp|max\.? (fuse|breaker|ocp)( size)?|maximum overcurrent protection)$/i,
+  sccr: /^(sccr|short.?circuit|withstand|interrupting rating|kaic)$/i,
+  enclosure: /^(enclosure|nema|nema type|ip rating|enclosure type)$/i,
+  standards: /^(standards?|listings?|approvals?|compliance|ul|iec|ansi)$/i,
+  batteryType: /^(battery type|battery technology|battery chemistry|cell type)$/i,
   refrigerant: /^(refrigerant|ref\.?)$/i,
+  charge: /^(charge|refrigerant charge|charge (lbs|kg))$/i,
+  tons: /^(tons|tonnage|cooling \(tons\)|cooling tons|refrigeration tons|tr)$/i,
+  btu: /^(btu|btuh|btu\/h|cooling \(btu\/?h\)|cooling btu)$/i,
+  cfm: /^(cfm|airflow|air flow|air volume)$/i,
+  gpm: /^(gpm|flow|water flow|flow rate)$/i,
+  batteryAh: /^(ah|amp.?hours?|battery ah|battery capacity)$/i,
+  cells: /^(cells?|cell count|battery cells)$/i,
+  rpm: /^(rpm|speed|rated speed|r\/min)$/i,
+  weight: /^(weight|net weight|mass|wt|weight \(kg\))$/i,
+  uHeight: /^(u|u height|rack u|ru|height \(u\)|u size)$/i,
+  powerW: /^(power|power \(w\)|watts?|w|rated power|input power)$/i,
+  outlets: /^(outlets?|receptacles?|pdu outlets?|outlet count)$/i,
+  ports: /^(ports?|port count|network ports?)$/i,
   location: /^(location|room|area|level|space|served from|zone)$/i,
 };
 
@@ -197,7 +335,13 @@ export function parseEquipmentSchedule(text) {
     else items.push({
       tag, type: get('type'), manufacturer: get('manufacturer'), model: get('model'), serial: get('serial'),
       voltage: get('voltage'), phase: num(get('phase').match(/[13]/)?.[0]), kva: num(get('kva')) || null, kw: num(get('kw')) || null,
-      amps: num(get('amps')) || null, mca: num(get('mca')) || null, mocp: num(get('mocp')) || null, refrigerant: get('refrigerant'), location: get('location'),
+      amps: num(get('amps')) || null, pf: num(get('pf')) || null, mca: num(get('mca')) || null, mocp: num(get('mocp')) || null,
+      sccr: num(get('sccr')) || null, enclosure: get('enclosure'), standards: get('standards'), batteryType: get('batteryType'),
+      refrigerant: get('refrigerant'), charge: num(get('charge')) || null, tons: num(get('tons')) || null, btu: num(get('btu')) || null,
+      cfm: num(get('cfm')) || null, gpm: num(get('gpm')) || null, batteryAh: num(get('batteryAh')) || null,
+      cells: num(get('cells')) || null, rpm: num(get('rpm')) || null, weight: num(get('weight')) || null,
+      uHeight: num(get('uHeight')) || null, powerW: num(get('powerW')) || null,
+      outlets: num(get('outlets')) || null, ports: num(get('ports')) || null, location: get('location'),
     });
   });
   if (!items.length) problems.push('The header was found but no equipment rows under it.');
@@ -251,12 +395,23 @@ export function candidatesFor(reading, items, register = []) {
       const mk = item.manufacturer && f.manufacturer?.value ? (sameMaker(item.manufacturer, f.manufacturer.value) ? 1 : 0) : 0.5;
       const ty = reading.type && item.type ? (typeOf(item.type) === reading.type ? 1 : 0) : 0.5;
       score = 0.7 * m + 0.15 * mk + 0.15 * ty;
+      // A compatible voltage is a positive signal; mismatched voltages are only a
+      // tie-breaker, so a UPS plate still prefers a UPS row over a same-voltage PDU.
+      if (voltageCompatible(item, reading)) score += 0.1;
     }
     if (score >= 0.5) out.push({ item, score: Math.round(score * 100) / 100, registered: taken.has(item.tag) });
   }
   return out.sort((a, b) => (b.score - a.score) || (a.registered - b.registered));
 }
 
+/** True when the schedule row and the plate share at least one voltage. */
+function voltageCompatible(item, reading) {
+  if (!item.voltage) return false;
+  const want = scheduleVoltages(item.voltage);
+  const have = reading.fields?.voltage?.values || [];
+  return want.length > 0 && have.length > 0 && want.some(v => have.includes(v));
+}
+
 /** Equipment type key for free text such as a schedule's description column. */
 export function typeOf(text) {
   const s = up(text);
@@ -284,13 +439,31 @@ export function checkAgainst(reading, item) {
     push('voltage', item.voltage, f.voltage?.value, want.length > 0 && want.every(v => have.includes(v)));
   }
   if (item.phase) push('phase', item.phase, f.phase?.value, +item.phase === +f.phase?.value);
-  for (const k of ['kva', 'kw', 'amps', 'mca', 'mocp']) {
+  if (item.pf) push('pf', item.pf, f.pf?.value, Math.abs(+f.pf?.value - item.pf) <= 0.02);
+  for (const k of ['kva', 'kw', 'amps', 'mca', 'mocp', 'sccr', 'charge', 'tons', 'btu', 'cfm', 'gpm', 'batteryAh', 'cells', 'rpm', 'weight', 'uHeight', 'powerW', 'outlets', 'ports']) {
     if (item[k]) push(k, item[k], f[k]?.value, Math.abs(+f[k]?.value - item[k]) <= Math.max(0.5, item[k] * 0.01));
   }
+  if (item.enclosure) push('enclosure', item.enclosure, f.enclosure?.value, enclosureMatch(item.enclosure, f.enclosure?.value));
+  if (item.batteryType) push('batteryType', item.batteryType, f.batteryType?.value, looseEq(item.batteryType, f.batteryType?.value));
+  if (item.standards) push('standards', item.standards, f.standards?.value, looseEq(item.standards, f.standards?.value));
   if (item.refrigerant) push('refrigerant', item.refrigerant, f.refrigerant?.value, up(item.refrigerant).replace(/[^A-Z0-9]/g, '') === up(f.refrigerant?.value).replace(/[^A-Z0-9]/g, ''));
   return out;
 }
 
+/** Two short strings equal ignoring case, punctuation and spacing ("IP55" vs "IP 55"). */
+function looseEq(a, b) {
+  const norm = s => up(s).replace(/[^A-Z0-9]/g, '');
+  const x = norm(a), y = norm(b);
+  return !!x && !!y && (x === y || x.includes(y) || y.includes(x));
+}
+
+/** "NEMA 3R" vs "3R", "IP55" vs "IP 55": compare the rating code, ignoring the label. */
+function enclosureMatch(a, b) {
+  const norm = s => up(s).replace(/\bNEMA\b|\bTYPE\b|\bIP\b/g, '').replace(/[^A-Z0-9]/g, '');
+  const x = norm(a), y = norm(b);
+  return !!x && !!y && (x === y || x.includes(y) || y.includes(x));
+}
+
 /** Overall status of a register entry: matched and clean, matched with a problem, or not on the schedule. */
 export function statusOf(checks, tag) {
   if (!tag) return 'unmatched';
@@ -329,7 +502,10 @@ export function registerSummary(register, items = []) {
 
 /** Asset register CSV: one row per scanned plate, then every scheduled tag not scanned yet. */
 export function registerCsv(register, items = []) {
-  const head = ['Tag', 'Status', 'Type', 'Location', 'Manufacturer', 'Model', 'Serial', 'Voltage', 'Phase', 'Hz', 'kVA', 'kW', 'Amps', 'MCA', 'MOCP', 'Refrigerant', 'Mfg date', 'Issues', 'Scanned'];
+  const head = ['Tag', 'Status', 'Type', 'Location', 'Manufacturer', 'Model', 'Serial', 'Voltage', 'Phase', 'Hz', 'kVA', 'kW',
+    'Amps', 'PF', 'MCA', 'MOCP', 'SCCR', 'Enclosure', 'Listings', 'Battery type', 'Battery Ah', 'Battery cells',
+    'Refrigerant', 'Charge', 'Cooling (tons)', 'Cooling (BTU/h)', 'Airflow (CFM)', 'Flow (GPM)', 'Speed (RPM)',
+    'Weight (kg)', 'Rack U', 'Power (W)', 'Outlets', 'Ports', 'Mfg date', 'Issues', 'Scanned'];
   const byTag = new Map(items.map(i => [i.tag, i]));
   const typeLabel = k => (EQUIPMENT_TYPES.find(t => t[0] === k) || [])[1] || '';
   const dups = new Set(duplicateSerials(register).flat());
@@ -339,14 +515,19 @@ export function registerCsv(register, items = []) {
     const issues = (r.checks || []).filter(c => c.status === 'mismatch').map(c => `${c.label}: schedule ${c.expected}, plate ${c.found}`);
     if (dups.has(r.id)) issues.push('Serial also on another scanned plate');
     return [r.tag || '', STATUS_LABELS[r.status] || r.status, typeLabel(r.type), byTag.get(r.tag)?.location || '',
-      v('manufacturer'), v('model'), v('serial'), v('voltage'), v('phase'), v('hz'), v('kva'), v('kw'), v('amps'),
-      v('mca'), v('mocp'), v('refrigerant'), v('mfgDate'), issues.join('; '), r.scannedAt ? new Date(r.scannedAt).toISOString().slice(0, 16).replace('T', ' ') : ''];
+      v('manufacturer'), v('model'), v('serial'), v('voltage'), v('phase'), v('hz'), v('kva'), v('kw'), v('amps'), v('pf'),
+      v('mca'), v('mocp'), v('sccr'), v('enclosure'), v('standards'), v('batteryType'), v('batteryAh'), v('cells'),
+      v('refrigerant'), v('charge'), v('tons'), v('btu'), v('cfm'), v('gpm'), v('rpm'), v('weight'), v('uHeight'), v('powerW'), v('outlets'), v('ports'), v('mfgDate'),
+      issues.join('; '), r.scannedAt ? new Date(r.scannedAt).toISOString().slice(0, 16).replace('T', ' ') : ''];
   });
   const tags = new Set(register.map(r => r.tag));
   for (const i of items) {
     if (tags.has(i.tag)) continue;
-    rows.push([i.tag, STATUS_LABELS.missing, i.type, i.location, i.manufacturer, i.model, i.serial, i.voltage, i.phase ?? '', '',
-      i.kva ?? '', i.kw ?? '', i.amps ?? '', i.mca ?? '', i.mocp ?? '', i.refrigerant, '', '', '']);
+    rows.push([i.tag, STATUS_LABELS.missing, i.type, i.location, i.manufacturer, i.model, i.serial, i.voltage, i.phase ?? '',
+      '', i.kva ?? '', i.kw ?? '', i.amps ?? '', i.pf ?? '', i.mca ?? '', i.mocp ?? '', i.sccr ?? '', i.enclosure ?? '',
+      i.standards ?? '', i.batteryType ?? '', i.batteryAh ?? '', i.cells ?? '', i.refrigerant, i.charge ?? '', i.tons ?? '',
+      i.btu ?? '', i.cfm ?? '', i.gpm ?? '', i.rpm ?? '', i.weight ?? '', i.uHeight ?? '', i.powerW ?? '', i.outlets ?? '',
+      i.ports ?? '', '', '', '']);
   }
   return [head, ...rows].map(r => r.map(csvCell).join(',')).join('\n') + '\n';
 }
@@ -368,12 +549,25 @@ CRAH-1-01,Computer room air handler,Coldline Systems,CW-150-480,480,3,,,45,60,,D
 CH-01,Air-cooled chiller,Coldline Systems,AC-1200,460,3,,,612,800,R-513A,Roof
 `;
 
-/** Text of the two sample plates: one that matches UPS-1A, one delivered at the wrong voltage. */
+/** The two sample plates: one that matches UPS-1A, one delivered at the wrong voltage. */
 export const SAMPLE_PLATES = [
   ['NORTHLINE POWER SYSTEMS', 'UNINTERRUPTIBLE POWER SUPPLY', 'MODEL NO: NPX-750-480', 'SERIAL NO: NL26A01937',
     'INPUT: 480Y/277 VAC  3 PH  60 HZ', 'RATING: 750 KVA / 675 KW', 'INPUT CURRENT: 1002 A', 'MFG DATE: 03/2026'],
   ['NORTHLINE POWER SYSTEMS', 'UNINTERRUPTIBLE POWER SUPPLY', 'MODEL NO: NPX-750-415', 'SERIAL NO: NL26A02210',
     'INPUT: 415Y/240 VAC  3 PH  50 HZ', 'RATING: 750 KVA / 675 KW', 'INPUT CURRENT: 1160 A', 'MFG DATE: 04/2026'],
+  // A few more data centre plates so the sample shows the wider equipment set.
+  ['IRONSIDE SWITCHGEAR CORP', 'SWITCHBOARD', 'MODEL NO: IS-4000-MDP', 'SERIAL NO: IS26C01188',
+    '480Y/277 V  3 PH  60 HZ', '1000 KVA  MAIN BUS', 'SCCR 65 KAIC', 'NEMA 3R  MFG DATE: 05/2026'],
+  ['COLDLINE SYSTEMS', 'COMPUTER ROOM AIR HANDLER', 'MODEL NO: CW-150-480', 'SERIAL NO: CL6600172',
+    '480 V  3 PH  60 HZ', 'FLA 38.5  MCA 45  MOCP 60', 'AIRFLOW 12000 CFM', 'MFG DATE: 01/2026'],
+  ['HARBOR ENGINE WORKS INC', 'DIESEL GENERATOR SET', 'MODEL: HG-3000', 'S/N: HEW0098812',
+    '13.8 KV  3 PHASE  60 HZ', '3750 KVA  3000 EKW', '0.8 PF', 'BUILD DATE 2026-01'],
+  ['POLARIS THERMAL', 'COOLING TOWER', 'MODEL NO: PT-CT-900', 'SERIAL NO: PT26D00417',
+    '460 V  3 PH  60 HZ', 'MCA 86  MOCP 110', 'FLOW 2400 GPM', 'MFG DATE: 07/2026'],
+  ['DELL EMC', 'POWEREDGE R650 SERVER', 'MODEL NO: R650-2U', 'SERIAL NO: DL26R00442',
+    '480 V  3 PH  60 HZ', '800 W  12.5 A', 'AIRFLOW 120 CFM', 'MFG DATE: 06/2026'],
+  ['VERTIV', 'RACK PDU', 'MODEL NO: MPX-30-C13', 'SERIAL NO: VR26P00117',
+    '400 V  3 PH  60 HZ', '30 A  5.5 KW', '24 OUTLETS', 'MFG DATE: 08/2026'],
 ];
 
 // ------------------------------------------------------------------ helpers
@@ -382,6 +576,27 @@ function up(s) { return String(s ?? '').toUpperCase(); }
 function escapeRe(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 function cleanCode(s) { return s.replace(/[.\-/]+$/, ''); }
 function titleCase(s) { return s.toLowerCase().replace(/\b[a-z]/g, c => c.toUpperCase()); }
+/** Canonical battery chemistry from the many ways plates spell it. */
+function batteryTypeName(s) {
+  const t = up(s).replace(/\s+/g, ' ');
+  if (/LIFEPO4/.test(t)) return 'LiFePO4';
+  if (/LITHIUM|LI[-\s]?ION/.test(t)) return 'Lithium-ion';
+  if (/NICD|NICKEL/.test(t)) return 'NiCd';
+  if (/LEAD/.test(t)) return 'Lead-acid';
+  if (/VRLA|VALVE/.test(t)) return 'VRLA';
+  if (/AGM/.test(t)) return 'AGM';
+  if (/GEL/.test(t)) return 'Gel';
+  if (/FLOODED/.test(t)) return 'Flooded';
+  return titleCase(s);
+}
+/** Weight normalised to kilograms so a lb plate and a kg schedule compare. */
+function weightKg(v, unit) {
+  if (v == null) return null;
+  const u = up(unit || 'KG');
+  if (/^LB/.test(u)) return Math.round(v * 0.45359237 * 10) / 10;
+  if (/^TON/.test(u)) return Math.round(v * 907.18474 * 10) / 10;
+  return v;
+}
 function csvCell(v) { const s = String(v ?? ''); return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s; }
 
 export function levenshtein(a, b) {

sample_plates.json

@@ -1,8 +1,9 @@
 {
-  "note": "Two fictional UPS plates. The first matches schedule tag UPS-1A; the second is the same kVA and model family but a 415 V / 50 Hz unit, so it should be flagged on model and voltage.",
+  "note": "Fictional sample plates. UPS-1A matches schedule tag UPS-1A; the 415 V UPS is the same family but a different voltage variant, so it is flagged on model and voltage. The switchboard and server are not on the sample schedule, showing wider equipment recognition and the server-rack fields (Rack U, Power W).",
   "plates": [
     {
       "id": "ups-match",
+      "type": "ups",
       "expect_tag": "UPS-1A",
       "lines": [
         "NORTHLINE POWER SYSTEMS",
@@ -17,6 +18,7 @@
     },
     {
       "id": "ups-wrong-voltage",
+      "type": "ups",
       "expect_tag": "UPS-1A",
       "expect_mismatch": ["model", "voltage"],
       "lines": [
@@ -29,6 +31,51 @@
         "INPUT CURRENT: 1160 A",
         "MFG DATE: 04/2026"
       ]
+    },
+    {
+      "id": "switchboard",
+      "type": "switchgear",
+      "expect_tag": null,
+      "lines": [
+        "IRONSIDE SWITCHGEAR CORP",
+        "SWITCHBOARD",
+        "MODEL NO: IS-4000-MDP",
+        "SERIAL NO: IS26C01188",
+        "480Y/277 V  3 PH  60 HZ",
+        "1000 KVA  MAIN BUS",
+        "SCCR 65 KAIC  NEMA 3R",
+        "MFG DATE: 05/2026"
+      ]
+    },
+    {
+      "id": "server-rack",
+      "type": "server",
+      "expect_tag": null,
+      "lines": [
+        "DELL EMC",
+        "POWEREDGE R650 SERVER",
+        "MODEL NO: R650-2U",
+        "SERIAL NO: DL26R00442",
+        "480 V  3 PH  60 HZ",
+        "800 W  12.5 A",
+        "AIRFLOW 120 CFM",
+        "MFG DATE: 06/2026"
+      ]
+    },
+    {
+      "id": "rack-pdu",
+      "type": "pdu",
+      "expect_tag": null,
+      "lines": [
+        "VERTIV",
+        "RACK PDU",
+        "MODEL NO: MPX-30-C13",
+        "SERIAL NO: VR26P00117",
+        "400 V  3 PH  60 HZ",
+        "30 A  5.5 KW",
+        "24 OUTLETS",
+        "MFG DATE: 08/2026"
+      ]
     }
   ]
 }

tests/nameplate-model.test.mjs

@@ -4,7 +4,8 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
   parseNameplate, voltagesIn, parseEquipmentSchedule, scheduleVoltages, candidatesFor, checkAgainst, statusOf,
-  codeSimilarity, foldCode, duplicateSerials, registerSummary, registerCsv, SAMPLE_SCHEDULE, SAMPLE_PLATES,
+  codeSimilarity, foldCode, duplicateSerials, registerSummary, registerCsv, typeOf, EQUIPMENT_TYPES,
+  SAMPLE_SCHEDULE, SAMPLE_PLATES,
 } from '../nameplate-model.js';
 
 const plate = lines => parseNameplate(lines.join('\n'));
@@ -58,6 +59,11 @@ test('"New York" in an address is not the maker York; unknown makers come from a
   const r = plate(['ACME SWITCHGEAR CORP', 'NEW YORK NY', 'SWITCHBOARD', 'MODEL SB-4000']);
   assert.equal(val(r, 'manufacturer'), 'Acme Switchgear Corp');
   assert.equal(r.type, 'switchgear');
+
+  // A transformer winding is "delta"; that is not the maker Delta.
+  const t = plate(['VOLTARC TRANSFORMER CORP', 'DRY TYPE TRANSFORMER', 'MODEL VT-2500-HV', 'PRIMARY 13800 V DELTA', 'SECONDARY 480Y/277 V']);
+  assert.equal(val(t, 'manufacturer'), 'Voltarc Transformer Corp');
+  assert.equal(t.type, 'transformer');
 });
 
 test('codes compare the way OCR misreads them', () => {
@@ -91,6 +97,24 @@ test('a serial on the schedule decides the match outright', () => {
   assert.equal(candidatesFor(plate(SAMPLE_PLATES[0]), items)[0].item.tag, 'UPS-1B');
 });
 
+test('voltage compatibility is a positive signal, but the equipment type still wins', () => {
+  // The 415 V UPS shares a voltage with the PDU rows (480/415Y/240), yet the
+  // matching UPS rows must still rank first.
+  const first = candidatesFor(plate(SAMPLE_PLATES[1]), schedule);
+  assert.ok(first[0].item.tag.startsWith('UPS'), `first was ${first[0].item.tag}`);
+  assert.ok(!first.slice(0, 4).some(c => c.item.tag.startsWith('PDU')), 'no PDU outranks the UPS rows');
+});
+
+test('out-of-range OCR noise is not accepted as a rating', () => {
+  const r = plate(['ACME', 'SWITCHBOARD', 'MODEL SB-1', '0 KVA', 'SCCR 0', '0 A', '0 OUTLETS']);
+  assert.equal(val(r, 'kva'), undefined, 'a zero rating is not a rating');
+  assert.equal(val(r, 'sccr'), undefined);
+  assert.equal(val(r, 'amps'), undefined);
+  assert.equal(val(r, 'outlets'), undefined);
+  const ok = plate(['ACME', 'SWITCHBOARD', 'MODEL SB-1', '480 V', '65 KAIC']);
+  assert.equal(val(ok, 'sccr'), 65, 'a plausible value is kept');
+});
+
 test('checks: the right unit verifies; the wrong-voltage unit is flagged on model and voltage', () => {
   const ups1a = schedule.find(i => i.tag === 'UPS-1A');
   const good = checkAgainst(plate(SAMPLE_PLATES[0]), ups1a);
@@ -121,7 +145,7 @@ test('register: summary, duplicate serials, and a CSV that lists what is still u
   assert.equal(s.missing.length, schedule.length - 1);
   const rows = registerCsv(reg, schedule).trim().split('\n');
   assert.equal(rows.length, 1 + 2 + schedule.length - 1);
-  assert.match(rows[1], /^UPS-1A,Verified,UPS,Electrical Room 1A,Northline Power Systems,NPX-750-480,NL26A01937,480Y\/277 V,3,60,750,675,1002,,,,03\/2026,Serial also on another scanned plate,2026-10-02 14:30$/);
+  assert.match(rows[1], /^UPS-1A,Verified,UPS,Electrical Room 1A,Northline Power Systems,NPX-750-480,NL26A01937,480Y\/277 V,3,60,750,675,1002,,,,,,,,,,,,,,,,,,,,,,03\/2026,Serial also on another scanned plate,2026-10-02 14:30$/);
   assert.match(rows[3], /^UPS-1B,Not scanned yet,/);
 });
 
@@ -144,3 +168,145 @@ test('MCA and MOCP are checked when the schedule lists them; near-zero-confidenc
   const checks = checkAgainst(r, ch);
   assert.deepEqual(checks.filter(c => c.status === 'mismatch').map(c => c.key), ['mocp']);
 });
+
+test('a wide data centre equipment set is recognised, device wording beating its family', () => {
+  assert.ok(EQUIPMENT_TYPES.length >= 40, 'the taxonomy covers more than the classic dozen');
+  const cases = [
+    ['FLYWHEEL UPS', 'flywheel'], ['UNINTERRUPTIBLE POWER SUPPLY', 'ups'], ['STATIC TRANSFER SWITCH', 'sts'],
+    ['AUTOMATIC TRANSFER SWITCH', 'ats'], ['BATTERY CHARGER', 'rectifier'], ['POWER CONVERSION SYSTEM INVERTER', 'inverter'],
+    ['BATTERY ENERGY STORAGE SYSTEM', 'bess'], ['PARALLELING SWITCHGEAR', 'paralleling'], ['DIESEL GENERATOR SET', 'generator'],
+    ['FUEL OIL DAY TANK', 'fueltank'], ['SWITCHBOARD', 'switchgear'], ['MOTOR CONTROL CENTER', 'mcc'],
+    ['POWER METER', 'metering'], ['DRY TYPE TRANSFORMER', 'transformer'], ['SURGE PROTECTIVE DEVICE', 'spd'],
+    ['POWER FACTOR CORRECTION CAPACITOR', 'capacitor'], ['VARIABLE FREQUENCY DRIVE', 'vfd'], ['ISOLATED PHASE BUS', 'busway'],
+    ['PANELBOARD', 'panelboard'], ['REMOTE POWER PANEL', 'pdu'], ['BATTERY CABINET', 'battery'], ['LOAD BANK', 'loadbank'],
+    ['COOLING TOWER', 'coolingtower'], ['AIR-COOLED CHILLER', 'chiller'], ['DRY COOLER', 'condenser'],
+    ['LIQUID COOLING CDU', 'cdu'], ['REAR DOOR HEAT EXCHANGER', 'cdu'], ['COMPUTER ROOM AIR HANDLER', 'crah'],
+    ['AIR HANDLING UNIT', 'ahu'], ['HEAT PUMP', 'heatpump'], ['PLATE HEAT EXCHANGER', 'heatexchanger'],
+    ['CHILLED WATER PUMP', 'pump'], ['CONDENSER WATER PUMP', 'pump'], ['STEAM HUMIDIFIER', 'humidifier'],
+    ['WATER TREATMENT PLANT', 'watertreatment'], ['DESICCANT DRYER', 'dryer'], ['AIR COMPRESSOR', 'compressor'],
+    ['FAN COIL UNIT', 'fcu'], ['ROOFTOP UNIT', 'rtu'], ['MAKEUP AIR UNIT', 'mua'], ['FM-200 FIRE SUPPRESSION', 'firesuppression'],
+    ['VESDA ASPIRATING SMOKE DETECT', 'firealarm'], ['WATER LEAK DETECT', 'leakdetection'], ['BMS CONTROLLER', 'bms'],
+    ['KVM SWITCH', 'kvm'], ['SERVER RACK ENCLOSURE', 'rack'], ['BLADE SERVER', 'server'], ['NETWORK SWITCH', 'network'],
+    ['PROTECTIVE RELAY PANEL', 'relay'], ['TRANSFORMER MONITOR DGA', 'tmonitor'], ['NEUTRAL GROUNDING RESISTOR', 'ngr'],
+    ['ISOLATION TRANSFORMER', 'transformer'], ['K-RATED TRANSFORMER', 'transformer'], ['WATER SOFTENER', 'watertreatment'],
+    ['REVERSE OSMOSIS SYSTEM', 'watertreatment'], ['EXPANSION TANK', 'expansiontank'], ['AIR SEPARATOR', 'airseparator'],
+    ['NITROGEN GENERATOR', 'nitrogen'], ['HOT WATER BOILER', 'boiler'], ['THERMAL STORAGE TANK', 'thermalstorage'],
+    ['EVAPORATIVE COOLER', 'condenser'], ['STATIC BYPASS', 'sts'], ['RACK ATS', 'sts'],
+  ];
+  for (const [text, want] of cases) assert.equal(typeOf(text), want, text);
+});
+
+test('cooling and electrical nameplates read the wider field set', () => {
+  const sg = plate(['IRONSIDE SWITCHGEAR CORP', 'SWITCHBOARD', 'MODEL IS-4000-MDP', 'SERIAL IS26C01188',
+    '480Y/277 V 3 PH 60 HZ', 'SCCR 65 KAIC', 'NEMA 3R', '0.8 PF']);
+  assert.equal(sg.type, 'switchgear');
+  assert.equal(val(sg, 'sccr'), 65);
+  assert.equal(val(sg, 'enclosure'), 'NEMA 3R');
+  assert.equal(val(sg, 'pf'), 0.8);
+
+  const ch = plate(['POLARIS THERMAL', 'WATER-COOLED CHILLER', 'MODEL PT-WC-900', '460 V 3 PH 60 HZ',
+    'REFRIGERANT R-1234ZE CHARGE 620 LBS', 'CAPACITY 500 TONS', 'AIRFLOW 24000 CFM', 'FLOW 2400 GPM']);
+  assert.equal(ch.type, 'chiller');
+  assert.equal(val(ch, 'refrigerant'), 'R-1234ZE');
+  assert.equal(val(ch, 'charge'), 620);
+  assert.equal(val(ch, 'tons'), 500);
+  assert.equal(val(ch, 'cfm'), 24000);
+  assert.equal(val(ch, 'gpm'), 2400);
+
+  const bat = plate(['ENERSYS', 'BATTERY CABINET', 'MODEL MX-500', '480 V 3 PH', 'CAPACITY 500 AH', 'IP20']);
+  assert.equal(bat.type, 'battery');
+  assert.equal(val(bat, 'batteryAh'), 500);
+  assert.equal(val(bat, 'enclosure'), 'IP 20');
+});
+
+test('battery chemistry, listings, speed and rigging weight are read', () => {
+  const bat = plate(['EXIDE', 'BATTERY STRING', 'MODEL VR-48', 'VRLA 48 CELLS', 'LISTED UL 1989', 'WEIGHT 1250 LBS']);
+  assert.equal(val(bat, 'batteryType'), 'VRLA');
+  assert.equal(val(bat, 'cells'), 48);
+  assert.equal(val(bat, 'standards'), 'UL 1989');
+  assert.equal(val(bat, 'weight'), 567, '1250 lb normalised to kg');
+
+  const pump = plate(['GRUNDFOS', 'END SUCTION PUMP', 'MODEL CR-64', 'RATED SPEED 1750 RPM', 'MOTOR IE3', 'WEIGHT 320 KG']);
+  assert.equal(pump.type, 'pump');
+  assert.equal(val(pump, 'rpm'), 1750);
+  assert.equal(val(pump, 'weight'), 320);
+
+  const li = plate(['SAFT', 'BATTERY CABINET', 'LITHIUM-ION', 'MODEL LI-500', 'IEC 62619']);
+  assert.equal(val(li, 'batteryType'), 'Lithium-ion');
+  assert.equal(val(li, 'standards'), 'IEC 62619');
+});
+
+test('battery, listing, speed and weight columns are imported and checked', () => {
+  const { items, problems } = parseEquipmentSchedule(
+    'Tag,Type,Model,Voltage,Battery type,Listings,Ah,Cells,RPM,Weight\n' +
+    'BAT-1,Battery cabinet,MX-500,480,VRLA,UL 1989,500,48,,\n' +
+    'PMP-1,Pump,CR-64,460,,,,,1750,320\n');
+  assert.deepEqual(problems, []);
+  const [bat, pump] = items;
+  assert.equal(bat.batteryType, 'VRLA');
+  assert.equal(bat.standards, 'UL 1989');
+  assert.equal(bat.cells, 48);
+  assert.equal(pump.rpm, 1750);
+  assert.equal(pump.weight, 320);
+
+  const good = checkAgainst(plate(['EXIDE', 'BATTERY CABINET', 'MODEL MX-500', '480 V', 'VRLA 500 AH 48 CELLS', 'UL 1989']), bat);
+  assert.deepEqual(good.filter(c => c.status !== 'ok'), []);
+  const bad = checkAgainst(plate(['EXIDE', 'BATTERY CABINET', 'MODEL MX-500', '480 V', 'AGM 400 AH 24 CELLS', 'UL 891']), bat);
+  assert.deepEqual(bad.filter(c => c.status === 'mismatch').map(c => c.key), ['batteryAh', 'cells', 'batteryType', 'standards']);
+});
+
+test('server-rack nameplates: rack U height, watts and airflow', () => {
+  const srv = plate(['DELL EMC', 'POWEREDGE R650 SERVER', 'MODEL NO: R650-2U', 'SERIAL NO: DL26R00442',
+    '480 V 3 PH 60 HZ', '800 W 12.5 A', 'AIRFLOW 120 CFM']);
+  assert.equal(srv.type, 'server');
+  assert.equal(val(srv, 'uHeight'), 2, 'from the model suffix R650-2U');
+  assert.equal(val(srv, 'powerW'), 800);
+  assert.equal(val(srv, 'amps'), 12.5);
+  assert.equal(val(srv, 'cfm'), 120);
+
+  // A kW line must not be read as watts.
+  const pdu = plate(['VERTIV', 'RACK PDU', 'MODEL MPX-30', '400 V 3 PH', '5.5 KW', '24 OUTLETS']);
+  assert.equal(val(pdu, 'powerW'), undefined);
+  assert.equal(val(pdu, 'kw'), 5.5);
+
+  const { items } = parseEquipmentSchedule('Tag,Type,Model,W,Rack U\nSRV-1,Server,R650,800,2\n');
+  assert.equal(items[0].powerW, 800);
+  assert.equal(items[0].uHeight, 2);
+  assert.deepEqual(checkAgainst(srv, items[0]).filter(c => c.status === 'mismatch').map(c => c.key), ['model']);
+
+  // A rack PDU: outlets, kW (not watts) and amps.
+  const rpdu = plate(['VERTIV', 'RACK PDU', 'MODEL NO: MPX-30-C13', 'SERIAL NO: VR26P00117',
+    '400 V 3 PH 60 HZ', '30 A 5.5 KW', '24 OUTLETS']);
+  assert.equal(rpdu.type, 'pdu');
+  assert.equal(val(rpdu, 'outlets'), 24);
+  assert.equal(val(rpdu, 'kw'), 5.5);
+  assert.equal(val(rpdu, 'powerW'), undefined, 'kW is not watts');
+  assert.equal(val(rpdu, 'amps'), 30);
+
+  const sw = plate(['CISCO', 'CATALYST NETWORK SWITCH', 'MODEL NO: C9300-48P', 'SERIAL NO: FOC26X0011',
+    '230 V 3 PH 50 HZ', '48-PORT  POE 1100 W']);
+  assert.equal(sw.type, 'network');
+  assert.equal(val(sw, 'ports'), 48);
+  assert.equal(val(sw, 'powerW'), 1100);
+});
+
+test('schedule columns for the extra fields are read and checked', () => {
+  const { items, problems } = parseEquipmentSchedule('Tag,Type,Model,Voltage,PF,SCCR,Enclosure,Tons,CFM,GPM,Ah\n' +
+    'SWB-1,Switchboard,IS-4000,480Y/277,0.8,65,NEMA 3R,,,,,\n' +
+    'CH-1,Chiller,PT-900,460,,,,500,24000,2400,\n' +
+    'BAT-1,Battery cabinet,MX-500,480,,,,,,,500\n');
+  assert.deepEqual(problems, []);
+  const [swb, ch, bat] = items;
+  assert.equal(swb.pf, 0.8);
+  assert.equal(swb.sccr, 65);
+  assert.equal(swb.enclosure, 'NEMA 3R');
+  assert.equal(ch.tons, 500);
+  assert.equal(ch.cfm, 24000);
+  assert.equal(ch.gpm, 2400);
+  assert.equal(bat.batteryAh, 500);
+
+  const good = checkAgainst(plate(['ACME SWITCHBOARD', 'SWITCHBOARD', 'MODEL IS-4000', '480Y/277 V', 'PF 0.8', 'SCCR 65 KA', 'NEMA 3R']), swb);
+  assert.deepEqual(good.filter(c => c.status !== 'ok'), []);
+  const bad = checkAgainst(plate(['ACME SWITCHBOARD', 'SWITCHBOARD', 'MODEL IS-4000', '480Y/277 V', 'PF 0.9', 'SCCR 42 KA', 'NEMA 1']), swb);
+  assert.deepEqual(bad.filter(c => c.status === 'mismatch').map(c => c.key), ['pf', 'sccr', 'enclosure']);
+});

tests/nameplates-bench.mjs

@@ -1,4 +1,4 @@
-// Nameplate OCR benchmark: drawn plates of six equipment types, each put
+// Nameplate OCR benchmark: drawn plates of several equipment types, each put
 // through the degradations real phone photos have (small, blurred, noisy,
 // low-contrast, glare, tilted, keystoned, dark anodised plate, JPEG, plate
 // small in a cluttered frame, sideways), OCR'd by the app's own pipeline and
@@ -28,6 +28,16 @@ export const BENCH_PLATES = [
     'INPUT 480 V 3 PH 60 HZ', 'OUTPUT 415Y/240 V', '300 KVA', 'MFG DATE: 02/2026'],
   ['COLDLINE SYSTEMS', 'COMPUTER ROOM AIR HANDLER', 'MODEL: CW-150-480', 'SERIAL: CL6600172',
     '480 V  3 PH  60 HZ', 'FLA 38.5', 'MCA 45  MOCP 60', 'MFG DATE: 01/2026'],
+  ['IRONSIDE SWITCHGEAR CORP', 'SWITCHBOARD', 'MODEL NO: IS-4000-MDP', 'SERIAL NO: IS26C01188',
+    '480Y/277 V  3 PH  60 HZ', '1000 KVA  MAIN BUS', 'SCCR 65 KAIC  NEMA 3R', 'MFG DATE: 05/2026'],
+  ['POLARIS THERMAL', 'COOLING TOWER', 'MODEL NO: PT-CT-900', 'SERIAL NO: PT26D00417',
+    '460 V  3 PH  60 HZ', 'MCA 86  MOCP 110', 'FLOW 2400 GPM', 'MFG DATE: 07/2026'],
+  ['COLDLINE SYSTEMS', 'WATER-COOLED CHILLER', 'MODEL NO. WC-900-R5', 'SERIAL NO. CL5529901',
+    '460 V  3 PH  60 HZ', 'REFRIGERANT R-1234ZE CHARGE 620 LBS', 'CAPACITY 500 TONS', 'AIRFLOW 24000 CFM'],
+  ['EXIDE', 'BATTERY CABINET', 'MODEL NO. VR-48', 'SERIAL NO. EX26A00445',
+    '480 V  3 PH  60 HZ', 'VRLA  48 CELLS  500 AH', 'LISTED UL 1989', 'WEIGHT 1250 LBS'],
+  ['GRUNDFOS', 'END SUCTION PUMP', 'MODEL NO. CR-64-2', 'SERIAL NO. GF26C00912',
+    '460 V  3 PH  60 HZ', 'FLA 42  SPEED 1750 RPM', 'WEIGHT 320 KG', 'IEC 60034'],
 ];
 
 // Each degradation runs in the page against a canvas holding the clean plate.

tests/nameplates-extraction-bench.mjs

@@ -0,0 +1,265 @@
+// Nameplate extraction benchmark (pure, runs in Node — no browser, no OCR).
+//
+// The OCR benchmark (tests/nameplates-bench.mjs) measures what OCR loses; this
+// measures the *extraction and matching* layer on a labelled plate corpus. Each
+// plate is generated from constructed field values, rendered with the wording
+// variety real plates use, then optionally corrupted with the character errors
+// OCR actually makes on plate lettering. The parser must recover the fields the
+// generator put in — the truth is by construction, not the parser's own reading,
+// so this is not circular.
+//
+//   node tests/nameplates-extraction-bench.mjs [--n=400] [--json=out.json] [--verbose]
+//
+// Reported: per-field precision / recall / F1, whole-plate exact match, and
+// ms/plate. Feed the same corpus to any model (Donut, LayoutLM, a VLM) via
+// ml/nameplates/bench/README.md to compare on one test set.
+
+import { writeFileSync } from 'node:fs';
+import { parseNameplate, foldCode, codeSimilarity } from '../nameplate-model.js';
+
+// ---------------------------------------------------------------- vocabulary
+
+const MAKERS = ['Northline Power Systems', 'Harbor Engine Works', 'Coldline Systems', 'Voltarc Transformer Corp',
+  'Ironside Switchgear Corp', 'Polaris Thermal', 'Meridian Power', 'Westgate Power', 'Bluewater Power']; 
+const MODEL_PREFIX = { ups: 'NPX', generator: 'HG', chiller: 'AC', transformer: 'VT', pdu: 'NPD', crah: 'CW', switchgear: 'IS', battery: 'VR', server: 'R' };
+const VOLT_PAIRS = [['480Y/277', 480, 277], ['415Y/240', 415, 240], ['208Y/120', 208, 120], ['600Y/347', 600, 347], ['380Y/220', 380, 220]];
+const VOLT_SINGLE = [208, 230, 380, 415, 460, 480, 575, 600, 2400, 4160, 13800];
+const KVA = [100, 150, 225, 300, 500, 750, 1000, 1500, 2000, 2500];
+const REFRIGERANTS = ['R-410A', 'R-134A', 'R-513A', 'R-1234ZE', 'R-1234YF', 'R-454B', 'R-407C'];
+const BATTERY_TYPES = ['VRLA', 'AGM', 'GEL', 'LITHIUM-ION', 'LEAD ACID', 'NICD'];
+
+// ---------------------------------------------------------------- rng
+
+function mulberry(a) {
+  return function () { a |= 0; a = (a + 0x6D2B79F5) | 0; let t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
+}
+const pick = (r, a) => a[Math.floor(r() * a.length)];
+const int = (r, lo, hi) => lo + Math.floor(r() * (hi - lo + 1));
+
+function code(r, prefix, withVolt) {
+  const n = int(r, 100, 9999);
+  const letters = String.fromCharCode(65 + int(r, 0, 25)) + String.fromCharCode(65 + int(r, 0, 25));
+  return withVolt ? `${prefix}-${n}-${pick(r, [480, 415, 208, 600])}` : `${prefix}-${n}${letters}`;
+}
+function serial(r) {
+  const y = 24 + int(r, 0, 2);
+  let s = '';
+  for (let i = 0; i < 7; i++) s += '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'[int(r, 0, 35)];
+  return `NL${y}A${s.slice(0, 5)}`;   // no 0/O ambiguity in the suffix
+}
+function mfgDate(r) {
+  const m = int(r, 1, 12), y = int(r, 2024, 2026);
+  return `${String(m).padStart(2, '0')}/${y}`;
+}
+
+// ---------------------------------------------------------------- plate generator
+// Renders a plate and its by-construction truth. Wording is varied per plate so
+// the parser cannot be keyed to one layout.
+
+function makePlate(r) {
+  const manufacturer = pick(r, MAKERS);
+  const type = pick(r, ['ups', 'generator', 'chiller', 'transformer', 'pdu', 'crah', 'switchgear', 'battery', 'server']);
+  const prefix = MODEL_PREFIX[type];
+  const truth = { manufacturer, type };
+  const lines = [];
+
+  const modelLabel = pick(r, ['MODEL NO: ', 'MODEL: ', 'CAT. NO. ', 'M/N ']);
+  const serialLabel = pick(r, ['SERIAL NO: ', 'S/N: ', 'SER. ']);
+
+  if (type === 'server') {
+    const u = pick(r, [1, 2, 4]);
+    truth.model = `R${int(r, 600, 900)}-${u}U`;
+    truth.serial = serial(r);
+    truth.uHeight = u;
+    truth.powerW = pick(r, [450, 600, 800, 1100, 1600, 2000]);
+    truth.cfm = pick(r, [80, 120, 160, 220]);
+    truth.voltage = [pick(r, [208, 230, 400, 480])];
+    truth.phase = 3; truth.hz = 60;
+    truth.amps = int(r, 5, 20);
+    const d = mfgDate(r);
+    lines.push(manufacturer, 'POWEREDGE SERVER', `${modelLabel}${truth.model}`, `${serialLabel}${truth.serial}`,
+      `${truth.voltage[0]} V  3 PH  ${truth.hz} HZ`, `${truth.powerW} W  ${truth.amps} A`, `AIRFLOW ${truth.cfm} CFM`, `MFG DATE: ${d}`);
+    truth.mfgDate = d;
+    return { lines, truth };
+  }
+
+  if (type === 'battery') {
+    const bt = pick(r, BATTERY_TYPES);
+    truth.model = code(r, 'VR', false);
+    truth.serial = serial(r);
+    truth.batteryType = bt === 'LITHIUM-ION' ? 'Lithium-ion' : bt === 'LEAD ACID' ? 'Lead-acid' : bt === 'NICD' ? 'NiCd' : bt;
+    truth.cells = pick(r, [24, 40, 48, 60, 80]);
+    truth.batteryAh = pick(r, [100, 200, 300, 500]);
+    truth.voltage = [pick(r, [48, 110, 240, 480])];
+    lines.push(manufacturer, 'BATTERY CABINET', `${modelLabel}${truth.model}`, `${serialLabel}${truth.serial}`,
+      `${truth.voltage[0]} V`, `${truth.batteryType === 'NiCd' ? 'NICD' : truth.batteryType === 'Lithium-ion' ? 'LITHIUM-ION' : truth.batteryType === 'Lead-acid' ? 'LEAD ACID' : truth.batteryType}  ${truth.cells} CELLS  ${truth.batteryAh} AH`);
+    truth.mfgDate = null;
+    return { lines, truth };
+  }
+
+  // Equipment with one or two voltages.
+  const pair = pick(r, VOLT_PAIRS);
+  const single = pick(r, VOLT_SINGLE);
+  const usePair = type !== 'transformer' && (type === 'ups' || type === 'pdu' || r() < 0.4);
+  if (type === 'transformer') {
+    truth.voltage = [single, pair[1], pair[2]];
+    truth.kva = pick(r, KVA);
+    truth.phase = 3; truth.hz = pick(r, [50, 60]);
+    truth.model = code(r, prefix, false);
+    truth.serial = serial(r);
+    const d = mfgDate(r);
+    lines.push(manufacturer, 'DRY TYPE TRANSFORMER', `${modelLabel}${truth.model}`, `${serialLabel}${truth.serial}`,
+      `PRIMARY ${single} V DELTA`, `SECONDARY ${pair[0]} V`, `${truth.kva} KVA  3 PH  ${truth.hz} HZ`, `MFG DATE ${d}`);
+    truth.mfgDate = d;
+    return { lines, truth };
+  }
+
+  const volt = usePair ? pair : [single];
+  truth.voltage = usePair ? [pair[1], pair[2]] : [single];
+  truth.phase = 3; truth.hz = pick(r, [50, 60]);
+  truth.model = code(r, prefix, usePair);
+  truth.serial = serial(r);
+  const desc = { ups: 'UNINTERRUPTIBLE POWER SUPPLY', generator: 'DIESEL GENERATOR SET', chiller: 'AIR-COOLED CHILLER', pdu: 'POWER DISTRIBUTION UNIT', crah: 'COMPUTER ROOM AIR HANDLER', switchgear: 'SWITCHBOARD' }[type];
+  lines.push(manufacturer, desc, `${modelLabel}${truth.model}`, `${serialLabel}${truth.serial}`);
+  lines.push(usePair ? `INPUT: ${pair[0]} VAC  ${truth.phase} PH  ${truth.hz} HZ` : `INPUT ${single} V ${truth.phase} PH ${truth.hz} HZ`);
+  if (type === 'ups' || type === 'generator') {
+    truth.kva = pick(r, KVA); truth.kw = Math.round(truth.kva * 0.9);
+    truth.amps = Math.round(truth.kva * 1.34);
+    lines.push(type === 'generator' ? `${truth.kva} KVA  ${truth.kw} EKW` : `RATING: ${truth.kva} KVA / ${truth.kw} KW`);
+    lines.push(type === 'generator' ? `RATED CURRENT ${truth.amps} A` : `INPUT CURRENT: ${truth.amps} A`);
+    if (type === 'generator') { truth.pf = 0.8; lines.push('0.8 PF'); }
+  } else if (type === 'chiller') {
+    truth.mca = int(r, 30, 900); truth.mocp = truth.mca + int(r, 10, 200); truth.refrigerant = pick(r, REFRIGERANTS);
+    lines.push(`REFRIGERANT ${truth.refrigerant}`, `MCA ${truth.mca}  MOCP ${truth.mocp}`);
+  } else if (type === 'crah') {
+    truth.mca = int(r, 20, 200); truth.mocp = truth.mca + int(r, 5, 60); truth.cfm = pick(r, [4000, 8000, 12000, 20000, 24000]);
+    truth.amps = +(r() * 60 + 5).toFixed(1);
+    lines.push(`FLA ${truth.amps}`, `MCA ${truth.mca}  MOCP ${truth.mocp}`, `AIRFLOW ${truth.cfm} CFM`);
+  } else if (type === 'switchgear') {
+    truth.sccr = pick(r, [42, 65, 85, 100]); truth.enclosure = pick(r, ['NEMA 1', 'NEMA 3R', 'NEMA 12', 'IP 20']);
+    lines.push(`${truth.kva = pick(r, KVA)} KVA  MAIN BUS`, `SCCR ${truth.sccr} KAIC`, truth.enclosure);
+  } else if (type === 'pdu') {
+    truth.kva = pick(r, [100, 200, 300, 500]);
+    lines.push(`${truth.kva} KVA`);
+  }
+  const d = mfgDate(r);
+  lines.push(pick(r, [`MFG DATE: ${d}`, `MFG DATE ${d}`, `BUILD DATE ${d}`]));
+  truth.mfgDate = d;
+  return { lines, truth };
+}
+
+// ---------------------------------------------------------------- OCR corruption
+
+const RULES = [['O', '0'], ['0', 'O'], ['I', '1'], ['L', '1'], ['S', '5'], ['B', '8'], ['Z', '2'], ['G', '6'], ['D', '0']];
+function corruptLine(s, r) {
+  let out = '';
+  for (const ch of s) {
+    const idx = RULES.findIndex(([from]) => from === ch);
+    if (idx >= 0 && r() < 0.15) { out += RULES[idx][1]; continue; }
+    if (r() < 0.01) continue;                       // dropped character
+    if (r() < 0.02) { out += ch + ' '; continue; }  // split after a character
+    out += ch;
+  }
+  return out
+    .replace(/\s+([0-9])/g, ' $1')
+    .replace(/HZ/g, r() < 0.3 ? 'Hw' : 'HZ')
+    .replace(/KVA/g, r() < 0.2 ? 'XVA' : 'KVA')
+    .replace(/(\d)V\b/g, r() < 0.2 ? '$1 Vv' : '$1V');
+}
+
+// ---------------------------------------------------------------- scoring
+
+const normCode = v => foldCode(v);
+const normStr = v => String(v).toUpperCase().replace(/[^A-Z0-9]/g, '');
+const numEq = (a, b) => Math.abs(Number(a) - Number(b)) < 1e-6;
+function fieldEq(key, want, got, fieldObj) {
+  if (got == null) return false;
+  if (key === 'model' || key === 'serial') return codeSimilarity(want, got) >= 0.85;
+  if (key === 'voltage') { const g = fieldObj?.values || []; return want.every(v => g.includes(v)); }
+  if (key === 'manufacturer' || key === 'batteryType' || key === 'enclosure' || key === 'refrigerant' || key === 'standards') return normStr(want) === normStr(got) || normStr(got).includes(normStr(want));
+  if (key === 'mfgDate') return normStr(want) === normStr(got);
+  return numEq(want, got);
+}
+
+function scorePlate(truth, reading) {
+  const out = { tp: 0, fn: 0, fp: 0, fields: {} };
+  for (const [k, want] of Object.entries(truth)) {
+    if (k === 'type') { const ok = reading.type === want; out.fields.type = ok ? 'ok' : 'miss'; out.tp += ok ? 1 : 0; out.fn += ok ? 0 : 1; continue; }
+    if (want == null) continue;                       // field not on this plate
+    const fieldObj = reading.fields[k];
+    const ok = fieldEq(k, want, fieldObj?.value, fieldObj);
+    out.fields[k] = ok ? 'ok' : 'miss';
+    out.tp += ok ? 1 : 0; out.fn += ok ? 0 : 1;
+  }
+  // A field the parser returns that the plate never had is a false positive.
+  for (const k of Object.keys(reading.fields)) {
+    if (!(k in truth) || truth[k] == null) { out.fields[k] = 'extra'; out.fp++; }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------- main
+
+function run(condition, n, seed, verbose) {
+  const r = mulberry(seed);
+  const per = {};   // field -> {tp,fn,fp}
+  let plateOk = 0, ms = 0;
+  for (let i = 0; i < n; i++) {
+    const { lines, truth } = makePlate(r);
+    const text = (condition === 'ocr' ? lines.map(l => corruptLine(l, r)) : lines).join('\n');
+    const t0 = performance.now();
+    const reading = parseNameplate(text);
+    ms += performance.now() - t0;
+    const s = scorePlate(truth, reading);
+    if (s.fn === 0 && s.fp === 0) plateOk++;
+    for (const [k, res] of Object.entries(s.fields)) {
+      per[k] ??= { tp: 0, fn: 0, fp: 0 };
+      if (res === 'ok') per[k].tp++;
+      else if (res === 'extra') per[k].fp++;
+      else per[k].fn++;
+    }
+    if (verbose && s.fn) console.log(`  #${i} ${truth.type}: missed ${Object.entries(s.fields).filter(([, v]) => v === 'miss').map(([k]) => k).join(', ')}`);
+  }
+  const fields = {};
+  let T = 0, P = 0, R = 0;
+  for (const [k, c] of Object.entries(per)) {
+    const prec = c.tp / Math.max(1, c.tp + c.fp), rec = c.tp / Math.max(1, c.tp + c.fn);
+    const f1 = (prec + rec) ? (2 * prec * rec) / (prec + rec) : 0;
+    fields[k] = { precision: round3(prec), recall: round3(rec), f1: round3(f1), support: c.tp + c.fn };
+    T += c.tp; R += c.tp + c.fn; P += c.tp + c.fp;
+    void f1;
+  }
+  const Pmicro = T / Math.max(1, P), Rmicro = T / Math.max(1, R);
+  return { condition, n, exactPlate: round3(plateOk / n), microF1: round3((Pmicro + Rmicro) ? (2 * Pmicro * Rmicro) / (Pmicro + Rmicro) : 0), msPerPlate: round2(ms / n), fields };
+}
+
+const round2 = v => Math.round(v * 100) / 100;
+const round3 = v => Math.round(v * 1000) / 1000;
+
+function corpus(n, seed) {
+  const r = mulberry(seed);
+  const items = [];
+  for (let i = 0; i < n; i++) {
+    const { lines, truth } = makePlate(r);
+    const clean = lines.join('\n');
+    const ocr = lines.map(l => corruptLine(l, r)).join('\n');
+    items.push({ id: i, type: truth.type, clean, ocr, truth });
+  }
+  return items;
+}
+
+function main() {
+  const args = Object.fromEntries(process.argv.slice(2).map(a => a.replace(/^--/, '').split('=')));
+  const n = +(args.n || 400);
+  const results = { clean: run('clean', n, 20, !!args.verbose), ocr: run('ocr', n, 20, !!args.verbose) };
+  for (const key of ['clean', 'ocr']) {
+    const res = results[key];
+    console.log(`\n${key.toUpperCase()}  n=${res.n}  exact-plate ${(100 * res.exactPlate).toFixed(1)}%  micro-F1 ${(100 * res.microF1).toFixed(1)}%  ${res.msPerPlate} ms/plate`);
+    const rows = Object.entries(res.fields).sort((a, b) => a[1].f1 - b[1].f1);
+    for (const [k, c] of rows) console.log(`  ${k.padEnd(13)} P ${(100 * c.precision).toFixed(1).padStart(5)}  R ${(100 * c.recall).toFixed(1).padStart(5)}  F1 ${(100 * c.f1).toFixed(1).padStart(5)}  (${c.support})`);
+  }
+  if (args.json) writeFileSync(args.json, JSON.stringify(results, null, 2));
+  if (args.dump) writeFileSync(args.dump, corpus(+(args.dumpN || 200), 20).map(x => JSON.stringify(x)).join('\n') + '\n');
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main();