Data Centre Construction: rebrand + frontier-construction-AI positioning

README.md

@@ -1,5 +1,5 @@
 ---
-title: Data Centre Nameplates
+title: Data Centre Construction
 emoji: 🔌
 colorFrom: blue
 colorTo: indigo
@@ -9,14 +9,17 @@ license: apache-2.0
 short_description: Nameplate OCR checked against the equipment schedule
 ---
 
-# Data Centre Nameplates
+# Data Centre Construction
+
+> **Constructelligence is developing frontier construction-AI models.** This demo is the *lite*, open tier
+> of the Data Centre Construction kit (see [constructelligence.co](https://constructelligence.co)).
 
 **Read an equipment nameplate and know if it is the unit the schedule asked for.**
 
-Photograph the nameplate of a UPS, PDU, switchgear, generator, transformer, busway, battery, CRAH or chiller. This
-runs OCR in your browser, pulls out 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.
+Photograph the nameplate of a UPS, PDU, switchgear, generator, transformer, busway, battery, CRAH, chiller — or a
+**server rack**. This runs OCR in your browser, pulls out **31 plate fields** across **55 data-centre equipment
+types**, 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.
 
 Nothing is uploaded: the photo and the schedule stay on your device.
 
@@ -26,12 +29,18 @@ Nothing is uploaded: the photo and the schedule stay on your device.
 2. Drop a nameplate photo (or click **Try a sample nameplate**).
 3. Click **Read nameplate** and check the verdict, field by field, against the plate.
 
+Sample plates include a matching UPS, a wrong-voltage UPS, a switchboard, a server and a rack PDU.
+
 ## How it works
 
+- **Photo check** — a quick blur/glare/darkness/resolution read warns before you rely on a bad shot.
 - **OCR** — `tesseract.js@5` (English LSTM), loaded from a CDN, plus an error model for the way OCR misreads plate
   lettering (serifed `V`→`Vv`, `K`→`X` in `KVA`, `HZ`→`Hw`, codes split after their punctuation).
-- **Extraction** — labelled-field parsing of `MODEL`, `S/N`, `MVA`, `MCA`, `MOCP`, `FLA`, `VOLTS`, `REFRIGERANT`,
-  `MFG DATE`, with voltages read as `480Y/277`, `13.8 kV` or `208/120`.
+- **Extraction** — labelled-field parsing with numeric range guards, grouped into Identification, Electrical,
+  Cooling, Server racks/IT and Mechanical. Fields include voltage, phase, Hz, kVA, kW, amps, power factor, MCA,
+  MOCP, SCCR, enclosure, listings, battery type/Ah/cells, refrigerant, charge, cooling tons, BTU/h, CFM, GPM,
+  rack U, power W, PDU outlets, ports, speed and weight.
+- **Typing** — 55 equipment families, device wording ranked above its family (server racks included).
 - **Matching** — model and serial codes compared with `O/0`, `I/L/1`, `S/5`, `B/8`, `Z/2` folded, so a misread is
   not a false mismatch while a genuine voltage variant still fails.
 

index.html

@@ -3,8 +3,8 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Data Centre Nameplates — read &amp; verify equipment nameplates</title>
-    <meta name="description" content="Photograph an equipment nameplate and read it in your browser: model, serial, voltage and rating checked against your equipment schedule, with an asset register CSV. Nothing is uploaded." />
+    <title>Data Centre Construction — read &amp; verify equipment nameplates</title>
+    <meta name="description" content="Photograph an equipment nameplate and read it in your browser: model, serial, voltage and ratings checked against your equipment schedule, with an asset register CSV. Covers UPS, PDU, switchgear, generators, transformers, battery, cooling towers, chillers, CRAH, CDUs, pumps and more. Nothing is uploaded." />
     <meta name="robots" content="index, follow" />
     <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22><rect width=%2224%22 height=%2224%22 rx=%225%22 fill=%22%230f2547%22/><rect x=%225%22 y=%227%22 width=%2214%22 height=%2210%22 rx=%221.5%22 fill=%22none%22 stroke=%22white%22 stroke-width=%221.8%22/><path d=%22M8 11h8M8 14h5%22 stroke=%22white%22 stroke-width=%221.6%22/></svg>" />
     <meta name="theme-color" content="#0f2547" />
@@ -13,33 +13,35 @@
 
     <meta property="og:type" content="website" />
     <meta property="og:site_name" content="BuildVision" />
-    <meta property="og:title" content="Nameplates — read &amp; verify equipment nameplates in the browser" />
+    <meta property="og:title" content="Data Centre Construction — read &amp; verify equipment nameplates in the browser" />
     <meta property="og:description" content="Photograph a data centre equipment nameplate and read it in your browser: model, serial, voltage and rating checked against your equipment schedule, with an asset register CSV. Nothing is uploaded." />
     <meta property="og:image" content="og-nameplates.png" />
     <meta property="og:image:width" content="1200" />
     <meta property="og:image:height" content="630" />
-    <meta property="og:image:alt" content="BuildVision Nameplates — read and verify data centre equipment nameplates against the equipment schedule" />
+    <meta property="og:image:alt" content="BuildVision Data Centre Construction — read and verify data centre equipment nameplates against the equipment schedule" />
     <meta name="twitter:card" content="summary_large_image" />
-    <meta name="twitter:title" content="Nameplates — read &amp; verify equipment nameplates in the browser" />
+    <meta name="twitter:title" content="Data Centre Construction — read &amp; verify equipment nameplates in the browser" />
     <meta name="twitter:description" content="Photograph a UPS, PDU, switchgear or chiller nameplate and check model, serial, voltage and rating against the equipment schedule. Runs in your browser; nothing is uploaded." />
     <meta name="twitter:image" content="og-nameplates.png" />
-    <meta name="twitter:image:alt" content="BuildVision Nameplates — equipment-nameplate OCR checked against the equipment schedule" />
+    <meta name="twitter:image:alt" content="BuildVision Data Centre Construction — equipment-nameplate OCR checked against the equipment schedule" />
 
     <script type="application/ld+json">
     {
       "@context": "https://schema.org",
       "@type": "WebApplication",
-      "name": "BuildVision Nameplates",
-      "description": "Browser tool that reads an equipment nameplate (UPS, PDU, switchgear, generator, transformer, battery, CRAH, chiller) with in-browser OCR and checks model, serial, voltage, phase, Hz, kVA, kW, amps, MCA, MOCP and refrigerant against the equipment schedule, then exports an asset register CSV. Photos never leave the device.",
+      "name": "BuildVision Data Centre Construction",
+      "description": "Browser tool that reads an equipment nameplate (UPS, PDU, switchgear, generator, transformer, battery, cooling tower, chiller, CDU, CRAH, pump and more) with in-browser OCR and checks model, serial, voltage, phase, Hz, kVA, kW, amps, power factor, MCA, MOCP, SCCR, enclosure, listings, battery type/amp-hours/cells, refrigerant, charge, cooling, airflow, flow, speed and weight against the equipment schedule, then exports an asset register CSV. Photos never leave the device.",
       "applicationCategory": "BusinessApplication",
       "operatingSystem": "Any (runs in a modern web browser)",
       "offers": { "@type": "Offer", "price": "0", "priceCurrency": "USD" },
       "featureList": [
         "On-device nameplate OCR (nothing uploaded)",
-        "13 equipment types: UPS, generator, ATS, switchgear, transformer, PDU, panelboard, busway, battery, CDU, chiller, CRAH/CRAC, pump",
-        "Field-by-field check against the equipment schedule",
-        "Flags wrong voltage, rating or model instead of a silent pass",
-        "Asset register with duplicate-serial and missing-tag detection, exported as CSV"
+        "55 data centre equipment types: UPS, flywheel, ATS/STS, rectifier, inverter, BESS, generator, paralleling gear, fuel, nitrogen, switchgear, MCC, metering, protective relays, transformer and DGA monitors, SPD, capacitor, VFD, busway, panelboard, PDU, battery, load bank, cooling tower, chiller, dry cooler, CDU, CRAH/CRAC, AHU, heat pump, heat exchanger, pump, expansion tank, air separator, boiler, humidifier, water treatment, compressor, fan coil, RTU, makeup air, thermal storage, fire suppression, fire alarm, leak detection, BMS, KVM, rack, server, network and more",
+        "Field-by-field check against the equipment schedule, grouped into identification, electrical, cooling, server racks/IT and mechanical",
+        "Server-rack subsection: rack U and form factor, power and static/dynamic load, PDU outlet mix, network ports and link speed for servers, rack PDUs, switches and in-row cooling",
+        "Flags wrong voltage, rating, power factor, SCCR, battery type, listings or model instead of a silent pass",
+        "Advisory photo check: warns on blur, glare, dark or low-resolution shots before you rely on the read",
+        "Asset register with search, status filter, duplicate-serial and missing-tag detection, exported as CSV"
       ]
     }
     </script>
@@ -74,6 +76,13 @@
       .np-fields label { color: var(--text-dim); font-weight: 600; white-space: nowrap; display: flex; align-items: center; gap: 6px; }
       .np-fields input, .np-fields select, .np-tag select { width: 100%; padding: 6px 8px; border: 1px solid var(--border); border-radius: var(--radius-sm); font-size: 16px; background: var(--bg); color: var(--text); min-width: 0; }
       .np-fields input.low { border-color: var(--warning, #c98a00); background: color-mix(in srgb, var(--warning, #c98a00) 8%, var(--bg)); }
+      .np-fields .np-group { grid-column: 1 / -1; margin: 8px 0 0; padding-top: 6px; border-top: 1px solid var(--border); font-size: 0.68rem; letter-spacing: 0.06em; text-transform: uppercase; color: var(--text-dim); }
+      .np-fields .np-group:first-of-type { margin-top: 0; padding-top: 0; border-top: none; }
+      .np-quality { font-size: 0.8rem; color: var(--text-dim); min-height: 1.1em; margin: 8px 0 0; }
+      .np-quality.warn { color: var(--warning, #c98a00); }
+      .np-filter { display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 10px; }
+      .np-filter input, .np-filter select { padding: 6px 8px; border: 1px solid var(--border); border-radius: var(--radius-sm); font-size: 0.84rem; background: var(--bg); color: var(--text); }
+      .np-filter input { flex: 1; min-width: 140px; }
       .np-key { display: inline-block; width: 9px; height: 9px; border-radius: 2px; flex: none; }
       .np-tag { display: flex; flex-direction: column; gap: 6px; font-size: 0.84rem; font-weight: 600; }
       .np-checks { list-style: none; margin: 0; padding: 0; font-size: 0.84rem; display: flex; flex-direction: column; gap: 4px; }
@@ -125,7 +134,7 @@
       <nav class="mode-switch" aria-label="Page">
         <a class="mode-link" href="https://huggingface.co/constructelligence/data-centre-nameplates" target="_blank" rel="noopener">Model card</a>
         <a class="mode-link" href="https://constructelligence.co" target="_blank" rel="noopener">constructelligence.co</a>
-        <span class="mode-link active" aria-current="page">Nameplates</span>
+        <span class="mode-link active" aria-current="page">Data Centre Construction</span>
       </nav>
       <div class="header-status"><span id="npModel" class="status-pill model-status">OCR idle</span></div>
     </header>
@@ -143,7 +152,7 @@
             <button id="npSchedClear" class="np-btn link" type="button" hidden>Remove</button>
           </div>
           <p id="npSchedStatus" class="np-status" style="margin-top:8px" aria-live="polite"></p>
-          <p style="margin-top:6px">Optional. Needs a Tag or Model column; Manufacturer, Voltage, Phase, kVA, kW, Amps, Refrigerant, Serial and Location are checked when present.</p>
+          <p style="margin-top:6px">Optional. Needs a Tag or Model column; Manufacturer, Voltage, Phase, kVA, kW, Amps, Power factor, MCA, MOCP, SCCR, Enclosure, Listings, Battery type, Battery Ah, Cells, Rack U, Form factor, Power, Rack load, Outlet mix, Outlets, Port speed, Ports, Refrigerant, Charge, Cooling, Airflow, Flow, Speed, Weight, Serial and Location are checked when present.</p>
         </section>
         <section>
           <h2>2. Nameplate photo</h2>
@@ -156,6 +165,7 @@
             <button id="npRotate" class="np-btn" type="button" disabled title="Rotate the photo 90°">Rotate</button>
           </div>
           <p style="margin-top:8px">Fill the frame with the plate, without glare across the text. Tilted shots are straightened automatically. Pick several photos at once to read a whole walk into the register, then click a row to review it.</p>
+          <p id="npQuality" class="np-quality" role="status" aria-live="polite"></p>
         </section>
         <section>
           <button id="npRun" class="np-btn primary" type="button" disabled>Read nameplate</button>
@@ -192,6 +202,16 @@
         <div class="np-register">
           <h2>Asset register</h2>
           <div id="npSummary" class="np-summary"></div>
+          <div class="np-filter">
+            <input id="npSearch" type="search" placeholder="Search tag, model, serial or maker…" aria-label="Search the register" autocomplete="off" />
+            <select id="npFilter" aria-label="Filter the register by status">
+              <option value="all">All statuses</option>
+              <option value="verified">Verified</option>
+              <option value="partial">Matched, fields unread</option>
+              <option value="mismatch">Does not match</option>
+              <option value="unmatched">Not on schedule</option>
+            </select>
+          </div>
           <div class="np-row" style="margin-bottom:10px">
             <button id="npCsv" class="np-btn" type="button" disabled>Download register CSV</button>
             <button id="npClearReg" class="np-btn link" type="button" disabled>Clear register</button>

nameplate-model.js

@@ -11,41 +11,133 @@
 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'], ['formFactor', 'Form factor', 'rack'],
+  ['powerW', 'Power (W)', 'rack'], ['rackLoad', 'Rack load (kg)', 'rack'],
+  ['outletTypes', 'Outlet mix', 'rack'], ['outlets', 'PDU outlets', 'rack'],
+  ['portSpeed', 'Port speed (GbE)', '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 +163,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 +183,74 @@ 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 and IT: enclosure U height, the equipment's own form factor,
+  // power draw and static/dynamic load, the PDU outlet mix, and the network port
+  // count and speed. Rack U also catches the "42RU" spelling; the form factor is
+  // blade/tower or an explicitly labelled "FORM FACTOR 2U", so a server's model
+  // suffix ("R650-2U") is its Rack U, not a second field.
+  scan('uHeight', /\b(\d{1,2})\s*R?U\b/, m => { const v = +m[1]; return v >= 1 && v <= 60 ? v : null; });
+  scan('formFactor', /\b(?:FORM\s*FACTOR|CHASSIS|FORM)\s*[:]?\s*(\d{1,2})\s*U\b|\b(\d{1,2})\s*U\s*(?:SERVER|NODE|STORAGE|CHASSIS)\b/, m => `${m[1] || m[2]}U`);
+  if (!fields.formFactor) scan('formFactor', /\b(BLADE|TOWER)\b/, m => m[1].toLowerCase());
+  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('rackLoad', new RegExp(`(?:(?:STATIC|DYNAMIC|SEISMIC)\\s*(?:LOAD|RATING|CAPACITY)|(?:RACK|FLOOR|CABINET|EQUIPMENT)\\s*LOAD|LOAD\\s*(?:RATING|CAPACITY))[^0-9]{0,16}${NUM}\\s*(LBS?|LB|KGS?|KG|TONS?)?\\b`), m => inRange(weightKg(num(m[1]), m[2]), 1, 200000));
+  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));
+
+  // The outlet mix and the port speed need the whole line: a count can sit on
+  // either side of an outlet family ("24x C13" or "C13 x24"), and a switch's
+  // speed is the fastest link, not the first number seen.
+  for (const [i, l] of lines.entries()) {
+    const mix = outletMix(up(l.text));
+    if (mix) { set('outletTypes', mix, l.conf, i); break; }
+  }
+  for (const [i, l] of lines.entries()) {
+    const spd = portSpeed(up(l.text));
+    if (spd) { set('portSpeed', spd, l.conf, i); break; }
+  }
 
   // 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 +316,31 @@ 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,
+  formFactor: /^(form factor|ff|form|chassis|mounting|mount type)$/i,
+  powerW: /^(power|power \(w\)|watts?|w|rated power|input power)$/i,
+  rackLoad: /^(rack load|load|load (rating|capacity)|static load|dynamic load|floor load|seismic load|max load)$/i,
+  outletTypes: /^(outlet (types?|mix|configuration)|receptacle types?|outlet arrangement)$/i,
+  outlets: /^(outlets?|receptacles?|pdu outlets?|outlet count)$/i,
+  portSpeed: /^(port speed|uplink speed|link speed|network speed|speed \(gbe\))$/i,
+  ports: /^(ports?|port count|network ports?)$/i,
   location: /^(location|room|area|level|space|served from|zone)$/i,
 };
 
@@ -197,7 +361,15 @@ 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, formFactor: get('formFactor'), powerW: num(get('powerW')) || null,
+      rackLoad: num(get('rackLoad')) || null, outletTypes: get('outletTypes'),
+      outlets: num(get('outlets')) || null, portSpeed: num(get('portSpeed')) || 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 +423,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 +467,33 @@ 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', 'rackLoad', 'outlets', 'portSpeed', '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.formFactor) push('formFactor', item.formFactor, f.formFactor?.value, looseEq(item.formFactor, f.formFactor?.value));
+  if (item.outletTypes) push('outletTypes', item.outletTypes, f.outletTypes?.value, outletMix(up(item.outletTypes)) === outletMix(up(f.outletTypes?.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 +532,11 @@ 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', 'Form factor', 'Power (W)', 'Rack load (kg)', 'Outlet mix', 'Outlets', 'Port speed (GbE)',
+    '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 +546,20 @@ 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('formFactor'), v('powerW'), v('rackLoad'), v('outletTypes'), v('outlets'), v('portSpeed'), 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.formFactor ?? '', i.powerW ?? '',
+      i.rackLoad ?? '', i.outletTypes ?? '', i.outlets ?? '', i.portSpeed ?? '',
+      i.ports ?? '', '', '', '']);
   }
   return [head, ...rows].map(r => r.map(csvCell).join(',')).join('\n') + '\n';
 }
@@ -368,12 +581,29 @@ 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 (12x C13, 4x C19)', 'MFG DATE: 08/2026'],
+  ['CISCO', 'CATALYST NETWORK SWITCH', 'MODEL NO: C9300-48P', 'SERIAL NO: FOC26X0011',
+    '230 V  3 PH  50 HZ', '48-PORT POE 1100 W', 'UPLINK 25G', 'MFG DATE: 09/2026'],
+  ['NEXUS COMPUTE', 'BLADE SERVER CHASSIS', 'MODEL NO: BX-7000', 'SERIAL NO: NC26B00123',
+    'FORM FACTOR 8U', '480 V  3 PH  60 HZ', 'STATIC LOAD 1360 KG', 'MFG DATE: 05/2026'],
 ];
 
 // ------------------------------------------------------------------ helpers
@@ -382,6 +612,47 @@ 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;
+}
+/** Canonical PDU outlet mix from the ways plates write it: "24x C13, 6x C19" -> "C13x24 C19x6". */
+function outletMix(t) {
+  const counts = new Map();
+  let m;
+  const pairA = /\b(\d{1,3})\s*[X\u00d7]\s*(C\d{1,2})\b/g;   // 24x C13
+  while ((m = pairA.exec(t))) { const n = +m[1]; if (n >= 1 && n <= 1000) counts.set(m[2], (counts.get(m[2]) || 0) + n); }
+  const pairB = /\b(C\d{1,2})\s*[X\u00d7]\s*(\d{1,3})\b/g;   // C13 x24
+  while ((m = pairB.exec(t))) { const n = +m[2]; if (n >= 1 && n <= 1000) counts.set(m[1], (counts.get(m[1]) || 0) + n); }
+  if (!counts.size && !/OUTLET|RECEPTACLE/.test(t)) return null;   // a "C13" in a model code is not an outlet mix
+  const bare = /\b(C\d{1,2})\b/g;
+  while ((m = bare.exec(t))) if (!counts.has(m[1])) counts.set(m[1], 0);
+  return [...counts.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([f, n]) => (n > 0 ? `${f}x${n}` : f)).join(' ');
+}
+/** Fastest link speed on a line, in GbE: "48-port 10G", "25/100GbE" -> 100. */
+function portSpeed(t) {
+  let max = 0, m;
+  const re = /\b(1|10|25|40|50|100|200|400)\s*G(?:BE|BPS|BASE-T|IGABIT|IGE)?\b/g;
+  while ((m = re.exec(t))) max = Math.max(max, +m[1]);
+  return max || null;
+}
 function csvCell(v) { const s = String(v ?? ''); return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s; }
 
 export function levenshtein(a, b) {

nameplates-app.js

@@ -2,7 +2,7 @@
 // OCR it (Tesseract.js, in the browser), parse and check the fields against the
 // schedule, and keep an asset register that exports to CSV.
 import {
-  FIELDS, EQUIPMENT_TYPES, STATUS_LABELS, SAMPLE_SCHEDULE, SAMPLE_PLATES,
+  FIELDS, FIELD_GROUPS, EQUIPMENT_TYPES, STATUS_LABELS, SAMPLE_SCHEDULE, SAMPLE_PLATES,
   parseNameplate, parseEquipmentSchedule, candidatesFor, checkAgainst, statusOf,
   registerSummary, registerCsv, duplicateSerials, voltagesIn,
 } from './nameplate-model.js';
@@ -10,18 +10,22 @@ import {
 const TESSERACT = 'https://cdn.jsdelivr.net/npm/tesseract.js@5.1.1/dist/tesseract.min.js';
 const STORE = 'buildvision.nameplates.v1';
 const LOW_CONF = 70;
-const NUMERIC = new Set(['phase', 'hz', 'kva', 'kw', 'amps', 'mca', 'mocp']);
+const NUMERIC = new Set(['phase', 'hz', 'kva', 'kw', 'amps', 'pf', 'mca', 'mocp', 'sccr', 'charge', 'tons', 'btu', 'cfm', 'gpm', 'batteryAh', 'cells', 'rpm', 'weight', 'uHeight', 'powerW', 'rackLoad', 'outlets', 'portSpeed', 'ports']);
 // Dark enough for white label text on the photo overlay.
 const COLORS = {
   manufacturer: '#0f2547', model: '#1b5fa8', serial: '#7340a8', voltage: '#c0262d', phase: '#b04f00', hz: '#7a4a35',
-  kva: '#1f7a32', kw: '#0b7285', amps: '#a8327a', mca: '#5c6b00', mocp: '#8a5a00', refrigerant: '#4d6b1f', mfgDate: '#555b63',
+  kva: '#1f7a32', kw: '#0b7285', amps: '#a8327a', pf: '#8a1c5a', mca: '#5c6b00', mocp: '#8a5a00', sccr: '#6b2d8a',
+  enclosure: '#3a4a5a', standards: '#4a3f6b', batteryType: '#5a2d6b', batteryAh: '#7a3f00', cells: '#6b4a00',
+  refrigerant: '#4d6b1f', charge: '#2f6b3a', tons: '#0b6b6b', btu: '#0b5c8a', cfm: '#5a5c00', gpm: '#00636b',
+  uHeight: '#3a3f8a', formFactor: '#4a3f8a', powerW: '#8a5a1f', rackLoad: '#6b5a1f', outletTypes: '#6b3a6b', outlets: '#6b3a6b', portSpeed: '#3a6b5a', ports: '#3a6b5a',
+  rpm: '#7a2c2c', weight: '#444a52', mfgDate: '#555b63',
 };
 
 const $ = id => document.getElementById(id);
 const els = Object.fromEntries([
   'npSchedDrop', 'npSchedFile', 'npSchedSample', 'npSchedClear', 'npSchedStatus', 'npDrop', 'npFile', 'npSample', 'npRotate',
-  'npRun', 'npProg', 'npStatus', 'npModel', 'npCanvas', 'npEmpty', 'npReading', 'npVerdict', 'npFields', 'npTag', 'npTagNote',
-  'npChecks', 'npAdd', 'npText', 'npSummary', 'npCsv', 'npClearReg', 'npRows', 'npEmptyReg', 'npMissing',
+  'npRun', 'npProg', 'npStatus', 'npModel', 'npCanvas', 'npEmpty', 'npQuality', 'npReading', 'npVerdict', 'npFields', 'npTag', 'npTagNote',
+  'npChecks', 'npAdd', 'npText', 'npSummary', 'npCsv', 'npClearReg', 'npSearch', 'npFilter', 'npRows', 'npEmptyReg', 'npMissing',
 ].map(id => [id.slice(2, 3).toLowerCase() + id.slice(3), $(id)]));
 
 const state = {
@@ -33,6 +37,8 @@ const state = {
   tag: '',
   sample: 0,
   editing: null,         // register id being reviewed (Add then updates it)
+  photoFilter: 'all',    // register status filter
+  photoQuery: '',        // register search text
   photos: new Map(),     // register id -> { image, reading } for this session (photos are not stored)
 };
 window.BuildVisionNameplates = state;
@@ -151,9 +157,49 @@ function setImage(src, w, h) {
   els.reading.hidden = true;
   els.run.disabled = false;
   els.rotate.disabled = false;
+  showQuality(photoWarning(state.image, w, h));
   draw();
 }
 
+/** Show (or clear) the advisory "retake this photo" line. */
+function showQuality(text) {
+  if (!els.quality) return;
+  els.quality.textContent = text || '';
+  els.quality.classList.toggle('warn', !!text);
+}
+
+/**
+ * Advisory read of the photo before OCR: too blurry, dark, glared or small to
+ * read. Returns a sentence to show, or '' when the shot looks usable. Never
+ * blocks a read; it just tells the person to retake if the result looks poor.
+ */
+function photoWarning(src, origW, origH) {
+  try {
+    const w = Math.min(240, src.width), h = Math.max(1, Math.round((src.height * w) / src.width));
+    const c = document.createElement('canvas');
+    c.width = w; c.height = h;
+    const g = c.getContext('2d', { willReadFrequently: true });
+    g.drawImage(src, 0, 0, w, h);
+    const d = g.getImageData(0, 0, w, h).data;
+    const n = w * h, gray = new Float32Array(n);
+    let sum = 0, bright = 0;
+    for (let i = 0, j = 0; j < n; i += 4, j++) { gray[j] = d[i] * 0.299 + d[i + 1] * 0.587 + d[i + 2] * 0.114; sum += gray[j]; if (gray[j] > 250) bright++; }
+    let lapSum = 0, lapSq = 0, count = 0;
+    for (let y = 1; y < h - 1; y++) for (let x = 1; x < w - 1; x++) {
+      const i = y * w + x;
+      const lap = 4 * gray[i] - gray[i - 1] - gray[i + 1] - gray[i - w] - gray[i + w];
+      lapSum += lap; lapSq += lap * lap; count++;
+    }
+    const lapVar = count ? lapSq / count - (lapSum / count) ** 2 : 0;
+    const notes = [];
+    if (Math.min(origW || src.width, origH || src.height) < 500) notes.push('is low resolution');
+    else if (lapVar < 20) notes.push('looks blurry');
+    if (sum / n < 45) notes.push('is dark');
+    if (bright / n > 0.12) notes.push('has glare over the plate');
+    return notes.length ? `Photo ${notes.join(' and ')}. Retake closer and straight on, without glare, for a better read.` : '';
+  } catch { return ''; }
+}
+
 function rotate() {
   const s = state.image;
   const c = document.createElement('canvas');
@@ -415,14 +461,18 @@ function renderReading() {
   els.reading.hidden = !r;
   if (!r) return;
   els.text.textContent = r.text || '(no text)';
-  // Fields: editable, low-confidence ones highlighted.
+  // Fields: grouped, editable, low-confidence ones highlighted.
   const typeOpts = ['<option value="">Unknown</option>', ...EQUIPMENT_TYPES.map(([k, label]) => `<option value="${k}"${r.type === k ? ' selected' : ''}>${esc(label)}</option>`)].join('');
+  const fieldInput = ([k, label]) => {
+    const f = r.fields[k];
+    const low = f && !f.edited && f.conf < LOW_CONF;
+    return `<label for="npf-${k}"><span class="np-key" style="background:${f ? COLORS[k] : 'transparent'}"></span>${esc(label)}</label>` +
+      `<input id="npf-${k}" data-key="${k}" value="${esc(f?.value ?? '')}" ${low ? `class="low" title="OCR confidence ${f.conf}%: check against the plate"` : ''} autocomplete="off" spellcheck="false" />`;
+  };
   els.fields.innerHTML = `<label for="npf-type">Type</label><select id="npf-type">${typeOpts}</select>` +
-    FIELDS.map(([k, label]) => {
-      const f = r.fields[k];
-      const low = f && !f.edited && f.conf < LOW_CONF;
-      return `<label for="npf-${k}"><span class="np-key" style="background:${f ? COLORS[k] : 'transparent'}"></span>${esc(label)}</label>` +
-        `<input id="npf-${k}" data-key="${k}" value="${esc(f?.value ?? '')}" ${low ? `class="low" title="OCR confidence ${f.conf}%: check against the plate"` : ''} autocomplete="off" spellcheck="false" />`;
+    FIELD_GROUPS.map(([g, label]) => {
+      const group = FIELDS.filter(f => (f[2] || 'id') === g);
+      return group.length ? `<div class="np-group">${esc(label)}</div>${group.map(fieldInput).join('')}` : '';
     }).join('');
 
   // Tag picker: likely tags first, then the rest of the schedule.
@@ -588,7 +638,15 @@ function renderRegister() {
     sum.unmatched ? `<span><b>${sum.unmatched}</b> not on schedule</span>` : '',
     sum.duplicates ? `<span style="color:var(--danger)"><b>${sum.duplicates}</b> duplicate serial${sum.duplicates === 1 ? '' : 's'}</span>` : '',
   ].join('') : '';
-  els.rows.innerHTML = state.register.map(r => {
+  // Filter and search the register: a walk can be hundreds of tags.
+  const q = state.photoQuery.trim().toUpperCase();
+  const shown = state.register.filter(r => {
+    if (state.photoFilter !== 'all' && r.status !== state.photoFilter) return false;
+    if (!q) return true;
+    return [r.tag, typeLabel(r.type), r.fields?.model?.value, r.fields?.serial?.value, r.fields?.manufacturer?.value, r.source]
+      .join(' ').toUpperCase().includes(q);
+  });
+  els.rows.innerHTML = shown.map(r => {
     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');
     if (r.lowConf?.length) issues.push(`Check ${r.lowConf.map(x => { const [k, c] = x.split(':'); return `${inSentence((FIELDS.find(f => f[0] === k) || [k, k])[1])} (OCR ${c}%)`; }).join(', ')}`);
@@ -600,10 +658,15 @@ function renderRegister() {
       `<td><button class="np-btn link" type="button" data-remove="${r.id}" aria-label="Remove ${esc(r.tag || 'entry')}">✕</button></td></tr>`;
   }).join('');
   els.emptyReg.hidden = state.register.length > 0;
+  if (els.emptyReg) els.emptyReg.textContent = state.register.length && !shown.length
+    ? 'No register entries match the filter.'
+    : 'Nothing scanned yet. Each plate you add appears here with its check result.';
+  if (els.filter) els.filter.value = state.photoFilter;
   els.csv.disabled = !state.register.length && !items.length;
   els.clearReg.disabled = !state.register.length;
   els.missing.textContent = items.length && sum.missing.length && state.register.length
-    ? `Not scanned yet (${sum.missing.length}): ${sum.missing.slice(0, 24).join(', ')}${sum.missing.length > 24 ? '…' : ''}` : '';
+    ? `Not scanned yet (${sum.missing.length}): ${sum.missing.slice(0, 24).join(', ')}${sum.missing.length > 24 ? '…' : ''}` +
+      (shown.length !== state.register.length ? `    Showing ${shown.length} of ${state.register.length} scanned.` : '') : '';
 }
 
 function download(name, text, type) {
@@ -665,6 +728,8 @@ els.clearReg.addEventListener('click', () => {
   save();
   renderRegister();
 });
+els.search?.addEventListener('input', () => { state.photoQuery = els.search.value; renderRegister(); });
+els.filter?.addEventListener('change', () => { state.photoFilter = els.filter.value; renderRegister(); });
 els.csv.addEventListener('click', () => download('asset-register.csv', registerCsv(state.register, state.schedule?.items || []), 'text/csv'));
 
 load();