bmweb-cli 0.1.0 → 0.1.2

package/README.md

@@ -309,15 +309,19 @@ status line and the script's progress window are the two bottom lines.
 With no arguments it starts on the app's own home, an INPA script of the
 project's own (`home/bmweb-home.ips`): F1 picks a chassis then a module,
 F2 the chassis's whole-vehicle script, and `scriptchange` hands the screen
-to that script. The picks are numbered lists on the terminal; typing text
-filters, a number opens, Enter cancels. The home starts with or without a
-cable.
+to that script. A pick is a list the keyboard walks: Up/Down move the bar,
+typing narrows the list to the rows containing the text, Enter picks, Esc
+cancels. The home starts with or without a cable.
+
+The TUI runs on the terminal's alternate screen (the buffer vim and htop
+use), so the shell's scrollback is never touched and quitting restores it;
+a screen redraws in place, only the lines that changed.
 
 Every dialog INPA opens is a prompt: a message waits for Enter, an input
 asks for the number (or hex, or text) within the declared range, the
-two-word box takes y/n, the component picker (togglelist) lists the
-screen's lines by number, Select lists the named lines, save-as asks for a
-file name. **Every write is asked first**, exactly as the app asks: a key
+two-word box takes y/n, the component picker (togglelist) and Select are
+the same list picker (Space marks several where several may be picked),
+save-as asks for a file name. **Every write is asked first**, exactly as the app asks: a key
 whose body can send a write names the jobs and waits for y; a screen that
 sends one on every refresh asks once for as long as it is open; n or
 Enter abandons the key. On quit the leaving menu's Back job (the script's

package/dist/bmweb.js

@@ -1892,6 +1892,7 @@ function nodeTerminal() {
   };
   raw(true);
   input.resume();
+  output.write("\x1B[?1049h\x1B[H");
   const subs = /* @__PURE__ */ new Set();
   let paused = false;
   input.on(
@@ -1923,6 +1924,12 @@ function nodeTerminal() {
         subs.delete(fn);
       };
     },
+    onResize(fn) {
+      output.on("resize", fn);
+      return () => {
+        output.off("resize", fn);
+      };
+    },
     async readLine(prompt) {
       paused = true;
       raw(false);
@@ -1939,6 +1946,7 @@ function nodeTerminal() {
       }
     },
     close() {
+      output.write("\x1B[?1049l");
       raw(false);
       input.pause();
     }
