bmweb-cli 0.1.0

package/dist/bmweb.js

@@ -0,0 +1,2790 @@
+#!/usr/bin/env node
+
+// src/args.ts
+var CliError = class extends Error {
+};
+function parseArgs(argv, spec) {
+  const positional = [];
+  const flags = {};
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const [name, s] of Object.entries(spec))
+    if (s.alias) byAlias.set(s.alias, name);
+  const set = (name, raw) => {
+    const s = spec[name];
+    if (!s) throw new CliError(`unknown option --${name}`);
+    if (s.kind === "bool") {
+      if (raw !== null) throw new CliError(`--${name} takes no value`);
+      flags[name] = true;
+      return;
+    }
+    if (raw === null) throw new CliError(`--${name} needs a value`);
+    if (s.kind === "number") {
+      const n = Number(raw);
+      if (!Number.isFinite(n)) throw new CliError(`--${name} needs a number`);
+      flags[name] = n;
+      return;
+    }
+    if (s.kind === "list") {
+      const list = flags[name] || [];
+      list.push(raw);
+      flags[name] = list;
+      return;
+    }
+    flags[name] = raw;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--") {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      const name = eq >= 0 ? a.slice(2, eq) : a.slice(2);
+      const s = spec[name];
+      if (!s) throw new CliError(`unknown option --${name}`);
+      if (eq >= 0) set(name, a.slice(eq + 1));
+      else if (s.kind === "bool") set(name, null);
+      else {
+        const v = argv[i + 1];
+        if (v === void 0) throw new CliError(`--${name} needs a value`);
+        set(name, v);
+        i++;
+      }
+      continue;
+    }
+    if (a.length >= 2 && a[0] === "-" && a !== "-") {
+      const name = byAlias.get(a[1]);
+      if (!name) throw new CliError(`unknown option ${a.slice(0, 2)}`);
+      const s = spec[name];
+      if (a.length > 2) set(name, a.slice(2));
+      else if (s.kind === "bool") set(name, null);
+      else {
+        const v = argv[i + 1];
+        if (v === void 0) throw new CliError(`${a} needs a value`);
+        set(name, v);
+        i++;
+      }
+      continue;
+    }
+    positional.push(a);
+  }
+  return { positional, flags };
+}
+function helpLines(spec) {
+  const rows = Object.entries(spec).map(([name, s]) => {
+    const value = s.kind === "bool" ? "" : s.kind === "number" ? " N" : " <value>";
+    const left = `${s.alias ? `-${s.alias}, ` : "    "}--${name}${value}`;
+    return [left, s.help || ""];
+  });
+  const w = Math.max(0, ...rows.map((r) => r[0].length));
+  return rows.map(([l, h]) => `  ${l.padEnd(w)}  ${h}`.trimEnd());
+}
+
+// src/ipo.ts
+import { readdirSync, readFileSync as readFileSync3, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename, dirname as dirname2, join as join4, resolve } from "node:path";
+
+// src/table.ts
+function formatTable(rows, header, indent = "") {
+  const all = header ? [header, ...rows] : rows;
+  const text = all.map((r) => r.map((c) => c === void 0 ? "" : String(c)));
+  const cols = Math.max(0, ...text.map((r) => r.length));
+  const widths = [];
+  for (let c = 0; c < cols; c++)
+    widths[c] = Math.max(0, ...text.map((r) => (r[c] || "").length));
+  const line = (r) => indent + r.map(
+    (cell, c) => c === cols - 1 ? cell : cell.padEnd(widths[c])
+  ).join("  ").trimEnd();
+  const out = text.map(line);
+  if (header) {
+    const rule = widths.map((w) => "-".repeat(w));
+    out.splice(1, 0, line(rule));
+  }
+  return out;
+}
+function formatCount(n) {
+  return n.toLocaleString("en-US");
+}
+
+// src/runtime.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createContext, runInContext } from "node:vm";
+
+// src/runtime-files.json
+var runtime_files_default = [
+  "vendor/fflate.min.js",
+  "core/webshim/timers.js",
+  "core/webshim/trace.js",
+  "core/webshim/framing.js",
+  "core/webshim/exchange.js",
+  "core/webshim/transport-base.js",
+  "core/webshim/native-bus.js",
+  "core/webshim/web-serial-bus.js",
+  "core/webshim/bus.js",
+  "core/webshim/data-fetch.js",
+  "core/webshim/job-runner.js",
+  "core/webshim/variant-resolver.js",
+  "core/webshim/coding.js",
+  "core/webshim/api-router.js",
+  "core/webshim/install.js",
+  "core/bestvm/write-guard.js",
+  "core/bestvm/codec.js",
+  "core/bestvm/machine.js",
+  "core/bestvm/registers.js",
+  "core/bestvm/operands.js",
+  "core/bestvm/environment.js",
+  "core/bestvm/executor.js",
+  "core/bestvm/index.js",
+  "core/ipovm/values.js",
+  "core/ipovm/operators.js",
+  "core/ipovm/hosts.js",
+  "core/ipovm/emissions.js",
+  "core/ipovm/tape.js",
+  "core/ipovm/builtin-helpers.js",
+  "core/ipovm/builtins-screen.js",
+  "core/ipovm/builtins-api.js",
+  "core/ipovm/builtins-text.js",
+  "core/ipovm/builtins-table.js",
+  "core/ipovm/structures.js",
+  "core/ipovm/suspensions.js",
+  "core/ipovm/vm.js",
+  "core/ipofile/pool.js",
+  "core/ipofile/decls.js",
+  "core/ipofile/walk.js",
+  "core/ipofile/exec.js",
+  "core/ipofile/lex.js",
+  "core/ipofile/parse.js",
+  "core/ipofile/emit.js",
+  "core/ipofile/compile.js",
+  "core/translate.js",
+  "screens/ir.js",
+  "screens/ipo-runtime/script-scan.js",
+  "screens/ipo-runtime/translate-sets.js",
+  "screens/ipo-runtime/wire-policy.js",
+  "screens/ipo-runtime/program.js",
+  "screens/ipo-runtime/cells.js",
+  "screens/ipo-runtime/paint-modern.js",
+  "screens/ipo-runtime/paint-grid.js",
+  "screens/ipo-runtime/dialogs.js",
+  "screens/ipo-runtime/print.js",
+  "screens/ipo-runtime/protocol.js",
+  "screens/ipo-runtime/ui.js",
+  "screens/ipo-runtime/open.js",
+  "screens/ipo-runtime/home.js",
+  "home/bmweb-home.ips",
+  "home/bmweb.h",
+  "screens/activations.js",
+  "screens/garage/store.js",
+  "screens/garage/diff.js",
+  "screens/garage/share.js",
+  "screens/search/data.js",
+  "screens/search/match.js",
+  "screens/search/open.js"
+];
+
+// src/site.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join as join2 } from "node:path";
+
+// src/cache.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function cacheDir(env = process.env) {
+  const base = env.XDG_CACHE_HOME && env.XDG_CACHE_HOME.trim() ? env.XDG_CACHE_HOME : join(homedir(), ".cache");
+  return join(base, "bmweb-cli");
+}
+function indexCachePath(env = process.env) {
+  return join(cacheDir(env), "search-index.json.gz");
+}
+
+// src/site.ts
+var DEFAULT_API = "https://bmweb.danner.ink/";
+var config = {
+  base: DEFAULT_API,
+  refresh: false,
+  env: process.env,
+  fetchImpl: (...a) => fetch(...a)
+};
+function configureSite(opts) {
+  if (opts.base !== void 0) config.base = normalizeBase(opts.base);
+  if (opts.refresh !== void 0) config.refresh = opts.refresh;
+  if (opts.env !== void 0) config.env = opts.env;
+  if (opts.fetchImpl !== void 0) config.fetchImpl = opts.fetchImpl;
+}
+function normalizeBase(base) {
+  const s = String(base || "").trim();
+  return s.endsWith("/") ? s : `${s}/`;
+}
+function sitePath(input) {
+  const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) return null;
+  return url.replace(/^\/+/, "");
+}
+function siteCachePath(rel, env = config.env) {
+  const clean = rel.split("?")[0];
+  return join2(cacheDir(env), "site", ...clean.split("/"));
+}
+async function siteGet(rel) {
+  const file = siteCachePath(rel);
+  const have = existsSync(file);
+  const fresh = have && Date.now() - statSync(file).mtimeMs < CACHE_MAX_AGE_MS;
+  if (have && fresh && !config.refresh)
+    return { status: 200, bytes: readFileSync(file), fromCache: true };
+  let status = 0;
+  let bytes = null;
+  try {
+    const r = await config.fetchImpl(`${config.base}${rel}`);
+    status = r.status;
+    if (r.ok) bytes = new Uint8Array(await r.arrayBuffer());
+  } catch {
+    status = 0;
+  }
+  if (bytes) {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, bytes);
+    return { status: 200, bytes, fromCache: false };
+  }
+  if (have && status !== 404)
+    return { status: 200, bytes: readFileSync(file), fromCache: true };
+  return { status: status || 503, bytes: null, fromCache: false };
+}
+async function siteFetch(input, init) {
+  const rel = sitePath(input);
+  if (rel === null) return config.fetchImpl(input, init);
+  const r = await siteGet(rel);
+  if (!r.bytes)
+    return new Response(JSON.stringify({ error: `${rel}: HTTP ${r.status}` }), {
+      status: r.status,
+      statusText: r.status === 404 ? "Not Found" : "Unavailable"
+    });
+  return new Response(r.bytes, { status: 200 });
+}
+
+// src/runtime.ts
+var RUNTIME_DIR = fileURLToPath(
+  new URL("../runtime/", import.meta.url)
+);
+var loaded = null;
+var sandboxRef = null;
+var apiImpl = null;
+function setApiImpl(fn) {
+  apiImpl = fn;
+}
+function runtimeGlobals() {
+  loadRuntime();
+  return sandboxRef;
+}
+function hostGlobals() {
+  const noop = () => {
+  };
+  const sandbox = {
+    // the scripts test `typeof window` and read window.<x>; the context's own
+    // global stands in, as it does in the page (self: fflate's UMD attaches
+    // its global to `self` when there is no CommonJS `exports`)
+    console,
+    // timers.js's bmwSleep falls back to setTimeout where there is no
+    // Worker; program.js schedules screen cycles and drains key presses
+    // through setTimeout; activations.js defers a session end a microtask
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+    queueMicrotask,
+    // share.js: TextEncoder/TextDecoder, Blob, Response and the two
+    // compression streams encode and decode the link payload; btoa/atob do
+    // the base64url. api-router.js builds Responses and reads query strings;
+    // data-fetch.js decodes archive members. All are Node 18+ globals,
+    // handed into the fresh realm.
+    TextEncoder,
+    TextDecoder,
+    Blob,
+    Response,
+    Request,
+    URL,
+    URLSearchParams,
+    CompressionStream,
+    DecompressionStream,
+    btoa,
+    atob,
+    // WHAT THE APP READS ITS DATA THROUGH. install.js takes window.fetch as
+    // the real fetch and wraps it with the shim; every site-relative path
+    // the shim then asks for is served from the hosted site through the
+    // disk cache (site.ts), never from a local vendor tree.
+    fetch: siteFetch,
+    // web-serial-bus.js asks navigator.serial for the port; the CLI fills
+    // this in with the Node port once one is chosen (live.ts)
+    navigator: { serial: void 0 },
+    // activations.js registers a pagehide hook at load; the bus announces
+    // cable events; neither has a page here
+    addEventListener: noop,
+    removeEventListener: noop,
+    dispatchEvent: noop,
+    // ui.js writes the key caption into the document's style at render
+    // time and the harness stubs getElementById; neither draws anything
+    document: {
+      getElementById: () => null,
+      documentElement: { style: { setProperty: noop, removeProperty: noop } }
+    },
+    // the status bar the runtime writes to
+    sbLeft: { textContent: "" },
+    sbRight: { textContent: "" },
+    // HTML escaping, identity here: no DOM receives the text
+    esc: (s) => String(s == null ? "" : s),
+    // the F-key bar; the CLI's own UI adapter renders keys itself
+    setActions: noop,
+    // translate.js and translate-sets.js gate on the language setting
+    lang: () => "en",
+    // the fault dictionaries the fed results are translated through: the
+    // large generated ones are not in this package, so results stay as the
+    // module sent them (the app behaves the same in a build without them)
+    BMW_ENV_TEXT: {},
+    BMW_FAULT_PHRASES: {},
+    BMW_FAULT_DB: {},
+    scopedFaultDb: () => null,
+    // a chassis id's display name (core/core/ui.js); the id is fine here
+    dispChassis: (id) => String(id || ""),
+    // store.js persists through Settings and wire-policy.js reads the
+    // confirmActuators preference; the CLI stores nothing and confirms
+    // every actuator drive, so a read-only stand-in returning the default
+    // is exact
+    Settings: {
+      get: (_k, d) => d,
+      set: noop
+    },
+    // open.js's searchOpenHit assigns location.hash; api-router.js derives
+    // WEB_BASE from the pathname (empty: paths hang off the site root)
+    location: { hash: "", href: "", pathname: "/", search: "" },
+    // the engine client (core/core/api.js): a route in, its JSON out, the
+    // server's `error` field as the thrown message. Routed through apiImpl
+    // so a test can put a fake car behind the very same call.
+    api: async (path, opts) => {
+      if (apiImpl) return apiImpl(path, opts);
+      const f = sandbox.fetch;
+      const res = await f(path, opts);
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.error || res.statusText);
+      }
+      return res.json();
+    },
+    // the result-set projection (core/core/api.js): the engine's synthetic
+    // system set dropped when it leads
+    dataSets: (sets) => {
+      const list = sets || [];
+      const s = list[0];
+      const system = !!s && typeof s === "object" && ("SAETZE" in s || "JOBNAME" in s || "OBJECT" in s);
+      return list.length && system ? list.slice(1) : list;
+    }
+  };
+  sandbox.window = sandbox;
+  sandbox.self = sandbox;
+  sandbox.globalThis = sandbox;
+  return sandbox;
+}
+function loadRuntime() {
+  if (loaded) return loaded;
+  const sandbox = hostGlobals();
+  const collected = {};
+  sandbox.module = {
+    get exports() {
+      return collected;
+    },
+    set exports(v) {
+      Object.assign(collected, v);
+    }
+  };
+  const context = createContext(sandbox);
+  for (const rel of runtime_files_default) {
+    if (!rel.endsWith(".js")) continue;
+    const file = join3(RUNTIME_DIR, rel);
+    let code;
+    try {
+      code = readFileSync2(file, "utf8");
+    } catch {
+      throw new Error(
+        `runtime file missing: ${rel} (the package was built without scripts/sync-runtime.mjs)`
+      );
+    }
+    runInContext(code, context, { filename: rel });
+  }
+  for (const name of LIFTED_GLOBALS) {
+    collected[name] = runInContext(
+      `typeof ${name} === 'undefined' ? undefined : ${name}`,
+      context
+    );
+  }
+  sandboxRef = sandbox;
+  loaded = collected;
+  return loaded;
+}
+var LIFTED_GLOBALS = [
+  "IPO_IDENT_ROWS",
+  "IPO_TICK_MS",
+  "webBus",
+  "withBusLock",
+  "webResolveVariant",
+  "webResolveVariantLast",
+  "isWriteJob",
+  "ipoProtocolReport",
+  // home.js's host object: the status builtin reads it by name, so the
+  // CLI hangs its own status on it rather than on the VM
+  "IPO_HOME_HOST"
+];
+
+// src/ipo.ts
+var SHIFT_BASE = 10;
+var JOB_NAME_RE = /^[A-Z][A-Z0-9_]{2,}$/;
+var JOB_CALL_RE = /^(INP.?apiJob|INPAapiFsLesen|ApiJobFsLesenFAB)$/;
+var ACTION_CALLS = /* @__PURE__ */ new Set([
+  "exit",
+  "printscreen",
+  "printfile",
+  "select",
+  "deselect",
+  "start",
+  "stop",
+  "control",
+  "messagebox"
+]);
+var MAX_CALL_DEPTH = 4;
+function keyName(nr) {
+  return nr > SHIFT_BASE ? `Shift+F${nr - SHIFT_BASE}` : `F${nr}`;
+}
+function scanBody(exec, toks, start, end, R, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  const out = {
+    jobs: [],
+    screen: null,
+    frequent: false,
+    submenu: null,
+    scriptchange: null,
+    actions: [],
+    title: null
+  };
+  const byid = exec.byid || {};
+  let args = [];
+  const addJob = (j) => {
+    if (!out.jobs.includes(j)) out.jobs.push(j);
+  };
+  const strings = () => args.filter((t) => t.op === "const" && t.t === "s").map((t) => String(t.v));
+  const merge = (inner) => {
+    inner.jobs.forEach(addJob);
+    if (!out.screen && inner.screen) {
+      out.screen = inner.screen;
+      out.frequent = inner.frequent;
+    }
+    if (!out.submenu && inner.submenu) out.submenu = inner.submenu;
+    if (!out.scriptchange && inner.scriptchange)
+      out.scriptchange = inner.scriptchange;
+    if (!out.title && inner.title) out.title = inner.title;
+    for (const a of inner.actions)
+      if (!out.actions.includes(a)) out.actions.push(a);
+  };
+  for (let i = start; i < end && i < toks.length; i++) {
+    const t = toks[i];
+    if (t.op === "frame") {
+      args = [];
+      continue;
+    }
+    if (t.op === "const" || t.op === "var" || t.op === "procref") {
+      args.push(t);
+      continue;
+    }
+    if (t.op === "calluser") {
+      const name2 = byid[`func:${t.n}`];
+      if (name2 && depth < MAX_CALL_DEPTH && !seen.has(name2)) {
+        const body = exec.procs[name2];
+        if (body) {
+          const next = new Set(seen);
+          next.add(name2);
+          merge(scanBody(exec, body, 0, body.length, R, depth + 1, next));
+        }
+      }
+      args = [];
+      continue;
+    }
+    if (t.op !== "call") continue;
+    const name = t.name || "";
+    if (JOB_CALL_RE.test(name)) {
+      const s = strings();
+      let job;
+      if (/^INP.?apiJob$/.test(name)) {
+        const second = args[1];
+        if (second && second.op === "const" && second.t === "s")
+          job = String(second.v);
+      }
+      if (job === void 0) {
+        const first = args[0];
+        const sgbd = first && first.op === "const" && first.t === "s" ? String(first.v) : "";
+        job = s.find((v) => v !== sgbd && JOB_NAME_RE.test(v));
+      }
+      if (job && JOB_NAME_RE.test(job)) addJob(job);
+    } else if (name === "setscreen") {
+      const ref = args.find(
+        (a) => a.op === "procref" && a.kind === R.IPO_REF_SCREEN
+      );
+      const flag = args.find(
+        (a) => a.op === "const" && (a.t === "b" || a.t === "i")
+      );
+      const scr = ref ? byid[`screen:${ref.n}`] : void 0;
+      if (scr && !out.screen) {
+        out.screen = scr;
+        out.frequent = !!(flag && flag.v);
+      }
+    } else if (name === "setmenu") {
+      const ref = args.find(
+        (a) => a.op === "procref" && a.kind === R.IPO_REF_MENU
+      );
+      const menu = ref ? byid[`menu:${ref.n}`] : void 0;
+      if (menu && !out.submenu) out.submenu = menu;
+    } else if (name === "scriptchange") {
+      const s = strings();
+      if (s[0] && !out.scriptchange) out.scriptchange = s[0];
+    } else if (name === "setmenutitle" || name === "settitle") {
+      const s = strings();
+      if (s[0] && !out.title) out.title = s[0];
+    } else if (ACTION_CALLS.has(name)) {
+      if (!out.actions.includes(name)) out.actions.push(name);
+    }
+    args = [];
+  }
+  return out;
+}
+function scanScreen(exec, screen, R) {
+  const toks = screen ? exec.procs[screen] : void 0;
+  if (!toks) return null;
+  return scanBody(exec, toks, 0, toks.length, R);
+}
+function describeKey(exec, menu, item, R) {
+  const toks = exec.procs[menu] || [];
+  const own = scanBody(exec, toks, item.start, item.end, R);
+  const scr = scanScreen(exec, own.screen, R);
+  const jobs = [...own.jobs];
+  for (const j of scr ? scr.jobs : []) if (!jobs.includes(j)) jobs.push(j);
+  return {
+    menu,
+    nr: item.nr,
+    key: keyName(item.nr),
+    label: item.label,
+    hidden: item.hidden,
+    screen: own.screen,
+    screenTitle: scr ? scr.title : null,
+    frequent: own.frequent,
+    submenu: own.submenu,
+    scriptchange: own.scriptchange,
+    ownJobs: own.jobs,
+    screenJobs: scr ? scr.jobs : [],
+    jobs,
+    // the app's own verdict: the write classifier, minus the session
+    // plumbing every script sends without asking (wire-policy.js)
+    writes: jobs.filter((j) => R.ipoNeedsConfirm(j)),
+    actions: own.actions
+  };
+}
+function describeMenu(exec, name, R) {
+  const toks = exec.procs[name] || [];
+  const items = R.ipoMenuItems(exec, name);
+  const firstItem = items.length ? items[0].start - 1 : toks.length;
+  const prologue = scanBody(exec, toks, 0, firstItem, R);
+  const shown = R.ipoScreenForMenu(exec, name);
+  return {
+    name,
+    title: prologue.title,
+    screen: shown ? shown.screen : prologue.screen,
+    keys: items.map((it) => describeKey(exec, name, it, R))
+  };
+}
+function menuNames(exec) {
+  return Object.entries(exec.byid || {}).filter(([k]) => k.startsWith("menu:")).sort((a, b) => Number(a[0].split(":")[1]) - Number(b[0].split(":")[1])).map(([, v]) => v);
+}
+function describeScript(exec, source, R, includes = Array.from(exec.includes || [])) {
+  const inv = R.ipofInventory(exec);
+  const entry = exec.procs.inpainit ? "inpainit" : exec.procs.SgbdInpaCheck ? "SgbdInpaCheck" : null;
+  const entryScan = entry ? scanBody(exec, exec.procs[entry], 0, Infinity, R) : null;
+  return {
+    name: exec.ecu,
+    source,
+    form: exec.coding ? "NCS coding dispatcher (drives the coding host, not a diagnostic session)" : "INPA diagnostic script",
+    bytes: exec.bytes ?? null,
+    unknown: exec.unknown ?? 0,
+    entry,
+    rootMenu: entryScan ? entryScan.submenu : null,
+    rootScreen: entryScan ? entryScan.screen : null,
+    includes,
+    imports: Object.values(exec.imports || {}),
+    procedures: Object.keys(exec.procs).length,
+    functions: inv.funcs.length,
+    machines: inv.machines.length,
+    screens: inv.screens.length,
+    menus: menuNames(exec).map((m) => describeMenu(exec, m, R))
+  };
+}
+function gatherIncludes(dirs, skip) {
+  const R = loadRuntime();
+  const files = {};
+  const own = resolve(skip);
+  for (const dir of dirs) {
+    let names;
+    try {
+      names = readdirSync(dir);
+    } catch {
+      throw new CliError(`include directory not found: ${dir}`);
+    }
+    for (const name of names.sort()) {
+      if (!R.ipofIsInclude(name)) continue;
+      const p = join4(dir, name);
+      if (resolve(p) === own) continue;
+      try {
+        if (!statSync2(p).isFile()) continue;
+      } catch {
+        continue;
+      }
+      const key = name.toLowerCase();
+      if (!(key in files)) files[key] = readFileSync3(p, "latin1");
+    }
+  }
+  return files;
+}
+function readScript(file, includeDirs) {
+  const R = loadRuntime();
+  const name = basename(file);
+  const stem = R.ipofStem(name);
+  let bytes;
+  try {
+    bytes = readFileSync3(file);
+  } catch {
+    throw new CliError(`cannot read ${file}`);
+  }
+  if (R.ipofIsCompiled(name)) {
+    let exec;
+    try {
+      exec = R.ipofDecodeExec(new Uint8Array(bytes), stem);
+    } catch (e) {
+      throw new CliError(String(e.message || e));
+    }
+    return {
+      exec,
+      source: "compiled .IPO",
+      stem,
+      includes: Array.from(exec.includes || [])
+    };
+  }
+  if (!R.ipofIsSource(name))
+    throw new CliError(`${name}: not a script (.IPO) or a source (.IPS, .SRC)`);
+  const dirs = [dirname2(resolve(file)), ...includeDirs];
+  const files = gatherIncludes(dirs, file);
+  const r = R.ipofCompileSource(bytes.toString("latin1"), {
+    name: stem,
+    files
+  });
+  if (!r.ok || !r.exec) {
+    if (r.missing.length) {
+      throw new CliError(
+        `${name}: missing include${r.missing.length === 1 ? "" : "s"} ${r.missing.join(", ")} (searched ${dirs.join(", ")}; pass -I <dir> with the INPA headers)`
+      );
+    }
+    const first = r.errors[0];
+    const where = first && first.line ? `line ${first.line}: ` : "";
+    throw new CliError(
+      `${name}: ${where}${first ? first.text || first.message : "compile failed"}`
+    );
+  }
+  return {
+    exec: r.exec,
+    source: "compiled from source",
+    stem,
+    includes: Array.from(r.includes)
+  };
+}
+function ipoInfo(file, includeDirs, json) {
+  const R = loadRuntime();
+  const s = readScript(file, includeDirs);
+  const info = describeScript(s.exec, s.source, R, s.includes);
+  if (json) return [JSON.stringify(info, null, 2)];
+  const kv = [
+    ["Script", `${info.name} (${info.source})`],
+    ["Form", info.form],
+    [
+      "Entry",
+      info.entry ? `${info.entry}${info.rootMenu || info.rootScreen ? ` -> ${[info.rootMenu, info.rootScreen].filter(Boolean).join(" / ")}` : ""}` : "none (INPA starts at inpainit or SgbdInpaCheck; this script has neither)"
+    ],
+    ["Includes", info.includes.length ? info.includes.join(", ") : "none"],
+    [
+      "Procedures",
+      `${info.procedures} (${info.menus.length} menus, ${info.screens} screens, ${info.functions} functions, ${info.machines} state machines)`
+    ],
+    ["DLL imports", info.imports.length ? info.imports.join(", ") : "none"]
+  ];
+  if (info.bytes != null) {
+    kv.push([
+      "Bytecode",
+      `${formatCount(info.bytes)} bytes` + (info.unknown ? `, ${formatCount(info.unknown)} undecoded` : "")
+    ]);
+  }
+  const out = formatTable(kv);
+  for (const m of info.menus) {
+    out.push("");
+    out.push(...menuLines(m));
+  }
+  return out;
+}
+function menuLines(m) {
+  const head = [
+    m.name,
+    m.title ? `"${m.title}"` : "",
+    m.screen ? `(screen ${m.screen})` : ""
+  ].filter(Boolean).join("  ");
+  const rows = m.keys.map((k) => [
+    k.key,
+    keyLabel(k),
+    keyTarget(k),
+    keyJobsText(k)
+  ]);
+  return [head, ...formatTable(rows, void 0, "  ")];
+}
+function keyLabel(k) {
+  return k.hidden ? "(no caption)" : k.label;
+}
+function keyTarget(k) {
+  const parts = [];
+  if (k.screen) parts.push(`${k.screen}${k.frequent ? " (cyclic)" : ""}`);
+  if (k.submenu) parts.push(`menu ${k.submenu}`);
+  if (k.scriptchange) parts.push(`script ${k.scriptchange}`);
+  return parts.join(", ");
+}
+function keyJobsText(k) {
+  const jobs = k.jobs.map((j) => k.writes.includes(j) ? `${j} [WRITE]` : j);
+  const acts = k.actions.filter((a) => a !== "messagebox");
+  return [...jobs, ...acts.map((a) => `(${a})`)].join(", ");
+}
+function ipoKeys(file, includeDirs, menu, json) {
+  const R = loadRuntime();
+  const s = readScript(file, includeDirs);
+  const names = menu ? [menu] : menuNames(s.exec);
+  if (menu && !(menu in s.exec.procs))
+    throw new CliError(
+      `${s.stem}: no menu ${menu} (menus: ${menuNames(s.exec).join(", ") || "none"})`
+    );
+  const menus = names.map((m) => describeMenu(s.exec, m, R));
+  if (json) return [JSON.stringify(menus, null, 2)];
+  const rows = [];
+  for (const m of menus)
+    for (const k of m.keys)
+      rows.push([
+        m.name,
+        k.key,
+        keyLabel(k),
+        keyTarget(k),
+        keyJobsText(k),
+        k.writes.length ? "yes" : ""
+      ]);
+  if (!rows.length) return [`${s.stem}: no menu keys`];
+  return formatTable(rows, ["MENU", "KEY", "LABEL", "OPENS", "JOBS", "WRITES"]);
+}
+function ipoCompile(file, includeDirs, out) {
+  const R = loadRuntime();
+  const name = basename(file);
+  if (!R.ipofIsSource(name))
+    throw new CliError(`${name}: compile takes a .IPS or .SRC source`);
+  const s = readScript(file, includeDirs);
+  const target = out || join4(dirname2(resolve(file)), `${s.stem}.ipoexec.json`);
+  try {
+    writeFileSync2(target, JSON.stringify(s.exec));
+  } catch {
+    throw new CliError(`cannot write ${target}`);
+  }
+  const inv = R.ipofInventory(s.exec);
+  return [
+    `${name}: compiled ${Object.keys(s.exec.procs).length} procedures (${inv.menus.length} menus, ${inv.screens.length} screens, ${inv.funcs.length} functions, ${inv.machines.length} state machines)` + (s.includes.length ? `, includes ${s.includes.join(", ")}` : ""),
+    `wrote ${target} (the app's exec form; not INPA's binary .IPO)`
+  ];
+}
+
+// src/live.ts
+import { createInterface } from "node:readline";
+
+// src/serial.ts
+import { readdirSync as readdirSync2 } from "node:fs";
+var PORT_PATTERNS = [
+  /^cu\.usbserial/i,
+  /^cu\.SLAB/i,
+  /^cu\.wchusbserial/i,
+  /^ttyUSB/i,
+  /^ttyACM/i
+];
+var NodeSerialPort = class {
+  path;
+  opener;
+  binding = null;
+  /** chunks heard and not yet read */
+  chunks = [];
+  /** the one read waiting for bytes, when the queue is empty */
+  waiter = null;
+  /** the lines as last set, so a partial setSignals keeps the others */
+  lines = { dtr: false, rts: false, brk: false };
+  /** the wire trace sink, when the CLI wants one */
+  info;
+  /**
+   * @param path - the device path
+   * @param opener - how a binding is opened
+   * @param info - vendor and product ids, when known (portLabel shows them)
+   */
+  constructor(path, opener, info = {}) {
+    this.path = path;
+    this.opener = opener;
+    this.info = info;
+  }
+  /** Is a binding open (Web Serial's SerialPort.connected). */
+  get connected() {
+    return !!this.binding;
+  }
+  /**
+   * Open the device with the given settings.
+   * @param cfg - baud, bits, parity
+   */
+  async open(cfg) {
+    if (this.binding) throw new Error(`${this.path} is already open`);
+    const b = await this.opener(this.path, cfg);
+    this.binding = b;
+    this.chunks = [];
+    b.onData((chunk) => this.push(chunk));
+  }
+  /**
+   * Close the device: the binding goes, a waiting read is told `done`.
+   */
+  async close() {
+    const b = this.binding;
+    this.binding = null;
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = null;
+      w({ value: void 0, done: true });
+    }
+    this.chunks = [];
+    if (b) await b.close();
+  }
+  /**
+   * Bytes the binding heard: to the waiting read, else queued.
+   * @param chunk - the bytes
+   */
+  push(chunk) {
+    if (!chunk.length) return;
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = null;
+      w({ value: chunk, done: false });
+      return;
+    }
+    this.chunks.push(chunk);
+  }
+  /** The readable side: getReader() hands back the one reader. */
+  get readable() {
+    return {
+      getReader: () => ({
+        read: () => this.read(),
+        cancel: async () => this.cancel(),
+        releaseLock: () => {
+        }
+      })
+    };
+  }
+  /** The writable side: getWriter() hands back the one writer. */
+  get writable() {
+    return {
+      getWriter: () => ({
+        write: (bytes) => this.write(bytes),
+        releaseLock: () => {
+        }
+      })
+    };
+  }
+  /**
+   * One read: the next chunk, or `done` when the port is closed.
+   * @returns the read result
+   */
+  read() {
+    const next = this.chunks.shift();
+    if (next) return Promise.resolve({ value: next, done: false });
+    if (!this.binding) return Promise.resolve({ value: void 0, done: true });
+    return new Promise((resolve2) => {
+      this.waiter = resolve2;
+    });
+  }
+  /**
+   * Cancel the reader: a waiting read is told `done`, buffered bytes go.
+   */
+  cancel() {
+    this.chunks = [];
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = null;
+      w({ value: void 0, done: true });
+    }
+  }
+  /**
+   * Write bytes. Resolves when the OS has them, not when they have left the
+   * wire: the bus then holds DTR for the telegram's own byte time, and
+   * waiting for transmission here would double that hold and lose the
+   * ECU's answer (the reference interface's DtrTimeCorrCom is 0.3 ms).
+   * @param bytes - the framed request
+   */
+  async write(bytes) {
+    if (!this.binding) throw new Error(`${this.path} is not open`);
+    await this.binding.write(bytes);
+  }
+  /**
+   * Drive the modem lines. A partial call keeps the lines it does not name,
+   * as Web Serial does; the binding always gets all three, because
+   * `serialport` would otherwise assert the ones left unsaid.
+   * @param s - the lines to set
+   */
+  async setSignals(s) {
+    if (!this.binding) throw new Error(`${this.path} is not open`);
+    if (s.dataTerminalReady !== void 0)
+      this.lines.dtr = !!s.dataTerminalReady;
+    if (s.requestToSend !== void 0) this.lines.rts = !!s.requestToSend;
+    if (s.break !== void 0) this.lines.brk = !!s.break;
+    await this.binding.set({ ...this.lines });
+  }
+  /**
+   * Read the modem lines (KL15 arrives on DSR or DCD of a K+DCAN cable).
+   * @returns the lines, or null when the binding cannot say
+   */
+  async getSignals() {
+    if (!this.binding) return null;
+    const st = await this.binding.get();
+    if (!st) return null;
+    return {
+      dataSetReady: !!st.dsr,
+      dataCarrierDetect: !!st.dcd,
+      clearToSend: !!st.cts
+    };
+  }
+  /**
+   * The USB ids, for the bus's port label.
+   * @returns what is known
+   */
+  getInfo() {
+    return this.info;
+  }
+  /** Web Serial's disconnect event; a pulled USB cable is not watched here. */
+  addEventListener() {
+  }
+};
+var serialportModule = null;
+async function loadSerialport() {
+  if (serialportModule) return serialportModule;
+  try {
+    serialportModule = await import("serialport");
+  } catch {
+    throw new CliError(
+      "the serialport package is not installed; run: npm i -g serialport (or reinstall bmweb-cli with its optional dependencies)"
+    );
+  }
+  return serialportModule;
+}
+async function openSerialportBinding(path, cfg) {
+  const mod = await loadSerialport();
+  const port = new mod.SerialPort({
+    path,
+    baudRate: cfg.baudRate,
+    dataBits: cfg.dataBits,
+    stopBits: cfg.stopBits,
+    parity: cfg.parity,
+    autoOpen: false,
+    // keep the lines where we leave them across close/open
+    hupcl: false
+  });
+  await new Promise(
+    (res, rej) => port.open(
+      (e) => e ? rej(new CliError(`cannot open ${path}: ${e.message}`)) : res()
+    )
+  );
+  const call = (fn) => new Promise((res, rej) => fn((e) => e ? rej(e) : res()));
+  const binding = {
+    write: (bytes) => call((cb) => port.write(Buffer.from(bytes), cb)),
+    onData: (fn) => port.on("data", (b) => fn(new Uint8Array(b))),
+    set: (s) => call(
+      (cb) => port.set(
+        {
+          dtr: s.dtr,
+          rts: s.rts,
+          brk: s.brk,
+          cts: false,
+          dsr: false,
+          ...process.platform === "linux" ? { lowLatency: true } : {}
+        },
+        cb
+      )
+    ),
+    get: () => new Promise((res) => port.get((e, st) => res(e || !st ? null : st))),
+    close: () => new Promise((res) => port.close(() => res()))
+  };
+  await binding.set({ dtr: false, rts: false, brk: false });
+  return binding;
+}
+async function listPorts(devDir = "/dev") {
+  const found = /* @__PURE__ */ new Map();
+  try {
+    for (const name of readdirSync2(devDir))
+      if (PORT_PATTERNS.some((re) => re.test(name)))
+        found.set(`${devDir}/${name}`, "");
+  } catch {
+  }
+  try {
+    const mod = await loadSerialport();
+    for (const p of await mod.SerialPort.list()) {
+      const base = p.path.split("/").pop() || p.path;
+      if (!PORT_PATTERNS.some((re) => re.test(base))) continue;
+      const detail = [
+        p.manufacturer,
+        p.vendorId && p.productId ? `${p.vendorId}:${p.productId}` : "",
+        p.serialNumber ? `sn ${p.serialNumber}` : ""
+      ].filter(Boolean).join("  ");
+      found.set(p.path, detail);
+    }
+  } catch {
+  }
+  return [...found.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([path, detail]) => ({ path, detail }));
+}
+function choosePort(wanted, candidates) {
+  if (wanted) return wanted;
+  if (candidates.length === 1) return candidates[0].path;
+  if (!candidates.length)
+    throw new CliError(
+      "no K+DCAN cable found (looked for cu.usbserial*, cu.SLAB*, cu.wchusbserial*, ttyUSB*, ttyACM*); pass --port <device>"
+    );
+  throw new CliError(
+    `several ports found; pass --port: ${candidates.map((c) => c.path).join(", ")}`
+  );
+}
+
+// src/live.ts
+var FTDI_HINT = "If this is an FTDI cable, set its latency timer to 1 ms (Linux: done for you; macOS: FTDI D2XX/driver setting; Windows: Device Manager, Port Settings, Advanced).";
+async function connectBus(opts = {}) {
+  configureSite({
+    ...opts.api ? { base: opts.api } : {},
+    refresh: !!opts.refresh
+  });
+  const R = loadRuntime();
+  const g = runtimeGlobals();
+  const candidates = opts.ports || await listPorts();
+  const path = choosePort(opts.port, candidates);
+  const opener = opts.opener || openSerialportBinding;
+  const port = new NodeSerialPort(path, opener);
+  g.navigator.serial = {
+    requestPort: async () => port,
+    getPorts: async () => []
+  };
+  let label;
+  try {
+    label = await R.webBus.connect();
+  } catch (e) {
+    throw new CliError(`cannot open ${path}: ${e.message}`);
+  }
+  return { R, label, path };
+}
+async function disconnectBus(R) {
+  try {
+    await R.withBusLock(async () => {
+    });
+  } catch {
+  }
+  if (R.webBus.connected) await R.webBus.disconnect();
+}
+async function portsCommand(json, ports) {
+  const list = ports || await listPorts();
+  if (json) return [JSON.stringify(list, null, 2)];
+  if (!list.length)
+    return [
+      "no candidate ports (cu.usbserial*, cu.SLAB*, cu.wchusbserial*, ttyUSB*, ttyACM*)"
+    ];
+  return formatTable(list.map((p) => [p.path, p.detail]));
+}
+async function askYesNo(question, io = {}) {
+  const input = io.input || process.stdin;
+  const output = io.output || process.stderr;
+  if (!io.input && !process.stdin.isTTY) return false;
+  const rl = createInterface({ input, output });
+  const answer = await new Promise(
+    (res) => rl.question(`${question} [y/N] `, res)
+  );
+  rl.close();
+  return /^y(es)?$/i.test(answer.trim());
+}
+async function jobCommand(sgbd, job, opts = {}) {
+  const R = loadRuntime();
+  const name = job.toUpperCase();
+  const target = sgbd.toLowerCase();
+  if (R.isWriteJob(name) && !opts.yes) {
+    const ask = opts.confirm || askYesNo;
+    const ok = await ask(
+      `${name} on ${target} is a write (it changes the module or drives something). Send it?`
+    );
+    if (!ok)
+      return [
+        `${name} on ${target}: not sent (a write needs --yes or a y answer)`
+      ];
+  }
+  const api = opts.apiFn || runtimeGlobals().api;
+  const q = opts.arg != null && opts.arg !== "" ? `?arg=${encodeURIComponent(opts.arg)}` : "";
+  let d;
+  try {
+    d = await api(`/api/ecu/${target}/run/${encodeURIComponent(name)}${q}`, {
+      method: "POST"
+    });
+  } catch (e) {
+    const m = String(e.message || e);
+    throw new CliError(
+      `${name} on ${target}: ${m}${/IFH-0003/.test(m) ? `
+${FTDI_HINT}` : ""}`
+    );
+  }
+  if (opts.json) return [JSON.stringify(d, null, 2)];
+  return formatAnswer(d);
+}
+function formatAnswer(d) {
+  const sys = d.system || {};
+  const out = [
+    `${String(sys.OBJECT || "")} ${String(sys.VARIANTE || "")} ${String(sys.JOBNAME || d.job || "")}: ${(d.sets || []).length} set${(d.sets || []).length === 1 ? "" : "s"}`
+  ];
+  (d.sets || []).forEach((set, i) => {
+    out.push("", `set ${i + 1}`);
+    const rows = Object.entries(set).filter(([k]) => !k.startsWith("_")).map(([k, v]) => [k, valueText(v)]);
+    out.push(...formatTable(rows, void 0, "  "));
+  });
+  return out;
+}
+function valueText(v) {
+  if (v == null) return "";
+  if (Array.isArray(v))
+    return v.map(
+      (b) => (Number(b) & 255).toString(16).toUpperCase().padStart(2, "0")
+    ).join("-");
+  if (typeof v === "object") return JSON.stringify(v);
+  return String(v);
+}
+async function openModule(chassis, sgbd, api = runtimeGlobals().api) {
+  const cid = chassis.toUpperCase();
+  const want = sgbd.toLowerCase();
+  let ecu;
+  if (want === cid.toLowerCase()) {
+    ecu = {
+      code: cid,
+      sgbd: want,
+      label: `INPA ${cid} script`,
+      group: null,
+      kind: "vehicle",
+      chassis: cid
+    };
+  } else {
+    let config2;
+    try {
+      config2 = await api(`/api/chassis/${cid}`);
+    } catch (e) {
+      throw new CliError(
+        `no chassis ${cid} on the site (${e.message})`
+      );
+    }
+    const rows = [];
+    for (const s of config2.sections || []) rows.push(...s.ecus || []);
+    const row = rows.find((r) => String(r.sgbd).toLowerCase() === want) || rows.find((r) => String(r.code || "").toLowerCase() === want) || rows.find(
+      (r) => (r.variants || []).some((v) => String(v).toLowerCase() === want)
+    );
+    if (!row)
+      throw new CliError(
+        `${cid} carries no module ${sgbd} (try: ${rows.slice(0, 12).map((r) => r.sgbd).join(", ")}${rows.length > 12 ? ", ..." : ""})`
+      );
+    ecu = {
+      code: row.code || "",
+      label: row.label || row.sgbd,
+      sgbd: String(row.sgbd).toLowerCase(),
+      group: row.group || null,
+      chassis: cid
+    };
+  }
+  return prepareModule(ecu, api);
+}
+async function prepareModule(ecu, api = runtimeGlobals().api) {
+  const R = loadRuntime();
+  try {
+    const idx = await api("/api/ecu-index.json");
+    ecu._ipoKnownSgbds = new Set(
+      Object.keys(idx || {}).map((k) => k.toLowerCase())
+    );
+  } catch {
+    ecu._ipoKnownSgbds = /* @__PURE__ */ new Set();
+  }
+  await resolveGroupVariant(ecu, api, R);
+  const codeHint = ecu.code ? `?code=${encodeURIComponent(ecu.code)}` : "";
+  ecu._ir = await api(`/api/ecu/${ecu.sgbd}/ir${codeHint}`).catch(() => null);
+  const menusOf = (ir) => Object.keys((ir || {}).menus || {}).length;
+  if (!menusOf(ecu._ir) && ecu._sgbdBase && ecu._sgbdBase !== ecu.sgbd) {
+    const base = await api(`/api/ecu/${ecu._sgbdBase}/ir${codeHint}`).catch(
+      () => null
+    );
+    if (menusOf(base)) {
+      ecu._ir = base;
+      ecu._irFrom = ecu._sgbdBase;
+    }
+  }
+  const script = String(ecu._irFrom || ecu.sgbd).toLowerCase();
+  const exec = await R.irLiveExec(script);
+  if (!exec || !exec.procs || !Object.keys(exec.procs).length)
+    throw new CliError(
+      `${script}: the site ships no runnable script for this module`
+    );
+  if (!(exec.procs.inpainit || exec.procs.SgbdInpaCheck))
+    throw new CliError(
+      `${script}: the script has no INPA entry point (inpainit)`
+    );
+  return { ecu, exec };
+}
+async function resolveGroupVariant(ecu, api, R) {
+  const g = String(ecu.group || "").toLowerCase();
+  ecu._variantSource = null;
+  if (!g) {
+    ecu._variantSource = "ungrouped";
+    return;
+  }
+  let idx = null;
+  try {
+    idx = await api("/data/groups/index.json");
+  } catch {
+    idx = null;
+  }
+  if (!idx || !(idx.groups || []).includes(g)) {
+    ecu._variantSource = "nogroup";
+    return;
+  }
+  let v = null;
+  try {
+    v = await R.webResolveVariant(g);
+  } catch {
+    v = null;
+  }
+  if (!v) {
+    ecu._variantSource = "unverified";
+    return;
+  }
+  ecu._variant = v.toUpperCase();
+  ecu._variantSource = "confirmed";
+  if (v === String(ecu.sgbd).toLowerCase()) return;
+  try {
+    const jobs = await api(`/api/ecu/${v}/jobs`);
+    if (!Array.isArray(jobs) || !jobs.length) return;
+  } catch {
+    return;
+  }
+  ecu._sgbdBase = ecu._sgbdBase || ecu.sgbd;
+  ecu.sgbd = v;
+  ecu._variantSource = "identified";
+}
+var SCAN_CHASSIS = [
+  "E46",
+  "E53",
+  "E65",
+  "E83",
+  "E85",
+  "E87",
+  "E89",
+  "E90",
+  "R50",
+  "R56"
+];
+
+// src/faults.ts
+function hexDigits(v) {
+  if (v == null || v === "") return "";
+  const text = Array.isArray(v) ? v.map((b) => (Number(b) & 255).toString(16).padStart(2, "0")).join("") : String(v);
+  return text.trim().toUpperCase().replace(/^0X/, "").replace(/[^0-9A-F]/g, "").slice(0, 4);
+}
+function leadingCode(text) {
+  const m = /^([0-9A-F]{3,5})\b/i.exec(String(text || "").trim());
+  return m ? m[1].toUpperCase() : "";
+}
+function faultCode(c) {
+  const hex = hexDigits(c.F_HEX_CODE);
+  if (hex) return hex;
+  const lead = leadingCode(c.F_ORT_TEXT);
+  if (lead) return lead;
+  const nr = c.F_ORT_NR;
+  if (nr != null && String(nr).trim() !== "") return String(nr).trim();
+  return "";
+}
+function faultText(c, code) {
+  const text = String(c.F_ORT_TEXT || "").trim();
+  const lead = leadingCode(text);
+  if (lead && lead === code) return text.slice(lead.length).trim();
+  return text;
+}
+function faultCount(c) {
+  const n = c.F_HFK ?? c.F_LZ;
+  return n == null || n === "" ? "" : String(n);
+}
+function faultState(c) {
+  const vt = String(c.F_VORHANDEN_TEXT || "").toLowerCase();
+  if (!vt) return "";
+  const says = /momentan vorhanden|currently present/.test(vt);
+  const denies = /nicht vorhanden|not (currently )?present/.test(vt);
+  return says && !denies ? "present" : "stored";
+}
+function faultRow(c) {
+  const code = faultCode(c);
+  return {
+    code,
+    text: faultText(c, code),
+    count: faultCount(c),
+    state: faultState(c)
+  };
+}
+
+// src/report.ts
+function payloadOf(arg) {
+  const s = String(arg || "").trim();
+  const at = s.indexOf("#report/");
+  if (at >= 0) return s.slice(at + "#report/".length);
+  if (s.startsWith("report/")) return s.slice("report/".length);
+  if (/^https?:\/\//i.test(s))
+    throw new CliError("that link carries no #report/ fragment");
+  return s;
+}
+async function decodeReport(arg) {
+  const R = loadRuntime();
+  const payload = payloadOf(arg);
+  if (!payload) throw new CliError("no report payload given");
+  const p = await R.garageShareDecode(payload);
+  if (!p)
+    throw new CliError(
+      "this link does not carry a readable report (it may have been cut short when pasted)"
+    );
+  return p;
+}
+function scanOf(p) {
+  const R = loadRuntime();
+  return {
+    kind: p.kind,
+    at: p.at,
+    chassis: p.chassis,
+    report: p.report,
+    summary: p.summary || R.garageScanSummary(p.report)
+  };
+}
+function moduleName(m) {
+  return m.label || String(m.sgbd || "").toUpperCase();
+}
+function identRows(ident) {
+  const R = loadRuntime();
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  const val = (k) => ident[k] == null ? "" : String(ident[k]).trim();
+  for (const [keys, cap] of R.IPO_IDENT_ROWS || []) {
+    for (const k of keys) {
+      seen.add(k);
+      const v = val(k);
+      if (v) rows.push([keys.length > 1 ? `${cap} (${k})` : cap, k, v]);
+    }
+  }
+  for (const k of Object.keys(ident)) {
+    if (seen.has(k) || k.startsWith("_")) continue;
+    const v = val(k);
+    if (v) rows.push([k, k, v]);
+  }
+  return rows;
+}
+function headerLines(p) {
+  const R = loadRuntime();
+  const sum = p.summary || R.garageScanSummary(p.report);
+  const who = [p.label, p.chassis].filter(Boolean).join(" / ");
+  const kind = p.kind === "ident" ? "identification" : "fault memories";
+  return formatTable([
+    ["Report", `${kind}${who ? ` of ${who}` : ""}`],
+    ["Read", p.at || ""],
+    [
+      "Modules",
+      `${sum.modules} read, ${sum.withFaults} with faults, ${sum.faults} fault${sum.faults === 1 ? "" : "s"}, ${sum.silent} silent`
+    ]
+  ]);
+}
+function faultLines(report) {
+  const rows = [];
+  for (const m of report.modules || []) {
+    const codes = m.codes || [];
+    if (!codes.length) {
+      rows.push([moduleName(m), "", "no faults stored"]);
+      continue;
+    }
+    for (const c of codes) {
+      const r = faultRow(c);
+      rows.push([moduleName(m), r.code, r.text, r.count, r.state]);
+    }
+  }
+  if (!rows.length) return ["no modules in this report"];
+  return formatTable(rows, ["MODULE", "CODE", "TEXT", "COUNT", "STATE"]);
+}
+function identLines(report) {
+  const rows = [];
+  for (const m of report.modules || []) {
+    const ident = m.ident;
+    if (!ident || !Object.keys(ident).length) {
+      rows.push([moduleName(m), "", "(no identification)"]);
+      continue;
+    }
+    for (const [cap, , v] of identRows(ident))
+      rows.push([moduleName(m), cap, v]);
+  }
+  if (!rows.length) return ["no modules in this report"];
+  return formatTable(rows, ["MODULE", "FIELD", "VALUE"]);
+}
+function silentLines(report) {
+  const silent = report.silent || [];
+  if (!silent.length) return [];
+  return [
+    "",
+    `Silent (${silent.length}):`,
+    ...formatTable(
+      silent.map((s) => [
+        String(s.target || "").toUpperCase(),
+        s.label || "",
+        s.error || ""
+      ]),
+      void 0,
+      "  "
+    )
+  ];
+}
+async function reportShow(arg, json) {
+  const p = await decodeReport(arg);
+  if (json) return [JSON.stringify(p, null, 2)];
+  return [...headerLines(p), "", ...reportBodyLines(p.report, p.kind)];
+}
+function reportBodyLines(report, kind) {
+  const body = kind === "ident" ? identLines(report) : faultLines(report);
+  return [...body, ...silentLines(report)];
+}
+function diffFaultRow(sign, c) {
+  const r = faultRow(c);
+  return [sign, r.code, r.text, r.count];
+}
+function diffJson(a, b, diff) {
+  const R = loadRuntime();
+  const strip = (p) => ({
+    kind: p.kind,
+    at: p.at,
+    chassis: p.chassis,
+    label: p.label
+  });
+  return {
+    from: strip(a),
+    to: strip(b),
+    kind: diff.kind,
+    counts: R.garageDiffCounts(diff),
+    modules: diff.modules,
+    silence: diff.silence
+  };
+}
+async function reportDiff(argA, argB, json) {
+  const R = loadRuntime();
+  const a = await decodeReport(argA);
+  const b = await decodeReport(argB);
+  const diff = R.garageDiffScans(scanOf(a), scanOf(b));
+  if (json) return [JSON.stringify(diffJson(a, b, diff), null, 2)];
+  const counts = R.garageDiffCounts(diff);
+  const out = formatTable([
+    ["From", `${a.at || ""}${a.label ? `  ${a.label}` : ""}`],
+    ["To", `${b.at || ""}${b.label ? `  ${b.label}` : ""}`],
+    [
+      "Changes",
+      `${counts.added} new, ${counts.cleared} cleared, ${counts.same} still present` + (diff.kind !== "faults" ? `, ${counts.fields} ident fields changed` : "") + `, ${counts.modules} module${counts.modules === 1 ? "" : "s"} changed`
+    ]
+  ]);
+  for (const m of diff.modules) {
+    out.push("");
+    if (m.unread) {
+      out.push(`${m.label}  (not read in the newer report)`);
+      continue;
+    }
+    if (!m.changed) {
+      out.push(
+        `${m.label}  unchanged` + (m.same.length ? ` (${m.same.length} still present)` : "")
+      );
+      continue;
+    }
+    out.push(m.label);
+    const rows = [];
+    for (const c of m.added) rows.push(diffFaultRow("+", c));
+    for (const c of m.cleared) rows.push(diffFaultRow("-", c));
+    for (const c of m.same) rows.push(diffFaultRow("=", c));
+    for (const f of m.fields)
+      rows.push(["~", f.label, `${f.from || "(none)"} -> ${f.to || "(none)"}`]);
+    out.push(...formatTable(rows, void 0, "  "));
+  }
+  if (diff.silence.length) {
+    out.push("", "Answering changed:");
+    out.push(
+      ...formatTable(
+        diff.silence.map((s) => [
+          s.state === "silent" ? "silent now" : "answering now",
+          s.label,
+          s.error || ""
+        ]),
+        void 0,
+        "  "
+      )
+    );
+  }
+  out.push("", "+ new   - cleared   = still present   ~ ident field changed");
+  return out;
+}
+
+// src/scan.ts
+var VEHICLE_SCRIPTS = {
+  E46: "e46",
+  E53: "e53",
+  E65: "e65",
+  E83: "e83",
+  E85: "e85",
+  E87: "e87",
+  E89: "e89_d_all",
+  E90: "e90",
+  R50: "r50",
+  R56: "r56_all"
+};
+var FAULT_KEY_RE = /^(FS lesen|Fehlerspeicher lesen|Read (fault|error) memory)$/i;
+var FAULT_MENU = "m_fs";
+function headlessUi(progress) {
+  let lastBox = "";
+  return {
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    loadExec: async (sgbd) => loadRuntime().irLiveExec(sgbd),
+    route: () => {
+    },
+    status: () => {
+    },
+    error: (_p, text) => progress(`error: ${text}`),
+    message: async (title, body) => {
+      progress(`${title}${body ? `: ${body}` : ""}`);
+    },
+    // a prompt cannot be answered headless: the key is abandoned
+    askInput: async () => null,
+    // a scan reads; a key that would write is declined, never sent
+    confirmKey: async () => false,
+    confirmWrite: async () => false,
+    pickComponent: async () => null,
+    pickLines: async () => null,
+    saveFile: async () => null,
+    writeFile: async () => {
+    },
+    printScreen: () => {
+    },
+    resolveScriptEcu: (from, script, exec) => loadRuntime().ipoResolveScriptEcu(from, script, exec),
+    machineTick: async () => "tick",
+    userbox: (_p, box) => {
+      if (!box) return;
+      const lines = box.lines || [];
+      const text = lines.length ? String(lines[lines.length - 1]) : "";
+      if (text && text !== lastBox) {
+        lastBox = text;
+        progress(text.trim());
+      }
+    },
+    renderKeys: () => {
+    },
+    paint: () => {
+    },
+    left: () => {
+    }
+  };
+}
+async function scanCommand(chassis, opts = {}) {
+  const R = loadRuntime();
+  const cid = chassis.toUpperCase();
+  if (opts.apiFn) setApiImpl(opts.apiFn);
+  try {
+    return await scanRun(R, cid, opts);
+  } finally {
+    if (opts.apiFn) setApiImpl(null);
+  }
+}
+async function scanRun(R, cid, opts) {
+  const progress = opts.progress || ((l) => process.stderr.write(`${l}
+`));
+  const api = opts.apiFn || runtimeGlobals().api;
+  let ecu;
+  let exec;
+  if (opts.exec) {
+    ecu = opts.ecu || {
+      code: cid,
+      sgbd: cid.toLowerCase(),
+      label: `INPA ${cid} script`,
+      group: null,
+      kind: "vehicle",
+      chassis: cid
+    };
+    exec = opts.exec;
+  } else {
+    const script = VEHICLE_SCRIPTS[cid];
+    if (!script)
+      throw new CliError(
+        `no whole-vehicle script for ${cid} (one ships for ${Object.keys(VEHICLE_SCRIPTS).join(" ")})`
+      );
+    ({ ecu, exec } = await openModule(cid, script, api));
+    ecu.kind = "vehicle";
+  }
+  const ui = headlessUi(progress);
+  const p = new R.IpoProgram(ecu, exec, ui);
+  const r = await p.start();
+  if (p.noCable) throw new CliError("no cable connected");
+  if (!r.ok) {
+    const last = p.messages[p.messages.length - 1];
+    throw new CliError(
+      `${cid}: the script did not start (${r.reason || "stopped"})` + (last ? `: ${last.title}${last.body ? ` ${last.body}` : ""}` : "")
+    );
+  }
+  if (exec.procs[FAULT_MENU] && p.menu !== FAULT_MENU)
+    await p.openMenu(FAULT_MENU);
+  const key = p.items.find(
+    (it) => FAULT_KEY_RE.test(String(it.label || it.legendLabel || "").trim())
+  );
+  if (!key) {
+    const have = p.items.map((it) => `F${it.nr} ${it.label}`).join(", ");
+    p.close();
+    throw new CliError(
+      `${cid}: no fault-memory read key on ${p.menu} (keys: ${have})`
+    );
+  }
+  progress(`${cid}: ${key.label} (F${key.nr})`);
+  await p.press(key.nr);
+  const report = p.view && p.view.report || R.ipoProtocolReport(p.wireReads, p.view && p.view.lines || []);
+  await p.leaveModule();
+  const summary = R.garageScanSummary(report);
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  let link;
+  if (opts.share) {
+    const payload = await R.garageShareEncode(
+      { kind: report.kind, at, chassis: cid, report, summary },
+      { label: opts.label || "", chassis: cid }
+    );
+    link = `https://bmweb.danner.ink/#report/${payload}`;
+  }
+  if (opts.json) {
+    return {
+      report,
+      link,
+      lines: [
+        JSON.stringify({ chassis: cid, at, summary, report, link }, null, 2)
+      ]
+    };
+  }
+  const lines = formatTable([
+    ["Scan", `${cid} fault memories (${ecu.sgbd}.ipo)`],
+    ["Read", at],
+    [
+      "Modules",
+      `${summary.modules} answered, ${summary.withFaults} with faults, ${summary.faults} fault${summary.faults === 1 ? "" : "s"}, ${summary.silent} silent`
+    ]
+  ]);
+  lines.push("", ...reportBodyLines(report, report.kind));
+  if (link) lines.push("", `Share: ${link}`);
+  return { report, lines, link };
+}
+
+// src/search.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
+  statSync as statSync3,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { gunzipSync } from "node:zlib";
+var SITE = "https://bmweb.danner.ink/";
+var INDEX_URL = `${SITE}api/search-index.json.gz`;
+var INDEX_MAX_AGE_MS = CACHE_MAX_AGE_MS;
+function parseIndex(gz) {
+  const R = loadRuntime();
+  let doc;
+  try {
+    doc = JSON.parse(gunzipSync(gz).toString("utf8"));
+  } catch {
+    throw new CliError("the search index is not readable (not gzipped JSON)");
+  }
+  if (!doc || doc.v !== R.SEARCH_INDEX_VERSION)
+    throw new CliError(
+      `the search index is format v${doc && doc.v}; this bmweb-cli reads v${R.SEARCH_INDEX_VERSION} (update the package)`
+    );
+  return doc;
+}
+async function loadIndex(opts = {}) {
+  const env = opts.env || process.env;
+  const file = indexCachePath(env);
+  const warn = opts.warn || ((line) => console.error(line));
+  const have = existsSync2(file);
+  const fresh = have && Date.now() - statSync3(file).mtimeMs < INDEX_MAX_AGE_MS;
+  if (have && fresh && !opts.refresh) return parseIndex(readFileSync4(file));
+  const doFetch = opts.fetchImpl || fetch;
+  let bytes = null;
+  let why = "";
+  try {
+    const r = await doFetch(INDEX_URL);
+    if (r.ok) bytes = new Uint8Array(await r.arrayBuffer());
+    else why = `HTTP ${r.status}`;
+  } catch (e) {
+    why = String(e.message || e);
+  }
+  if (bytes) {
+    const index = parseIndex(bytes);
+    mkdirSync2(cacheDir(env), { recursive: true });
+    writeFileSync3(file, bytes);
+    return index;
+  }
+  if (have) {
+    warn(
+      `bmweb: could not refresh the search index (${why}); using the cached copy`
+    );
+    return parseIndex(readFileSync4(file));
+  }
+  throw new CliError(
+    `could not fetch the search index from ${INDEX_URL} (${why})`
+  );
+}
+function hitLink(hit, chassis) {
+  const R = loadRuntime();
+  const route = R.searchHitRoute(hit, chassis);
+  return route ? `${SITE}#${route}` : null;
+}
+function searchRows(result) {
+  const rows = [];
+  for (const g of result.groups)
+    for (const m of g.modules)
+      for (const h of m.hits) {
+        const e = h.entry;
+        rows.push({
+          chassis: g.chassis,
+          sgbd: m.module.sgbd,
+          module: m.module.label,
+          code: m.module.code,
+          kind: e.t === "k" ? "key" : "screen",
+          key: e.t === "k" && e.n != null ? keyText(e.n) : null,
+          menu: e.t === "k" ? e.m || null : null,
+          screen: e.s || null,
+          label: h.label,
+          title: h.sub,
+          jobs: h.jobs,
+          writes: !!e.w,
+          link: hitLink(h, g.chassis),
+          score: h.score
+        });
+      }
+  return rows;
+}
+function keyText(n) {
+  return n > 10 ? `Shift+F${n - 10}` : `F${n}`;
+}
+function runSearch(query, opts) {
+  const R = loadRuntime();
+  if (!R.searchTerms(query).length)
+    throw new CliError("the query needs at least two characters");
+  const result = R.searchRun(opts.index, query, {
+    chassis: opts.chassis,
+    max: opts.limit
+  });
+  const rows = searchRows(result);
+  if (opts.json)
+    return [
+      JSON.stringify(
+        { query, total: result.total, shown: result.shown, rows },
+        null,
+        2
+      )
+    ];
+  if (!rows.length) return [`no results for "${query}"`];
+  const out = [];
+  for (const g of result.groups) {
+    out.push(
+      g.chassis || "(modules no car carries; open them by name in the app)"
+    );
+    for (const m of g.modules) {
+      const head = [
+        m.module.sgbd,
+        m.module.label,
+        m.module.code ? `(${m.module.code})` : ""
+      ].filter(Boolean).join("  ");
+      out.push(`  ${head}`);
+      const table = m.hits.map((h) => {
+        const e = h.entry;
+        const what = e.t === "k" && e.n != null ? keyText(e.n) : "screen";
+        const label = h.label + (h.sub ? `  (${h.sub})` : "");
+        const jobs = h.jobs.join(", ") + (e.w ? "  [WRITE]" : "");
+        const link = hitLink(h, g.chassis) || "(not openable)";
+        return [what, label, jobs, link];
+      });
+      out.push(...formatTable(table, void 0, "    "));
+    }
+    out.push("");
+  }
+  out.push(
+    result.shown < result.total ? `${result.shown} of ${result.total} results shown (raise --limit for more)` : `${result.total} result${result.total === 1 ? "" : "s"}`
+  );
+  return out;
+}
+
+// src/tui.ts
+import { writeFileSync as writeFileSync4 } from "node:fs";
+import { createInterface as createInterface2, emitKeypressEvents } from "node:readline";
+function terminalHomeHost(api, status) {
+  return {
+    chassis: async () => {
+      const ids = await api("/api/chassis");
+      return (ids || []).map((id) => ({ value: id, label: id }));
+    },
+    modules: async (chassis) => {
+      const ch = await api(`/api/chassis/${encodeURIComponent(chassis)}`);
+      const out = [];
+      for (const sec of ch && ch.sections || [])
+        for (const ecu of sec.ecus || [])
+          if (ecu && ecu.sgbd)
+            out.push({
+              value: String(ecu.sgbd).toLowerCase(),
+              label: ecu.label || ecu.code || ecu.sgbd,
+              meta: `${sec.name || ""}  ${ecu.sgbd}`
+            });
+      return out;
+    },
+    vehicle: async (chassis) => VEHICLE_SCRIPTS[String(chassis).toUpperCase()] || "",
+    status
+  };
+}
+var SHIFTED_DIGITS = "!@#$%^&*()";
+var DIGITS = "1234567890";
+var GAUGE_WIDTH = 12;
+function keyToPress(k) {
+  if (k.ctrl && k.name === "c") return "quit";
+  if (k.name === "escape") return "back";
+  if (k.ch === "q" || k.ch === "Q") return "quit";
+  const f = /^f(\d{1,2})$/.exec(k.name);
+  if (f) {
+    const n = Number(f[1]);
+    if (n >= 1 && n <= 10) return k.shift ? n + 10 : n;
+    return null;
+  }
+  const d = DIGITS.indexOf(k.ch);
+  if (k.ch && d >= 0) return d + 1;
+  const s = SHIFTED_DIGITS.indexOf(k.ch);
+  if (k.ch && s >= 0) return s + 11;
+  return null;
+}
+function nodeTerminal() {
+  const input = process.stdin;
+  const output = process.stdout;
+  emitKeypressEvents(input);
+  const raw = (on) => {
+    if (input.isTTY) input.setRawMode(on);
+  };
+  raw(true);
+  input.resume();
+  const subs = /* @__PURE__ */ new Set();
+  let paused = false;
+  input.on(
+    "keypress",
+    (str, key) => {
+      if (paused) return;
+      const k = {
+        name: key && key.name || "",
+        ch: str || "",
+        shift: !!(key && key.shift),
+        ctrl: !!(key && key.ctrl)
+      };
+      for (const f of subs) f(k);
+    }
+  );
+  return {
+    write: (s) => {
+      output.write(s);
+    },
+    get columns() {
+      return output.columns || 80;
+    },
+    get rows() {
+      return output.rows || 24;
+    },
+    onKey(fn) {
+      subs.add(fn);
+      return () => {
+        subs.delete(fn);
+      };
+    },
+    async readLine(prompt) {
+      paused = true;
+      raw(false);
+      const rl = createInterface2({ input, output, terminal: true });
+      try {
+        return await new Promise((res) => {
+          rl.question(prompt, (a) => res(a));
+          rl.on("close", () => res(null));
+        });
+      } finally {
+        rl.close();
+        raw(true);
+        paused = false;
+      }
+    },
+    close() {
+      raw(false);
+      input.pause();
+    }
+  };
+}
+var TuiUi = class {
+  term;
+  sent = [];
+  statusText = "";
+  progressText = "";
+  stopRequested = false;
+  writeKeys = /* @__PURE__ */ new Set();
+  program = null;
+  leftResolve = null;
+  /** resolves once the program reports it left the module */
+  leftPromise;
+  R;
+  /** the home script's host: what its picks list */
+  home;
+  /**
+   * @param term - the terminal
+   * @param R - the runtime (for the write verdict on key captions)
+   * @param home - the home script's host, when the home may run
+   */
+  constructor(term, R, home = null) {
+    this.term = term;
+    this.R = R;
+    this.home = home;
+    this.leftPromise = new Promise((res) => {
+      this.leftResolve = res;
+    });
+  }
+  /**
+   * BMWeb's own picker (the home script's bmweb_pick): the host's list as
+   * numbered rows; a number picks, anything else narrows the list to the
+   * rows containing it, an empty answer cancels. A vehicle pick has one
+   * answer and asks nothing.
+   * @param _p - the program
+   * @param step - the pick suspension
+   * @returns the chosen value, or null for cancel
+   */
+  async pickHome(_p, step) {
+    if (!this.home) return null;
+    if (step.what === "vehicle") return this.home.vehicle(step.arg);
+    let options;
+    try {
+      options = step.what === "module" ? await this.home.modules(step.arg) : await this.home.chassis();
+    } catch (e) {
+      await this.message("No list", String(e.message || e));
+      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(
+        (o) => `${o.label} ${o.meta || ""} ${o.value}`.toLowerCase().includes(q)
+      );
+      shown = next.length ? next : options;
+    }
+  }
+  /** Note the program once it exists, for the key handler. */
+  attach(p) {
+    this.program = p;
+  }
+  /** Esc during a parked state machine: stop it at the next tick. */
+  requestStop() {
+    this.stopRequested = true;
+  }
+  sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+  loadExec(sgbd) {
+    return this.R.irLiveExec(sgbd);
+  }
+  route() {
+  }
+  status(_p, text) {
+    this.statusText = text;
+    this.drawFooter();
+  }
+  error(_p, text) {
+    this.statusText = `error: ${text}`;
+    this.drawFooter();
+  }
+  async message(title, body) {
+    await this.term.readLine(
+      `
+${title}${body ? `
+${body}` : ""}
+[Enter to continue] `
+    );
+  }
+  /**
+   * INPA's prompts, answered on the keyboard with the meanings irAskInput
+   * gives them: inputdigital is the script's two words and stores 1 for the
+   * true word; the plain OK/Cancel box stores 0 for OK; inputhex takes a hex
+   * string, input2text words, inputnum a real, the rest whole numbers within
+   * the declared range. A cancel (empty answer, Esc) abandons the key.
+   * @param step - the input suspension
+   * @param label - the key's caption, when the script gave no title
+   * @returns what resume() stores, or null for cancel
+   */
+  async askInput(step, label) {
+    const prompts = step.prompts || [];
+    const refs = Math.max(1, Number(step.refs || 1));
+    const name = String(step.name || "");
+    const p0 = prompts[0] || label || "";
+    const p1 = prompts[1] || "";
+    if (name === "inputdigital") {
+      const f = prompts[prompts.length - 2] || "OFF";
+      const t = prompts[prompts.length - 1] || "ON";
+      const a = await this.term.readLine(
+        `
+${p0}
+${p1}
+[${t} = y, ${f} = n, cancel = Enter] `
+      );
+      if (a == null || !a.trim()) return null;
+      return /^y/i.test(a.trim()) ? 1 : 0;
+    }
+    if (name === "builtin_3f" && prompts.length <= 2 && refs === 1) {
+      const a = await this.term.readLine(
+        `
+${p0}
+${p1}
+[OK = y, cancel = n] `
+      );
+      return a != null && /^y/i.test(a.trim()) ? 0 : null;
+    }
+    const hex = /hex/i.test(name);
+    const text = /text/i.test(name);
+    const real = name === "inputnum";
+    const vals = [];
+    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(`
+${p0}
+${cap}${range}: `);
+      if (a == null) return null;
+      if (text) {
+        vals.push(String(a));
+        continue;
+      }
+      if (!a.trim()) return null;
+      if (hex) {
+        vals.push(a.trim());
+        continue;
+      }
+      const n = real ? Number(a) : Math.trunc(Number(a));
+      if (!Number.isFinite(n)) return null;
+      if (refs === 1 && step.lo != null && step.hi != null && (n < step.lo || n > step.hi))
+        return null;
+      vals.push(n);
+    }
+    return refs > 1 ? vals : vals[0];
+  }
+  async confirmKey(_p, it, jobs, writes) {
+    const a = await this.term.readLine(
+      `
+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] `
+    );
+    return !!a && /^y(es)?$/i.test(a.trim());
+  }
+  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(
+      `
+Send ${job}${arg ? ` ${arg}` : ""} to the module (${ctx.label})?${every} [y/N] `
+    );
+    return !!a && /^y(es)?$/i.test(a.trim());
+  }
+  /**
+   * INPA's togglelist: the active screen's LINE declarations, numbered;
+   * one is picked and switched on or off (a tick list with the multiple
+   * 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] || "",
+      caption: l.label || String(l.keys).split(";")[0] || ""
+    }));
+    if (!rows.length) {
+      await this.message(
+        "No components to pick",
+        "This screen lists no components."
+      );
+      return null;
+    }
+    const list = rows.map((r, i2) => `  ${i2 + 1}. ${r.caption}  (${r.key})`).join("\n");
+    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 [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
+    };
+  }
+  /** INPA's Select: which named logical lines to keep on screen. */
+  async pickLines(_p, names, multiple, _current, hints) {
+    if (!names.length) {
+      const where = (hints || []).map((h) => `${h.key} ${h.label} (${h.lines} lines)`).join(", ");
+      await this.message(
+        "Nothing to select here",
+        where ? `Select works after one of: ${where}` : "This screen has no named lines."
+      );
+      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;
+  }
+  /** INPA's save-as dialog: a file name, written when the body ends. */
+  async saveFile() {
+    const a = await this.term.readLine(`
+Save as [fault-memory.txt]: `);
+    if (a == null) return null;
+    return { name: a.trim() || "fault-memory.txt" };
+  }
+  async writeFile(_p, picked, lines) {
+    writeFileSync4(picked.name, lines.join("\r\n") + "\r\n", "latin1");
+    this.status(_p, `wrote ${picked.name}`);
+  }
+  printScreen(p) {
+    this.term.write(`
+${this.gridLines(p).join("\n")}
+`);
+  }
+  /**
+   * The module a scriptchange names. From the home script it is the car's
+   * own config row for the picked chassis (home.js ipoHomeEcuFor), prepared
+   * the way opening it from the module list prepares it; from any other
+   * script it is the module the car identifies (open.js).
+   */
+  async resolveScriptEcu(from, script, exec) {
+    if (from && from.sgbd === this.R.IPO_HOME_SGBD) {
+      const row = await this.R.ipoHomeEcuFor(from, script);
+      if (!row) return null;
+      try {
+        const api = runtimeGlobals().api;
+        return (await prepareModule(row, api)).ecu;
+      } catch {
+        return row;
+      }
+    }
+    return this.R.ipoResolveScriptEcu(from, script, exec);
+  }
+  /** A %STATE park: tick after IPO_TICK_MS, or stop when Esc was pressed. */
+  async machineTick(_p, step) {
+    this.progressText = `state ${String(step.name || "").replace(/^%/, "")} (Esc stops)`;
+    this.drawFooter();
+    await this.sleep(this.R.IPO_TICK_MS);
+    if (this.stopRequested) {
+      this.stopRequested = false;
+      this.progressText = "";
+      return "stop";
+    }
+    return "tick";
+  }
+  userbox(_p, box) {
+    if (!box) {
+      this.progressText = "";
+    } else {
+      const lines = box.lines || [];
+      const text = lines.length ? String(lines[lines.length - 1]) : "";
+      this.progressText = `${box.title ? `${box.title}: ` : ""}${text}`.trim();
+    }
+    this.drawFooter();
+  }
+  /** The F-key bar: the write verdict per key marks what will ask. */
+  renderKeys(p) {
+    this.writeKeys = /* @__PURE__ */ new Set();
+    const jobsOf = runtimeGlobals().irItemBodyJobs;
+    for (const it of p.items) {
+      const jobs = jobsOf ? jobsOf(p.exec, p.exec.procs[p.menu || ""], it.start, it.end) : [];
+      if (jobs.some((j) => this.R.ipoNeedsConfirm(j)))
+        this.writeKeys.add(it.nr);
+    }
+    this.paint(p);
+  }
+  /** Redraw everything: title, grid, keys, footer. */
+  paint(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));
+    }
+    out.push("");
+    out.push(...this.keyLines(p));
+    this.term.write(`\x1B[H\x1B[2J${out.join("\n")}
+`);
+    this.drawFooter();
+  }
+  /**
+   * The grid as text rows: cells placed at their column, a lamp as a dot
+   * and its word, a gauge as a bar and its number, the rest as its text.
+   */
+  gridLines(p) {
+    const w = this.term.columns;
+    const rows = /* @__PURE__ */ new Map();
+    for (const c of p.cells.values()) {
+      if (!rows.has(c.row)) rows.set(c.row, []);
+      rows.get(c.row).push(c);
+    }
+    const maxRow = rows.size ? Math.max(...rows.keys()) : -1;
+    const out = [];
+    for (let r = 0; r <= maxRow; r++) {
+      const line = [];
+      for (const c of (rows.get(r) || []).sort((a, b) => a.col - b.col)) {
+        const text = cellText(c);
+        while (line.length < c.col) line.push(" ");
+        for (const ch of text) line.push(ch);
+      }
+      out.push(line.join("").replace(/\s+$/, "").slice(0, w));
+    }
+    return out;
+  }
+  /** The key bar: the plain bank on one line, the shifted on the next. */
+  keyLines(p) {
+    const shown = p.items.filter((it) => !it.hidden || !!it.legendLabel);
+    const label = (it) => `${it.shift ? "S" : ""}F${it.shift ? it.nr - 10 : it.nr} ${it.label || it.legendLabel || ""}${this.writeKeys.has(it.nr) ? "*" : ""}`;
+    const plain = shown.filter((it) => !it.shift).map(label);
+    const shifted = shown.filter((it) => it.shift).map(label);
+    const out = [];
+    if (plain.length) out.push(plain.join("   "));
+    if (shifted.length) out.push(shifted.join("   "));
+    out.push(
+      "(1..9,0 = F1..F10, shifted symbols = Shift+F, Esc = back, q = quit, * asks first)"
+    );
+    return out;
+  }
+  /** The two bottom lines: status and progress. */
+  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`
+    );
+  }
+  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") {
+    const word = text.trim();
+    const on = c.meta && c.meta.on != null && word === String(c.meta.on) || /^(1|ein|on|an|ja|yes|aktiv|true)$/i.test(word);
+    return `${on ? "(*)" : "( )"} ${word}`;
+  }
+  if (c.kind === "gauge" && c.meta && c.meta.min != null && c.meta.max != null) {
+    const n = parseFloat(text);
+    if (Number.isFinite(n)) {
+      const span = c.meta.max - c.meta.min || 1;
+      const fill = Math.round(
+        Math.max(0, Math.min(1, (n - c.meta.min) / span)) * GAUGE_WIDTH
+      );
+      return `[${"#".repeat(fill)}${".".repeat(GAUGE_WIDTH - fill)}] ${text.trim()}`;
+    }
+  }
+  return text;
+}
+async function tuiCommand(chassis, sgbd, opts = {}) {
+  const R = loadRuntime();
+  const home = !chassis && !sgbd;
+  if (opts.apiFn) setApiImpl(opts.apiFn);
+  let cable = false;
+  if (!opts.noBus) {
+    if (home) {
+      try {
+        await connectBus(opts);
+        cable = true;
+      } catch (e) {
+        if (!(e instanceof CliError)) throw e;
+      }
+    } else {
+      await connectBus(opts);
+      cable = true;
+    }
+  }
+  const api = opts.apiFn || runtimeGlobals().api;
+  const host = terminalHomeHost(
+    api,
+    () => `bmweb-cli ${opts.version || ""}  ${cable || opts.noBus && !home ? "cable connected" : "no cable"}`.trim()
+  );
+  Object.assign(R.IPO_HOME_HOST, host);
+  const term = opts.term || nodeTerminal();
+  const ui = new TuiUi(term, R, host);
+  let p = null;
+  try {
+    let ecu;
+    let exec;
+    if (opts.exec) {
+      ecu = opts.ecu || {
+        sgbd: String(sgbd || "").toLowerCase(),
+        label: String(sgbd || "").toUpperCase(),
+        chassis: String(chassis || "").toUpperCase()
+      };
+      exec = opts.exec;
+    } else if (home) {
+      exec = R.ipoHomeExec();
+      ecu = {
+        sgbd: R.IPO_HOME_SGBD,
+        code: "BMWEB",
+        label: "BMWeb",
+        _variant: R.IPO_HOME_SGBD.toUpperCase()
+      };
+    } else {
+      ({ ecu, exec } = await openModule(
+        chassis,
+        sgbd,
+        opts.apiFn
+      ));
+    }
+    p = new R.IpoProgram(ecu, exec, ui);
+    ui.attach(p);
+    const r = await p.start();
+    if (p.noCable) throw new CliError("no cable connected");
+    if (!r.ok) {
+      const last = p.messages[p.messages.length - 1];
+      throw new CliError(
+        `${ecu.sgbd}: the script did not start (${r.reason || "stopped"})` + (last ? `: ${last.title}${last.body ? ` ${last.body}` : ""}` : "")
+      );
+    }
+    if (opts.menu) {
+      if (!exec.procs[opts.menu])
+        throw new CliError(`${ecu.sgbd}: no menu ${opts.menu}`);
+      if (opts.menu !== p.menu) await p.openMenu(opts.menu);
+    }
+    const program = p;
+    const unsubscribe = term.onKey((k) => {
+      const what = keyToPress(k);
+      if (what === null) return;
+      if (what === "quit") {
+        unsubscribe();
+        program.leaveModule().catch(() => {
+        });
+        return;
+      }
+      if (what === "back") {
+        ui.requestStop();
+        program.back().catch(() => {
+        });
+        return;
+      }
+      program.press(what).catch(() => {
+      });
+    });
+    await ui.leftPromise;
+    unsubscribe();
+    return { log: program.log, messages: program.messages };
+  } finally {
+    if (p && !p.closed) p.close();
+    term.close();
+    if (opts.apiFn) setApiImpl(null);
+    if (!opts.noBus) await disconnectBus(R);
+  }
+}
+
+// src/bmweb.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var INCLUDE = {
+  include: {
+    kind: "list",
+    alias: "I",
+    help: "a directory holding the INPA headers a source needs (repeatable)"
+  }
+};
+var JSON_FLAG = {
+  json: {
+    kind: "bool",
+    help: "print machine-readable JSON instead of a table"
+  }
+};
+var LIVE = {
+  port: {
+    kind: "string",
+    alias: "p",
+    help: "the serial device (the single candidate when there is one)"
+  },
+  api: {
+    kind: "string",
+    help: "the site the module data comes from (default https://bmweb.danner.ink/)"
+  },
+  refresh: {
+    kind: "bool",
+    help: "fetch the module data again even when the cached copy is fresh"
+  }
+};
+var COMMANDS = {
+  "ipo info": {
+    usage: "bmweb ipo info <file.IPO|file.IPS|file.SRC> [-I dir]... [--json]",
+    summary: "what a script is: form, includes, entry, procedures, DLL imports, and every menu with its keys and jobs",
+    flags: { ...INCLUDE, ...JSON_FLAG },
+    async run(pos, flags) {
+      const file = pos[0];
+      if (!file || pos.length > 1)
+        throw new CliError("usage: " + COMMANDS["ipo info"].usage);
+      return ipoInfo(file, flags.include || [], !!flags.json);
+    }
+  },
+  "ipo keys": {
+    usage: "bmweb ipo keys <file.IPO|file.IPS|file.SRC> [--menu m_x] [-I dir]... [--json]",
+    summary: "the F-keys of every menu (or one): the screen each opens, the jobs it sends, and which of them write",
+    flags: {
+      ...INCLUDE,
+      menu: { kind: "string", alias: "m", help: "only this menu procedure" },
+      ...JSON_FLAG
+    },
+    async run(pos, flags) {
+      const file = pos[0];
+      if (!file || pos.length > 1)
+        throw new CliError("usage: " + COMMANDS["ipo keys"].usage);
+      return ipoKeys(
+        file,
+        flags.include || [],
+        flags.menu,
+        !!flags.json
+      );
+    }
+  },
+  "ipo compile": {
+    usage: "bmweb ipo compile <file.IPS|file.SRC> [-I dir]... [-o out.ipoexec.json]",
+    summary: "compile an INPA source into the app's exec form (JSON); missing includes are named",
+    flags: {
+      ...INCLUDE,
+      out: {
+        kind: "string",
+        alias: "o",
+        help: "where to write (default: <stem>.ipoexec.json beside the source)"
+      }
+    },
+    async run(pos, flags) {
+      const file = pos[0];
+      if (!file || pos.length > 1)
+        throw new CliError(
+          "usage: " + COMMANDS["ipo compile"].usage
+        );
+      return ipoCompile(
+        file,
+        flags.include || [],
+        flags.out
+      );
+    }
+  },
+  search: {
+    usage: "bmweb search <query...> [--chassis E46] [--limit N] [--refresh] [--json]",
+    summary: "find the INPA key or screen that does a thing, across every module the site ships, with a deep link per hit",
+    flags: {
+      chassis: {
+        kind: "string",
+        alias: "c",
+        help: "only modules this chassis carries"
+      },
+      limit: { kind: "number", alias: "n", help: "rows to show (default 50)" },
+      refresh: {
+        kind: "bool",
+        help: "fetch the index again even when the cached copy is fresh"
+      },
+      ...JSON_FLAG
+    },
+    async run(pos, flags) {
+      const query = pos.join(" ").trim();
+      if (!query)
+        throw new CliError("usage: " + COMMANDS.search.usage);
+      const index = await loadIndex({ refresh: !!flags.refresh });
+      return runSearch(query, {
+        chassis: flags.chassis,
+        limit: flags.limit || 50,
+        json: !!flags.json,
+        index
+      });
+    }
+  },
+  "report show": {
+    usage: "bmweb report show <link-or-payload> [--json]",
+    summary: "decode a shared Garage report link: module, code, text, count per fault, plus the silent addresses",
+    flags: { ...JSON_FLAG },
+    async run(pos, flags) {
+      const arg = pos[0];
+      if (!arg || pos.length > 1)
+        throw new CliError(
+          "usage: " + COMMANDS["report show"].usage
+        );
+      return reportShow(arg, !!flags.json);
+    }
+  },
+  "report diff": {
+    usage: "bmweb report diff <link-a> <link-b> [--json]",
+    summary: "what changed between two shared reports: new, cleared and still-present faults per module",
+    flags: { ...JSON_FLAG },
+    async run(pos, flags) {
+      const [a, b] = pos;
+      if (!a || !b || pos.length > 2)
+        throw new CliError(
+          "usage: " + COMMANDS["report diff"].usage
+        );
+      return reportDiff(a, b, !!flags.json);
+    }
+  },
+  ports: {
+    usage: "bmweb ports [--json]",
+    summary: "the serial ports a K+DCAN cable shows up as (cu.usbserial*, cu.SLAB*, cu.wchusbserial*, ttyUSB*, ttyACM*)",
+    flags: { ...JSON_FLAG },
+    async run(pos, flags) {
+      if (pos.length)
+        throw new CliError("usage: " + COMMANDS.ports.usage);
+      return portsCommand(!!flags.json);
+    }
+  },
+  job: {
+    usage: "bmweb job <sgbd> <JOB> [arg] [--port p] [--api url] [--yes] [--json]",
+    summary: "one raw job on one module over the cable, like the app's Tool32; a write needs --yes or a y answer",
+    flags: {
+      ...LIVE,
+      yes: {
+        kind: "bool",
+        alias: "y",
+        help: "consent to a write job on the command line"
+      },
+      ...JSON_FLAG
+    },
+    async run(pos, flags) {
+      const [sgbd, job, arg] = pos;
+      if (!sgbd || !job || pos.length > 3)
+        throw new CliError("usage: " + COMMANDS.job.usage);
+      const { R } = await connectBus(liveOptions(flags));
+      try {
+        return await jobCommand(sgbd, job, {
+          arg,
+          yes: !!flags.yes,
+          json: !!flags.json
+        });
+      } finally {
+        await disconnectBus(R);
+      }
+    }
+  },
+  scan: {
+    usage: "bmweb scan <chassis> [--port p] [--api url] [--share] [--json]",
+    summary: `INPA's whole-vehicle script over the cable (${SCAN_CHASSIS.join(" ")}): every fault memory as a report, --share adds a Garage link`,
+    flags: {
+      ...LIVE,
+      share: {
+        kind: "bool",
+        help: "print a Garage share link carrying the report"
+      },
+      label: {
+        kind: "string",
+        help: "the car name on the share link"
+      },
+      ...JSON_FLAG
+    },
+    async run(pos, flags) {
+      const chassis = pos[0];
+      if (!chassis || pos.length > 1)
+        throw new CliError("usage: " + COMMANDS.scan.usage);
+      const { R } = await connectBus(liveOptions(flags));
+      try {
+        const r = await scanCommand(chassis, {
+          share: !!flags.share,
+          json: !!flags.json,
+          label: flags.label
+        });
+        return r.lines;
+      } finally {
+        await disconnectBus(R);
+      }
+    }
+  },
+  tui: {
+    usage: "bmweb tui [<chassis> <sgbd>] [--port p] [--api url] [--menu m_x]",
+    summary: "INPA screens in the terminal: the app's home (pick a chassis and a module) with no arguments, else that module; F-keys on the number row, every write asked first, released on quit",
+    flags: {
+      ...LIVE,
+      menu: {
+        kind: "string",
+        alias: "m",
+        help: "the menu procedure to open once the script is up"
+      }
+    },
+    async run(pos, flags) {
+      const [chassis, sgbd] = pos;
+      if (pos.length === 1 || pos.length > 2)
+        throw new CliError("usage: " + COMMANDS.tui.usage);
+      const r = await tuiCommand(chassis, sgbd, {
+        ...liveOptions(flags),
+        menu: flags.menu,
+        version: VERSION
+      });
+      return [
+        `${r.log.length} job${r.log.length === 1 ? "" : "s"} sent:`,
+        ...r.log.map(
+          (l) => `  ${l.target} ${l.job}${l.arg ? ` ${l.arg}` : ""}  ${l.status}`
+        )
+      ];
+    }
+  }
+};
+function liveOptions(flags) {
+  return {
+    port: flags.port,
+    api: flags.api,
+    refresh: !!flags.refresh
+  };
+}
+function helpText() {
+  const out = [
+    `bmweb ${VERSION}: BMWeb's tools as a command line (https://bmweb.danner.ink/)`,
+    "",
+    "usage: bmweb <command> [options]",
+    "",
+    "commands:"
+  ];
+  const names = Object.keys(COMMANDS);
+  const w = Math.max(...names.map((n) => n.length));
+  for (const n of names)
+    out.push(`  ${n.padEnd(w)}  ${COMMANDS[n].summary}`);
+  out.push(
+    "",
+    "  bmweb <command> --help    options of one command",
+    "  bmweb --version",
+    "",
+    "ports, job, scan and tui talk to the car over a K+DCAN cable (the serialport",
+    "package, an optional dependency). Module data and the search index are",
+    "fetched from the site and cached under $XDG_CACHE_HOME/bmweb-cli",
+    "(default ~/.cache/bmweb-cli) for a day; nothing BMW-derived ships here."
+  );
+  return out;
+}
+function commandHelp(name) {
+  const c = COMMANDS[name];
+  return [
+    `usage: ${c.usage}`,
+    "",
+    c.summary,
+    "",
+    "options:",
+    ...helpLines(c.flags)
+  ];
+}
+function resolveCommand(argv) {
+  for (const n of [2, 1]) {
+    const name = argv.slice(0, n).join(" ");
+    if (COMMANDS[name]) return { name, rest: argv.slice(n) };
+  }
+  return null;
+}
+async function main(argv, out = (l) => process.stdout.write(l + "\n"), err = (l) => process.stderr.write(l + "\n")) {
+  try {
+    if (!argv.length || argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help") {
+      helpText().forEach(out);
+      return 0;
+    }
+    if (argv[0] === "--version" || argv[0] === "-v") {
+      out(VERSION);
+      return 0;
+    }
+    const picked = resolveCommand(argv);
+    if (!picked) {
+      const group = argv[0];
+      const members = Object.keys(COMMANDS).filter(
+        (n) => n.startsWith(group + " ")
+      );
+      if (members.length) {
+        members.forEach((n) => out(`usage: ${COMMANDS[n].usage}`));
+        return 1;
+      }
+      throw new CliError(
+        `unknown command "${argv.join(" ")}" (try bmweb --help)`
+      );
+    }
+    if (picked.rest.includes("--help") || picked.rest.includes("-h")) {
+      commandHelp(picked.name).forEach(out);
+      return 0;
+    }
+    const c = COMMANDS[picked.name];
+    const parsed = parseArgs(picked.rest, c.flags);
+    const lines = await c.run(parsed.positional, parsed.flags);
+    lines.forEach(out);
+    return 0;
+  } catch (e) {
+    if (e instanceof CliError) {
+      err(`bmweb: ${e.message}`);
+      return 1;
+    }
+    err(`bmweb: unexpected error: ${e.stack || e}`);
+    return 1;
+  }
+}
+if (typeof process !== "undefined" && process.argv[1] && /bmweb(\.js)?$/.test(process.argv[1])) {
+  main(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+  });
+}
+export {
+  VERSION,
+  commandHelp,
+  helpText,
+  main,
+  resolveCommand
+};