bmweb-cli 0.1.0

package/runtime/screens/ipo-runtime/paint-modern.js

@@ -0,0 +1,424 @@
+/**
+ * @file The modern skin: the same cycle's emissions grouped the way the
+ * script wrote them -- one row per LINE block -- and a menu's backdrop
+ * legend shown as the function-group tiles the app has always used. Nothing
+ * here decides what a line means: a row exists because the program painted
+ * it this cycle, keyed by the result the script bound.
+ */
+
+/**
+ * INPA's key-legend notation as a menu's backdrop prints it: "< F4 >
+ * Fehlerspeicher lesen", "< Shift > + < F6 >  EWS". Group 1 = the Shift
+ * prefix, 2 = the key number, 3 = the caption.
+ * @type {RegExp}
+ */
+const IPO_KEY_LEGEND =
+  /^\s*(<\s*Shift\s*>\s*\+\s*)?<\s*F\s*(\d+)\s*>\s*(\S.*)$/i;
+
+/** How many tiles enter with a stagger before the animation is skipped. */
+const IPO_TILE_STAGGER = 20;
+
+/**
+ * One row of the modern skin.
+ * @typedef {object} IpoRow
+ * @property {string} caption - the caption pieces joined
+ * @property {string[]} parts - the caption pieces as printed
+ * @property {IpoRowCell[]} cells - the value/lamp/gauge cells
+ * @property {string} trailer - text printed after the values (a unit)
+ * @property {boolean} band - first row of its logical line
+ */
+
+/**
+ * A cell of a modern row.
+ * @typedef {object} IpoRowCell
+ * @property {'text'|'value'|'lamp'|'gauge'} kind - what drew it
+ * @property {string|null} key - the result key
+ * @property {string} text - the text
+ * @property {string} [on] - a lamp's TrueText
+ * @property {string} [off] - a lamp's FalseText
+ * @property {IpoCellMeta|null} meta - the instrument's declaration
+ */
+
+/**
+ * A menu shown as tiles.
+ * @typedef {object} IpoMenuTiles
+ * @property {Array<{nr: number, shift: boolean, label: string, legend: string, cat: string}>} tiles - one per key
+ * @property {IpoRow[]} rest - the rows that were not legend lines
+ */
+
+/**
+ * The rows of the last cycle, one per LINE block (a LINE that prints several
+ * screen rows is several rows here too: INPA laid them out one under the
+ * other). Within a row the text elements before the first value are its
+ * caption, the value/lamp/gauge elements are its cells, text after a value
+ * is a unit or trailer. A row with only text is a note -- unless it was
+ * printed in two or more pieces at different columns, which is a caption
+ * and its value (ZKE5's info screen: "Rework program" at column 0, ":" at
+ * 33, the name at 35 -- copied into strings at startup and printed with
+ * ftextout). The first piece is the caption, a lone ":" is dropped, the
+ * rest are the value.
+ * @param {IpoProgram} p - the program (its lines and cells)
+ * @returns {IpoRow[]}
+ */
+function ipoLineRows(p) {
+  const rows = [];
+  for (const ln of p.lines || []) {
+    const els = (ln.elements || [])
+      .filter((el) => el.row != null && el.col != null)
+      .sort((a, b) => a.row - b.row || a.col - b.col);
+    if (!els.length) continue;
+    const cellOf = (el) => p.cells.get(`${el.row}:${el.col}`);
+    const byRow = new Map();
+    for (const el of els) {
+      if (!byRow.has(el.row)) byRow.set(el.row, []);
+      byRow.get(el.row).push(el);
+    }
+    let first = true;
+    const groups = [...byRow.values()];
+    for (let gi = 0; gi < groups.length; gi++) {
+      const group = groups[gi];
+      // INPA's status idiom: captions on one screen row, the lamps or bars
+      // under them on the next, column by column ("Klemme 15" at col 1 over
+      // its lamp at col 1, "Motor steht" at col 30 over its own). Read as
+      // rows those were a caption row with the second caption taken for a
+      // value, then an anonymous row of lamps. Pair each cell with the
+      // caption standing over it and emit one row per pair.
+      const paired = ipoPairCaptionRow(group, groups[gi + 1], cellOf);
+      if (paired) {
+        for (const r of paired) {
+          rows.push({ ...r, band: first });
+          first = false;
+        }
+        gi += 1; // the cell row is consumed
+        continue;
+      }
+      const caption = [];
+      const cells = [];
+      const trailer = [];
+      for (const el of group) {
+        const c = cellOf(el);
+        const text = c ? c.text : '';
+        if (el.t === 'text') {
+          if (!text.trim()) continue;
+          (cells.length ? trailer : caption).push(text.trim());
+        } else {
+          cells.push({
+            kind: el.t,
+            key: el.key || null,
+            text,
+            on: el.on,
+            off: el.off,
+            meta: c ? c.meta : null,
+          });
+        }
+      }
+      if (!caption.length && !cells.length) continue;
+      if (
+        !cells.length &&
+        caption.length >= 2 &&
+        !IPO_KEY_LEGEND.test(caption[0])
+      ) {
+        const rest = caption.slice(1).filter((t) => t !== ':');
+        if (rest.length) {
+          for (const t of rest)
+            cells.push({ kind: 'text', key: null, text: t, meta: null });
+          caption.length = 1;
+        }
+      }
+      rows.push({
+        caption: caption.join('  '),
+        parts: caption,
+        cells,
+        trailer: trailer.join(' '),
+        band: first, // first row of its logical line
+      });
+      first = false;
+    }
+  }
+  return rows;
+}
+
+/**
+ * A caption row over a cell row, paired by column: each lamp/bar takes the
+ * nearest caption at or left of its column. Null when the two rows are not
+ * that shape (the top row has a non-text element, the bottom row has text,
+ * or two cells would share a caption -- a heading over several lamps stays
+ * a heading).
+ * @param {IpoElement[]} top - the elements of one screen row
+ * @param {IpoElement[]|undefined} bottom - the elements of the next row
+ * @param {(el: IpoElement) => IpoCell|undefined} cellOf - the painted cell for an element
+ * @returns {Array<{caption: string, parts: string[], cells: IpoRowCell[], trailer: string}>|null}
+ */
+function ipoPairCaptionRow(top, bottom, cellOf) {
+  if (!bottom || !bottom.length) return null;
+  const textOf = (el) => ((cellOf(el) || {}).text || '').trim();
+  // a caption is printed text, or a result printed as text that reads as a
+  // label (a measurement block prints STAT_MESSWERTn_TEXT over each bar)
+  const isLabel = (el) =>
+    el.t === 'text' ||
+    (el.t === 'value' &&
+      /[A-Za-z]/.test(textOf(el)) &&
+      !/^-?\d/.test(textOf(el)));
+  if (!top.every(isLabel)) return null;
+  // the row under it holds lamps or bars, plus printed units after them
+  if (!bottom.some((el) => el.t === 'lamp' || el.t === 'gauge')) return null;
+  if (
+    bottom.some((el) => el.t !== 'lamp' && el.t !== 'gauge' && el.t !== 'text')
+  )
+    return null;
+  const caps = top
+    .map((el) => ({ col: el.col, text: textOf(el) }))
+    .sort((a, b) => a.col - b.col);
+  if (!caps.length) return null;
+  const sorted = [...bottom].sort((a, b) => a.col - b.col);
+  const used = new Set();
+  const out = [];
+  for (const el of sorted) {
+    if (el.t === 'text') {
+      // a unit or note printed after a cell belongs to that cell
+      const t = textOf(el);
+      if (!out.length) return null;
+      if (t) {
+        const last = out[out.length - 1];
+        last.trailer = `${last.trailer} ${t}`.trim();
+      }
+      continue;
+    }
+    let cap = null;
+    for (const c of caps) if (c.col <= el.col + 1) cap = c;
+    if (!cap) cap = caps[0];
+    if (used.has(cap)) return null;
+    used.add(cap);
+    const c = cellOf(el);
+    out.push({
+      caption: cap.text,
+      parts: cap.text ? [cap.text] : [],
+      cells: [
+        {
+          kind: el.t,
+          key: el.key || null,
+          text: c ? c.text : '',
+          on: el.on,
+          off: el.off,
+          meta: c ? c.meta : null,
+        },
+      ],
+      trailer: '',
+    });
+  }
+  return out;
+}
+
+/**
+ * A tile's category class from the SGBD job the key's body sends (a fixed
+ * vocabulary), never from the caption.
+ * @param {string|null|undefined} job - job name
+ * @returns {string}
+ */
+function ipoJobCategory(job) {
+  if (!job) return '';
+  if (/^(FS|IS|HS)_/i.test(job)) return 'gt-fault';
+  if (/^(STATUS|MESSWERT)/i.test(job)) return 'gt-live';
+  if (/^(STEUERN|START)/i.test(job)) return 'gt-act';
+  if (/IDENT|^INFO$/i.test(job)) return 'gt-info';
+  if (/COD|ADAPT|ABGLEICH/i.test(job)) return 'gt-code';
+  return '';
+}
+
+/**
+ * nr -> the caption the current screen printed for that key in its legend.
+ * @param {IpoProgram} p - the program
+ * @param {string[]|null} [notes] - collects the caption pieces that are not legend lines
+ * @returns {Map<number, string>}
+ */
+function ipoLegendMap(p, notes) {
+  const legend = new Map();
+  for (const r of ipoLineRows(p)) {
+    for (const t of r.parts || []) {
+      const m = t.match(IPO_KEY_LEGEND);
+      if (!m) {
+        if (notes) notes.push(t);
+        continue;
+      }
+      const nr = Number(m[2]) + (m[1] ? IPO_SHIFT_BASE : 0);
+      if (!legend.has(nr)) legend.set(nr, m[3].trim());
+    }
+  }
+  return legend;
+}
+
+/**
+ * A menu's backdrop as tiles: one per ITEM the script declared, captioned
+ * by the ITEM's own short label, described by the legend line the screen
+ * printed for that key. A screen that prints no legend is a readout, drawn
+ * as rows (null). ZKE5's main screen prints BOTH -- the part number and
+ * build date above the legend -- so those rows stay rows (`rest`) and the
+ * legend becomes the tiles.
+ * @param {IpoProgram} p - the program
+ * @returns {IpoMenuTiles|null}
+ */
+function ipoMenuTiles(p) {
+  const rows = ipoLineRows(p);
+  const legend = ipoLegendMap(p, null);
+  if (!legend.size) return null;
+  const items = (p.items || []).filter((it) => !it.hidden || legend.has(it.nr));
+  if (!items.length || !items.some((it) => legend.has(it.nr))) return null;
+  const rest = rows.filter(
+    (r) => !(r.parts || []).some((t) => IPO_KEY_LEGEND.test(t))
+  );
+  const toks = p.exec && p.exec.procs ? p.exec.procs[p.menu] : null;
+  const tiles = items.map((it) => {
+    let cat = '';
+    if (toks && typeof irItemBodyJobs === 'function') {
+      const jobs = irItemBodyJobs(p.exec, toks, it.start, it.end) || [];
+      for (const j of jobs) {
+        cat = ipoJobCategory(j);
+        if (cat) break;
+      }
+    }
+    return {
+      nr: it.nr,
+      shift: !!it.shift,
+      label: it.label || legend.get(it.nr) || '',
+      legend: legend.get(it.nr) || '',
+      cat: cat || 'gt-default',
+    };
+  });
+  return { tiles, rest };
+}
+
+/**
+ * Paint a menu's tiles. A backdrop screen can be frequent: the cycle
+ * repaints every tick. The tiles are rebuilt (and their entrance animation
+ * replayed) only when what they show changed, else the grid is left exactly
+ * as it is.
+ * @param {HTMLElement} gridEl - the screen container
+ * @param {IpoProgram} p - the program
+ * @param {IpoMenuTiles} menu - the tiles to draw
+ * @returns {void}
+ */
+function ipoPaintTiles(gridEl, p, menu) {
+  const sig = JSON.stringify([p.menu, menu.tiles, menu.rest]);
+  if (gridEl._ipoTilesSig === sig) return;
+  gridEl._ipoTilesSig = sig;
+  const notes = ipoRowsHtml(menu.rest);
+  const grid = document.createElement('div');
+  grid.className = 'group-grid stagger';
+  for (const t of menu.tiles) {
+    const tile = document.createElement('div');
+    tile.className = `group-tile ${t.cat}`;
+    const fk = `${t.shift ? 'Shift+' : ''}F${t.nr > IPO_SHIFT_BASE ? t.nr - IPO_SHIFT_BASE : t.nr}`;
+    const name = ipoText(t.label);
+    const desc = t.legend ? ipoText(t.legend) : '';
+    tile.innerHTML =
+      `<div class="group-header-row"><span class="group-fkey">${esc(fk)}</span></div>` +
+      `<div class="group-name">${esc(name)}</div>` +
+      `<div class="group-count">${esc(desc !== name ? desc : '')}</div>` +
+      `<div class="group-arrow">→</div>`;
+    tile.onclick = () => p.press(t.nr);
+    grid.appendChild(tile);
+  }
+  gridEl.classList.add('ipo-tiles');
+  gridEl.innerHTML = notes ? `<div class="ipo-notes">${notes}</div>` : '';
+  gridEl.appendChild(grid);
+  if (typeof stagger === 'function') stagger(grid, IPO_TILE_STAGGER);
+}
+
+/**
+ * Paint the modern skin: a menu's tiles when the screen printed a legend,
+ * else the LINE rows; a screen func that printed without LINE blocks (a
+ * userbox, a banner) falls back to its rows of text in order.
+ * @param {HTMLElement} gridEl - the screen container
+ * @param {IpoProgram} p - the program
+ * @returns {void}
+ */
+function ipoPaintLines(gridEl, p) {
+  const menu = ipoMenuTiles(p);
+  if (menu) {
+    ipoPaintTiles(gridEl, p, menu);
+    return;
+  }
+  gridEl._ipoTilesSig = null;
+  gridEl.classList.remove('ipo-tiles');
+  const rows = ipoLineRows(p);
+  if (!rows.length) {
+    const texts = [...p.cells.values()]
+      .filter((c) => c.text && c.text.trim())
+      .sort((a, b) => a.row - b.row || a.col - b.col);
+    if (!texts.length) {
+      gridEl.innerHTML = `<div class="ipo-empty">${esc(ipoText(p.title || ''))}</div>`;
+      return;
+    }
+    const byRow = new Map();
+    for (const c of texts) {
+      if (!byRow.has(c.row)) byRow.set(c.row, []);
+      byRow.get(c.row).push(ipoText(c.text).trim());
+    }
+    gridEl.innerHTML = [...byRow.values()]
+      .map(
+        (parts) =>
+          `<div class="ipo-line ipo-line-note">${esc(parts.join(' '))}</div>`
+      )
+      .join('');
+    return;
+  }
+  gridEl.innerHTML = ipoRowsHtml(rows);
+}
+
+/**
+ * The modern rows' HTML (see ipoLineRows). A logical line's first row gets
+ * air above it (one LINE per fault); a row with no caption is the value
+ * itself (a fault's own header row).
+ * @param {IpoRow[]} rows - the rows
+ * @returns {string} HTML
+ */
+function ipoRowsHtml(rows) {
+  const html = [];
+  const capHtml = (parts) =>
+    parts
+      .map((t) => esc(ipoText(t).replace(/\s*[:=]\s*$/, '')))
+      .join('<span class="ipo-line-gap"></span>');
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    const cap = capHtml(r.parts || [r.caption]);
+    const band = i > 0 && r.band ? ' ipo-band' : '';
+    if (!r.cells.length) {
+      html.push(`<div class="ipo-line ipo-line-note${band}">${cap}</div>`);
+      continue;
+    }
+    const cells = r.cells
+      .map((c) => {
+        const text = ipoText(c.text);
+        const key = c.key ? ` data-key="${esc(c.key)}"` : '';
+        if (c.kind === 'lamp') return ipoLampHtml(c);
+        if (c.kind === 'gauge') return ipoGaugeHtml(c);
+        return `<span class="ipo-line-val ipo-${c.kind}"${key}>${esc(text.trim())}</span>`;
+      })
+      .join('');
+    const unit = r.trailer
+      ? `<span class="ipo-line-unit">${esc(ipoText(r.trailer))}</span>`
+      : '';
+    const nocap = r.parts && r.parts.length ? '' : ' ipo-nocap';
+    html.push(
+      `<div class="ipo-line${band}${nocap}">` +
+        `<span class="ipo-line-cap">${cap}</span>` +
+        `<span class="ipo-line-cells">${cells}${unit}</span>` +
+        `</div>`
+    );
+  }
+  return html.join('');
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    IPO_KEY_LEGEND,
+    ipoLineRows,
+    ipoPairCaptionRow,
+    ipoJobCategory,
+    ipoLegendMap,
+    ipoMenuTiles,
+    ipoPaintTiles,
+    ipoPaintLines,
+    ipoRowsHtml,
+  };
+}