@@ -1952,6 +1960,12 @@ var TuiUi = class {
   stopRequested = false;
   writeKeys = /* @__PURE__ */ new Set();
   program = null;
+  /** the lines of the frame on screen, when the cursor sits right below it */
+  frame = [];
+  /** a picker owns the keyboard: the program's key handler must stand back */
+  modal = false;
+  /** the terminal size the frame was drawn for; a change draws fresh */
+  frameSize = "";
   leftResolve = null;
   /** resolves once the program reports it left the module */
   leftPromise;
@@ -1970,6 +1984,16 @@ var TuiUi = class {
     this.leftPromise = new Promise((res) => {
       this.leftResolve = res;
     });
+    if (term.onResize) term.onResize(() => this.resized());
+  }
+  /**
+   * The terminal changed size: the frame on screen no longer fits its
+   * rows, so it is erased (as far as the cursor can climb back over it)
+   * and drawn again for the new size.
+   */
+  resized() {
+    this.frame = [];
+    if (this.program) this.paint(this.program);
   }
   /**
    * BMWeb's own picker (the home script's bmweb_pick): the host's list as
@@ -1991,32 +2015,133 @@ var TuiUi = class {
       return null;
     }
     const title = step.what === "module" ? `Modules of ${step.arg}` : "Vehicles";
-    let shown = options;
-    for (; ; ) {
-      const rows = shown.map(
-        (o, i) => `  ${String(i + 1).padStart(3)}. ${o.label}${o.meta ? `  (${o.meta})` : ""}`
-      ).join("\n");
-      const a = await this.term.readLine(
-        `
-${title}${shown.length !== options.length ? ` (${shown.length} of ${options.length})` : ""}
-${rows}
-Number to open, text to filter, Enter to cancel: `
-      );
-      if (a == null || !a.trim()) return null;
-      const n = Number(a.trim());
-      if (Number.isInteger(n) && n >= 1 && n <= shown.length)
-        return shown[n - 1].value;
-      const q = a.trim().toLowerCase();
-      const next = options.filter(
+    const picked = await this.pickList(title, options);
+    return picked ? picked[0] : null;
+  }
+  /**
+   * The picker: a list the keyboard walks. Up/Down (and PageUp/PageDown)
+   * move the bar, typing narrows the list to the rows containing the text,
+   * Backspace widens it again, Enter picks the row under the bar (Space
+   * marks a row when several may be picked, Enter then takes the marked
+   * ones, or the bar's row when none is marked), Esc cancels. Drawn as the
+   * frame, so it repaints in place like a screen.
+   * @param title - what is being picked
+   * @param options - the rows
+   * @param multiple - whether several rows may be picked
+   * @returns the picked values (one, unless multiple), or null for cancel
+   */
+  async pickList(title, options, multiple = false) {
+    let filter = "";
+    let cursor = 0;
+    let top = 0;
+    const marked = /* @__PURE__ */ new Set();
+    const shown = () => {
+      const q = filter.toLowerCase();
+      return q ? options.filter(
         (o) => `${o.label} ${o.meta || ""} ${o.value}`.toLowerCase().includes(q)
+      ) : options;
+    };
+    const draw = () => {
+      const rows = shown();
+      const w = this.term.columns;
+      const window = Math.max(3, this.term.rows - 7);
+      if (cursor >= rows.length) cursor = Math.max(0, rows.length - 1);
+      if (cursor < top) top = cursor;
+      if (cursor >= top + window) top = cursor - window + 1;
+      const count = rows.length === options.length ? `${options.length}` : `${rows.length} of ${options.length}`;
+      const lines = [
+        `${title}  \x1B[2m(${count})\x1B[0m`,
+        `\x1B[2mFilter:\x1B[0m ${filter}\x1B[7m \x1B[0m`,
+        ""
+      ];
+      for (const o of rows.slice(top, top + window)) {
+        const i = rows.indexOf(o);
+        const mark = multiple ? marked.has(o.value) ? "[x] " : "[ ] " : "";
+        const meta = o.meta ? `  ${o.meta}` : "";
+        const text = `${mark}${o.label}${meta}`.slice(0, w - 4);
+        lines.push(
+          i === cursor ? `\x1B[7m > ${text.padEnd(w - 4)} \x1B[0m` : `   ${o.meta ? `${mark}${o.label}\x1B[2m${meta}\x1B[0m` : text}`
+        );
+      }
+      if (!rows.length) lines.push("   \x1B[2m(nothing matches)\x1B[0m");
+      if (rows.length > top + window)
+        lines.push(`   \x1B[2m... ${rows.length - top - window} more\x1B[0m`);
+      lines.push("");
+      lines.push(
+        `\x1B[2m\u2191\u2193 move   type to filter   Enter picks${multiple ? "   Space marks" : ""}   Esc cancels\x1B[0m`
       );
-      shown = next.length ? next : options;
+      this.flush(lines);
+    };
+    this.modal = true;
+    try {
+      return await new Promise((resolve2) => {
+        const off = this.term.onKey((k) => {
+          const rows = shown();
+          const finish = (v) => {
+            off();
+            resolve2(v);
+          };
+          if (k.name === "escape" || k.ctrl && k.name === "c") {
+            finish(null);
+            return;
+          }
+          if (k.name === "return" || k.name === "enter") {
+            if (multiple && marked.size) {
+              finish(
+                options.filter((o2) => marked.has(o2.value)).map((o2) => o2.value)
+              );
+              return;
+            }
+            const o = rows[cursor];
+            finish(o ? [o.value] : null);
+            return;
+          }
+          if (k.name === "up" || k.ctrl && k.name === "p")
+            cursor = Math.max(0, cursor - 1);
+          else if (k.name === "down" || k.ctrl && k.name === "n")
+            cursor = Math.min(rows.length - 1, cursor + 1);
+          else if (k.name === "pageup")
+            cursor = Math.max(0, cursor - (this.term.rows - 7));
+          else if (k.name === "pagedown")
+            cursor = Math.min(rows.length - 1, cursor + (this.term.rows - 7));
+          else if (k.name === "home") cursor = 0;
+          else if (k.name === "end") cursor = Math.max(0, rows.length - 1);
+          else if (k.name === "backspace") filter = filter.slice(0, -1);
+          else if (multiple && k.name === "space") {
+            const o = rows[cursor];
+            if (o) {
+              if (marked.has(o.value)) marked.delete(o.value);
+              else marked.add(o.value);
+            }
+          } else if (k.ch && !k.ctrl && k.ch >= " " && k.ch !== "\x7F") {
+            filter += k.ch;
+            cursor = 0;
+          } else return;
+          draw();
+        });
+        draw();
+      });
+    } finally {
+      this.modal = false;
+      this.frame = [];
+      if (this.program) this.paint(this.program);
     }
   }
   /** Note the program once it exists, for the key handler. */
   attach(p) {
     this.program = p;
   }
+  /**
+   * A typed prompt under the frame (readline, raw mode off). It moves the
+   * cursor, so the frame is forgotten and the next paint clears the screen
+   * and draws fresh.
+   * @param prompt - the prompt text
+   * @returns the answer, or null when cancelled
+   */
+  async ask(prompt) {
+    this.frame = [];
+    return this.term.readLine(prompt);
+  }
   /** Esc during a parked state machine: stop it at the next tick. */
   requestStop() {
     this.stopRequested = true;
@@ -2038,7 +2163,7 @@ Number to open, text to filter, Enter to cancel: `
     this.drawFooter();
   }
   async message(title, body) {
-    await this.term.readLine(
+    await this.ask(
       `
 ${title}${body ? `
 ${body}` : ""}
@@ -2064,7 +2189,7 @@ ${body}` : ""}
     if (name === "inputdigital") {
       const f = prompts[prompts.length - 2] || "OFF";
       const t = prompts[prompts.length - 1] || "ON";
-      const a = await this.term.readLine(
+      const a = await this.ask(
         `
 ${p0}
 ${p1}
@@ -2074,12 +2199,10 @@ ${p1}
       return /^y/i.test(a.trim()) ? 1 : 0;
     }
     if (name === "builtin_3f" && prompts.length <= 2 && refs === 1) {
-      const a = await this.term.readLine(
-        `
+      const a = await this.ask(`
 ${p0}
 ${p1}
-[OK = y, cancel = n] `
-      );
+[OK = y, cancel = n] `);
       return a != null && /^y/i.test(a.trim()) ? 0 : null;
     }
     const hex = /hex/i.test(name);
@@ -2089,7 +2212,7 @@ ${p1}
     for (let k = 0; k < refs; k++) {
       const cap = refs > 1 ? prompts[2 + k] || `${p0} (${k + 1}/${refs})` : p1;
       const range = step.lo != null && step.hi != null && !hex ? ` [${step.lo}..${step.hi}]` : "";
-      const a = await this.term.readLine(`
+      const a = await this.ask(`
 ${p0}
 ${cap}${range}: `);
       if (a == null) return null;
@@ -2111,7 +2234,7 @@ ${cap}${range}: `);
     return refs > 1 ? vals : vals[0];
   }
   async confirmKey(_p, it, jobs, writes) {
-    const a = await this.term.readLine(
+    const a = await this.ask(
       `
 Run "${it.label || it.legendLabel || `F${it.nr}`}"? It can send ${jobs.join(", ")} and ${writes.join(", ")} write${writes.length === 1 ? "s" : ""} to the module. [y/N] `
     );
@@ -2119,7 +2242,7 @@ Run "${it.label || it.legendLabel || `F${it.nr}`}"? It can send ${jobs.join(", "
   }
   async confirmWrite(_p, job, arg, ctx) {
     const every = String(ctx.scope || "").startsWith("screen:") ? " This screen sends it on every refresh; yes allows it while the screen is open." : "";
-    const a = await this.term.readLine(
+    const a = await this.ask(
       `
 Send ${job}${arg ? ` ${arg}` : ""} to the module (${ctx.label})?${every} [y/N] `
     );
@@ -2131,8 +2254,8 @@ Send ${job}${arg ? ` ${arg}` : ""} to the module (${ctx.label})?${every} [y/N] `
    * flag, every picked key ';'-joined).
    */
   async pickComponent(p, step) {
-    const rows = this.R.ipoScreenComponents(p.exec, p.screen).map((l, i2) => ({
-      key: step.argnum ? String(i2 + 1) : String(l.keys).split(";")[0] || "",
+    const rows = this.R.ipoScreenComponents(p.exec, p.screen).map((l, i) => ({
+      key: step.argnum ? String(i + 1) : String(l.keys).split(";")[0] || "",
       caption: l.label || String(l.keys).split(";")[0] || ""
     }));
     if (!rows.length) {
@@ -2142,32 +2265,27 @@ Send ${job}${arg ? ` ${arg}` : ""} to the module (${ctx.label})?${every} [y/N] `
       );
       return null;
     }
-    const list = rows.map((r, i2) => `  ${i2 + 1}. ${r.caption}  (${r.key})`).join("\n");
+    const options = rows.map((r) => ({
+      value: r.key,
+      label: r.caption,
+      meta: r.key !== r.caption ? r.key : ""
+    }));
     if (step.multiple) {
-      const a2 = await this.term.readLine(
-        `
-${list}
-Components, comma-separated (Enter cancels): `
-      );
-      const picked = pickNumbers(a2, rows.length).map(
-        (i2) => rows[i2]
-      );
-      if (!picked.length) return null;
-      return { ort: picked.map((r) => r.key).join(";"), ein: 0 };
-    }
-    const a = await this.term.readLine(
-      `
-${list}
-Component number (Enter cancels): `
+      const picked2 = await this.pickList("Components", options, true);
+      if (!picked2 || !picked2.length) return null;
+      return { ort: picked2.join(";"), ein: 0 };
+    }
+    const picked = await this.pickList("Component", options);
+    if (!picked) return null;
+    const onOff = await this.pickList(
+      `${options.find((o) => o.value === picked[0])?.label || picked[0]}`,
+      [
+        { value: "on", label: "On" },
+        { value: "off", label: "Off" }
+      ]
     );
-    const [i] = pickNumbers(a, rows.length);
-    if (i == null) return null;
-    const onOff = await this.term.readLine(`On or off? [on/off] `);
-    if (onOff == null || !onOff.trim()) return null;
-    return {
-      ort: rows[i].key,
-      ein: /^on/i.test(onOff.trim()) ? 0 : 1
-    };
+    if (!onOff) return null;
+    return { ort: picked[0], ein: onOff[0] === "on" ? 0 : 1 };
   }
   /** INPA's Select: which named logical lines to keep on screen. */
   async pickLines(_p, names, multiple, _current, hints) {
@@ -2179,20 +2297,18 @@ Component number (Enter cancels): `
       );
       return null;
     }
-    const list = names.map((n, i) => `  ${i + 1}. ${n}`).join("\n");
-    const a = await this.term.readLine(
-      `
-${list}
-Lines to show${multiple ? ", comma-separated" : ""} (a = all, Enter cancels): `
-    );
-    if (a == null) return null;
-    if (/^a(ll)?$/i.test(a.trim())) return [];
-    const picked = pickNumbers(a, names.length).map((i) => names[i]);
-    return picked.length ? picked : null;
+    const options = [
+      { value: "\0all", label: "(all lines)" },
+      ...names.map((n) => ({ value: n, label: n }))
+    ];
+    const picked = await this.pickList("Lines to show", options, multiple);
+    if (!picked || !picked.length) return null;
+    if (picked.includes("\0all")) return [];
+    return picked;
   }
   /** INPA's save-as dialog: a file name, written when the body ends. */
   async saveFile() {
-    const a = await this.term.readLine(`
+    const a = await this.ask(`
 Save as [fault-memory.txt]: `);
     if (a == null) return null;
     return { name: a.trim() || "fault-memory.txt" };
@@ -2202,9 +2318,9 @@ Save as [fault-memory.txt]: `);
     this.status(_p, `wrote ${picked.name}`);
   }
   printScreen(p) {
-    this.term.write(`
-${this.gridLines(p).join("\n")}
-`);
+    const name = `bmweb-screen-${Date.now()}.txt`;
+    writeFileSync4(name, this.gridLines(p).join("\n") + "\n", "utf8");
+    this.status(p, `printed the screen to ${name}`);
   }
   /**
    * The module a scriptchange names. From the home script it is the car's
@@ -2258,23 +2374,63 @@ ${this.gridLines(p).join("\n")}
     }
     this.paint(p);
   }
-  /** Redraw everything: title, grid, keys, footer. */
+  /** Redraw everything: title, grid, keys, footer -- in place. */
   paint(p) {
+    this.flush(this.frameLines(p));
+  }
+  /**
+   * The frame as lines: title, rule, the view or the grid, a blank, the
+   * key bar, then the status and progress lines. Cut to the terminal's
+   * width (a wrapped line would break the row count the redraw relies on)
+   * and to its height, the body giving way first.
+   * @param p - the program
+   * @returns the lines, none wider than the terminal
+   */
+  frameLines(p) {
     const w = this.term.columns;
-    const out = [];
     const title = `${p.ecu.label || p.ecu.sgbd}  ${p.ecu.sgbd}.prg  ${p.title || ""}`.trim();
-    out.push(title.slice(0, w));
-    out.push("-".repeat(Math.min(w, 78)));
-    if (p.view) {
-      out.push(...(p.view.lines || []).slice(0, this.term.rows - 8));
-    } else {
-      out.push(...this.gridLines(p));
+    const head = [title, "-".repeat(Math.min(w, 78))];
+    let body = p.view ? [...p.view.lines || []] : this.gridLines(p);
+    const tail = ["", ...this.keyLines(p), this.statusText, this.progressText];
+    const room = Math.max(1, this.term.rows - 1 - head.length - tail.length);
+    if (body.length > room) body = body.filter((l, i) => l || body[i - 1]);
+    if (body.length > room) {
+      const hidden = body.length - (room - 1);
+      body = [
+        ...body.slice(0, room - 1),
+        `(${hidden} more rows: enlarge the terminal)`
+      ];
     }
-    out.push("");
-    out.push(...this.keyLines(p));
-    this.term.write(`\x1B[H\x1B[2J${out.join("\n")}
-`);
-    this.drawFooter();
+    return [...head, ...body, ...tail].map(
+      (l) => String(l).replace(/[\r\n]/g, " ").slice(0, w)
+    );
+  }
+  /**
+   * Put a frame on the screen over the last one. The frame always starts
+   * at the top-left of the alternate screen: go there, rewrite the lines
+   * that differ (each erased to the end of the row), step over the ones
+   * that match, and erase whatever the old frame had below the new one.
+   * With no frame to build on (first paint, after a prompt, after a
+   * resize) the screen is cleared first -- on the alternate screen that
+   * costs no scrollback.
+   * @param lines - the new frame
+   */
+  flush(lines) {
+    const size = `${this.term.columns}x${this.term.rows}`;
+    if (size !== this.frameSize) this.frame = [];
+    this.frameSize = size;
+    const prev = this.frame;
+    if (prev.length === lines.length && prev.every((l, i) => l === lines[i]))
+      return;
+    let s = prev.length ? "\x1B[H" : "\x1B[2J\x1B[H";
+    lines.forEach((line, i) => {
+      if (i < prev.length && prev[i] === line) s += "\x1B[B";
+      else s += `\r${line}\x1B[K\r
+`;
+    });
+    if (lines.length < prev.length) s += "\r\x1B[J";
+    this.term.write(s);
+    this.frame = lines;
   }
   /**
    * The grid as text rows: cells placed at their column, a lamp as a dot
@@ -2314,21 +2470,25 @@ ${this.gridLines(p).join("\n")}
     );
     return out;
   }
-  /** The two bottom lines: status and progress. */
+  /**
+   * The two bottom lines of the frame: status and progress. They are part
+   * of the frame, so a change repaints it (which writes just those lines);
+   * before a program exists the text is written on its own.
+   */
   drawFooter() {
-    this.term.write(
-      `\x1B[s\x1B[${Math.max(1, this.term.rows - 1)};1H\x1B[K${this.statusText}
-\x1B[K${this.progressText}\x1B[u`
-    );
+    if (this.program) {
+      this.paint(this.program);
+      return;
+    }
+    this.frame = [];
+    this.term.write(`${this.statusText}\r
+${this.progressText}\r
+`);
   }
   left() {
     if (this.leftResolve) this.leftResolve();
   }
 };
-function pickNumbers(a, n) {
-  if (a == null) return [];
-  return a.split(/[,\s]+/).map((s) => Number(s)).filter((i) => Number.isInteger(i) && i >= 1 && i <= n).map((i) => i - 1);
-}
 function cellText(c) {
   const text = String(c.text || "");
   if (c.kind === "lamp") {
@@ -2417,6 +2577,7 @@ async function tuiCommand(chassis, sgbd, opts = {}) {
     }
     const program = p;
     const unsubscribe = term.onKey((k) => {
+      if (ui.modal) return;
       const what = keyToPress(k);
       if (what === null) return;
       if (what === "quit") {
@@ -2446,7 +2607,7 @@ async function tuiCommand(chassis, sgbd, opts = {}) {
 }
 
 // src/bmweb.ts
-var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var VERSION = true ? "0.1.2" : "0.0.0-dev";
 var INCLUDE = {
   include: {
     kind: "list",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmweb-cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "BMWeb's tools as a command line: read INPA .IPO scripts, compile .IPS sources, search the corpus job index, decode and diff shared Garage reports, and, over a K+DCAN cable, run jobs, whole-car scans and INPA screens in the terminal.",
   "license": "GPL-3.0-only",
   "type": "module",

package/runtime/core/bestvm/index.js

@@ -41,9 +41,7 @@ if (typeof module !== 'undefined' && module.exports) {
     JUMP_TESTS,
     REG_BYTES,
     isWriteJob,
-    // the classifier's parts, exported so test_write_gate.js
-    // can compare each against its Python twin in
-    // tools/verify/sgbd_bulk_verify.py pattern-by-pattern
+    // the classifier's parts, exported for tests and tooling
     READ_TOKEN,
     CONFIG_READ_TOKEN,
     WRITE_TOKEN,

package/runtime/core/bestvm/machine.js

@@ -6,8 +6,9 @@
  * strings); executing the program handles all of it, which is why EDIABAS is
  * flawless. Input is tools/sgbd_code.py output (ops array, jumps as indices);
  * telegram I/O is a callback, so one VM runs live cable / .sim / fixture.
- * Semantics ported from vendored EdiabasLib (EdOperations.cs, EdiabasNet.cs),
- * the engine tools/sgbd_bulk_verify.py diffs against and test_bestvm.js checks.
+ * Semantics ported from EdiabasLib (EdOperations.cs, EdiabasNet.cs); the
+ * engine's own result sets for 460 E46 jobs are the committed fixture
+ * data/sim-captures/vmfix.json that test_bestvm.js replays.
  *
  * THE REGISTER MODEL, which nothing else here makes sense without:
  * B/I/L/A are VIEWS over one 32-byte array, LITTLE-endian within a view, so

package/runtime/core/bestvm/write-guard.js

@@ -35,9 +35,9 @@
  * changed in the corpus -- but with INFO checked after writes (rule 3), a
  * hypothetical SYSTEMCHECK_STOP_INFO must hit the write tier, not fall
  * through to the INFO tier. Relaxing a WRITE token is the safe direction.
- * Kept identical to the classifier in tools/verify/sgbd_bulk_verify.py --
- * two different answers to "is this a write?" is worse than either alone.
- * test_write_gate.js check 3 enforces the twin token-by-token.
+ * This is the ONE classifier: the Python twin that the retired engine
+ * harness carried is gone, so there is no second answer to "is this a
+ * write?" to drift from.
  */
 
 /**

package/runtime/core/ipovm/builtins-api.js

@@ -444,6 +444,18 @@ function bViewopen(vm, stack) {
   };
 }
 
+/**
+ * printfile(->ErrorCode, FileName, PrinterName, PrinterPort, ErrorMsgFlag):
+ * INPA prints the named file (the fault protocol a read wrote) on the
+ * printer. The print itself is the runtime's (suspensions.js 'printfile');
+ * here the error code is 0, printed or not, so the script never takes its
+ * "could not print" branch over a sheet the browser handles.
+ * @type {IpoBuiltin}
+ */
+function bPrintfile(vm, stack) {
+  storeOut(vm, stack, 0);
+}
+
 /**
  * filewrite(text): append a line to the open file.
  * @type {IpoBuiltin}
@@ -601,6 +613,7 @@ if (typeof module !== 'undefined' && module.exports) {
     bInputDigital,
     bFileopen,
     bFileclose,
+    bPrintfile,
     bFilewrite,
     bFileread,
     bSettimer,

package/runtime/core/ipovm/builtins-screen.js

@@ -13,6 +13,12 @@ const IPO_ANALOG_FMT_RE = /^(\d+)\.(\d+)$/;
 /** toFixed()'s upper bound on decimals; a stray format never asks for more. */
 const IPO_MAX_DECIMALS = 20;
 
+/** Bytes per line of INPA's hexdump. */
+const IPO_HEXDUMP_LINE = 16;
+
+/** The fewest hex digits a hexdump address column shows. */
+const IPO_HEXDUMP_ADDR_MIN = 4;
+
 /**
  * settitle / setmenutitle: the first argument is the title.
  * @type {IpoBuiltin}
@@ -113,6 +119,38 @@ function bUserboxClear(vm) {
   if (vm.onUserbox) vm.onUserbox(vm.userbox);
 }
 
+/**
+ * The foreground / background pair a colour builtin was handed: its last
+ * two integer arguments (userboxsetcolor leads with the box number).
+ * @param {IpoValue[]} stack - the call's arguments
+ * @returns {{fg: number, bk: number}|null} null when the call named no pair
+ */
+function ipoColorArgs(stack) {
+  const n = allInts(stack);
+  if (n.length < 2) return null;
+  return { fg: n[n.length - 2], bk: n[n.length - 1] };
+}
+
+/**
+ * setcolor(FgColor, BkColor): the colour every text printed after it takes.
+ * Recorded on the run so a host that draws colour can honour it; the
+ * browser's skins keep their own palette.
+ * @type {IpoBuiltin}
+ */
+function bSetcolor(vm, stack) {
+  const c = ipoColorArgs(stack);
+  if (c) vm.out.color = c;
+}
+
+/**
+ * userboxsetcolor(BoxNum, FgColor, BkColor): the progress window's colours.
+ * @type {IpoBuiltin}
+ */
+function bUserboxSetcolor(vm, stack) {
+  const c = ipoColorArgs(stack);
+  if (c && vm.userbox) vm.userbox.color = c;
+}
+
 /**
  * userboxftextout(text, row, col ...): a line of the progress window. It is
  * also a textout, so a body without a box paints it with the screen.
@@ -234,9 +272,69 @@ function bTextout(vm, stack) {
     el.row = ints[0];
     el.col = ints[1];
   }
+  // the colour setcolor chose for what follows rides on the live cell so a
+  // host that draws colour (the terminal UI) can; offline the element stays
+  // byte-identical to the Python twin's
+  if (vm.wireJobs && vm.out.color) el.color = vm.out.color;
   line.elements.push(el);
 }
 
+/**
+ * The lines of INPA's hexdump: one per 16 bytes, the address (the start
+ * address plus the line's offset, in hex, at least as wide as the start
+ * address was written) then the bytes as two hex digits each. A start
+ * address that is not hex counts from 0.
+ * @param {string} startAdr - the address the bytes were read from ("0x1000")
+ * @param {number[]} bytes - the bytes to show
+ * @returns {string[]}
+ */
+function ipoHexdumpLines(startAdr, bytes) {
+  const digits = String(startAdr || '')
+    .trim()
+    .replace(/^0x/i, '');
+  const base = /^[0-9a-f]+$/i.test(digits) ? parseInt(digits, 16) : 0;
+  const width = Math.max(IPO_HEXDUMP_ADDR_MIN, digits.length);
+  const out = [];
+  for (let i = 0; i < bytes.length; i += IPO_HEXDUMP_LINE) {
+    const addr = (base + i).toString(16).toUpperCase().padStart(width, '0');
+    const hex = bytes
+      .slice(i, i + IPO_HEXDUMP_LINE)
+      .map((b) => (b & 0xff).toString(16).toUpperCase().padStart(2, '0'));
+    out.push(`${addr}  ${hex.join(' ')}`);
+  }
+  return out;
+}
+
+/**
+ * hexdump(StartAdr, numbytes, row, col): the bytes of the last
+ * INPAapiResultBinary painted as a hex table at (row, col), the way the
+ * Speicher-lesen screens show memory. The bytes come from the wire, so
+ * offline there is nothing to paint (the lift sees the call, not a table).
+ * Each line is printed as ftextout would print it, one row down from the
+ * last, so the grid, the sheet and Select treat it as text.
+ * @type {IpoBuiltin}
+ */
+function bHexdump(vm, stack) {
+  if (!vm.wireJobs) return;
+  const key = vm.globals.get('__pending_binary__');
+  if (!key || !vm.host || typeof vm.host.raw !== 'function') return;
+  const set = vm.globals.get('__pending_binary_set__');
+  const hex = ipoBinaryHex(
+    vm.host.raw(key, { set: set == null ? undefined : set })
+  );
+  if (!hex) return;
+  let bytes = (hex.match(/[0-9A-F]{2}/g) || []).map((h) => parseInt(h, 16));
+  const args = stack.filter((x) => !isRef(x));
+  const count = args.length > 1 ? Math.trunc(num(args[1])) : bytes.length;
+  if (count > 0) bytes = bytes.slice(0, count);
+  const row = args.length > 2 ? Math.trunc(num(args[2])) : 0;
+  const col = args.length > 3 ? Math.trunc(num(args[3])) : 0;
+  const startAdr = args.length ? asStr(args[0]) : '';
+  ipoHexdumpLines(startAdr, bytes).forEach((text, i) =>
+    bTextout(vm, [text, row + i, col])
+  );
+}
+
 /**
  * The element a lamp or bar builtin declares, placed on the current line.
  * Offline the row/col come from the int scan the Python twin uses (for
@@ -464,7 +562,20 @@ function bCallwin(vm, stack, item) {
 }
 
 /**
- * A builtin with no effect on the model (window chrome, colours, stop).
+ * viewclose(): INPA closes its viewer window. Live, the run says so and
+ * drops a view it opened earlier in the same body; a viewopen after it
+ * sets a new one, which wins (the runtime reads the view first, the close
+ * only when there is none). Offline nothing is lifted from a window.
+ * @type {IpoBuiltin}
+ */
+function bViewclose(vm) {
+  if (!vm.wireJobs) return;
+  vm.out.view = null;
+  vm.out.viewClose = true;
+}
+
+/**
+ * A builtin with no effect on the model (window chrome, stop).
  * @type {IpoBuiltin}
  */
 function bNoop() {}
@@ -476,6 +587,11 @@ if (typeof module !== 'undefined' && module.exports) {
     bSetmenu,
     bSetscreen,
     bTextout,
+    ipoHexdumpLines,
+    bHexdump,
+    bSetcolor,
+    bUserboxSetcolor,
+    bViewclose,
     drawField,
     bAnalogout,
     bMultiAnalogout,

package/runtime/core/ipovm/builtins-table.js

@@ -56,7 +56,7 @@ const BUILTINS = {
   userboxopen: bUserboxOpen,
   userboxclose: bUserboxClose,
   viewopen: bViewopen,
-  viewclose: bNoop,
+  viewclose: bViewclose,
   setstate: bSetstate,
   start: bSetstate,
   select: bSelect,
@@ -81,8 +81,8 @@ const BUILTINS = {
   fileclose: bFileclose,
   filewrite: bFilewrite,
   fileread: bFileread,
-  hexdump: bNoop,
-  printfile: bNoop,
+  hexdump: bHexdump,
+  printfile: bPrintfile,
   setstatemachine: bNoop,
   StrArrayCreate: bStrArrayCreate,
   StrArrayDestroy: bNoop,
@@ -147,7 +147,8 @@ const BUILTINS = {
   builtin_87: bUnavailable,
   builtin_93: bUnavailable,
   builtin_90: bStrArraySize, // string array length, out-param
-  builtin_1a: bNoop, // setcolor
+  builtin_1a: bSetcolor, // setcolor
+  setcolor: bSetcolor,
   builtin_51: bBlankscreen, // blankscreen
   blankscreen: bBlankscreen,
   settimer: bSettimer,
@@ -158,7 +159,8 @@ const BUILTINS = {
   bmweb_pick: bBmwebPick,
   bmweb_status: bBmwebStatus,
   builtin_57: bUserboxClear, // userboxclear
-  builtin_58: bNoop, // userboxsetcolor
+  builtin_58: bUserboxSetcolor, // userboxsetcolor
+  userboxsetcolor: bUserboxSetcolor,
 };
 
 if (typeof module !== 'undefined' && module.exports) {

package/runtime/core/ipovm/emissions.js

@@ -24,6 +24,15 @@
  * @property {string} [fmt] - analogout display format ("6.2")
  * @property {string} [on] - digitalout's TrueText
  * @property {string} [off] - digitalout's FalseText
+ * @property {IpoColor} [color] - the setcolor in force when a live run printed it
+ */
+
+/**
+ * A colour pair as INPA's setcolor / userboxsetcolor name it: two of
+ * INPA's palette indices. Recorded for hosts that draw colour.
+ * @typedef {object} IpoColor
+ * @property {number} fg - foreground index
+ * @property {number} bk - background index
  */
 
 /**
@@ -111,6 +120,18 @@ class Emissions {
      * @type {{path: string, lines: string[]}|null}
      */
     this.view = null;
+    /**
+     * viewclose(): a live body closed INPA's viewer window. Read only when
+     * no viewopen in the same body left a view behind.
+     * @type {boolean}
+     */
+    this.viewClose = false;
+    /**
+     * setcolor(fg, bk): the colour in force for the text printed after it,
+     * null until a body sets one.
+     * @type {IpoColor|null}
+     */
+    this.color = null;
     /**
      * setscreen's second argument: TRUE = a frequent screen, re-run its cycle
      * while it is current (INPA's WM_TIMER loop); null = no setscreen.

package/runtime/core/ipovm/suspensions.js

@@ -12,12 +12,14 @@
  * says why; `out` is the emissions so far (a parked machine's drawn screen
  * IS the picker).
  * @typedef {object} IpoStep
- * @property {'done'|'yield'|'job'|'wait'|'input'|'message'|'toggle'|'print'|'select'|'exit'} kind -
+ * @property {'done'|'yield'|'job'|'wait'|'input'|'message'|'toggle'|'print'|'printfile'|'select'|'exit'} kind -
  *   done: the proc finished; yield: parked at a %STATE; job: a wire job to
  *   run and feed back; wait: a timed wartezeit; input: an INPA prompt;
  *   message: a blocking messagebox; toggle: the component picker; print:
- *   printscreen; select: INPA's line filter; exit: the script ended itself
+ *   printscreen; printfile: a written file to print; select: INPA's line
+ *   filter; exit: the script ended itself
  * @property {Emissions} [out] - emissions so far
+ * @property {string} [file] - printfile / fsread: the file's name
  * @property {string} [name] - yield: the state label
  * @property {string} [job] - job: the job name
  * @property {string|null} [sgbd] - job: the SGBD the script addressed
@@ -46,7 +48,9 @@ const IPO_SUSPEND_KINDS = new Set([
   'message',
   'toggle',
   'pick', // bmweb_pick: the host lists, the user chooses (home script)
+  'fsread', // INPAapiFsLesen: the renderer reads the fault memory and writes the file
   'print',
+  'printfile', // printfile: the renderer prints a file the body wrote
   'select',
   'exit',
 ]);
@@ -184,6 +188,15 @@ function ipoDriveBuiltin(vm, t, stack) {
   if (vm.wireJobs && name === 'printscreen') {
     return { kind: 'print', out: vm.out };
   }
+  // INPA's printfile(->rc, file, printer, port, flag): the protocol file a
+  // read wrote goes to the printer. The builtin answers rc = 0 first (the
+  // script's own error branch must not fire), then the renderer prints the
+  // file's lines from the VM's files. Offline only the rc is stored.
+  if (vm.wireJobs && name === 'printfile') {
+    vm._builtin(t, stack, null);
+    const strs = stack.filter((x) => !isRef(x)).map((x) => asStr(x));
+    return { kind: 'printfile', file: strs[0] || '', out: vm.out };
+  }
   // A LIVE togglelist is INPA's component picker: park until the renderer
   // hands back the pick ({ort, ein}); resume re-runs the builtin with it.
   // togglelist(MultipleSelectFlag, ArgNumFlag, ->ApiToggleString)
@@ -196,6 +209,23 @@ function ipoDriveBuiltin(vm, t, stack) {
       out: vm.out,
     };
   }
+  // INPAapiFsLesen(sgbd, file): INPA's API reads the module's fault memory
+  // (FS_LESEN, then the detail of every entry) and writes the protocol file
+  // the script then viewopen()s. 161 shipped scripts read faults only this
+  // way. Live, the renderer does that read and hands the file back; offline
+  // it stays a noop (nothing to lift from the API's own work).
+  if (
+    vm.wireJobs &&
+    (name === 'INPAapiFsLesen' || name === 'INPAapiFsLesen2')
+  ) {
+    const strs = stack.filter((x) => !isRef(x)).map((x) => asStr(x));
+    return {
+      kind: 'fsread',
+      sgbd: strs[0] || '',
+      file: strs[1] || 'na_fs.tmp',
+      out: vm.out,
+    };
+  }
   // BMWeb's own picker: bmweb_pick("chassis"|"module"|"vehicle", arg,
   // ->choice). Park like a togglelist; the renderer asks the host for the
   // list and resumes with the choice, which the re-run builtin stores.

package/runtime/core/translate.js

@@ -178,9 +178,9 @@ const PCODE_MAP = {
   '27C2': 'P2562',
   '27C4': 'P2564',
 };
-// Flatten an EDIABAS result value to the same text the native bridge produces
-// (src/EdiabasMac/Diag.cs Format): byte arrays become dashed hex ("27-DA"),
-// everything else its plain string. The web VM returns live typed values --
+// Flatten an EDIABAS result value to the text EDIABAS itself would print:
+// byte arrays become dashed hex ("27-DA"), everything else its plain string.
+// The web VM returns live typed values --
 // `ergy` (binary) emits a byte Array, `ergi`/`ergb`/... emit numbers -- so
 // screens that only ever saw the native path's strings funnel through here.
 // An empty binary result ([]) is truthy but must read as "no code", which the

package/runtime/core/webshim/transport-base.js

@@ -20,9 +20,9 @@
  * here): SerialProxy.cs is the byte-mover behind NativeSerialBus (open/write/
  * readAvailable/close/flush). Bytes cross that bridge as a JSON int[]
  * (BmacwBridge.cs AsNumberArray), NOT base64 -- base64 corrupted the
- * echo/checksum. src/EdiabasMac is LEGACY (its InpaMac.Api server is deleted);
- * it is reference for what JS reimplemented, not a transport, and is
- * deliberately NOT part of this interface.
+ * echo/checksum. The former C# engine (deleted with its InpaMac.Api server) was
+ * reference for what JS reimplemented, not a transport, and was never part
+ * of this interface.
  */
 /* exported SerialTransportBase */
 

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

@@ -269,6 +269,84 @@ function ipoPrintScreen(p, ecu, inpa) {
   return Promise.resolve();
 }
 
+/**
+ * Whether a printfile names the file the viewer is showing: the same path,
+ * or the same text (the API's fault read and a save-as can leave the
+ * script holding a different name for the same protocol).
+ * @param {IpoProgram} p - the program
+ * @param {string} name - the file name printfile passed
+ * @param {string[]} lines - the file's lines
+ * @returns {boolean}
+ */
+function ipoPrintFileIsView(p, name, lines) {
+  const v = p.view;
+  if (!v) return false;
+  if (v.path && v.path === name) return true;
+  const shown = v.lines || [];
+  return (
+    shown.length > 0 &&
+    shown.length === lines.length &&
+    shown.every((l, i) => l === lines[i])
+  );
+}
+
+/**
+ * The print document for INPA's printfile: the fault protocol as the
+ * report's tables plus INPA's text when the file is the one the viewer
+ * shows (what printscreen prints over that view), else the file's lines
+ * as a monospace sheet. Pure, so the harness can pin it.
+ * @param {IpoProgram} p - the program
+ * @param {EcuRecord} ecu - the module
+ * @param {string} name - the file's name
+ * @param {string[]} lines - the file's lines
+ * @returns {PrintDocOptions}
+ */
+function ipoPrintFileDocument(p, ecu, name, lines) {
+  const isView = ipoPrintFileIsView(p, name, lines);
+  const sections = [];
+  if (
+    isView &&
+    p.view.report &&
+    typeof ipoProtocolPrintSections === 'function'
+  ) {
+    sections.push(...ipoProtocolPrintSections(p.view));
+  } else {
+    sections.push({
+      html: `<pre class="pr-screen">${esc((lines || []).join('\n'))}</pre>`,
+    });
+  }
+  const subtitle =
+    isView && p.view.title ? ipoText(p.view.title) : ipoText(p.title || '');
+  return {
+    title: ecu.label || ecu.sgbd,
+    subtitle: subtitle || name,
+    meta: [
+      ecu.chassis ? ['Chassis', String(ecu.chassis).toUpperCase()] : null,
+      ['SGBD', `${ecu.sgbd}.prg`],
+      ['File', name],
+      ['Printed', new Date().toLocaleString()],
+    ],
+    sections,
+  };
+}
+
+/**
+ * INPA's printfile for the module view: the clean sheet when the print
+ * builder is loaded, nothing otherwise (the browser's own print would show
+ * the screen, not the file).
+ * @param {IpoProgram} p - the program
+ * @param {EcuRecord} ecu - the module
+ * @param {string} name - the file's name
+ * @param {string[]} lines - the file's lines
+ * @returns {Promise<void>}
+ */
+function ipoPrintFile(p, ecu, name, lines) {
+  if (typeof printDoc === 'function') {
+    return printDoc(ipoPrintFileDocument(p, ecu, name, lines));
+  }
+  return Promise.resolve();
+}
+
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = {
     IPO_PRINT_COLS,
@@ -277,5 +355,7 @@ if (typeof module !== 'undefined' && module.exports) {
     ipoPrintKeysHtml,
     ipoPrintDocument,
     ipoPrintScreen,
+    ipoPrintFileDocument,
+    ipoPrintFile,
   };
 }

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

@@ -103,6 +103,8 @@ const IPO_SILENT_RE = /IFH-0009|IFH-0019|no answer/i;
  * @property {(p: IpoProgram, step: IpoStep) => Promise<IpoPick|null>} pickComponent - the togglelist picker
  * @property {(p: IpoProgram, names: string[], multiple: boolean, current: Set<string>|null, hints?: Array<{key: string, label: string, lines: number}>) => Promise<string[]|null>} pickLines - INPA's Select
  * @property {(p: IpoProgram) => void} printScreen - INPA's printscreen
+ * @property {(p: IpoProgram, name: string, lines: string[]) => void} [printFile] -
+ *   INPA's printfile: a file the script wrote, by name, as its lines
  * @property {(ecu: EcuRecord, script: string, exec: IpoExec) => Promise<EcuRecord|null>} [resolveScriptEcu] -
  *   the module a scriptchange target addresses, identified by the car
  * @property {(p: IpoProgram, step: IpoStep, guards: Set<number>) => Promise<'tick'|'press'|'stop'>} machineTick - a %STATE park
@@ -173,6 +175,8 @@ class IpoProgram {
     this.script = null;
     /** @type {string|null} the menu the entry set (the route's root) */
     this.rootMenu = null;
+    /** @type {string|null} the screen the entry set on the root menu */
+    this.rootScreen = null;
     this.answered = false; // INITIALISIERUNG returned any result
     this.silent = false; // INITIALISIERUNG got no answer at all
     this.noCable = false; // no adapter: the script cannot ask the car
@@ -276,6 +280,14 @@ class IpoProgram {
         this.messages.push({ title: step.title, body: step.body });
         await this.ui.message(step.title, step.body);
         step = vm.resume();
+      } else if (step.kind === 'fsread') {
+        // INPA's API fault read: FS_LESEN and every entry's detail on the
+        // wire, then the protocol file the script goes on to viewopen
+        const lines = await this.apiFaultRead(step.sgbd, step.file, ctx);
+        if (lines == null) return { done: false, cancelled: true };
+        vm.files.set(step.file, lines);
+        vm.lastWritten = step.file;
+        step = vm.resume();
       } else if (step.kind === 'pick') {
         // BMWeb's own picker (the home script): the host lists chassis,
         // modules or the whole-vehicle script; a cancel leaves the body
@@ -298,6 +310,9 @@ class IpoProgram {
       } else if (step.kind === 'print') {
         this.ui.printScreen(this);
         step = vm.resume();
+      } else if (step.kind === 'printfile') {
+        this.printFile(step.file);
+        step = vm.resume();
       } else if (step.kind === 'select') {
         // INPA's Select: which of the screen's named logical lines to show.
         // A screen with none still opens the box (INPA shows an empty
@@ -341,6 +356,23 @@ class IpoProgram {
     return { done: true, exit: !!(vm.out && vm.out.exit) };
   }
 
+  /**
+   * INPA's printfile: the named file's lines go to the UI's printer. The
+   * name is what the script computed; when the VM holds no file by it the
+   * last one written stands in, as viewopen's does (the API's fault read
+   * names its file for the script, and a save-as may have renamed it).
+   * @param {string} name - the file name the script passed
+   * @returns {void}
+   */
+  printFile(name) {
+    if (typeof this.ui.printFile !== 'function' || !this.vm) return;
+    const { files, lastWritten } = this.vm;
+    let path = name;
+    if (!files.has(path) && lastWritten && files.has(lastWritten))
+      path = lastWritten;
+    this.ui.printFile(this, path, [...(files.get(path) || [])]);
+  }
+
   /**
    * Select's choice: the names of the logical lines to show, or null for
    * all. The current screen is repainted through it; a screen change keeps
@@ -406,6 +438,79 @@ class IpoProgram {
    * @param {IpoRunContext} ctx - what is running
    * @returns {Promise<IpoFeed|null>} the feed, or null when the user declined
    */
+  /**
+   * What INPAapiFsLesen does inside INPA: read the module's fault memory
+   * (FS_LESEN), then the detail of every stored fault (FS_LESEN_DETAIL by
+   * its location number), and write the protocol file. The reads go through
+   * runJob, so wireReads carries them and the viewopen that follows draws
+   * the report joined with the fault lookup, as the whole-vehicle protocol
+   * does; the lines are INPA's own layout for the plain-text view.
+   * @param {string} sgbd - the module the script names
+   * @param {string} file - the file the script will viewopen
+   * @param {object} ctx - the body's context (scope, label)
+   * @returns {Promise<string[]|null>} the file's lines, or null when cancelled
+   */
+  async apiFaultRead(sgbd, file, ctx) {
+    const fed = await this.runJob(sgbd, 'FS_LESEN', null, ctx);
+    if (fed == null) return null;
+    const sets = (fed.sets || []).slice(1);
+    const faults = sets.filter(
+      (s) => s && (s.F_ORT_NR != null || s.F_HEX_CODE)
+    );
+    const name = String(sgbd || this.ecu.sgbd || '').toUpperCase();
+    const lines = [name, ''];
+    if (String(fed.get('JOB_STATUS') || 'OKAY') !== 'OKAY') {
+      lines.push(`Fehlerspeicher lesen: ${fed.get('JOB_STATUS')}`);
+      return lines;
+    }
+    if (!faults.length) {
+      lines.push('Kein Fehler im Fehlerspeicher');
+      return lines;
+    }
+    lines.push(
+      `${faults.length} Fehler im Fehlerspeicher`.replace(
+        /^1 Fehler/,
+        '1 Fehler'
+      ),
+      ''
+    );
+    for (const f of faults) {
+      const nr = f.F_ORT_NR != null ? String(f.F_ORT_NR) : '';
+      let det = f;
+      if (nr) {
+        // the detail pass, as INPA's API makes it; a module without the job
+        // answers with an error and the memory's own fields stand
+        const d = await this.runJob(sgbd, 'FS_LESEN_DETAIL', nr, ctx);
+        if (d == null) return null;
+        const ds = (d.sets || []).slice(1).find((s) => s && s.F_ORT_NR != null);
+        if (ds) det = Object.assign({}, f, ds);
+      }
+      const hex =
+        typeof hexText === 'function'
+          ? hexText(det.F_HEX_CODE)
+          : String(det.F_HEX_CODE || '');
+      lines.push(
+        `${nr}${hex ? ` (${hex})` : ''}  ${det.F_ORT_TEXT || ''}`.trim()
+      );
+      const bits = [];
+      if (det.F_ART1_TEXT) bits.push(`Fehlerart: ${det.F_ART1_TEXT}`);
+      if (det.F_HFK != null) bits.push(`Häufigkeit: ${det.F_HFK}`);
+      if (det.F_LZ != null) bits.push(`Logistikzähler: ${det.F_LZ}`);
+      if (det.F_VORHANDEN_TEXT) bits.push(det.F_VORHANDEN_TEXT);
+      if (bits.length) lines.push(`    ${bits.join('  ')}`);
+      const n = Number(det.F_UW_ANZ) || 0;
+      for (let i = 1; i <= n; i++) {
+        const t = det[`F_UW${i}_TEXT`];
+        if (t == null) continue;
+        const v = det[`F_UW${i}_WERT`];
+        const u = det[`F_UW${i}_EINH`];
+        lines.push(`    ${t}: ${v != null ? v : ''}${u ? ` ${u}` : ''}`);
+      }
+      lines.push('');
+    }
+    return lines;
+  }
+
   async runJob(sgbd, job, arg, ctx) {
     const target = ipoWireTarget(this.ecu, sgbd);
     const entry = !!(ctx && (ctx.scope === 'entry' || ctx.scope === 'exit'));
@@ -561,6 +666,10 @@ class IpoProgram {
     this.menu = out.menu || null;
     this.screen = out.screen || null;
     this.frequent = !!out.screenFrequent;
+    // the script's own front: the menu and screen its entry set. Esc on
+    // that menu first returns to that screen (see back()).
+    this.rootMenu = this.menu;
+    this.rootScreen = this.screen;
     this.title = out.title || null;
     return { ok: true };
   }
@@ -1232,6 +1341,10 @@ class IpoProgram {
         const rep = ipoProtocolReport(this.wireReads, out.view.lines);
         this.view.report = rep.modules.length ? rep : null;
       }
+    } else if (out.viewClose) {
+      // viewclose without a viewopen after it: INPA's viewer window is
+      // gone, the screen behind it shows again
+      this.view = null;
     }
     // the body painted (userbox text, a result line): show it with the screen
     this.takeCells(out);
@@ -1281,6 +1394,21 @@ class IpoProgram {
       this.queued = 'back';
       return;
     }
+    // On the root menu, a key like Ident or Code only swaps the screen
+    // (setscreen without setmenu) and the menu's own F10 is "End", which
+    // leaves the module. Esc there first returns to the screen the entry
+    // set, so one Esc undoes the screen and the next one leaves -- INPA's
+    // main menu never strands the user on a sub-screen.
+    if (
+      this.menu &&
+      this.menu === this.rootMenu &&
+      this.rootScreen &&
+      this.screen !== this.rootScreen &&
+      this.exec.procs[this.rootScreen]
+    ) {
+      await this.showScreen(this.rootScreen, false);
+      return;
+    }
     if (this.items.some((it) => it.nr === IPO_BACK_KEY))
       return this.press(IPO_BACK_KEY);
     return this.leaveModule();

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

@@ -165,6 +165,8 @@ function ipoMakeUi(ecu, container, back) {
       ipoPickLines(names, multiple, current, hints),
     // INPA's printscreen: the module view as a clean sheet (print.js)
     printScreen: (p) => ipoPrintScreen(p, p.ecu || ecu, inpa),
+    // INPA's printfile: the protocol file the script wrote, as a sheet
+    printFile: (p, name, lines) => ipoPrintFile(p, p.ecu || ecu, name, lines),
     resolveScriptEcu: (from, script, exec) =>
       // the home script names a module by its SGBD after a chassis pick:
       // that module is the car's own record, not a wire-resolved variant