bmweb-cli 0.1.0

package/runtime/home/bmweb-home.ips

@@ -0,0 +1,76 @@
+//**********************************************************************
+//*
+//* BMWeb home: the app's front door as an INPA script, so a terminal (or
+//* any host that runs .IPO) starts where the app starts. Pick a chassis,
+//* pick a module, and scriptchange hands the screen to that module's own
+//* INPA script, exactly as INPA's vehicle selection does.
+//*
+//* Written by the BMWeb project.
+//*
+//**********************************************************************
+#include "bmweb.h"
+
+string chassis = "";
+string module  = "";
+string status  = "";
+
+inpainit()
+{
+  settitle("BMWeb");
+  setscreen(s_main, TRUE);
+  setmenu(m_main);
+}
+
+MENU m_main()
+{
+  INIT {
+    setmenutitle("BMWeb");
+  }
+  ITEM( 1 ,"Vehicle")  {
+    bmweb_pick("chassis", "", chassis);
+    if (chassis != "")
+    {
+      bmweb_pick("module", chassis, module);
+      if (module != "")
+      {
+        scriptchange(module);
+      }
+    }
+  }
+  ITEM( 2 ,"Error scan")  {
+    bmweb_pick("chassis", "", chassis);
+    if (chassis != "")
+    {
+      bmweb_pick("vehicle", chassis, module);
+      if (module != "")
+      {
+        scriptchange(module);
+      }
+      else
+      {
+        messagebox("Error scan", "INPA ships no whole-vehicle script for this chassis.");
+      }
+    }
+  }
+  ITEM( 9 ,"Print")  {
+    printscreen();
+  }
+  ITEM( 20 ,"Exit")  {
+    exit();
+  }
+}
+
+SCREEN s_main()
+{
+  bmweb_status(status);
+  ftextout("BMWeb", 1, 0, 1, 0);
+  ftextout("", 3, 0, 0, 0);
+  LINE("","")
+  {
+    ftextout("< F1 >  Vehicle: pick a chassis, then a module", 4, 5, 0, 1);
+    ftextout("< F2 >  Error scan: INPA's whole-vehicle script", 6, 5, 0, 1);
+    ftextout("< F9 >  Print", 20, 5, 0, 1);
+    ftextout("<Shift> + < F10>  Exit", 22, 45, 0, 1);
+    ftextout(status, 12, 5, 0, 1);
+  }
+}

package/runtime/home/bmweb.h

@@ -0,0 +1,26 @@
+// BMWeb's own include for scripts of its own: the INPA builtins those
+// scripts call, declared the way inpa.h declares them (parameter modes are
+// what the compiler needs to pass out-parameters by reference), plus the
+// two builtins BMWeb adds so a script can ask the app for a pick.
+//
+// Written by the BMWeb project. Nothing here is copied from BMW's headers.
+
+// INPA builtins used by the home script
+extern setmenutitle( in: string title);
+extern settitle( in: string title);
+extern setmenu( in: menu name);
+extern setscreen( in: screen name, in: bool flag);
+extern scriptchange( in: string NewScriptFile);
+extern printscreen();
+extern exit();
+extern messagebox( in: string Title, in: string Text);
+extern ftextout( in: string text, in: int row, in: int col, in: int attr, in: int mode);
+
+// BMWeb builtins (0xE0 and up; unused by INPA)
+//   bmweb_pick("chassis", "", chassis)     the app lists its chassis, the user picks one
+//   bmweb_pick("module", chassis, sgbd)    the modules of that chassis, picked one's SGBD
+//   bmweb_pick("vehicle", chassis, sgbd)   the chassis's whole-vehicle script, "" if none
+//   A cancelled pick leaves the out-string empty.
+extern bmweb_pick( in: string what, in: string arg, out: string choice);
+//   bmweb_status(text)   one line from the app: cable state, version
+extern bmweb_status( out: string text);

package/runtime/screens/activations.js