package/runtime/screens/ipo-runtime/print.js

@@ -0,0 +1,281 @@
+/**
+ * @file INPA's Print screen (the script's printscreen, the F9 key, Cmd/Ctrl+P
+ * on a module view) as a clean sheet: the module and menu named at the top,
+ * the screen as the car answered it, the keys the script offers, and no app
+ * chrome. In INPA mode the sheet is the 80-column text grid, lamps and bars
+ * spelled out; in modern mode it is the same rows as a caption / value /
+ * unit table. Built on core/print.js, so it paginates and prints
+ * black-on-white whatever theme the app wears.
+ */
+
+/** Columns of INPA's virtual screen the printed grid keeps. */
+const IPO_PRINT_COLS = 80;
+
+/**
+ * One grid row as plain text: cells placed at their columns, a lamp as
+ * "[x] word" / "[ ] word", a bar as its reading followed by the declared
+ * scale.
+ * @param {Array<{col: number, text: string, kind: string, meta: IpoCellMeta|null}>} cells - the row's cells, column order
+ * @returns {string}
+ */
+function ipoPrintRowText(cells) {
+  let out = '';
+  for (const c of cells) {
+    const gap = Math.max(c.col - out.length, out.length > 0 ? 1 : 0);
+    out += ' '.repeat(gap);
+    if (c.kind === 'lamp') {
+      out += `[${ipoLampOn(c) ? 'x' : ' '}] ${ipoText(c.text).trim()}`;
+    } else if (c.kind === 'gauge') {
+      out += `${ipoText(c.text).trim()}${ipoPrintScale(c.meta)}`;
+    } else {
+      out += c.text;
+    }
+  }
+  return out.replace(/\s+$/, '');
+}
+
+/**
+ * A bar's declared scale for the sheet: " (min..max)" when it has one.
+ * @param {IpoCellMeta|null} m - the cell's declaration
+ * @returns {string}
+ */
+function ipoPrintScale(m) {
+  if (
+    !m ||
+    m.min == null ||
+    m.max == null ||
+    !Number.isFinite(m.min) ||
+    !Number.isFinite(m.max)
+  )
+    return '';
+  return ` (${ipoScaleLabel(m.min)}..${ipoScaleLabel(m.max)})`;
+}
+
+/**
+ * The INPA grid as text lines, top row to the last printed one, blank rows
+ * kept so the layout INPA chose survives on paper.
+ * @param {IpoProgram} p - the program
+ * @returns {string[]}
+ */
+function ipoPrintGridText(p) {
+  const byRow = ipoGridRows(p);
+  const rows = [...byRow.keys()].sort((a, b) => a - b);
+  if (!rows.length) return [];
+  const last = rows[rows.length - 1];
+  const out = [];
+  for (let r = 0; r <= last; r++) {
+    const cells = (byRow.get(r) || []).sort((a, b) => a.col - b.col);
+    out.push(cells.length ? ipoPrintRowText(cells) : '');
+  }
+  // trailing blank rows only lengthen the sheet
+  while (out.length && !out[out.length - 1]) out.pop();
+  return out;
+}
+
+/**
+ * A modern-mode cell as text for the sheet.
+ * @param {{kind: string, text: string, meta: IpoCellMeta|null}} c - the cell
+ * @returns {string}
+ */
+function ipoPrintCellText(c) {
+  const text = ipoText(c.text).trim();
+  if (c.kind === 'lamp') return `${ipoLampOn(c) ? '●' : '○'} ${text}`;
+  if (c.kind === 'gauge') return `${text}${ipoPrintScale(c.meta)}`;
+  return text;
+}
+
+/**
+ * The modern rows as a caption / value / unit table, notes spanning the
+ * width, a logical line's first row separated from the one before.
+ * @param {IpoRow[]} rows - the rows (see ipoLineRows)
+ * @returns {string} HTML
+ */
+function ipoPrintRowsHtml(rows) {
+  if (!rows.length) return '';
+  const body = rows
+    .map((r, i) => {
+      const cap = (r.parts || [r.caption])
+        .map((t) => ipoText(t).replace(/\s*[:=]\s*$/, ''))
+        .join('  ');
+      const band = i > 0 && r.band ? ' class="pr-band"' : '';
+      if (!r.cells.length) {
+        return `<tr${band}><td colspan="3" class="pr-note">${esc(cap)}</td></tr>`;
+      }
+      const vals = r.cells.map(ipoPrintCellText).filter(Boolean).join('  ');
+      return (
+        `<tr${band}><td>${esc(cap)}</td>` +
+        `<td class="pr-mono pr-num">${esc(vals)}</td>` +
+        `<td class="pr-unit">${esc(r.trailer ? ipoText(r.trailer) : '')}</td></tr>`
+      );
+    })
+    .join('');
+  return `<table class="pr-table pr-screen-table"><tbody>${body}</tbody></table>`;
+}
+
+/**
+ * The keys the script offers on this menu, drawn as the F-key bar the app
+ * shows under the screen: ten slots F1..F10 with the short caption, a
+ * second row for the Shift keys when the menu has any, and the menu's own
+ * legend text under a caption where it says more. Empty slots stay as
+ * blank boxes, as on the bar.
+ * @param {IpoProgram} p - the program
+ * @returns {string} HTML, empty when the menu has no keys
+ */
+function ipoPrintKeysHtml(p, inpa) {
+  const items = (p.items || []).filter((it) => it.nr !== 20);
+  if (!items.length) return '';
+  if (inpa) return ipoPrintInpaKeysHtml(p, items);
+  const menu = ipoMenuTiles(p);
+  const legend = new Map();
+  for (const t of (menu && menu.tiles) || []) {
+    if (t.legend) legend.set(`${t.shift ? 's' : ''}${t.nr}`, t.legend);
+  }
+  const byKey = new Map(items.map((it) => [it.nr, it]));
+  const row = (shift) => {
+    let any = false;
+    const slots = [];
+    for (let k = 1; k <= 10; k++) {
+      const nr = shift ? IPO_SHIFT_BASE + k : k;
+      const it = byKey.get(nr);
+      const label = it ? ipoKeyLabel(p, it) : '';
+      if (label) any = true;
+      const lg = it ? legend.get(`${shift ? 's' : ''}${nr}`) : null;
+      const sub =
+        lg && ipoText(lg).trim() !== label.trim()
+          ? `<span class="pr-fkey-s">${esc(ipoText(lg).trim())}</span>`
+          : '';
+      slots.push(
+        `<span class="pr-fkey${label ? '' : ' empty'}">` +
+          `<span class="pr-fkey-k">${shift ? '⇧' : ''}F${k}</span>` +
+          `<span class="pr-fkey-l">${esc(label)}</span>${sub}</span>`
+      );
+    }
+    return any ? `<div class="pr-fkeys">${slots.join('')}</div>` : '';
+  };
+  const plain = row(false);
+  const shifted = row(true);
+  if (!plain && !shifted) return '';
+  return `<div class="pr-keys">${plain}${shifted}</div>`;
+}
+
+/**
+ * The print document for the module view as it stands: what printDoc()
+ * takes. Pure, so the harness can pin it without a printer.
+ * @param {IpoProgram} p - the program
+ * @param {EcuRecord} ecu - the module
+ * @param {boolean} inpa - INPA layout (the text grid) rather than the modern rows
+ * @returns {PrintDocOptions}
+ */
+/**
+ * The key bar the way the INPA layout draws it on screen: a row of key
+ * numbers over a row of flat boxes with the caption centred, and a Shift
+ * row below when the menu has shifted keys.
+ * @param {object} p - the running program
+ * @param {object[]} items - the menu's keys (Shift+F10 excluded)
+ * @returns {string} HTML
+ */
+function ipoPrintInpaKeysHtml(p, items) {
+  const byKey = new Map(items.map((it) => [it.nr, it]));
+  const row = (shift) => {
+    let any = false;
+    const nums = [];
+    const btns = [];
+    for (let k = 1; k <= 10; k++) {
+      const it = byKey.get(shift ? IPO_SHIFT_BASE + k : k);
+      const label = it ? ipoKeyLabel(p, it) : '';
+      if (label) any = true;
+      nums.push(`<span class="pr-ikey-num">${shift ? '⇧' : ''}F${k}</span>`);
+      btns.push(
+        `<span class="pr-ikey${label ? '' : ' empty'}">${esc(label)}</span>`
+      );
+    }
+    return any
+      ? `<div class="pr-ikeys"><div class="pr-ikey-nums">${nums.join('')}</div>` +
+          `<div class="pr-ikey-btns">${btns.join('')}</div></div>`
+      : '';
+  };
+  const plain = row(false);
+  const shifted = row(true);
+  if (!plain && !shifted) return '';
+  return `<div class="pr-keys">${plain}${shifted}</div>`;
+}
+
+function ipoPrintDocument(p, ecu, inpa) {
+  const title = ipoText(p.title || '') || p.menu || '';
+  const sections = [];
+  if (
+    p.view &&
+    p.view.report &&
+    typeof ipoProtocolPrintSections === 'function'
+  ) {
+    // viewopen over a fault read: the scan report's tables, then INPA's text
+    sections.push(...ipoProtocolPrintSections(p.view));
+  } else if (p.view) {
+    // viewopen: the file the script wrote
+    sections.push({
+      html: `<pre class="pr-screen">${esc((p.view.lines || []).join('\n'))}</pre>`,
+    });
+  } else if (inpa) {
+    const lines = ipoPrintGridText(p);
+    if (lines.length) {
+      sections.push({
+        html: `<pre class="pr-screen">${esc(lines.join('\n'))}</pre>`,
+      });
+    }
+  } else {
+    const menu = ipoMenuTiles(p);
+    const rows = menu && menu.tiles.length ? menu.rest : ipoLineRows(p);
+    const html = ipoPrintRowsHtml(rows);
+    if (html) sections.push({ html });
+  }
+  const keys = ipoPrintKeysHtml(p, inpa);
+  if (keys) sections.push({ html: keys, avoidBreak: true });
+  if (!sections.length) {
+    sections.push({
+      html: `<p class="pr-p">${esc(title || 'Nothing on screen yet.')}</p>`,
+    });
+  }
+  const meta = [
+    ecu.chassis ? ['Chassis', String(ecu.chassis).toUpperCase()] : null,
+    ['SGBD', `${ecu.sgbd}.prg`],
+    p.menu ? ['Menu', p.menu] : null,
+    p.screen ? ['Screen', p.screen] : null,
+    ['Printed', new Date().toLocaleString()],
+  ];
+  return {
+    title: ecu.label || ecu.sgbd,
+    subtitle: title,
+    meta,
+    sections,
+    landscape:
+      inpa && ipoPrintGridText(p).some((l) => l.length > IPO_PRINT_COLS),
+  };
+}
+
+/**
+ * INPA's printscreen for the module view: the clean sheet when the print
+ * builder is loaded, the browser's own print otherwise.
+ * @param {IpoProgram} p - the program
+ * @param {EcuRecord} ecu - the module
+ * @param {boolean} inpa - INPA layout
+ * @returns {Promise<void>}
+ */
+function ipoPrintScreen(p, ecu, inpa) {
+  if (typeof printDoc === 'function') {
+    return printDoc(ipoPrintDocument(p, ecu, inpa));
+  }
+  if (typeof window !== 'undefined' && typeof window.print === 'function')
+    window.print();
+  return Promise.resolve();
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    IPO_PRINT_COLS,
+    ipoPrintGridText,
+    ipoPrintRowsHtml,
+    ipoPrintKeysHtml,
+    ipoPrintDocument,
+    ipoPrintScreen,
+  };
+}