Upload folder using huggingface_hub

LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Constructelligence
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,277 @@
+---
+license: apache-2.0
+language:
+  - en
+library_name: custom
+pipeline_tag: image-to-text
+tags:
+  - ocr
+  - document-ai
+  - information-extraction
+  - nameplate
+  - nameplate-ocr
+  - equipment-nameplate
+  - data-center
+  - data-centre
+  - datacenter
+  - mission-critical
+  - mep
+  - electrical
+  - equipment-schedule
+  - schedule-verification
+  - asset-register
+  - commissioning
+  - quality-assurance
+  - ups
+  - pdu
+  - switchgear
+  - generator
+  - ats
+  - transformer
+  - busway
+  - battery
+  - crah
+  - crac
+  - chiller
+  - cooling
+  - construction
+  - aec
+  - edge-ai
+  - on-device
+  - privacy-preserving
+  - tesseract
+  - browser
+---
+
+# Data Centre Nameplates — equipment-nameplate OCR checked against the 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.
+
+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.
+
+| | |
+|---|---|
+| **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) |
+| **OCR** | Tesseract.js 5 (English LSTM), pretrained — no fine-tuning |
+| **Extraction** | Deterministic labelled-field parser with an OCR error model |
+| **Runtime** | Browser · Node · edge — no GPU, no server, no data egress |
+| **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:
+
+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.
+
+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
+```
+
+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
+   an overall status: `verified`, `partial`, `mismatch`, `unmatched` or `missing` (scheduled but not scanned).
+
+## Fields extracted
+
+| 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.
+
+
+## Intended use
+
+- **Commissioning and QA walks:** photograph each unit as it is installed; confirm the delivered unit matches
+  the equipment schedule; capture an asset register as you go.
+- **Receiving and delivery checks:** flag the unit that arrived at the wrong voltage or rating before it is set.
+- **Register completion:** track scheduled tags that have no plate scanned against them yet.
+- **Takeoff and submittal review:** pull model/rating fields off a plate photo into a spreadsheet.
+
+### Out of scope — do not use it for
+
+- **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.
+
+## 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).
+- **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
+  here.
+
+## Quickstart
+
+The engine is plain ES modules with no build step. `nameplate-model.js` is the extractor and verifier;
+`schedule-import.js` is the CSV reader it depends on.
+
+```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
+SERIAL NO: NL26A01937
+INPUT: 480Y/277 VAC  3 PH  60 HZ
+RATING: 750 KVA / 675 KW
+INPUT CURRENT: 1002 A
+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' | ...
+```
+
+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
+
+- **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`.
+
+## Repository contents
+
+| File | What it is |
+|---|---|
+| `nameplate-model.js` | the extractor, matcher and register builder (ES module) |
+| `schedule-import.js` | the CSV schedule reader it depends on |
+| `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 |
+
+## Provenance
+
+An open extraction and verification engine from Constructelligence, the same code path that powers the
+**Nameplates** mode of BuildVision. No customer data is used; sample plates use fictional makers and models.
+It is the document-AI sibling of the vision models
+[`construction-site-safety-hazards`](https://huggingface.co/constructelligence/construction-site-safety-hazards)
+and [`electrical-circuit-connectivity`](https://huggingface.co/constructelligence/electrical-circuit-connectivity).
+
+## Safety
+
+This is a **prompt to look**, not a finding. It is not safety-rated, not a compliance decision, and not a
+substitute for inspection by a competent person. Verify every flagged field against the physical plate before
+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.
+
+## Citation
+
+```bibtex
+@misc{constructelligence_nameplates,
+  title  = {Data Centre Nameplates: equipment-nameplate OCR checked against the equipment schedule},
+  author = {Constructelligence},
+  year   = {2026},
+  howpublished = {\url{https://huggingface.co/constructelligence/data-centre-nameplates}}
+}
+```

config.json

@@ -0,0 +1,25 @@
+{
+  "name": "data-centre-nameplates",
+  "version": "1.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.",
+  "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",
+    "runtime": "browser / Node, no server, no upload"
+  },
+  "fields": [
+    "manufacturer", "model", "serial", "voltage", "phase", "hz",
+    "kva", "kw", "amps", "mca", "mocp", "refrigerant", "mfgDate"
+  ],
+  "equipment_types": [
+    "ups", "generator", "ats", "switchgear", "transformer", "pdu",
+    "panelboard", "busway", "battery", "cdu", "chiller", "crah", "pump"
+  ],
+  "statuses": ["verified", "partial", "mismatch", "unmatched", "missing"],
+  "license": "apache-2.0",
+  "repo": "constructelligence/data-centre-nameplates"
+}

eval/bench.json

@@ -0,0 +1,99 @@
+{
+  "overall": 0.9986263736263736,
+  "msPerPlate": 768.0833333332976,
+  "results": {
+    "clean": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 1236,
+      "misses": {}
+    },
+    "small": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 897,
+      "misses": {}
+    },
+    "blur": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 540,
+      "misses": {}
+    },
+    "noise": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 748,
+      "misses": {}
+    },
+    "lowContrast": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 557,
+      "misses": {}
+    },
+    "glare": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 532,
+      "misses": {}
+    },
+    "tilt": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 612,
+      "misses": {}
+    },
+    "keystone": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 474,
+      "misses": {}
+    },
+    "darkPlate": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 808,
+      "misses": {}
+    },
+    "jpeg": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 524,
+      "misses": {}
+    },
+    "inScene": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 895,
+      "misses": {}
+    },
+    "sideways": {
+      "acc": 1,
+      "ok": 56,
+      "total": 56,
+      "msPerPlate": 554,
+      "misses": {}
+    },
+    "phone": {
+      "acc": 0.9821428571428571,
+      "ok": 55,
+      "total": 56,
+      "msPerPlate": 1607,
+      "misses": {
+        "hz": 1
+      }
+    }
+  }
+}

eval/bench.log

@@ -0,0 +1,14 @@
+clean        100.0%   1236 ms/plate  missed: —
+small        100.0%    897 ms/plate  missed: —
+blur         100.0%    540 ms/plate  missed: —
+noise        100.0%    748 ms/plate  missed: —
+lowContrast  100.0%    557 ms/plate  missed: —
+glare        100.0%    532 ms/plate  missed: —
+tilt         100.0%    612 ms/plate  missed: —
+keystone     100.0%    474 ms/plate  missed: —
+darkPlate    100.0%    808 ms/plate  missed: —
+jpeg         100.0%    524 ms/plate  missed: —
+inScene      100.0%    895 ms/plate  missed: —
+sideways     100.0%    554 ms/plate  missed: —
+phone         98.2%   1607 ms/plate  missed: hz×1
+OVERALL       99.9%    768 ms/plate

nameplate-model.js

@@ -0,0 +1,399 @@
+// Nameplates: equipment nameplate OCR checked against the equipment schedule.
+// On a data centre job the gear is the job (UPS, PDUs, switchgear, gensets,
+// CRAHs, chillers), and the costly mistakes are a unit delivered at the wrong
+// voltage or rating, or one that never gets onto the asset register. This
+// module turns OCR text into nameplate fields, matches a reading to the
+// schedule, checks each field, and builds the register CSV.
+//
+// OCR is Tesseract.js (pretrained, loaded from the CDN like the other models),
+// so nothing here is trained: it is parsing and matching.
+// Pure functions (tests/nameplate-model.test.mjs).
+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'],
+];
+
+export const EQUIPMENT_TYPES = [
+  ['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/],
+  ['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/],
+  ['pump', 'Pump', /\bPUMP\b/],
+];
+
+// 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.
+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',
+];
+const COMPANY_LINE = /\b(INC|CORP|CORPORATION|LTD|LLC|GMBH|CO\.|COMPANY|SYSTEMS|ELECTRIC|POWER|TECHNOLOGIES|INDUSTRIES)\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(',', '.')));
+
+/**
+ * Nameplate fields from OCR output: a string, or lines as [{ text, confidence }]
+ * (Tesseract's data.lines). Each field is { value, conf } (conf 0–100, the OCR
+ * confidence of the line it came from; 100 for plain text).
+ */
+export function parseNameplate(input) {
+  const lines = (typeof input === 'string' ? input.split(/\r?\n/).map(text => ({ text, confidence: 100 })) : input)
+    .map(l => ({ text: ocrFix(String(l.text || '').replace(/\s+/g, ' ').trim()), conf: Math.round(l.confidence ?? 100), bbox: l.bbox || null }))
+    // Lines Tesseract itself scores near zero are texture read as text (brushed metal, a busy background).
+    .filter(l => l.text && l.conf >= 20);
+  const fields = {};
+  // line: index of the OCR line the value came from, so the page can outline it on the photo.
+  const set = (key, value, conf, line) => { if (fields[key] == null && value != null && value !== '') fields[key] = { value, conf, line }; };
+  // Each rule runs over every line in order, so the first line that has the field wins.
+  const scan = (key, re, map = m => m[1]) => {
+    for (const [i, l] of lines.entries()) {
+      const m = up(l.text).match(re);
+      if (m) { const v = map(m); if (v != null && v !== '') { set(key, v, l.conf, i); return; } }
+    }
+  };
+
+  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('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('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).
+  const volts = [];
+  let voltLine = null;
+  for (const [i, l] of lines.entries()) {
+    const found = voltagesIn(up(l.text));
+    if (found.values.length) {
+      for (const v of found.values) if (!volts.includes(v)) volts.push(v);
+      if (!voltLine) voltLine = { text: found.display, conf: l.conf, line: i };
+    }
+  }
+  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]));
+
+  // Manufacturer: a known maker anywhere, else a line that reads like a company name.
+  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 (!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);
+  }
+
+  const all = up(lines.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 })) };
+}
+
+/**
+ * Undo the misreads Tesseract makes on plate lettering (seen in tests/nameplates-bench.mjs):
+ * a serifed "V" read as "Vv", "Y" as "¥", codes and decimals split after their punctuation
+ * ("NPX- 750- 480", "38. 5"), "HZ" as "Hw"/"H2", "KVA" as "XVA".
+ */
+export function ocrFix(t) {
+  return t
+    .replace(/[¥]/g, 'Y')
+    .replace(/[‘’`]/g, "'")
+    .replace(/(\d)\s*V[vV]\b/g, '$1 V')
+    .replace(/([A-Za-z0-9])-\s+(?=[A-Za-z0-9])/g, '$1-')
+    .replace(/(\d)\.\s+(?=\d)/g, '$1.')
+    .replace(/\b(50|60)\s*H[wW2]\b/g, '$1 HZ')
+    // K read as X in KVA / KW / EKW.
+    .replace(/(\d\s*)XVA\b/g, '$1KVA')
+    .replace(/(\d\s*)E[KX][WN]\b/g, '$1EKW')
+    .replace(/(\d\s*)XW\b/g, '$1KW');
+}
+
+/** Voltages written on one line: 480Y/277V, 208/120 VAC, VOLTS: 480, 13.8 kV. */
+export function voltagesIn(s) {
+  s = s.replace(/(\d),(\d{3})\b/g, '$1$2');   // 13,800 V
+  const values = [];
+  let display = null;
+  const add = (v, shown) => {
+    if (!(v >= 100 && v <= 40000)) return;
+    if (!values.includes(v)) values.push(v);
+    if (!display) display = shown;
+  };
+  const pair = /\b(\d{3,5})\s*(Y)?\s*\/\s*(\d{3,5})\s*(?:V|VAC|VOLTS?)?\b/g;
+  let m;
+  const isLabelled = /VOLT|\bV\b|\bVAC\b|\dV\b/.test(s);
+  while ((m = pair.exec(s))) {
+    // "480/277" with no V anywhere on the line could be anything; require a voltage word or unit.
+    if (!isLabelled && !/\d\s*(?:V|VAC|VOLTS?)\b/.test(m[0])) continue;
+    add(+m[1], `${m[1]}${m[2] ? 'Y' : ''}/${m[3]} V`);
+    add(+m[3], null);
+  }
+  const single = /\b(\d{3,5})\s*(?:V|VAC|VDC|VOLTS?)\b/g;
+  while ((m = single.exec(s))) add(+m[1], `${m[1]} V`);
+  const labelled = /\bVOLT(?:S|AGE)?\b[^0-9]{0,12}(\d{3,5})\b/g;
+  while ((m = labelled.exec(s))) add(+m[1], `${m[1]} V`);
+  const kv = /\b(\d{1,2}(?:\.\d{1,2})?)\s*KV\b/g;
+  while ((m = kv.exec(s))) add(Math.round(parseFloat(m[1]) * 1000), `${m[1]} kV`);
+  return { values, display };
+}
+
+// ------------------------------------------------------------------ schedule
+
+const HEADERS = {
+  tag: /^(tag|mark|equipment tag|equip(ment)? (id|no\.?|number|tag)|asset( tag| id)?|id|unit tag)$/i,
+  type: /^(type|equipment|equipment type|description|desc|item|system)$/i,
+  manufacturer: /^(manufacturer|mfr\.?|mfg\.?|make|brand|vendor|basis of design)$/i,
+  model: /^(model|model no\.?|model number|model #|cat(alog)? no\.?|catalog number|part (no\.?|number))$/i,
+  serial: /^(serial|serial no\.?|serial number|s\/n)$/i,
+  voltage: /^(voltage|volts|v|input voltage|volts\/phase|electrical)$/i,
+  phase: /^(phase|ph|phases)$/i,
+  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,
+  mca: /^(mca|min\.? circuit amp(s|acity)?|minimum circuit ampacity)$/i,
+  mocp: /^(mocp|max\.? (fuse|breaker|ocp)( size)?|maximum overcurrent protection)$/i,
+  refrigerant: /^(refrigerant|ref\.?)$/i,
+  location: /^(location|room|area|level|space|served from|zone)$/i,
+};
+
+/** Equipment schedule from a CSV export: the header row is the first that names a tag or model column plus one more. */
+export function parseEquipmentSchedule(text) {
+  const rows = parseCsv(String(text || ''));
+  const known = r => Object.values(HEADERS).filter(re => r.some(c => re.test(c.trim()))).length;
+  const headerIdx = rows.findIndex(r => (r.some(c => HEADERS.tag.test(c.trim())) || r.some(c => HEADERS.model.test(c.trim()))) && known(r) >= 2);
+  if (headerIdx < 0) return { items: [], problems: ['No header row with a Tag or Model column was found.'] };
+  const header = rows[headerIdx].map(c => c.trim());
+  const cols = Object.fromEntries(Object.keys(HEADERS).map(k => [k, header.findIndex(h => HEADERS[k].test(h))]));
+  const items = [], problems = [];
+  rows.slice(headerIdx + 1).forEach((r, i) => {
+    const get = k => (cols[k] >= 0 ? String(r[cols[k]] ?? '').trim() : '');
+    const tag = get('tag') || (get('model') ? `Row ${headerIdx + i + 2}` : '');
+    if (!tag) return;
+    if (items.some(x => x.tag === tag)) problems.push(`Tag ${tag} appears more than once; the first row is used.`);
+    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'),
+    });
+  });
+  if (!items.length) problems.push('The header was found but no equipment rows under it.');
+  return { items, problems };
+}
+
+/** Voltages a schedule cell asks for: "480Y/277", "480V 3PH", "13.8kV". */
+export function scheduleVoltages(cell) {
+  const s = up(cell);
+  const r = voltagesIn(s);
+  if (r.values.length) return r.values;
+  return [...s.matchAll(/(?<![\d.])(\d{3,5})(?![\d.])/g)].map(m => +m[1]).filter(v => v >= 100 && v <= 40000);
+}
+
+// ------------------------------------------------------------------ matching
+
+/** Model/serial codes compared the way OCR gets them wrong: O/0, I/L/1, S/5, B/8, Z/2, punctuation and case ignored. */
+export function foldCode(s) {
+  return up(s).replace(/[^A-Z0-9]/g, '').replace(/O/g, '0').replace(/[IL]/g, '1').replace(/S/g, '5').replace(/B/g, '8').replace(/Z/g, '2');
+}
+
+export function codeSimilarity(a, b) {
+  const x = foldCode(a), y = foldCode(b);
+  if (!x || !y) return 0;
+  if (x === y) return 1;
+  // Plate models often carry option suffixes the schedule leaves off (9395P-750 vs 9395P-750-N-480).
+  const [short, long] = x.length <= y.length ? [x, y] : [y, x];
+  if (short.length >= 5 && long.startsWith(short)) return 0.92;
+  return 1 - levenshtein(x, y) / Math.max(x.length, y.length);
+}
+
+const sameMaker = (a, b) => {
+  const x = up(a).replace(/[^A-Z0-9]/g, ''), y = up(b).replace(/[^A-Z0-9]/g, '');
+  return !!x && !!y && (x.includes(y) || y.includes(x));
+};
+
+/**
+ * Schedule rows this reading could be, best first: [{ item, score, registered }].
+ * Data halls repeat, so several tags often share one model (UPS-1A, UPS-1B…):
+ * among equal scores, tags not on the register yet come first.
+ */
+export function candidatesFor(reading, items, register = []) {
+  const f = reading.fields || {};
+  const taken = new Set(register.map(r => r.tag).filter(Boolean));
+  const out = [];
+  for (const item of items) {
+    let score;
+    if (item.serial && f.serial?.value && foldCode(item.serial) === foldCode(f.serial.value)) score = 1.5;
+    else {
+      const m = item.model && f.model?.value ? codeSimilarity(item.model, f.model.value) : 0;
+      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;
+    }
+    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));
+}
+
+/** Equipment type key for free text such as a schedule's description column. */
+export function typeOf(text) {
+  const s = up(text);
+  return (EQUIPMENT_TYPES.find(([, , re]) => re.test(s)) || [null])[0];
+}
+
+/**
+ * Field-by-field check of a reading against one schedule row:
+ * [{ key, label, status: 'ok' | 'mismatch' | 'unread', expected, found }].
+ * Fields the schedule leaves blank are not checked.
+ */
+export function checkAgainst(reading, item) {
+  const f = reading.fields || {};
+  const out = [];
+  const push = (key, expected, found, ok) => out.push({
+    key, label: FIELDS.find(x => x[0] === key)?.[1] || key, expected: String(expected), found: found == null ? '' : String(found),
+    status: found == null || found === '' ? 'unread' : ok ? 'ok' : 'mismatch',
+  });
+  if (item.manufacturer) push('manufacturer', item.manufacturer, f.manufacturer?.value, sameMaker(item.manufacturer, f.manufacturer?.value));
+  if (item.model) push('model', item.model, f.model?.value, codeSimilarity(item.model, f.model?.value) >= 0.85);
+  if (item.serial) push('serial', item.serial, f.serial?.value, foldCode(item.serial) === foldCode(f.serial?.value));
+  if (item.voltage) {
+    const want = scheduleVoltages(item.voltage);
+    const have = f.voltage?.values || (f.voltage?.value ? scheduleVoltages(f.voltage.value) : []);
+    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[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.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;
+}
+
+/** 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';
+  if (checks.some(c => c.status === 'mismatch')) return 'mismatch';
+  if (checks.some(c => c.status === 'unread')) return 'partial';
+  return 'verified';
+}
+
+export const STATUS_LABELS = { verified: 'Verified', partial: 'Matched, fields unread', mismatch: 'Does not match schedule', unmatched: 'Not on schedule', missing: 'Not scanned yet' };
+
+/** Register entries that share a serial (the same plate scanned twice, or a copied serial). */
+export function duplicateSerials(register) {
+  const seen = new Map();
+  for (const r of register) {
+    const s = foldCode(r.fields?.serial?.value);
+    if (!s) continue;
+    seen.set(s, [...(seen.get(s) || []), r.id]);
+  }
+  return [...seen.values()].filter(ids => ids.length > 1);
+}
+
+/** Progress against the schedule: scanned, verified, flagged, not scanned. */
+export function registerSummary(register, items = []) {
+  const tags = new Set(register.map(r => r.tag).filter(Boolean));
+  return {
+    scanned: register.length,
+    scheduled: items.length,
+    scannedOfSchedule: items.filter(i => tags.has(i.tag)).length,
+    verified: register.filter(r => r.status === 'verified').length,
+    flagged: register.filter(r => r.status === 'mismatch').length,
+    unmatched: register.filter(r => r.status === 'unmatched').length,
+    duplicates: duplicateSerials(register).length,
+    missing: items.filter(i => !tags.has(i.tag)).map(i => i.tag),
+  };
+}
+
+/** 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 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());
+  const rows = register.map(r => {
+    const f = r.fields || {};
+    const v = k => f[k]?.value ?? '';
+    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', ' ') : ''];
+  });
+  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, '', '', '']);
+  }
+  return [head, ...rows].map(r => r.map(csvCell).join(',')).join('\n') + '\n';
+}
+
+// ------------------------------------------------------------------ sample data
+
+// Fictional maker and models: the sample shows the workflow without implying
+// any real product's ratings.
+export const SAMPLE_SCHEDULE = `Tag,Description,Manufacturer,Model,Voltage,Phase,kVA,kW,MCA,MOCP,Refrigerant,Location
+UPS-1A,Static UPS module,Northline Power Systems,NPX-750-480,480Y/277,3,750,675,,,,Electrical Room 1A
+UPS-1B,Static UPS module,Northline Power Systems,NPX-750-480,480Y/277,3,750,675,,,,Electrical Room 1B
+UPS-2A,Static UPS module,Northline Power Systems,NPX-750-480,480Y/277,3,750,675,,,,Electrical Room 2A
+UPS-2B,Static UPS module,Northline Power Systems,NPX-750-480,480Y/277,3,750,675,,,,Electrical Room 2B
+PDU-1-01,Power distribution unit,Northline Power Systems,NPD-300-415,480 / 415Y/240,3,300,,,,,Data Hall 1
+PDU-1-02,Power distribution unit,Northline Power Systems,NPD-300-415,480 / 415Y/240,3,300,,,,,Data Hall 1
+GEN-01,Diesel generator,Harbor Engine Works,HG-3000,13800,3,3750,3000,,,,Generator Yard
+GEN-02,Diesel generator,Harbor Engine Works,HG-3000,13800,3,3750,3000,,,,Generator Yard
+CRAH-1-01,Computer room air handler,Coldline Systems,CW-150-480,480,3,,,45,60,,Data Hall 1
+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. */
+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'],
+];
+
+// ------------------------------------------------------------------ helpers
+
+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()); }
+function csvCell(v) { const s = String(v ?? ''); return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s; }
+
+export function levenshtein(a, b) {
+  const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let diag = prev[0];
+    prev[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const tmp = prev[j];
+      prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, diag + (a[i - 1] === b[j - 1] ? 0 : 1));
+      diag = tmp;
+    }
+  }
+  return prev[b.length];
+}