@@ -0,0 +1,258 @@
+// Actuator release, INPA's way: we do NOT synthesize a stop telegram.
+//
+// An actuator menu in the .IPO releases (or does not) through its OWN keys.
+// On the MS45 MIL menu the release is a key -- "Ansteuerung zurück an DME"
+// (STEUERN_MIL_ENDE) -- and its BACK key just navigates: INPA leaves the MIL
+// commanded and lets the ECU's own actuator timeout end it. On kombi's
+// STEUERN_46 menu the BACK key itself carries DIAGNOSE_ENDE. Either way the
+// truth is in the bytecode the IR already carries, so the ONE honest release
+// is: run the leaving menu's Back-item job, and only that.
+//
+// The old registry (activeTests / activeDrives / an "<arg>;0" off form
+// replayed on leave) invented releases INPA never sends and guessed the wrong
+// telegram when it did -- firing STEUERN_MIL?arg=0, itself a drive command,
+// on back-out. Gone. What a menu owes on the way out is what its Back key
+// runs; what it owes on ECU exit is inpaexit's DIAGNOSE_ENDE (registerSessionEnd
+// below), which is likewise read from the script, not made up.
+
+// ---- the menu's on-leave job -----------------------------------------------
+//
+// Set by ir.js as it renders a menu: the job the current menu's Back item
+// runs (null for a menu whose Back only navigates). Sent once, when a render
+// for a DIFFERENT menu (or a real leave) follows -- a same-menu repaint must
+// not fire it.
+/** The ECU whose menu is open. @type {{sgbd: string}|null} */
+let leaveEcu = null;
+/** The job the current menu's Back item runs on leave. @type {string|null} */
+let leaveJob = null;
+/** The Back key's argument (STEUERN_DISPLAY "0"): sent with it. @type {string|null} */
+let leaveArg = null;
+/** "sgbd:menu", so a repaint of the same menu is a no-op. @type {string|null} */
+let leaveKey = null;
+/** Did THIS menu fire a drive? (for pagehide only) @type {boolean} */
+let _leftEnergized = false;
+
+/**
+ * Register what the menu being drawn owes on the way out, first settling what
+ * the PREVIOUS menu owed (its composite neutral word and/or its Back job).
+ * Called by the runtime as it renders a menu; a same-menu repaint keeps the
+ * key and fires nothing.
+ * @param {{sgbd: string}|null} ecu - The ECU the menu belongs to.
+ * @param {string|null} menuKey - "sgbd:menu" identity of the menu.
+ * @param {string|null} job - The Back item's job, or null when Back only navigates.
+ * @param {string|number|null} [arg] - The Back item's argument, if any.
+ * @returns {void}
+ */
+function registerMenuLeave(ecu, menuKey, job, arg) {
+  // a different menu is being set up: run what the PREVIOUS one owed
+  if (leaveKey && leaveKey !== menuKey) {
+    if (compEcu?.sgbd && compJob) {
+      try {
+        api(
+          `/api/ecu/${compEcu.sgbd}/run/${compJob}` +
+            `?arg=${encodeURIComponent(compArg)}`,
+          { method: 'POST' }
+        ).catch(() => {});
+      } catch (e) {
+        /* leaving */
+      }
+      _clearComposite();
+    }
+    if (leaveJob && leaveEcu) _sendLeave(leaveEcu, leaveJob, leaveArg);
+  }
+  leaveEcu = ecu || null;
+  leaveJob = job || null;
+  leaveArg = arg != null && arg !== '' ? String(arg) : null;
+  leaveKey = menuKey || null;
+  _leftEnergized = false;
+}
+
+// ir.js calls this when a drive is fired in the current menu, so a tab-close
+// can run the Back job even for a menu whose release is a separate key.
+/**
+ * Note that the current menu energized something (drives the pagehide release).
+ * @returns {void}
+ */
+function markEnergized() {
+  _leftEnergized = true;
+}
+
+// A composite actuator word (LSZ-style: several outputs in one job) releases
+// by being RE-COMMANDED to neutral -- INPA's own behavior, not a synthetic
+// _ENDE. ir.js registers the neutral word here; runMenuLeave re-sends it.
+/** The ECU / job / neutral argument of a registered composite word. */
+let compEcu = null,
+  compJob = null,
+  compArg = null;
+
+/**
+ * Register a composite actuator word's neutral form, re-sent on leave.
+ * @param {{sgbd: string}|null} ecu - The ECU.
+ * @param {string|null} job - The composite job.
+ * @param {string} neutralArg - The argument that commands every output to neutral.
+ * @returns {void}
+ */
+function registerCompositeNeutral(ecu, job, neutralArg) {
+  compEcu = ecu || null;
+  compJob = job || null;
+  compArg = neutralArg;
+}
+
+/**
+ * Forget the registered composite word.
+ * @returns {void}
+ */
+function _clearComposite() {
+  compEcu = compJob = compArg = null;
+}
+
+/**
+ * Fire a leave/end job, best effort: errors are swallowed, we are leaving anyway.
+ * @param {{sgbd: string}|null} ecu - The ECU.
+ * @param {string|null} job - The job.
+ * @param {string|null} [arg] - The argument, if any.
+ * @returns {void}
+ */
+function _sendLeave(ecu, job, arg) {
+  if (!ecu?.sgbd || !job) return;
+  try {
+    const q = arg != null ? `?arg=${encodeURIComponent(arg)}` : '';
+    api(`/api/ecu/${ecu.sgbd}/run/${job}${q}`, { method: 'POST' }).catch(
+      () => {}
+    );
+  } catch (e) {
+    /* leaving anyway */
+  }
+}
+
+// Called from the setActions leave hook (core.js). A same-menu repaint keeps
+// leaveKey unchanged and is held, so nothing fires; a real navigation has
+// already re-registered (or cleared) leaveKey via ir.js, so run what the menu
+// we are leaving owed.
+/**
+ * Run what the menu being left owed: the composite neutral word, then the
+ * Back item's job; then forget both.
+ * @returns {void}
+ */
+function runMenuLeave() {
+  // a composite word: re-command it to neutral, then forget the flags
+  if (compEcu?.sgbd && compJob) {
+    try {
+      api(
+        `/api/ecu/${compEcu.sgbd}/run/${compJob}` +
+          `?arg=${encodeURIComponent(compArg)}`,
+        { method: 'POST' }
+      ).catch(() => {});
+    } catch (e) {
+      /* leaving */
+    }
+    _clearComposite();
+  }
+  if (leaveJob && leaveEcu) {
+    const ecu = leaveEcu,
+      job = leaveJob,
+      arg = leaveArg;
+    _sendLeave(ecu, job, arg);
+  }
+  leaveEcu = leaveJob = leaveArg = leaveKey = null;
+}
+
+// ---- ECU session end (inpaexit's DIAGNOSE_ENDE) ----------------------------
+// Unchanged in spirit: read from the script, sent on ECU exit however it
+// happens. Registered on ENTRY so it fires even when the user leaves by a
+// path we do not draw.
+/** The ECU whose session-end job is registered. @type {{sgbd: string}|null} */
+let sessionEndEcu = null;
+/** The registered session-end job (inpaexit's DIAGNOSE_ENDE). @type {string|null} */
+let sessionEndJob = null;
+/** An end deferred to the microtask, so a submenu hop can cancel it. @type {{ecu: {sgbd: string}, job: string}|null} */
+let _pendingEnd = null;
+
+/**
+ * Register the ECU's session-end job on ENTRY, so it fires however the user
+ * leaves.
+ * @param {{sgbd: string}|null} ecu - The ECU.
+ * @param {string|null} job - The session-end job.
+ * @returns {void}
+ */
+function registerSessionEnd(ecu, job) {
+  if (!ecu || !job) return;
+  sessionEndEcu = ecu;
+  sessionEndJob = job;
+}
+
+/**
+ * Send the registered session-end job, deferred one microtask so a submenu
+ * hop that re-registers the same ECU cancels it.
+ * @returns {void}
+ */
+function endActivationSession() {
+  const ecu = sessionEndEcu;
+  const job = sessionEndJob;
+  sessionEndEcu = null;
+  sessionEndJob = null;
+  if (!ecu?.sgbd || !job) return;
+  // a submenu hop re-registers the same ECU before this microtask runs, so
+  // only send once we are truly off this ECU.
+  _pendingEnd = { ecu, job };
+  queueMicrotask(() => {
+    const p = _pendingEnd;
+    _pendingEnd = null;
+    if (!p || (sessionEndJob === p.job && sessionEndEcu?.sgbd === p.ecu.sgbd)) {
+      return;
+    }
+    _sendLeave(p.ecu, p.job);
+  });
+}
+
+// ---- same-screen repaint hold ----------------------------------------------
+// ir.js reopens its menu after a drive so each row shows its armed state.
+// That repaint must not count as leaving: registerMenuLeave keeps the same
+// leaveKey, and this hold stops the leave hook from running mid-repaint.
+/** True while a same-menu repaint runs, so the leave hook stays quiet. @type {boolean} */
+let _activationsHeld = false;
+
+/**
+ * Run a same-menu repaint with the leave hook held off.
+ * @param {() => void} fn - The repaint.
+ * @returns {void}
+ */
+function keepActivationsDuring(fn) {
+  _activationsHeld = true;
+  try {
+    fn();
+  } finally {
+    _activationsHeld = false;
+  }
+}
+
+/**
+ * Whether a repaint hold is active (read by the action bar's leave hook).
+ * @returns {boolean}
+ */
+const activationsHeld = () => _activationsHeld;
+
+// ---- page teardown ---------------------------------------------------------
+// Tab close / reload / navigation: the setActions leave hook never fires.
+// Run the leaving menu's Back job (if it had one and we energized something)
+// and the ECU session end, synchronously -- microtasks never run on unload.
+window.addEventListener('pagehide', () => {
+  if (_leftEnergized) {
+    if (compEcu?.sgbd && compJob) {
+      _sendLeave(compEcu, compJob); // best effort; arg lost on unload, but neutral job runs
+    }
+    if (leaveEcu && leaveJob) _sendLeave(leaveEcu, leaveJob, leaveArg);
+  }
+  const ecu = sessionEndEcu,
+    job = sessionEndJob;
+  sessionEndEcu = sessionEndJob = _pendingEnd = null;
+  _sendLeave(ecu, job);
+});
+
+// Warn before closing the tab while an actuator is energized -- only prompts;
+// the actual release rides pagehide so a cancelled close does not kill it.
+window.addEventListener('beforeunload', (e) => {
+  if (!_leftEnergized) return;
+  e.preventDefault();
+  e.returnValue = '';
+});

