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

README.md

@@ -46,11 +46,15 @@ tags:
   - browser
 ---
 
-# Data Centre Nameplates — equipment-nameplate OCR checked against the equipment schedule
+# Data Centre Construction — equipment-nameplate OCR checked against the equipment schedule
+
+> **Constructelligence is developing frontier construction-AI models.** This kit is the *lite*, open tier —
+> released for research and evaluation; the company's flagship production models are a separate, larger
+> tier (see [constructelligence.co](https://constructelligence.co)).
 
 **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, chiller — or a **server
-rack** — and the engine returns the plate's fields (31 of them, grouped Identification / Electrical / Cooling /
+rack** — and the engine returns the plate's fields (35 of them, grouped Identification / Electrical / Cooling /
 Server racks / Mechanical) and **checks each one against the equipment schedule**, flagging a mismatch instead
 of a silent pass. It builds an asset register and exports it to CSV.
 
@@ -66,7 +70,7 @@ delivered at the wrong voltage or rating, or one that quietly never makes it ont
 | | |
 |---|---|
 | **Task** | Image → structured nameplate fields → schedule verification |
-| **Fields** | **31**, in five groups (Identification, Electrical, Cooling, Server racks/IT, Mechanical) |
+| **Fields** | **35**, in five groups (Identification, Electrical, Cooling, Server racks/IT, Mechanical) |
 | **Equipment** | **55 types**, device wording ranked above family (see below) |
 | **OCR** | Tesseract.js 5 (English LSTM), pretrained — no fine-tuning |
 | **Extraction** | Deterministic labelled-field parser + OCR error model + numeric range guards |
@@ -120,7 +124,7 @@ The result is a pass/mismatch verdict per plate, with the fields that disagree n
 6. **Field checks** compare the reading to the chosen row (`ok` / `mismatch` / `unread` per field) and return
    an overall status: `verified`, `partial`, `mismatch`, `unmatched` or `missing` (scheduled but not scanned).
 
-## Fields extracted (31)
+## Fields extracted (35)
 
 **Identification** — `manufacturer`, `model`, `serial`, `mfgDate`
 
@@ -142,7 +146,9 @@ The result is a pass/mismatch verdict per plate, with the fields that disagree n
 
 **Cooling** — `refrigerant`, `charge`, `tons`, `btu`, `cfm`, `gpm`
 
-**Server racks / IT** — `uHeight` (rack U), `powerW`, `outlets`, `ports`
+**Server racks / IT** — `uHeight` (rack U, incl. "42RU"), `formFactor` (blade / tower / a labelled "2U"),
+`powerW`, `rackLoad` (static/dynamic load, kg), `outletTypes` (canonical outlet mix, e.g. `C13x12 C19x4`),
+`outlets`, `portSpeed` (fastest link, GbE), `ports`
 
 **Mechanical** — `rpm`, `weight` (normalised to kg)
 
@@ -163,9 +169,11 @@ IT & white space: **rack** · **server/storage** · network gear · KVM/console
 ## Server racks — a first-class subsection
 
 Racks, rack PDUs, switches and in-row cooling are what the electrical and cooling design actually serves, so
-they are treated as data-centre equipment, not an afterthought: `Rack U`, `Power (W)`, `PDU outlets` and
-`Ports` are extracted and checked like any other field, and the equipment set covers rack/enclosure, server,
-network, KVM and rack PDU. Sample plates include a PowerEdge-class server and a rack PDU.
+they are treated as data-centre equipment, not an afterthought: `Rack U`, `Form factor`, `Power (W)`,
+`Rack load (kg)`, `Outlet mix`, `PDU outlets`, `Port speed (GbE)` and `Ports` are extracted and checked like any
+other field, and the equipment set covers rack/enclosure, server, network, KVM and rack PDU. Sample plates
+include a PowerEdge-class server, a rack PDU with a C13/C19 outlet mix, a 25G switch and a blade chassis with a
+static floor load.
 
 ## Results
 
@@ -311,7 +319,8 @@ keep OCR confidence and the plate line each value came from.
 ## 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.
+**Data Centre Construction** 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).
@@ -332,7 +341,7 @@ this project is independent and not affiliated with or endorsed by them.
 
 ```bibtex
 @misc{constructelligence_nameplates,
-  title  = {Data Centre Nameplates: equipment-nameplate OCR checked against the equipment schedule},
+  title  = {Data Centre Construction: equipment-nameplate OCR checked against the equipment schedule},
   author = {Constructelligence},
   year   = {2026},
   howpublished = {\url{https://huggingface.co/constructelligence/data-centre-nameplates}}

config.json

@@ -1,10 +1,10 @@
 {
   "name": "data-centre-nameplates",
-  "version": "2.0",
+  "version": "2.1",
   "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 and IT gear across 55 equipment types, including a server-rack subsection (rack U height, power, PDU outlets, network ports).",
+  "summary": "Reads an equipment nameplate (OCR) and checks it against an equipment schedule for data-centre MEP and IT gear across 55 equipment types, including a server-rack subsection (rack U and form factor, power and static/dynamic load, PDU outlet mix, network ports and link speed).",
   "engine": {
     "ocr": "tesseract.js 5 (LSTM English)",
     "extraction": "deterministic labelled-field parser + OCR error model + numeric range guards",
@@ -16,14 +16,14 @@
     "id": ["manufacturer", "model", "serial", "mfgDate"],
     "electrical": ["voltage", "phase", "hz", "kva", "kw", "amps", "pf", "mca", "mocp", "sccr", "enclosure", "standards", "batteryType", "batteryAh", "cells"],
     "cooling": ["refrigerant", "charge", "tons", "btu", "cfm", "gpm"],
-    "rack": ["uHeight", "powerW", "outlets", "ports"],
+    "rack": ["uHeight", "formFactor", "powerW", "rackLoad", "outletTypes", "outlets", "portSpeed", "ports"],
     "mechanical": ["rpm", "weight"]
   },
   "fields": [
     "manufacturer", "model", "serial", "mfgDate",
     "voltage", "phase", "hz", "kva", "kw", "amps", "pf", "mca", "mocp", "sccr", "enclosure", "standards", "batteryType", "batteryAh", "cells",
     "refrigerant", "charge", "tons", "btu", "cfm", "gpm",
-    "uHeight", "powerW", "outlets", "ports",
+    "uHeight", "formFactor", "powerW", "rackLoad", "outletTypes", "outlets", "portSpeed", "ports",
     "rpm", "weight"
   ],
   "equipment_types": [

nameplate-model.js

@@ -23,7 +23,10 @@ export const FIELDS = [
   ['refrigerant', 'Refrigerant', 'cooling'], ['charge', 'Refrigerant charge', 'cooling'], ['tons', 'Cooling (tons)', 'cooling'],
   ['btu', 'Cooling (BTU/h)', 'cooling'], ['cfm', 'Airflow (CFM)', 'cooling'], ['gpm', 'Flow (GPM)', 'cooling'],
   // Server racks and IT.
-  ['uHeight', 'Rack U', 'rack'], ['powerW', 'Power (W)', 'rack'], ['outlets', 'PDU outlets', 'rack'], ['ports', 'Ports', 'rack'],
+  ['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'],
 ];
@@ -207,12 +210,31 @@ export function parseNameplate(input) {
   scan('weight', new RegExp(`(?:WEIGHT|NET\\s?WEIGHT|NET\\s?WT|MASS)\\s*[:]?\\s*${NUM}\\s*(LBS?|LB|KGS?|KG|TONS?)?\\b`), m => positive(weightKg(num(m[1]), m[2])));
   scan('standards', /\b(UL\s?\d{3,5}[A-Z]?|IEC\s?\d{4,5}|ANSI\s?[A-Z]{1,3}[-\s]?\d{1,4}|IEEE\s?\d{1,4}|NFPA\s?\d{1,3}|CSA\s?[A-Z]?\d{1,4}|EN\s?\d{4,5})\b/, m => m[1].replace(/\s+/g, ' ').trim());
 
-  // Server racks: rack-unit height, IT power draw, PDU outlets and network ports.
-  scan('uHeight', /\b(\d{1,2})\s*U\b/, m => { const v = +m[1]; return v >= 1 && v <= 60 ? v : null; });
+  // 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()) {
@@ -312,8 +334,12 @@ const HEADERS = {
   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,
 };
@@ -340,8 +366,10 @@ export function parseEquipmentSchedule(text) {
       refrigerant: get('refrigerant'), charge: num(get('charge')) || null, tons: num(get('tons')) || null, btu: num(get('btu')) || null,
       cfm: num(get('cfm')) || null, gpm: num(get('gpm')) || null, batteryAh: num(get('batteryAh')) || null,
       cells: num(get('cells')) || null, rpm: num(get('rpm')) || null, weight: num(get('weight')) || null,
-      uHeight: num(get('uHeight')) || null, powerW: num(get('powerW')) || null,
-      outlets: num(get('outlets')) || null, ports: num(get('ports')) || null, location: get('location'),
+      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.');
@@ -440,12 +468,14 @@ export function checkAgainst(reading, item) {
   }
   if (item.phase) push('phase', item.phase, f.phase?.value, +item.phase === +f.phase?.value);
   if (item.pf) push('pf', item.pf, f.pf?.value, Math.abs(+f.pf?.value - item.pf) <= 0.02);
-  for (const k of ['kva', 'kw', 'amps', 'mca', 'mocp', 'sccr', 'charge', 'tons', 'btu', 'cfm', 'gpm', 'batteryAh', 'cells', 'rpm', 'weight', 'uHeight', 'powerW', 'outlets', 'ports']) {
+  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;
 }
@@ -505,7 +535,8 @@ export function registerCsv(register, items = []) {
   const head = ['Tag', 'Status', 'Type', 'Location', 'Manufacturer', 'Model', 'Serial', 'Voltage', 'Phase', 'Hz', 'kVA', 'kW',
     'Amps', 'PF', 'MCA', 'MOCP', 'SCCR', 'Enclosure', 'Listings', 'Battery type', 'Battery Ah', 'Battery cells',
     'Refrigerant', 'Charge', 'Cooling (tons)', 'Cooling (BTU/h)', 'Airflow (CFM)', 'Flow (GPM)', 'Speed (RPM)',
-    'Weight (kg)', 'Rack U', 'Power (W)', 'Outlets', 'Ports', 'Mfg date', 'Issues', 'Scanned'];
+    '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());
@@ -517,7 +548,7 @@ export function registerCsv(register, items = []) {
     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('pf'),
       v('mca'), v('mocp'), v('sccr'), v('enclosure'), v('standards'), v('batteryType'), v('batteryAh'), v('cells'),
-      v('refrigerant'), v('charge'), v('tons'), v('btu'), v('cfm'), v('gpm'), v('rpm'), v('weight'), v('uHeight'), v('powerW'), v('outlets'), v('ports'), v('mfgDate'),
+      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));
@@ -526,7 +557,8 @@ export function registerCsv(register, items = []) {
     rows.push([i.tag, STATUS_LABELS.missing, i.type, i.location, i.manufacturer, i.model, i.serial, i.voltage, i.phase ?? '',
       '', i.kva ?? '', i.kw ?? '', i.amps ?? '', i.pf ?? '', i.mca ?? '', i.mocp ?? '', i.sccr ?? '', i.enclosure ?? '',
       i.standards ?? '', i.batteryType ?? '', i.batteryAh ?? '', i.cells ?? '', i.refrigerant, i.charge ?? '', i.tons ?? '',
-      i.btu ?? '', i.cfm ?? '', i.gpm ?? '', i.rpm ?? '', i.weight ?? '', i.uHeight ?? '', i.powerW ?? '', i.outlets ?? '',
+      i.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';
@@ -567,7 +599,11 @@ export const SAMPLE_PLATES = [
   ['DELL EMC', 'POWEREDGE R650 SERVER', 'MODEL NO: R650-2U', 'SERIAL NO: DL26R00442',
     '480 V  3 PH  60 HZ', '800 W  12.5 A', 'AIRFLOW 120 CFM', 'MFG DATE: 06/2026'],
   ['VERTIV', 'RACK PDU', 'MODEL NO: MPX-30-C13', 'SERIAL NO: VR26P00117',
-    '400 V  3 PH  60 HZ', '30 A  5.5 KW', '24 OUTLETS', 'MFG DATE: 08/2026'],
+    '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
@@ -597,6 +633,26 @@ function weightKg(v, unit) {
   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) {

sample_plates.json

@@ -1,5 +1,5 @@
 {
-  "note": "Fictional sample plates. UPS-1A matches schedule tag UPS-1A; the 415 V UPS is the same family but a different voltage variant, so it is flagged on model and voltage. The switchboard and server are not on the sample schedule, showing wider equipment recognition and the server-rack fields (Rack U, Power W).",
+  "note": "Fictional sample plates. UPS-1A matches schedule tag UPS-1A; the 415 V UPS is the same family but a different voltage variant, so it is flagged on model and voltage. The switchboard and the IT gear are not on the sample schedule, showing wider equipment recognition and the server-rack fields (Rack U, Form factor, Power W, Rack load, Outlet mix, Port speed, Ports).",
   "plates": [
     {
       "id": "ups-match",
@@ -73,9 +73,39 @@
         "SERIAL NO: VR26P00117",
         "400 V  3 PH  60 HZ",
         "30 A  5.5 KW",
-        "24 OUTLETS",
+        "24 OUTLETS (12x C13, 4x C19)",
         "MFG DATE: 08/2026"
       ]
+    },
+    {
+      "id": "network-switch",
+      "type": "network",
+      "expect_tag": null,
+      "lines": [
+        "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"
+      ]
+    },
+    {
+      "id": "blade-chassis",
+      "type": "server",
+      "expect_tag": null,
+      "lines": [
+        "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"
+      ]
     }
   ]
 }

tests/nameplate-model.test.mjs

@@ -145,7 +145,7 @@ test('register: summary, duplicate serials, and a CSV that lists what is still u
   assert.equal(s.missing.length, schedule.length - 1);
   const rows = registerCsv(reg, schedule).trim().split('\n');
   assert.equal(rows.length, 1 + 2 + schedule.length - 1);
-  assert.match(rows[1], /^UPS-1A,Verified,UPS,Electrical Room 1A,Northline Power Systems,NPX-750-480,NL26A01937,480Y\/277 V,3,60,750,675,1002,,,,,,,,,,,,,,,,,,,,,,03\/2026,Serial also on another scanned plate,2026-10-02 14:30$/);
+  assert.match(rows[1], /^UPS-1A,Verified,UPS,Electrical Room 1A,Northline Power Systems,NPX-750-480,NL26A01937,480Y\/277 V,3,60,750,675,1002,,,,,,,,,,,,,,,,,,,,,,,,,,03\/2026,Serial also on another scanned plate,2026-10-02 14:30$/);
   assert.match(rows[3], /^UPS-1B,Not scanned yet,/);
 });
 
@@ -310,3 +310,57 @@ test('schedule columns for the extra fields are read and checked', () => {
   const bad = checkAgainst(plate(['ACME SWITCHBOARD', 'SWITCHBOARD', 'MODEL IS-4000', '480Y/277 V', 'PF 0.9', 'SCCR 42 KA', 'NEMA 1']), swb);
   assert.deepEqual(bad.filter(c => c.status === 'mismatch').map(c => c.key), ['pf', 'sccr', 'enclosure']);
 });
+
+test('server-rack plates read form factor, static load, outlet mix and port speed', () => {
+  // A blade chassis: its own form factor, and a static floor load.
+  const blade = plate(['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']);
+  assert.equal(blade.type, 'server');
+  assert.equal(val(blade, 'formFactor'), '8U');
+  assert.equal(val(blade, 'rackLoad'), 1360);
+
+  // A rack PDU: the outlet mix is canonicalised whichever way it is written.
+  const pdu = plate(['VERTIV', 'RACK PDU', 'MODEL NO: MPX-30-C13', 'SERIAL NO: VR26P00117',
+    '400 V 3 PH 60 HZ', '30 A 5.5 KW', '24 OUTLETS (12x C13, 4x C19)']);
+  assert.equal(pdu.type, 'pdu');
+  assert.equal(val(pdu, 'outletTypes'), 'C13x12 C19x4');
+  assert.equal(val(pdu, 'outlets'), 24);
+  // "C13" in a model code alone is not an outlet mix.
+  assert.equal(val(plate(['VERTIV', 'RACK PDU', 'MODEL NO: MPX-30-C13', '400 V 3 PH']), 'outletTypes'), undefined);
+
+  // A switch: the fastest link, not the first number.
+  const sw = plate(['CISCO', 'CATALYST NETWORK SWITCH', 'MODEL NO: C9300-48P', 'SERIAL NO: FOC26X0011',
+    '230 V 3 PH 50 HZ', '48-PORT POE 1100 W', 'UPLINK 10/25G']);
+  assert.equal(sw.type, 'network');
+  assert.equal(val(sw, 'ports'), 48);
+  assert.equal(val(sw, 'portSpeed'), 25);
+  assert.equal(val(sw, 'powerW'), 1100);
+
+  // "42RU" is a rack height, and a tower server is a form factor.
+  assert.equal(val(plate(['RITTAL', 'SERVER RACK ENCLOSURE', 'MODEL TS-42RU', '42RU 800x1200']), 'uHeight'), 42);
+  assert.equal(val(plate(['DELL', 'TOWER SERVER', 'MODEL T-360', 'Tower chassis']), 'formFactor'), 'tower');
+});
+
+test('new rack columns import from the schedule and are checked field by field', () => {
+  const { items, problems } = parseEquipmentSchedule(
+    'Tag,Type,Model,Form factor,Rack load,Outlet mix,Port speed,Ports\n' +
+    'SRV-1,Server,R650-2U,2U,1360,C13x24,25,48\n' +
+    'SW-1,Network switch,C9300,,,,25,48\n');
+  assert.deepEqual(problems, []);
+  const [srv, sw] = items;
+  assert.equal(srv.formFactor, '2U');
+  assert.equal(srv.rackLoad, 1360);
+  assert.equal(srv.outletTypes, 'C13x24');
+  assert.equal(srv.portSpeed, 25);
+  assert.equal(sw.portSpeed, 25);
+  assert.equal(sw.ports, 48);
+
+  const good = checkAgainst(plate(['ACME SERVER', 'POWEREDGE SERVER', 'MODEL R650-2U', '480 V 3 PH',
+    'FORM FACTOR 2U', 'STATIC LOAD 1360 KG', '25 OUTLETS (24x C13)', '48-PORT 25G']), srv);
+  assert.deepEqual(good.filter(c => c.status !== 'ok'), []);
+
+  const bad = checkAgainst(plate(['ACME SERVER', 'POWEREDGE SERVER', 'MODEL R650-2U', '480 V 3 PH',
+    'FORM FACTOR 4U', 'STATIC LOAD 900 KG', '25 OUTLETS (12x C13)', '48-PORT 10G']), srv);
+  assert.deepEqual(bad.filter(c => c.status === 'mismatch').map(c => c.key).sort(),
+    ['formFactor', 'outletTypes', 'portSpeed', 'rackLoad'].sort());
+});