sample_plates.json

@@ -0,0 +1,34 @@
+{
+  "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.",
+  "plates": [
+    {
+      "id": "ups-match",
+      "expect_tag": "UPS-1A",
+      "lines": [
+        "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"
+      ]
+    },
+    {
+      "id": "ups-wrong-voltage",
+      "expect_tag": "UPS-1A",
+      "expect_mismatch": ["model", "voltage"],
+      "lines": [
+        "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"
+      ]
+    }
+  ]
+}

sample_schedule.csv

@@ -0,0 +1,11 @@
+Tag,Description,Manufacturer,Model,Voltage,Phase,kVA,kW,MCA,MOCP,Refrigerant,Location
+UPS-1A,Static UPS module,Northline Power Systems,NPX-750-480,480Y/277,3,750,675,,,,Electrical Room 1A
+UPS-1B,Static UPS module,Northline Power Systems,NPX-750-480,480Y/277,3,750,675,,,,Electrical Room 1B
+UPS-2A,Static UPS module,Northline Power Systems,NPX-750-480,480Y/277,3,750,675,,,,Electrical Room 2A
+UPS-2B,Static UPS module,Northline Power Systems,NPX-750-480,480Y/277,3,750,675,,,,Electrical Room 2B
+PDU-1-01,Power distribution unit,Northline Power Systems,NPD-300-415,480 / 415Y/240,3,300,,,,,Data Hall 1
+PDU-1-02,Power distribution unit,Northline Power Systems,NPD-300-415,480 / 415Y/240,3,300,,,,,Data Hall 1
+GEN-01,Diesel generator,Harbor Engine Works,HG-3000,13800,3,3750,3000,,,,Generator Yard
+GEN-02,Diesel generator,Harbor Engine Works,HG-3000,13800,3,3750,3000,,,,Generator Yard
+CRAH-1-01,Computer room air handler,Coldline Systems,CW-150-480,480,3,,,45,60,,Data Hall 1
+CH-01,Air-cooled chiller,Coldline Systems,AC-1200,460,3,,,612,800,R-513A,Roof