package/runtime/screens/garage/diff.js

@@ -0,0 +1,331 @@
+/**
+ * @file Comparing two stored scans. Pure data in, pure data out -- the screen
+ * draws what this returns and the harness pins it without a DOM.
+ *
+ * What a fault is matched on: the module it sits in (SGBD, the variant that
+ * answered) plus the fault's own identity within that module. A stored fault
+ * carries both a hex code (F_HEX_CODE) and a location number (F_ORT_NR); the
+ * hex is the DTC and is preferred, and the location number is the fallback
+ * for the older modules that report no hex. Matching on the text would make a
+ * translation change look like a different fault.
+ *
+ * Presence (F_VORHANDEN / "currently present" vs merely stored) is NOT part of
+ * the identity: the same fault going from stored-only to present is the same
+ * fault, and is reported as unchanged rather than as one cleared and one new.
+ */
+
+/* exported garageFaultKeys, garageDiffScans, garageFaultKey, garageDiffCounts */
+
+/**
+ * What changed between two scans.
+ * @typedef {object} GarageDiff
+ * @property {GarageScan} from - the older scan
+ * @property {GarageScan} to - the newer scan
+ * @property {'faults'|'ident'|'mixed'} kind - what the two reads were
+ * @property {GarageDiffModule[]} modules - per module, in the newer scan's order
+ * @property {GarageDiffSilence[]} silence - modules whose answering changed
+ */
+
+/**
+ * One module's changes.
+ * @typedef {object} GarageDiffModule
+ * @property {string} sgbd
+ * @property {string} label
+ * @property {object[]} added - faults only the newer scan has
+ * @property {object[]} cleared - faults only the older scan has
+ * @property {object[]} same - faults in both
+ * @property {object[]} recurred - always empty now: a fault in both reads
+ *   is unchanged whatever its counter or freeze frame did (kept so the
+ *   screen and print paths need no shape change)
+ * @property {GarageDiffField[]} fields - ident fields whose value changed
+ * @property {boolean} [unread] - the newer read has no record of the module: nothing cleared, nothing known
+ * @property {boolean} changed - anything at all differs
+ */
+
+/**
+ * One ident field that moved.
+ * @typedef {object} GarageDiffField
+ * @property {string} key - the EDIABAS result name (ID_SW_NR, ...)
+ * @property {string} label - its caption
+ * @property {string} from - the older value ('' when absent)
+ * @property {string} to - the newer value ('' when absent)
+ */
+
+/**
+ * A module whose answering changed between the two reads.
+ * @typedef {object} GarageDiffSilence
+ * @property {string} target - the address or SGBD
+ * @property {string} label
+ * @property {'silent'|'answering'} state - 'silent' = answered before, quiet (or unread) now
+ * @property {string} [error] - the failure the newer scan recorded
+ */
+
+/**
+ * The identity of one fault inside its module: the DTC where the module
+ * reports one, else its location number, else the code its text leads with.
+ * @param {object} code - an FS_LESEN entry
+ * @returns {string} a stable key, '' when the entry names none of them
+ */
+function garageFaultKey(code) {
+  return garageFaultKeys(code)[0] || '';
+}
+
+/**
+ * EVERY identity a fault carries, strongest first. Two reads of the same
+ * module do not always carry the same fields for the same fault: one read
+ * has F_HEX_CODE and the next has only F_ORT_NR, one F_ORT_TEXT leads with
+ * the DTC ("27C3 DMTL ...") and the next is the bare description -- so a
+ * fault is matched on ANY identity it shares with the other read, or the
+ * one fault shows up as cleared AND new.
+ * @param {object} code - an FS_LESEN entry
+ * @returns {string[]} keys: 'H:<hex digits>' (from F_HEX_CODE or the text's leading DTC), 'N:<location nr>'
+ */
+function garageFaultKeys(code) {
+  const c = code || {};
+  const out = [];
+  // F_HEX_CODE is the whole fault word: the two-byte DTC and then status
+  // and environment bytes ("27-C3-22" one read, "27-C3-62" the next, once
+  // the fault's status moved). Only the code bytes are the identity, the
+  // same four digits the fault text leads with; and "27C3" / "27-C3" (bytes
+  // joined by hexText) are one spelling once the separators go.
+  const hex = String(c.F_HEX_CODE == null ? '' : c.F_HEX_CODE)
+    .trim()
+    .toUpperCase()
+    .replace(/^0X/, '')
+    .replace(/[^0-9A-F]/g, '')
+    .slice(0, 4);
+  if (hex) out.push('H:' + hex);
+  const nr = c.F_ORT_NR;
+  if (nr != null && String(nr).trim() !== '' && Number.isFinite(Number(nr)))
+    out.push('N:' + String(Number(nr)));
+  // the DTC a fault text leads with IS the hex code, so it shares the hex
+  // namespace: a read that carries only the text still meets one that
+  // carries only F_HEX_CODE
+  const m = /^([0-9A-F]{3,5})\b/i.exec(String(c.F_ORT_TEXT || '').trim());
+  if (m) {
+    const t = 'H:' + m[1].toUpperCase();
+    if (!out.includes(t)) out.push(t);
+  }
+  return out;
+}
+
+/**
+ * Index a report's modules by SGBD.
+ * @param {object} report - a stored report
+ * @returns {Map<string, object>}
+ */
+function garageModuleMap(report) {
+  const m = new Map();
+  for (const mod of (report && report.modules) || [])
+    m.set(String(mod.sgbd || '').toLowerCase(), mod);
+  return m;
+}
+
+/**
+ * Index a module's faults by identity. An entry naming neither a hex nor a
+ * location number cannot be matched, so it is left out of the comparison
+ * rather than being reported as both added and cleared every time.
+ * @param {object} mod - a module record
+ * @returns {Map<string, object>}
+ */
+function garageFaultMap(mod) {
+  const m = new Map();
+  for (const c of (mod && mod.codes) || []) {
+    for (const k of garageFaultKeys(c)) if (!m.has(k)) m.set(k, c);
+  }
+  return m;
+}
+
+/**
+ * The counterpart of a fault in the other read: the entry sharing any of
+ * its identities.
+ * @param {Map<string, object>} map - the other read's fault map
+ * @param {object} code - the fault to find
+ * @returns {object|null}
+ */
+function garageFaultMatch(map, code) {
+  for (const k of garageFaultKeys(code)) {
+    const hit = map.get(k);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+/**
+ * The ident fields that differ between two module records, in the order the
+ * protocol prints them.
+ * @param {object} a - the older module record
+ * @param {object} b - the newer module record
+ * @returns {GarageDiffField[]}
+ */
+function garageIdentFields(a, b) {
+  const ia = (a && a.ident) || null;
+  const ib = (b && b.ident) || null;
+  if (!ia && !ib) return [];
+  const rows =
+    typeof IPO_IDENT_ROWS !== 'undefined'
+      ? IPO_IDENT_ROWS
+      : [[['VARIANTE'], 'Variant']];
+  const out = [];
+  const seen = new Set();
+  const val = (id, k) => (id && id[k] != null ? String(id[k]).trim() : '');
+  for (const [keys, cap] of rows) {
+    for (const k of keys) {
+      seen.add(k);
+      const from = val(ia, k);
+      const to = val(ib, k);
+      if (from !== to)
+        out.push({
+          key: k,
+          label: keys.length > 1 ? `${cap} (${k})` : cap,
+          from,
+          to,
+        });
+    }
+  }
+  // anything the module answered that the printed table does not cover still
+  // counts as a change -- a new coding index matters whether or not it has a
+  // caption
+  const extra = new Set([...Object.keys(ia || {}), ...Object.keys(ib || {})]);
+  for (const k of extra) {
+    if (seen.has(k) || k.startsWith('_')) continue;
+    const from = val(ia, k);
+    const to = val(ib, k);
+    if (from !== to) out.push({ key: k, label: k, from, to });
+  }
+  return out;
+}
+
+/**
+ * Compare two stored scans, older against newer.
+ * @param {GarageScan} from - the older scan
+ * @param {GarageScan} to - the newer scan
+ * @returns {GarageDiff}
+ */
+function garageDiffScans(from, to) {
+  const ra = (from && from.report) || { modules: [], silent: [] };
+  const rb = (to && to.report) || { modules: [], silent: [] };
+  const A = garageModuleMap(ra);
+  const B = garageModuleMap(rb);
+  const kind = ra.kind === rb.kind ? rb.kind || 'faults' : 'mixed';
+
+  /** @type {GarageDiffModule[]} */
+  const modules = [];
+  // the newer scan's order first, then anything only the older one saw
+  const order = [...B.keys(), ...[...A.keys()].filter((k) => !B.has(k))];
+  /** @type {GarageDiffSilence[]} */
+  const silence = [];
+  const noted = new Set();
+  const note = (target, label, state, error) => {
+    const t = String(target || '').toLowerCase();
+    if (!t || noted.has(t)) return;
+    noted.add(t);
+    silence.push({ target: t, label: label || t.toUpperCase(), state, error });
+  };
+  for (const sgbd of order) {
+    const a = A.get(sgbd);
+    const b = B.get(sgbd);
+    // a module the newer read has no record of did not answer (or was not
+    // asked) this time: its faults are not cleared, they are unread, and
+    // that is an answering change, not a fault change
+    if (a && !b) {
+      note(a.via || sgbd, a.label, 'silent', 'not read this time');
+      modules.push({
+        sgbd,
+        label: a.label || sgbd,
+        added: [],
+        cleared: [],
+        same: [],
+        recurred: [],
+        fields: [],
+        unread: true,
+        changed: false,
+      });
+      continue;
+    }
+    if (!a && b) note(b.via || sgbd, b.label, 'answering');
+    const fa = garageFaultMap(a);
+    const added = [];
+    const cleared = [];
+    const same = [];
+    // a fault present in both reads is unchanged, full stop: the occurrence
+    // counter and the freeze frame are not consulted (the DME keeps the
+    // frame from the first occurrence and bumps the counter on its own, and
+    // neither is a change the owner did anything about)
+    const recurred = [];
+    const matched = new Set(); // the older read's entries that found a partner
+    for (const c of (b && b.codes) || []) {
+      if (!garageFaultKeys(c).length) continue; // nothing to match on
+      const old = garageFaultMatch(fa, c);
+      if (!old) {
+        added.push(c);
+        continue;
+      }
+      matched.add(old);
+      same.push(c);
+    }
+    for (const c of (a && a.codes) || [])
+      if (garageFaultKeys(c).length && !matched.has(c)) cleared.push(c);
+    const fields = kind === 'faults' ? [] : garageIdentFields(a, b);
+    modules.push({
+      sgbd,
+      label: (b && b.label) || (a && a.label) || sgbd,
+      added,
+      cleared,
+      same,
+      recurred,
+      fields,
+      changed: !!(
+        added.length ||
+        cleared.length ||
+        fields.length ||
+        recurred.length
+      ),
+    });
+  }
+
+  // answering changed: a module that answered before and is quiet now (or the
+  // other way round). Reading the silent lists alone would miss a module that
+  // simply stopped being asked, so both sides are checked.
+  const silentA = new Map(
+    (ra.silent || []).map((s) => [String(s.target || '').toLowerCase(), s])
+  );
+  const silentB = new Map(
+    (rb.silent || []).map((s) => [String(s.target || '').toLowerCase(), s])
+  );
+  for (const [t, s] of silentB)
+    if (!silentA.has(t)) note(t, s.label, 'silent', s.error);
+  for (const [t, s] of silentA)
+    if (!silentB.has(t)) note(t, s.label, 'answering');
+
+  return { from, to, kind, modules, silence };
+}
+
+/**
+ * The headline counts of a diff.
+ * @param {GarageDiff} diff - the comparison
+ * @returns {{added: number, cleared: number, same: number, fields: number, silence: number, modules: number}}
+ */
+function garageDiffCounts(diff) {
+  const mods = (diff && diff.modules) || [];
+  const n = (pick) => mods.reduce((t, m) => t + m[pick].length, 0);
+  return {
+    added: n('added'),
+    cleared: n('cleared'),
+    same: n('same'),
+    recurred: n('recurred'),
+    fields: n('fields'),
+    silence: ((diff && diff.silence) || []).length,
+    modules: mods.filter((m) => m.changed).length,
+  };
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    garageDiffScans,
+    garageFaultKey,
+    garageFaultKeys,
+    garageDiffCounts,
+    garageIdentFields,
+  };
+}