schedule-import.js

@@ -0,0 +1,195 @@
+// Schedule import for Progress mode: planned dates from the project schedule
+// instead of typed in area by area — the link Buildots makes between what the
+// camera saw and the programme (P6 / MS Project). Reads a CSV export (P6,
+// MS Project, Smartsheet and Excel all export one) or an MS Project XML file,
+// then matches each activity to the app's areas and trades by name:
+//
+//   "L3 Unit 3B – hang drywall"   → area "L3 Unit 3B", trade Walls
+//   "Level 4 ceiling grid"        → every area on floor L4, trade Ceiling
+//   "L3 Unit 3B fit-out"          → area "L3 Unit 3B", the area's own window
+//
+// Nothing is applied until the user has seen what matched and what did not.
+// Pure functions (tests/schedule-import.test.mjs).
+import { floorOf } from './progress-project.js';
+
+const MONTHS = { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 };
+
+/**
+ * Schedule dates as local noon (the app stores capture dates the same way).
+ * ISO 2026-09-01 (optionally with a time), US 9/1/2026 or 09/01/26, P6 01-Sep-26 / 01-Sep-2026, "Sep 1, 2026".
+ * A trailing "A" (P6 actual) or "*" (constraint) is ignored.
+ */
+export function parseScheduleDate(raw) {
+  const s = String(raw ?? '').trim().replace(/\s*[A*]$/, '');
+  if (!s) return null;
+  let m = s.match(/^(\d{4})-(\d{1,2})-(\d{1,2})/);
+  if (m) return new Date(+m[1], +m[2] - 1, +m[3], 12).getTime();
+  m = s.match(/^(\d{1,2})\/(\d{1,2})\/(\d{2,4})/);
+  if (m) return new Date(+m[3] < 100 ? 2000 + +m[3] : +m[3], +m[1] - 1, +m[2], 12).getTime();
+  m = s.match(/^(\d{1,2})[- ]([A-Za-z]{3})[a-z]*[- ,]+(\d{2,4})/);
+  if (m && MONTHS[m[2].toLowerCase()] != null) return new Date(+m[3] < 100 ? 2000 + +m[3] : +m[3], MONTHS[m[2].toLowerCase()], +m[1], 12).getTime();
+  m = s.match(/^([A-Za-z]{3})[a-z]*\.? (\d{1,2}),? (\d{4})/);
+  if (m && MONTHS[m[1].toLowerCase()] != null) return new Date(+m[3], MONTHS[m[1].toLowerCase()], +m[2], 12).getTime();
+  return null;
+}
+
+/** RFC-4180-ish CSV: quoted fields, doubled quotes, commas/newlines inside quotes; also tab-separated. */
+export function parseCsv(text) {
+  const delim = (text.split('\n')[0].match(/\t/g) || []).length > (text.split('\n')[0].match(/,/g) || []).length ? '\t' : ',';
+  const rows = [];
+  let row = [], field = '', q = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (q) {
+      if (ch === '"' && text[i + 1] === '"') { field += '"'; i++; }
+      else if (ch === '"') q = false;
+      else field += ch;
+    } else if (ch === '"') q = true;
+    else if (ch === delim) { row.push(field); field = ''; }
+    else if (ch === '\n' || ch === '\r') {
+      if (ch === '\r' && text[i + 1] === '\n') i++;
+      row.push(field); field = '';
+      if (row.some(c => c.trim())) rows.push(row);
+      row = [];
+    } else field += ch;
+  }
+  row.push(field);
+  if (row.some(c => c.trim())) rows.push(row);
+  return rows;
+}
+
+const HEADERS = {
+  name: /^(activity|task|activity name|task name|name|description|activity description)$/i,
+  start: /^(start|start date|planned start|early start|baseline start|bl start)$/i,
+  finish: /^(finish|finish date|end|end date|planned finish|early finish|baseline finish|bl finish)$/i,
+  area: /^(area|location|zone|room|space|wbs name)$/i,
+  trade: /^(trade|discipline|activity code|responsibility)$/i,
+};
+
+/** Activities from a CSV export: finds the header row (first row naming a start and a finish column). */
+export function parseScheduleCsv(text) {
+  const rows = parseCsv(text);
+  const headerIdx = rows.findIndex(r => r.some(c => HEADERS.start.test(c.trim())) && r.some(c => HEADERS.finish.test(c.trim())));
+  if (headerIdx < 0) return { activities: [], problems: ['No header row with a start and a finish column was found.'] };
+  const header = rows[headerIdx].map(c => c.trim());
+  const col = key => header.findIndex(h => HEADERS[key].test(h));
+  const cols = { name: col('name'), start: col('start'), finish: col('finish'), area: col('area'), trade: col('trade') };
+  if (cols.name < 0) cols.name = header.findIndex((h, i) => i !== cols.start && i !== cols.finish && h);
+  const activities = [], problems = [];
+  rows.slice(headerIdx + 1).forEach((r, i) => {
+    const name = (r[cols.name] || '').trim();
+    const start = parseScheduleDate(r[cols.start]), finish = parseScheduleDate(r[cols.finish]);
+    if (!name) return;
+    if (start == null || finish == null) { problems.push(`Row ${headerIdx + i + 2} (${name}): unreadable dates`); return; }
+    activities.push({ name, start: Math.min(start, finish), finish: Math.max(start, finish),
+      area: cols.area >= 0 ? (r[cols.area] || '').trim() || null : null, trade: cols.trade >= 0 ? (r[cols.trade] || '').trim() || null : null });
+  });
+  return { activities, problems };
+}
+
+const xmlText = s => s.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, '&');
+
+/** Activities from an MS Project XML export (File → Save As → XML). Summary tasks are skipped. */
+export function parseMsProjectXml(text) {
+  const activities = [], problems = [];
+  for (const block of text.match(/<Task>[\s\S]*?<\/Task>/g) || []) {
+    const get = tag => { const m = block.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`)); return m ? xmlText(m[1]).trim() : null; };
+    if (get('Summary') === '1' || get('IsNull') === '1') continue;
+    const name = get('Name');
+    if (!name) continue;
+    const start = parseScheduleDate(get('Start')), finish = parseScheduleDate(get('Finish'));
+    if (start == null || finish == null) { problems.push(`${name}: unreadable dates`); continue; }
+    activities.push({ name, start, finish, area: null, trade: null });
+  }
+  return { activities, problems };
+}
+
+export function parseSchedule(text, fileName = '') {
+  return /\.xml$/i.test(fileName) || /^\s*<\?xml|<Project[\s>]/.test(text) ? parseMsProjectXml(text) : parseScheduleCsv(text);
+}
+
+// Trade keywords → Progress mode's item keys. Order matters: "ceiling grid" is Ceiling, not Walls.
+const TRADES = [
+  ['ceiling', /\b(ceiling|ceilings|act|acoustic|grid|soffit|bulkhead)\b/i],
+  ['exits', /\bexit\b/i],
+  ['supply', /\b(diffuser|diffusers|supply air)\b/i],
+  ['returns', /\b(return|returns|grille|grilles)\b/i],
+  ['fixtures', /\b(light|lights|lighting|fixture|fixtures|luminaire|luminaires)\b/i],
+  ['wall', /\b(drywall|gypsum|gyp|plasterboard|sheetrock|board|partition|partitions|stud|studs|framing|frame|tape|taping|mud|finish walls|wall|walls|paint|painting)\b/i],
+];
+export function tradeOf(text) {
+  for (const [key, re] of TRADES) if (re.test(text || '')) return key;
+  return null;
+}
+
+const norm = s => String(s || '').toLowerCase().replace(/[·•|_]+/g, ' ').replace(/[-–—]+/g, ' ').replace(/\s+/g, ' ').trim();
+
+/** A floor named in an activity ("Level 4 …", "L4 …", "4th floor …") in the same keys floorOf gives areas. */
+function floorInText(text) {
+  const s = String(text || '');
+  let m = s.match(/\b(?:l|lvl|level|fl|floor)\s*-?\s*0*(\d+)\b/i) || s.match(/\b0*(\d+)(?:st|nd|rd|th)?\s*(?:f|fl|floor)\b/i);
+  if (m) return `L${Number(m[1])}`;
+  m = s.match(/\b(?:b|basement)\s*-?\s*0*(\d+)\b/i);
+  return m ? `B${Number(m[1])}` : null;
+}
+
+/**
+ * Match activities to areas and trades. An activity names an area when the
+ * area's name appears in it (longest name wins, so "L3 Unit 3B" beats "L3");
+ * otherwise, if it names a floor, it applies to every area on that floor that
+ * has no activity of its own for that trade. Returns per-area windows and
+ * per-trade windows (earliest start → latest finish across matching activities)
+ * plus what could not be placed.
+ */
+export function matchSchedule(activities, areaNames) {
+  const areas = [...areaNames].sort((a, b) => norm(b).length - norm(a).length);
+  const plan = {}, unmatched = [], used = [];
+  const widen = (w, a) => ({ start: Math.min(w?.start ?? Infinity, a.start), finish: Math.max(w?.finish ?? -Infinity, a.finish) });
+  const direct = new Set();   // "area|trade" set by an activity naming the area itself
+  const floorActs = [];
+  for (const act of activities) {
+    const hay = norm(`${act.area || ''} ${act.name}`);
+    const area = areas.find(n => norm(n) && (norm(act.area) === norm(n) || hay.includes(norm(n))));
+    const trade = tradeOf(act.trade) || tradeOf(act.name);
+    if (area) {
+      const p = (plan[area] ||= { window: null, trades: {}, activities: [] });
+      if (trade) { p.trades[trade] = widen(p.trades[trade], act); direct.add(`${area}|${trade}`); }
+      else p.window = widen(p.window, act);
+      p.activities.push(act.name);
+      used.push(act);
+    } else if (floorInText(act.area || act.name)) floorActs.push({ act, floor: floorInText(act.area || act.name), trade });
+    else unmatched.push(act.name);
+  }
+  for (const { act, floor, trade } of floorActs) {
+    const onFloor = areaNames.filter(n => floorOf(n) === floor);
+    if (!onFloor.length) { unmatched.push(act.name); continue; }
+    for (const area of onFloor) {
+      const p = (plan[area] ||= { window: null, trades: {}, activities: [] });
+      if (trade) { if (direct.has(`${area}|${trade}`)) continue; p.trades[trade] = widen(p.trades[trade], act); }
+      else if (!p.window) p.window = { start: act.start, finish: act.finish };
+      p.activities.push(`${act.name} (floor ${floor})`);
+    }
+    used.push(act);
+  }
+  // An area whose schedule only names trades gets a window spanning them —
+  // marked as derived, so applying it never replaces dates the area already has.
+  for (const p of Object.values(plan)) {
+    if (!p.window && Object.keys(p.trades).length) {
+      p.window = Object.values(p.trades).reduce((w, t) => ({ start: Math.min(w.start, t.start), finish: Math.max(w.finish, t.finish) }), { start: Infinity, finish: -Infinity });
+      p.derivedWindow = true;
+    }
+  }
+  return { plan, unmatched, matched: used.length };
+}
+
+/** Write a match into a Progress store (mutates and returns it). Imported dates replace typed ones for matched areas only. */
+export function applySchedule(store, plan) {
+  for (const [area, p] of Object.entries(plan)) {
+    const rec = (store.areas[area] ||= { captures: [] });
+    const hasOwn = Number.isFinite(rec.schedule?.start) && Number.isFinite(rec.schedule?.finish);
+    const setWindow = p.window && !(p.derivedWindow && hasOwn);
+    rec.schedule = { ...(rec.schedule || {}), ...(setWindow ? { start: p.window.start, finish: p.window.finish } : {}),
+      trades: { ...(rec.schedule?.trades || {}), ...p.trades } };
+  }
+  return store;
+}

tests/nameplate-model.test.mjs

@@ -0,0 +1,146 @@
+// Nameplate parsing, schedule matching and the register CSV (pure functions).
+// Run: npm test
+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,
+} from '../nameplate-model.js';
+
+const plate = lines => parseNameplate(lines.join('\n'));
+const val = (r, k) => r.fields[k]?.value;
+const schedule = parseEquipmentSchedule(SAMPLE_SCHEDULE).items;
+
+test('a UPS plate reads into every field', () => {
+  const r = plate(SAMPLE_PLATES[0]);
+  assert.equal(r.type, 'ups');
+  assert.equal(val(r, 'manufacturer'), 'Northline Power Systems');
+  assert.equal(val(r, 'model'), 'NPX-750-480');
+  assert.equal(val(r, 'serial'), 'NL26A01937');
+  assert.equal(val(r, 'voltage'), '480Y/277 V');
+  assert.deepEqual(r.fields.voltage.values, [480, 277]);
+  assert.equal(val(r, 'phase'), 3);
+  assert.equal(val(r, 'hz'), 60);
+  assert.equal(val(r, 'kva'), 750);
+  assert.equal(val(r, 'kw'), 675);
+  assert.equal(val(r, 'amps'), 1002);
+  assert.equal(val(r, 'mfgDate'), '03/2026');
+});
+
+test('real-world plate wording: S/N, CAT. NO., kV, thousands separators, known makers', () => {
+  const gen = plate(['CATERPILLAR', 'GENERATOR SET', 'CAT. NO. 3516C-HD', 'S/N: ZBA00412', '13.8 KV 3 PHASE 60 HZ', '3,750 KVA 3000 EKW', 'FLA 1,569']);
+  assert.equal(gen.type, 'generator');
+  assert.equal(val(gen, 'manufacturer'), 'Caterpillar');
+  assert.equal(val(gen, 'model'), '3516C-HD');
+  assert.equal(val(gen, 'serial'), 'ZBA00412');
+  assert.deepEqual(gen.fields.voltage.values, [13800]);
+  assert.equal(val(gen, 'kva'), 3750);
+  assert.equal(val(gen, 'kw'), 3000);
+  assert.equal(val(gen, 'amps'), 1569);
+
+  const ch = plate(['AIR-COOLED CHILLER', 'MODEL: AC-1200', 'REFRIGERANT R-513A CHARGE 410 LBS', '460V 3PH 60HZ', 'MCA 612 MOCP 800']);
+  assert.equal(ch.type, 'chiller');
+  assert.equal(val(ch, 'refrigerant'), 'R-513A');
+  assert.equal(val(ch, 'mca'), 612);
+  assert.equal(val(ch, 'mocp'), 800);
+  assert.equal(val(ch, 'amps'), undefined, 'R-513A and a charge weight are not amps');
+});
+
+test('voltages: transformer pairs, labelled values, and numbers that are not voltages', () => {
+  assert.deepEqual(voltagesIn('PRI 13,800 V DELTA SEC 480Y/277 V').values, [480, 277, 13800]);
+  assert.deepEqual(voltagesIn('VOLTS: 208').values, [208]);
+  assert.deepEqual(voltagesIn('DWG 480/277 REV 2').values, [], 'a bare pair with no voltage word or unit');
+  assert.deepEqual(scheduleVoltages('480 / 415Y/240'), [480, 415, 240]);
+  assert.deepEqual(scheduleVoltages('13.8kV'), [13800]);
+});
+
+test('"New York" in an address is not the maker York; unknown makers come from a company line', () => {
+  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');
+});
+
+test('codes compare the way OCR misreads them', () => {
+  assert.equal(foldCode('NPX-75O-48O'), foldCode('NPX750480'));
+  assert.equal(codeSimilarity('NL26A0I937', 'NL26A01937'), 1);
+  assert.ok(codeSimilarity('9395P-750', '9395P-750-N-480') >= 0.9, 'option suffix on the plate');
+  assert.ok(codeSimilarity('NPX-750-415', 'NPX-750-480') < 0.85, 'a different voltage variant is not the same model');
+});
+
+test('schedule CSV: header row found below title rows, duplicate tags reported', () => {
+  const { items, problems } = parseEquipmentSchedule('Data Hall 1 equipment schedule\n\nMark,Equipment,Mfr,Model No.,Volts,kVA\nUPS-1A,UPS,Eaton,9395XR,480,750\nUPS-1A,UPS,Eaton,9395XR,480,750\n');
+  assert.equal(items.length, 1);
+  assert.equal(items[0].manufacturer, 'Eaton');
+  assert.equal(items[0].kva, 750);
+  assert.match(problems[0], /UPS-1A appears more than once/);
+  assert.match(parseEquipmentSchedule('a,b\n1,2').problems[0], /No header row/);
+});
+
+test('identical units: the first unscanned tag is offered first', () => {
+  const r = plate(SAMPLE_PLATES[0]);
+  const first = candidatesFor(r, schedule);
+  assert.deepEqual(first.slice(0, 4).map(c => c.item.tag), ['UPS-1A', 'UPS-1B', 'UPS-2A', 'UPS-2B']);
+  const next = candidatesFor(r, schedule, [{ tag: 'UPS-1A' }]);
+  assert.equal(next[0].item.tag, 'UPS-1B');
+  assert.equal(next.find(c => c.item.tag === 'UPS-1A').registered, true);
+  assert.ok(!first.some(c => c.item.tag.startsWith('GEN')), 'a generator is not a candidate for a UPS plate');
+});
+
+test('a serial on the schedule decides the match outright', () => {
+  const items = parseEquipmentSchedule('Tag,Model,Serial\nUPS-1A,NPX-750-480,NL26A00001\nUPS-1B,NPX-750-480,NL26A01937\n').items;
+  assert.equal(candidatesFor(plate(SAMPLE_PLATES[0]), items)[0].item.tag, 'UPS-1B');
+});
+
+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);
+  assert.ok(good.every(c => c.status === 'ok'), JSON.stringify(good));
+  assert.equal(statusOf(good, 'UPS-1A'), 'verified');
+
+  const bad = checkAgainst(plate(SAMPLE_PLATES[1]), ups1a);
+  assert.deepEqual(bad.filter(c => c.status === 'mismatch').map(c => c.key), ['model', 'voltage']);
+  assert.equal(statusOf(bad, 'UPS-1A'), 'mismatch');
+
+  const unread = checkAgainst(parseNameplate('MODEL NPX-750-480'), ups1a);
+  assert.equal(statusOf(unread, 'UPS-1A'), 'partial');
+  assert.equal(statusOf([], ''), 'unmatched');
+});
+
+test('register: summary, duplicate serials, and a CSV that lists what is still unscanned', () => {
+  const a = plate(SAMPLE_PLATES[0]);
+  const ups1a = schedule.find(i => i.tag === 'UPS-1A');
+  const reg = [
+    { id: 'a', tag: 'UPS-1A', type: 'ups', fields: a.fields, checks: checkAgainst(a, ups1a), status: 'verified', scannedAt: Date.UTC(2026, 9, 2, 14, 30) },
+    { id: 'b', tag: '', type: 'ups', fields: a.fields, checks: [], status: 'unmatched', scannedAt: Date.UTC(2026, 9, 2, 14, 35) },
+  ];
+  assert.deepEqual(duplicateSerials(reg), [['a', 'b']]);
+  const s = registerSummary(reg, schedule);
+  assert.equal(s.scannedOfSchedule, 1);
+  assert.equal(s.verified, 1);
+  assert.equal(s.unmatched, 1);
+  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[3], /^UPS-1B,Not scanned yet,/);
+});
+
+test('OCR misreads seen on real lettering are undone before parsing', () => {
+  const r = parseNameplate(['MODEL NO: NPX- 750- 480', '480¥/277 VAC 3 PH 60 Hw', '460 Vv', '750 XVA / 675 XW', 'FLA 38. 5'].join('\n'));
+  assert.equal(r.fields.model.value, 'NPX-750-480');
+  assert.deepEqual(r.fields.voltage.values, [480, 277, 460]);
+  assert.equal(r.fields.hz.value, 60);
+  assert.equal(r.fields.kva.value, 750);
+  assert.equal(r.fields.kw.value, 675);
+  assert.equal(r.fields.amps.value, 38.5);
+});
+
+test('MCA and MOCP are checked when the schedule lists them; near-zero-confidence lines are ignored', () => {
+  const ch = schedule.find(i => i.tag === 'CH-01');
+  assert.equal(ch.mca, 612);
+  const r = parseNameplate([{ text: 'MODEL AC-1200', confidence: 90 }, { text: '460 V 3 PH', confidence: 88 }, { text: 'MCA 612 MOCP 700', confidence: 85 },
+    { text: 'REFRIGERANT R-513A', confidence: 90 }, { text: 'MODEL ZZ-9 480 V', confidence: 8 }]);
+  assert.equal(r.fields.model.value, 'AC-1200', 'the 8% line is texture, not a second model');
+  const checks = checkAgainst(r, ch);
+  assert.deepEqual(checks.filter(c => c.status === 'mismatch').map(c => c.key), ['mocp']);
+});

tests/nameplates-bench.mjs

@@ -0,0 +1,129 @@
+// Nameplate OCR benchmark: drawn plates of six 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
+// scored field by field against the plate text. Not part of `npm test` (it
+// takes minutes); run when changing OCR or parsing:
+//
+//   PW_CHANNEL=chrome node tests/nameplates-bench.mjs [--only=glare,blur] [--json=out.json]
+//
+// Plates use fictional makers. The truth for each plate is parseNameplate()
+// of its clean text, so this measures what OCR loses, not parser coverage
+// (tests/nameplate-model.test.mjs covers that).
+import { createServer } from 'vite';
+import { chromium } from 'playwright';
+import { writeFileSync } from 'node:fs';
+import { parseNameplate, foldCode } from '../nameplate-model.js';
+
+export const BENCH_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'],
+  ['HARBOR ENGINE WORKS INC', 'DIESEL GENERATOR SET', 'MODEL: HG-3000-MV', 'S/N: HEW0098812',
+    '13.8 KV  3 PHASE  60 HZ', '3750 KVA  3000 EKW  0.8 PF', 'RATED CURRENT 157 A', 'BUILD DATE 2026-01'],
+  ['COLDLINE SYSTEMS', 'AIR-COOLED CHILLER', 'MODEL NO. AC-1200-R5', 'SERIAL NO. CL5517320',
+    '460 V  3 PH  60 HZ', 'REFRIGERANT R-513A', 'MCA 612  MOCP 800', 'MFG DATE 11/2025'],
+  ['VOLTARC TRANSFORMER CORP', 'DRY TYPE TRANSFORMER', 'CAT. NO. VT-2500-HV', 'SERIAL VT2511047',
+    'PRIMARY 13800 V DELTA', 'SECONDARY 480Y/277 V', '2500 KVA  3 PH  60 HZ', 'MFG DATE 08/2025'],
+  ['NORTHLINE POWER SYSTEMS', 'POWER DISTRIBUTION UNIT', 'MODEL NO: NPD-300-415', 'SERIAL NO: NL26B00411',
+    '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'],
+];
+
+// Each degradation runs in the page against a canvas holding the clean plate.
+export const DEGRADATIONS = {
+  clean: '',
+  small: 'c = resize(c, 640);',
+  blur: "c = filt(c, 'blur(2.2px)');",
+  noise: 'c = noise(c, 28);',
+  lowContrast: 'c = contrast(c, 0.28);',
+  glare: 'c = glare(c, 0.8);',
+  tilt: 'c = rotate(c, 7);',
+  keystone: 'c = keystone(c, 0.3);',
+  darkPlate: "c = filt(c, 'invert(1)');",
+  jpeg: 'c = await jpeg(resize(c, 900), 0.3);',
+  inScene: 'c = scene(c);',
+  sideways: 'c = rotate(c, 90);',
+  phone: "c = await jpeg(noise(glare(filt(rotate(scene(c), 4), 'blur(1.4px)'), 0.55), 14), 0.6);",
+};
+
+const HELPERS = `
+  const mk = (w, h) => { const c = document.createElement('canvas'); c.width = w; c.height = h; return c; };
+  const resize = (s, w) => { const c = mk(w, Math.round(s.height * w / s.width)); c.getContext('2d').drawImage(s, 0, 0, c.width, c.height); return c; };
+  const filt = (s, f) => { const c = mk(s.width, s.height); const g = c.getContext('2d'); g.filter = f; g.drawImage(s, 0, 0); return c; };
+  let seed = 7; const rnd = () => ((seed = (seed * 16807) % 2147483647) / 2147483647);
+  const gauss = () => Math.sqrt(-2 * Math.log(rnd() + 1e-9)) * Math.cos(2 * Math.PI * rnd());
+  const pixels = (s, fn) => { const c = mk(s.width, s.height); const g = c.getContext('2d'); g.drawImage(s, 0, 0);
+    const im = g.getImageData(0, 0, c.width, c.height); fn(im.data, c.width, c.height); g.putImageData(im, 0, 0); return c; };
+  const noise = (s, sd) => pixels(s, d => { for (let i = 0; i < d.length; i += 4) { const n = gauss() * sd; d[i] += n; d[i + 1] += n; d[i + 2] += n; } });
+  const contrast = (s, k) => pixels(s, d => { for (let i = 0; i < d.length; i += 4) for (let j = 0; j < 3; j++) d[i + j] = 150 + (d[i + j] - 150) * k; });
+  const glare = (s, a) => { const c = filt(s, 'none'); const g = c.getContext('2d');
+    const r = g.createRadialGradient(c.width * 0.62, c.height * 0.45, 0, c.width * 0.62, c.height * 0.45, c.width * 0.33);
+    r.addColorStop(0, 'rgba(255,255,250,' + a + ')'); r.addColorStop(1, 'rgba(255,255,250,0)'); g.fillStyle = r; g.fillRect(0, 0, c.width, c.height); return c; };
+  const rotate = (s, deg) => { const t = deg * Math.PI / 180, w = Math.abs(s.width * Math.cos(t)) + Math.abs(s.height * Math.sin(t)), h = Math.abs(s.width * Math.sin(t)) + Math.abs(s.height * Math.cos(t));
+    const c = mk(Math.round(w), Math.round(h)); const g = c.getContext('2d'); g.fillStyle = '#4b5057'; g.fillRect(0, 0, c.width, c.height);
+    g.translate(w / 2, h / 2); g.rotate(t); g.drawImage(s, -s.width / 2, -s.height / 2); return c; };
+  const keystone = (s, k) => { const c = mk(s.width, s.height); const g = c.getContext('2d'); g.fillStyle = '#4b5057'; g.fillRect(0, 0, c.width, c.height);
+    for (let y = 0; y < s.height; y++) { const z = 1 - k * (1 - y / s.height); const w = s.width * z; g.drawImage(s, 0, y, s.width, 1, (s.width - w) / 2, y, w, 1); } return c; };
+  const jpeg = async (s, q) => { const img = new Image(); img.src = s.toDataURL('image/jpeg', q); await img.decode(); const c = mk(s.width, s.height); c.getContext('2d').drawImage(img, 0, 0); return c; };
+  const scene = s => { const c = mk(2400, 1800); const g = c.getContext('2d');
+    g.fillStyle = '#7d8a83'; g.fillRect(0, 0, c.width, c.height);                     // cabinet paint
+    g.fillStyle = '#6c7871'; for (let x = 0; x < c.width; x += 300) g.fillRect(x, 0, 8, c.height);   // panel seams
+    g.fillStyle = '#f2c200'; g.fillRect(1650, 1280, 560, 300); g.fillStyle = '#111'; g.font = 'bold 54px Arial';
+    g.fillText('DANGER', 1800, 1370); g.font = 'bold 34px Arial'; g.fillText('HIGH VOLTAGE 480 V', 1700, 1450); g.fillText('ARC FLASH HAZARD', 1720, 1510);
+    g.drawImage(s, 360, 260, 1260, Math.round(1260 * s.height / s.width)); return c; };
+`;
+
+const score = (truth, got) => {
+  const keys = Object.keys(truth.fields);
+  const ok = keys.filter(k => {
+    const a = truth.fields[k].value, b = got.fields?.[k]?.value;
+    if (b == null) return false;
+    return ['model', 'serial'].includes(k) ? foldCode(a) === foldCode(b) : String(a).toUpperCase() === String(b).toUpperCase();
+  });
+  return { ok: ok.length, total: keys.length, missed: keys.filter(k => !ok.includes(k)) };
+};
+
+async function main() {
+  const args = Object.fromEntries(process.argv.slice(2).map(a => a.replace(/^--/, '').split('=')));
+  const only = args.only ? args.only.split(',') : Object.keys(DEGRADATIONS);
+  const server = await createServer({ server: { port: 0, host: '127.0.0.1' }, logLevel: 'error' });
+  await server.listen();
+  const browser = await chromium.launch(process.env.PW_CHANNEL ? { channel: process.env.PW_CHANNEL } : {});
+  const page = await (await browser.newContext({ viewport: { width: 1280, height: 900 } })).newPage();
+  page.on('pageerror', e => console.error('pageerror', e.message));
+  await page.goto(server.resolvedUrls.local[0] + 'nameplates.html');
+  await page.evaluate(() => window.__nameplates.getWorker());
+
+  const results = {};
+  let sumOk = 0, sumTotal = 0, sumMs = 0, runs = 0;
+  for (const name of only) {
+    let ok = 0, total = 0, ms = 0;
+    const misses = {};
+    for (const [i, lines] of BENCH_PLATES.entries()) {
+      const truth = parseNameplate(lines.join('\n'));
+      const out = await page.evaluate(`(async () => {
+        ${HELPERS}
+        let c = window.__nameplates.samplePlate(${JSON.stringify(lines)});
+        ${DEGRADATIONS[name]}
+        c = window.__nameplates.fitForOcr(c, c.width, c.height);
+        const t0 = performance.now();
+        const r = await window.__nameplates.ocrImage(c);
+        return { fields: Object.fromEntries(Object.entries(r.fields).map(([k, f]) => [k, { value: f.value }])), ms: performance.now() - t0 };
+      })()`);
+      const s = score(truth, out);
+      ok += s.ok; total += s.total; ms += out.ms;
+      for (const k of s.missed) misses[k] = (misses[k] || 0) + 1;
+      if (args.verbose && s.missed.length) console.log(`  ${name} #${i}: missed ${s.missed.map(k => `${k}=${JSON.stringify(out.fields[k]?.value ?? null)} (want ${JSON.stringify(truth.fields[k].value)})`).join(', ')}`);
+    }
+    results[name] = { acc: ok / total, ok, total, msPerPlate: Math.round(ms / BENCH_PLATES.length), misses };
+    sumOk += ok; sumTotal += total; sumMs += ms; runs += BENCH_PLATES.length;
+    console.log(`${name.padEnd(12)} ${(100 * ok / total).toFixed(1).padStart(5)}%  ${String(Math.round(ms / BENCH_PLATES.length)).padStart(5)} ms/plate  missed: ${Object.entries(misses).map(([k, n]) => `${k}×${n}`).join(' ') || '—'}`);
+  }
+  console.log(`${'OVERALL'.padEnd(12)} ${(100 * sumOk / sumTotal).toFixed(1).padStart(5)}%  ${String(Math.round(sumMs / runs)).padStart(5)} ms/plate`);
+  if (args.json) writeFileSync(args.json, JSON.stringify({ overall: sumOk / sumTotal, msPerPlate: sumMs / runs, results }, null, 2));
+  await browser.close();
+  await server.close();
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main();