rk86 2.0.15 → 2.0.17

package/README.md

@@ -5,24 +5,33 @@
 ## Запуск
 
 ```bash
-bunx rk86
+bunx rk86                          # встроенный монитор mon32
+bunx rk86 CHESS.GAM                # загрузить и запустить файл из текущей директории
+bunx rk86 -p CHESS.GAM             # загрузить без запуска
+bunx rk86 -g 0x100 prog.bin        # запуск с адреса 0x100
+bunx rk86 -m mon16.bin             # другой монитор
+bunx rk86 prog.asm                 # собрать и запустить .asm (i8080)
+bunx rk86 -l                       # список файлов встроенного каталога
 ```
 
-## С программой
-
-```bash
-bunx rk86 CHESS.GAM
-```
-
-Файл программы загружается из текущей директории.
-
 ## Опции
 
 ```
-  -h              справка
-  -l              список файлов из каталога
-  -m <файл>       монитор (по умолчанию: встроенный mon32.bin)
-  -p              загрузить файл без запуска
+  -v                       версия
+  -h                       справка
+  -l                       список файлов из каталога
+  -m <файл>                монитор (по умолчанию: встроенный mon32.bin)
+  -p                       загрузить файл без запуска
+  -g <адрес>               адрес запуска (несовместим с -p)
+  --exit-halt              выход при выполнении HLT
+  --exit-address [адрес]   выход при переходе на адрес (по умолчанию: 0xFFFE)
+  --headless               без отображения экрана (для автотестов)
+  --timeout <сек>          выход по таймауту
+  --memory <файл>          сохранить память в файл при выходе
+  --memory-from <адрес>    начало области дампа памяти (по умолчанию: 0x0000)
+  --memory-to <адрес>      конец области дампа памяти включительно (по умолчанию: 0xFFFF)
+  --screen <файл>          сохранить экран 78x30 как текст при выходе
+  --input <seq>            инъекция клавиш (через запятую): KeyA,Digit1,Enter,...
 ```
 
 ## Управление
@@ -30,6 +39,55 @@ bunx rk86 CHESS.GAM
 - Клавиатура работает через stdin (raw mode)
 - `Ctrl+C` — выход
 
+## Безголовый режим (headless) и автотесты
+
+Флаг `--headless` отключает вывод на терминал и настройку stdin — удобно для
+автоматизированных e2e-проверок. Обычно комбинируется с `--input`, `--timeout`,
+`--exit-halt` и `--screen`/`--memory` для анализа результата.
+
+Формат `--input`: через запятую указываются WebKit-коды клавиш
+(`KeyA`..`KeyZ`, `Digit0`..`Digit9`, `Enter`, `Space`, `Comma`, `Period`,
+`Backspace`, `ArrowLeft`, `F1`..`F10`, и т.д.). Инъекция начинается после того,
+как эмулятор инициализируется (как при подгрузке файла — с небольшой задержкой),
+клавиши нажимаются по одной с минимальной паузой.
+
+Формат файла `--screen`: 30 строк по 78 символов, разделитель `\r\n`.
+Байты `\0`, `\t`, `\n`, `\r` заменяются на `.`, остальные символы с кодами <0x20
+рисуются псевдографикой (как на реальном РК-86).
+
+### Пример 1. Дамп памяти через команду монитора `D`
+
+Монитор `mon32` печатает дамп памяти с адреса 0 до FFh, через 10 секунд
+эмулятор завершается по таймауту и содержимое экрана сохраняется в файл:
+
+```bash
+bunx rk86 --headless \
+  --input "KeyD,Digit0,Comma,KeyF,KeyF,Enter" \
+  --timeout 10 \
+  --screen out.txt
+```
+
+После выхода `out.txt` содержит приглашение `-->D0,FF` и 16 строк шестнадцатеричного
+дампа `0000..00F0`.
+
+### Пример 2. Запись HLT и запуск через команды `M` / `G`
+
+Командой `M` мы помещаем байт `76h` (опкод HLT) в ячейку `0000`, выходим из режима
+редактирования (`.`), затем командой `G 0` запускаем с адреса 0. На первой же
+инструкции срабатывает HLT и `--exit-halt` завершает эмулятор:
+
+```bash
+bunx rk86 --headless \
+  --exit-halt \
+  --input "KeyM,Enter,Digit7,Digit6,Enter,Period,KeyG,Digit0,Enter" \
+  --timeout 15 \
+  --screen out.txt \
+  --memory mem.bin --memory-from 0x0000 --memory-to 0x0000
+```
+
+После выхода `mem.bin` содержит один байт `76h`, а `out.txt` — скриншот с
+приглашениями `-->M` и `-->G0`.
+
 ## Требования
 
 - [Bun](https://bun.sh) runtime

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rk86",
-    "version": "2.0.15",
+    "version": "2.0.17",
     "description": "Эмулятор Радио-86РК (Intel 8080) для терминала",
     "bin": {
         "rk86": "rk86.js"

package/rk86.js

@@ -1589,6 +1589,22 @@ var init_catalog_data = __esm(() => {
 });
 
 // node_modules/asm8080/dist/asm8.js
+class AsmError extends Error {
+  line;
+  column;
+  source;
+  constructor(message, line, source, column = 1) {
+    super(message);
+    this.name = "AsmError";
+    this.line = line;
+    this.source = source;
+    this.column = column;
+  }
+}
+function firstNonSpaceCol(s) {
+  const m = s.match(/\S/);
+  return m ? (m.index ?? 0) + 1 : 1;
+}
 var REG8 = {
   B: 0,
   C: 1,
@@ -1682,6 +1698,81 @@ var ADDR16 = {
   LHLD: 42,
   SHLD: 34
 };
+var ALL_MNEMONICS = new Set([
+  ...Object.keys(IMPLIED),
+  ...Object.keys(ALU_REG),
+  ...Object.keys(ALU_IMM),
+  ...Object.keys(ADDR16),
+  "MOV",
+  "MVI",
+  "INR",
+  "DCR",
+  "LXI",
+  "DAD",
+  "INX",
+  "DCX",
+  "PUSH",
+  "POP",
+  "LDAX",
+  "STAX",
+  "IN",
+  "OUT",
+  "RST",
+  "DB",
+  "DW",
+  "DS",
+  "ORG",
+  "SECTION",
+  "END",
+  "EQU"
+]);
+var MAX_STATEMENTS_PER_LINE = 10;
+function splitStatements(line) {
+  const src = stripComment(line);
+  const out = [];
+  let start = 0;
+  let inQ = false;
+  let qc = "";
+  for (let i = 0;i + 2 < src.length; i++) {
+    const c = src[i];
+    if (inQ) {
+      if (c === qc)
+        inQ = false;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inQ = true;
+      qc = c;
+      continue;
+    }
+    if (c !== " " || src[i + 1] !== "/" || src[i + 2] !== " ")
+      continue;
+    let j = i + 3;
+    while (j < src.length && src[j] === " ")
+      j++;
+    let tokStart = j;
+    if (src[j] === ".")
+      j++;
+    let tokEnd = j;
+    while (tokEnd < src.length && /\w/.test(src[tokEnd]))
+      tokEnd++;
+    if (tokEnd === j)
+      continue;
+    let tok = src.slice(tokStart, tokEnd).toUpperCase();
+    if (tok.startsWith("."))
+      tok = tok.slice(1);
+    if (!ALL_MNEMONICS.has(tok))
+      continue;
+    out.push(src.slice(start, i));
+    start = i + 2;
+    i += 2;
+  }
+  out.push(src.slice(start));
+  if (out.length > MAX_STATEMENTS_PER_LINE) {
+    throw new Error(`too many statements on one line (max ${MAX_STATEMENTS_PER_LINE})`);
+  }
+  return out;
+}
 function instrSize(m) {
   if (m in IMPLIED)
     return 1;
@@ -1749,6 +1840,13 @@ function splitOperands(s) {
     r.push(current.trim());
   return r;
 }
+var DIRECTIVES = new Set(["ORG", "SECTION", "END", "DB", "DW", "DS", "EQU"]);
+function stripDirectiveDot(s) {
+  if (s.startsWith(".") && DIRECTIVES.has(s.slice(1).toUpperCase())) {
+    return s.slice(1);
+  }
+  return s;
+}
 function parseLine(line) {
   let s = stripComment(line).trim();
   if (!s)
@@ -1766,7 +1864,7 @@ function parseLine(line) {
   const rest = si < 0 ? "" : s.slice(si).trim();
   if (!label && rest) {
     const parts = rest.split(/\s+/);
-    if (parts[0].toUpperCase() === "EQU") {
+    if (stripDirectiveDot(parts[0]).toUpperCase() === "EQU") {
       return {
         label: first,
         mnemonic: "EQU",
@@ -1775,43 +1873,189 @@ function parseLine(line) {
       };
     }
   }
-  return { label, mnemonic: first, operands: rest ? splitOperands(rest) : [] };
+  return {
+    label,
+    mnemonic: stripDirectiveDot(first),
+    operands: rest ? splitOperands(rest) : []
+  };
 }
-function evalAtom(s, symbols) {
-  s = s.trim();
-  if (s.length === 3 && s[0] === "'" && s[2] === "'")
-    return s.charCodeAt(1);
-  if (/^[0-9][0-9A-Fa-f]*[hH]$/.test(s))
-    return parseInt(s.slice(0, -1), 16);
-  if (/^[0-9]+$/.test(s))
-    return parseInt(s, 10);
-  const k = s.toUpperCase();
-  if (symbols.has(k))
-    return symbols.get(k);
-  throw new Error(`unknown symbol: ${s}`);
+function tokenizeExpr(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    let c = expr[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (c === "'" && i + 2 < expr.length && expr[i + 2] === "'") {
+      tokens.push({ kind: "num", val: expr.charCodeAt(i + 1) });
+      i += 3;
+      continue;
+    }
+    if (/[0-9]/.test(c)) {
+      let j = i;
+      while (j < expr.length && /[0-9A-Fa-f]/.test(expr[j]))
+        j++;
+      if (j < expr.length && /[hH]/.test(expr[j])) {
+        tokens.push({ kind: "num", val: parseInt(expr.slice(i, j), 16) });
+        j++;
+      } else {
+        tokens.push({ kind: "num", val: parseInt(expr.slice(i, j), 10) });
+      }
+      i = j;
+      continue;
+    }
+    if (/[A-Za-z_]/.test(c)) {
+      let j = i;
+      while (j < expr.length && /\w/.test(expr[j]))
+        j++;
+      tokens.push({ kind: "id", val: expr.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (c === "<" && expr[i + 1] === "<") {
+      tokens.push({ kind: "op", val: "<<" });
+      i += 2;
+      continue;
+    }
+    if (c === ">" && expr[i + 1] === ">") {
+      tokens.push({ kind: "op", val: ">>" });
+      i += 2;
+      continue;
+    }
+    if ("+-*/%&|^~()".includes(c)) {
+      tokens.push({ kind: "op", val: c });
+      i++;
+      continue;
+    }
+    throw new Error(`unexpected character in expression: '${c}'`);
+  }
+  return tokens;
 }
 function evalExpr(expr, symbols) {
-  expr = expr.trim();
-  const tokens = [];
-  const ops = ["+"];
-  let current = "";
-  for (const c of expr) {
-    if ((c === "+" || c === "-") && current.trim()) {
-      tokens.push(current.trim());
-      ops.push(c);
-      current = "";
-    } else {
-      current += c;
+  const tokens = tokenizeExpr(expr);
+  let pos = 0;
+  function peek() {
+    return tokens[pos];
+  }
+  function next() {
+    return tokens[pos++];
+  }
+  function isOp(val) {
+    const t = peek();
+    return t !== undefined && t.kind === "op" && t.val === val;
+  }
+  function atom() {
+    const t = peek();
+    if (!t)
+      throw new Error("unexpected end of expression");
+    if (t.kind === "num") {
+      next();
+      return t.val;
+    }
+    if (t.kind === "id") {
+      next();
+      const k = t.val.toUpperCase();
+      if (k === "LOW" || k === "HIGH") {
+        if (!isOp("("))
+          throw new Error(`${k} requires parentheses`);
+        next();
+        const v = parseOr();
+        if (!isOp(")"))
+          throw new Error("expected ')'");
+        next();
+        return k === "LOW" ? v & 255 : v >> 8 & 255;
+      }
+      if (symbols.has(k))
+        return symbols.get(k);
+      throw new Error(`unknown symbol: ${t.val}`);
+    }
+    if (t.kind === "op" && t.val === "(") {
+      next();
+      const v = parseOr();
+      if (!isOp(")"))
+        throw new Error("expected ')'");
+      next();
+      return v;
     }
+    throw new Error(`unexpected token: ${t.val}`);
   }
-  if (current.trim())
-    tokens.push(current.trim());
-  let r = 0;
-  for (let i = 0;i < tokens.length; i++) {
-    const v = evalAtom(tokens[i], symbols);
-    r = ops[i] === "+" ? r + v : r - v;
+  function unary() {
+    if (isOp("-")) {
+      next();
+      return -unary() & 65535;
+    }
+    if (isOp("+")) {
+      next();
+      return unary();
+    }
+    if (isOp("~")) {
+      next();
+      return ~unary() & 65535;
+    }
+    return atom();
+  }
+  function multiplicative() {
+    let v = unary();
+    while (isOp("*") || isOp("/") || isOp("%")) {
+      const op = next().val;
+      let r = unary();
+      if (op === "*")
+        v = v * r & 65535;
+      else if (op === "/")
+        v = Math.trunc(v / r) & 65535;
+      else
+        v = v % r & 65535;
+    }
+    return v;
+  }
+  function additive() {
+    let v = multiplicative();
+    while (isOp("+") || isOp("-")) {
+      const op = next().val;
+      let r = multiplicative();
+      v = op === "+" ? v + r & 65535 : v - r & 65535;
+    }
+    return v;
+  }
+  function shift() {
+    let v = additive();
+    while (isOp("<<") || isOp(">>")) {
+      const op = next().val;
+      let r = additive();
+      v = op === "<<" ? v << r & 65535 : v >>> r & 65535;
+    }
+    return v;
+  }
+  function parseAnd() {
+    let v = shift();
+    while (isOp("&")) {
+      next();
+      v = v & shift();
+    }
+    return v;
+  }
+  function parseXor() {
+    let v = parseAnd();
+    while (isOp("^")) {
+      next();
+      v = (v ^ parseAnd()) & 65535;
+    }
+    return v;
   }
-  return r & 65535;
+  function parseOr() {
+    let v = parseXor();
+    while (isOp("|")) {
+      next();
+      v = (v | parseXor()) & 65535;
+    }
+    return v;
+  }
+  const result = parseOr();
+  if (pos < tokens.length)
+    throw new Error(`unexpected token: ${tokens[pos].val}`);
+  return result;
 }
 function encode(m, ops, symbols) {
   if (m in IMPLIED)
@@ -1825,7 +2069,9 @@ function encode(m, ops, symbols) {
     return [ADDR16[m], v & 255, v >> 8 & 255];
   }
   if (m === "MOV")
-    return [64 | REG8[ops[0].toUpperCase()] << 3 | REG8[ops[1].toUpperCase()]];
+    return [
+      64 | REG8[ops[0].toUpperCase()] << 3 | REG8[ops[1].toUpperCase()]
+    ];
   if (m === "MVI") {
     const v = evalExpr(ops[1], symbols);
     return [6 | REG8[ops[0].toUpperCase()] << 3, v & 255];
@@ -1836,7 +2082,11 @@ function encode(m, ops, symbols) {
     return [5 | REG8[ops[0].toUpperCase()] << 3];
   if (m === "LXI") {
     const v = evalExpr(ops[1], symbols);
-    return [1 | REG_PAIR[ops[0].toUpperCase()] << 4, v & 255, v >> 8 & 255];
+    return [
+      1 | REG_PAIR[ops[0].toUpperCase()] << 4,
+      v & 255,
+      v >> 8 & 255
+    ];
   }
   if (m === "DAD")
     return [9 | REG_PAIR[ops[0].toUpperCase()] << 4];
@@ -1882,6 +2132,24 @@ function dwBytes(operands, symbols) {
   }
   return out;
 }
+function parseDs(operands) {
+  if (operands.length !== 1)
+    throw new Error("DS takes one operand: count [(fill)]");
+  const m = operands[0].match(/^(.+?)\s+\((.+)\)\s*$/);
+  if (m)
+    return { count: m[1], fill: m[2] };
+  return { count: operands[0], fill: "0" };
+}
+function dsBytes(operands, symbols) {
+  const { count, fill } = parseDs(operands);
+  const n = evalExpr(count, symbols);
+  const f = evalExpr(fill, symbols) & 255;
+  return new Array(n).fill(f);
+}
+function countDs(operands, symbols) {
+  const { count } = parseDs(operands);
+  return evalExpr(count, symbols);
+}
 function countDb(operands) {
   let n = 0;
   for (const op of operands) {
@@ -1897,75 +2165,103 @@ function asm(source) {
 `);
   const symbols = new Map;
   let pc = 0;
-  for (const line of lines) {
-    const parts = parseLine(line);
-    if (parts.label) {
-      if (parts.isEqu) {
-        symbols.set(parts.label.toUpperCase(), evalExpr(parts.operands[0], symbols));
-        continue;
+  let ended = false;
+  for (let idx = 0;idx < lines.length && !ended; idx++) {
+    const line = lines[idx];
+    try {
+      for (const stmt of splitStatements(line)) {
+        const parts = parseLine(stmt);
+        if (parts.label) {
+          if (parts.isEqu) {
+            symbols.set(parts.label.toUpperCase(), evalExpr(parts.operands[0], symbols));
+            continue;
+          }
+          symbols.set(parts.label.toUpperCase(), pc);
+        }
+        if (!parts.mnemonic)
+          continue;
+        const m = parts.mnemonic.toUpperCase();
+        if (m === "EQU")
+          continue;
+        if (m === "ORG") {
+          pc = evalExpr(parts.operands[0], symbols);
+          continue;
+        }
+        if (m === "SECTION")
+          continue;
+        if (m === "END") {
+          ended = true;
+          break;
+        }
+        if (m === "DB") {
+          pc += countDb(parts.operands);
+          continue;
+        }
+        if (m === "DW") {
+          pc += parts.operands.length * 2;
+          continue;
+        }
+        if (m === "DS") {
+          pc += countDs(parts.operands, symbols);
+          continue;
+        }
+        pc += instrSize(m);
       }
-      symbols.set(parts.label.toUpperCase(), pc);
+    } catch (e) {
+      if (e instanceof AsmError)
+        throw e;
+      throw new AsmError(e.message, idx + 1, line, firstNonSpaceCol(line));
     }
-    if (!parts.mnemonic)
-      continue;
-    const m = parts.mnemonic.toUpperCase();
-    if (m === "EQU")
-      continue;
-    if (m === "ORG") {
-      pc = evalExpr(parts.operands[0], symbols);
-      continue;
-    }
-    if (m === "SECTION")
-      continue;
-    if (m === "END")
-      break;
-    if (m === "DB") {
-      pc += countDb(parts.operands);
-      continue;
-    }
-    if (m === "DW") {
-      pc += parts.operands.length * 2;
-      continue;
-    }
-    pc += instrSize(m);
   }
   const sections = [];
   let current = null;
   const sectionNames = new Set;
-  for (const line of lines) {
-    const parts = parseLine(line);
-    if (parts.isEqu || !parts.mnemonic)
-      continue;
-    const m = parts.mnemonic.toUpperCase();
-    if (m === "EQU")
-      continue;
-    if (m === "ORG") {
-      if (current && current.data.length) {
-        current.end = current.start + current.data.length - 1;
-        sections.push(current);
+  let endedPass2 = false;
+  for (let idx = 0;idx < lines.length && !endedPass2; idx++) {
+    const line = lines[idx];
+    try {
+      for (const stmt of splitStatements(line)) {
+        const parts = parseLine(stmt);
+        if (parts.isEqu || !parts.mnemonic)
+          continue;
+        const m = parts.mnemonic.toUpperCase();
+        if (m === "EQU")
+          continue;
+        if (m === "ORG") {
+          if (current && current.data.length) {
+            current.end = current.start + current.data.length - 1;
+            sections.push(current);
+          }
+          const addr = evalExpr(parts.operands[0], symbols);
+          current = { start: addr, end: addr, data: [] };
+          continue;
+        }
+        if (m === "SECTION") {
+          if (!current)
+            throw new Error("SECTION before ORG");
+          const name = parts.operands[0];
+          if (!name)
+            throw new Error("SECTION requires a name");
+          if (sectionNames.has(name.toUpperCase()))
+            throw new Error(`duplicate section name: ${name}`);
+          sectionNames.add(name.toUpperCase());
+          current.name = name;
+          continue;
+        }
+        if (m === "END") {
+          endedPass2 = true;
+          break;
+        }
+        if (!current)
+          throw new Error("code before ORG");
+        const bytes = m === "DB" ? dbBytes(parts.operands, symbols) : m === "DW" ? dwBytes(parts.operands, symbols) : m === "DS" ? dsBytes(parts.operands, symbols) : encode(m, parts.operands, symbols);
+        current.data.push(...bytes);
       }
-      const addr = evalExpr(parts.operands[0], symbols);
-      current = { start: addr, end: addr, data: [] };
-      continue;
-    }
-    if (m === "SECTION") {
-      if (!current)
-        throw new Error("SECTION before ORG");
-      const name = parts.operands[0];
-      if (!name)
-        throw new Error("SECTION requires a name");
-      if (sectionNames.has(name.toUpperCase()))
-        throw new Error(`duplicate section name: ${name}`);
-      sectionNames.add(name.toUpperCase());
-      current.name = name;
-      continue;
+    } catch (e) {
+      if (e instanceof AsmError)
+        throw e;
+      throw new AsmError(e.message, idx + 1, line, firstNonSpaceCol(line));
     }
-    if (m === "END")
-      break;
-    if (!current)
-      throw new Error("code before ORG");
-    const bytes = m === "DB" ? dbBytes(parts.operands, symbols) : m === "DW" ? dwBytes(parts.operands, symbols) : encode(m, parts.operands, symbols);
-    current.data.push(...bytes);
   }
   if (current && current.data.length) {
     current.end = current.start + current.data.length - 1;
@@ -1977,11 +2273,11 @@ if (false) {}
 
 // src/lib/terminal/rk86_terminal.ts
 import { existsSync } from "fs";
-import { readFile } from "fs/promises";
+import { readFile, writeFile } from "fs/promises";
 // packages/rk86/package.json
 var package_default = {
   name: "rk86",
-  version: "2.0.14",
+  version: "2.0.16",
   description: "\u042D\u043C\u0443\u043B\u044F\u0442\u043E\u0440 \u0420\u0430\u0434\u0438\u043E-86\u0420\u041A (Intel 8080) \u0434\u043B\u044F \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u0430",
   bin: {
     rk86: "rk86.js"
@@ -3924,6 +4220,11 @@ class TerminalRenderer {
     process.stdout.write(output);
   }
 }
+
+class HeadlessRenderer {
+  connect(_machine) {}
+  update() {}
+}
 var KEY_MAP = {
   a: "KeyA",
   b: "KeyB",
@@ -4045,6 +4346,13 @@ function printHelp() {
   -g <\u0430\u0434\u0440\u0435\u0441>               \u0430\u0434\u0440\u0435\u0441 \u0437\u0430\u043F\u0443\u0441\u043A\u0430 (\u043D\u0435\u0441\u043E\u0432\u043C\u0435\u0441\u0442\u0438\u043C \u0441 -p)
   --exit-halt              \u0432\u044B\u0445\u043E\u0434 \u043F\u0440\u0438 \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0438 HLT
   --exit-address [\u0430\u0434\u0440\u0435\u0441]   \u0432\u044B\u0445\u043E\u0434 \u043F\u0440\u0438 \u043F\u0435\u0440\u0435\u0445\u043E\u0434\u0435 \u043D\u0430 \u0430\u0434\u0440\u0435\u0441 (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E: 0xFFFE)
+  --headless               \u0431\u0435\u0437 \u043E\u0442\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u044F \u044D\u043A\u0440\u0430\u043D\u0430 (\u0434\u043B\u044F \u0430\u0432\u0442\u043E\u0442\u0435\u0441\u0442\u043E\u0432)
+  --timeout <\u0441\u0435\u043A>          \u0432\u044B\u0445\u043E\u0434 \u043F\u043E \u0442\u0430\u0439\u043C\u0430\u0443\u0442\u0443
+  --memory <\u0444\u0430\u0439\u043B>          \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u043F\u0430\u043C\u044F\u0442\u044C \u0432 \u0444\u0430\u0439\u043B \u043F\u0440\u0438 \u0432\u044B\u0445\u043E\u0434\u0435
+  --memory-from <\u0430\u0434\u0440\u0435\u0441>    \u043D\u0430\u0447\u0430\u043B\u043E \u043E\u0431\u043B\u0430\u0441\u0442\u0438 \u0434\u0430\u043C\u043F\u0430 \u043F\u0430\u043C\u044F\u0442\u0438 (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E: 0x0000)
+  --memory-to <\u0430\u0434\u0440\u0435\u0441>      \u043A\u043E\u043D\u0435\u0446 \u043E\u0431\u043B\u0430\u0441\u0442\u0438 \u0434\u0430\u043C\u043F\u0430 \u043F\u0430\u043C\u044F\u0442\u0438 \u0432\u043A\u043B\u044E\u0447\u0438\u0442\u0435\u043B\u044C\u043D\u043E (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E: 0xFFFF)
+  --screen <\u0444\u0430\u0439\u043B>          \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u044D\u043A\u0440\u0430\u043D 78x30 \u043A\u0430\u043A \u0442\u0435\u043A\u0441\u0442 \u043F\u0440\u0438 \u0432\u044B\u0445\u043E\u0434\u0435
+  --input <seq>            \u0438\u043D\u044A\u0435\u043A\u0446\u0438\u044F \u043A\u043B\u0430\u0432\u0438\u0448 (\u0447\u0435\u0440\u0435\u0437 \u0437\u0430\u043F\u044F\u0442\u0443\u044E): KeyA,Digit1,Enter,...
 
 \u041F\u0440\u0438\u043C\u0435\u0440\u044B:
   bunx rk86                          \u0437\u0430\u043F\u0443\u0441\u043A \u043C\u043E\u043D\u0438\u0442\u043E\u0440\u0430
@@ -4115,6 +4423,15 @@ async function main() {
   const exitAddrValue = arg(args, "--exit-address", "0xFFFE", /^0x[0-9a-fA-F]+$/i, (v) => parseInt(v, 16));
   const exitAddr = exitAddrValue !== undefined;
   const monitorFile_ = arg(args, "-m");
+  const headless = flag(args, "--headless");
+  const timeoutSec = arg(args, "--timeout", undefined, /^\d+(\.\d+)?$/, parseFloat);
+  const memoryFile = arg(args, "--memory");
+  const addrRe = /^(0x)?[0-9a-fA-F]+$/i;
+  const parseAddr = (v) => parseInt(v.toLowerCase().startsWith("0x") ? v.slice(2) : v, 16) & 65535;
+  const memoryFrom = arg(args, "--memory-from", undefined, addrRe, parseAddr) ?? 0;
+  const memoryTo = arg(args, "--memory-to", undefined, addrRe, parseAddr) ?? 65535;
+  const screenFile = arg(args, "--screen");
+  const inputSeq = arg(args, "--input");
   const programFile = args[0];
   const keyboard = new Keyboard;
   const io = new IO;
@@ -4176,19 +4493,36 @@ async function main() {
     if (goAddr !== undefined)
       entryPoint = goAddr;
   }
-  process.stdout.write("\x1B[?25l");
-  process.stdout.write("\x1B[2J");
-  setupKeyboard(keyboard);
-  const renderer = new TerminalRenderer;
-  renderer.loadInfo = loadInfo;
+  if (!headless) {
+    process.stdout.write("\x1B[?25l");
+    process.stdout.write("\x1B[2J");
+    setupKeyboard(keyboard);
+  } else {
+    process.on("SIGINT", () => doExit(null));
+  }
+  const renderer = headless ? new HeadlessRenderer : Object.assign(new TerminalRenderer, { loadInfo });
   machine.screen.start(renderer);
-  const onTerminate = exitOnHalt || exitAddr ? () => {
-    renderer.update();
-    setTimeout(() => {
+  let exiting = false;
+  const doExit = async (message) => {
+    if (exiting)
+      return;
+    exiting = true;
+    if (screenFile)
+      await writeFile(screenFile, dumpScreen(machine));
+    if (memoryFile)
+      await writeFile(memoryFile, new Uint8Array(machine.memory.buf.slice(memoryFrom, memoryTo + 1)));
+    if (!headless)
+      process.stdout.write("\x1B[?25h");
+    if (message !== null && !headless) {
       console.log();
-      console.log("\u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u0430 \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0430 \u0440\u0430\u0431\u043E\u0442\u0443 \u043D\u0430", hex16(machine.cpu.pc));
-      process.exit(0);
-    }, 1000);
+      console.log(message);
+    }
+    process.exit(0);
+  };
+  const onTerminate = exitOnHalt || exitAddr ? () => {
+    if (!headless)
+      renderer.update();
+    setTimeout(() => doExit(`\u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u0430 \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0430 \u0440\u0430\u0431\u043E\u0442\u0443 \u043D\u0430 ${hex16(machine.cpu.pc)}`), headless ? 0 : 1000);
   } : undefined;
   const armed = { value: entryPoint === undefined };
   machine.runner.execute({
@@ -4197,14 +4531,54 @@ async function main() {
     on_terminate: onTerminate,
     armed
   });
+  const armDelayMs = 500;
   if (entryPoint !== undefined && !loadOnly) {
     setTimeout(() => {
       machine.cpu.jump(entryPoint);
       armed.value = true;
-    }, 500);
+    }, armDelayMs);
   }
-  process.on("exit", () => {
-    process.stdout.write("\x1B[?25h");
-  });
+  if (inputSeq) {
+    const keys = inputSeq.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    const settleMs = armDelayMs + 1000;
+    const keyDownMs = 50;
+    const keyGapMs = 50;
+    setTimeout(() => {
+      const pressNext = (i) => {
+        if (i >= keys.length)
+          return;
+        const code = keys[i];
+        keyboard.onkeydown(code);
+        setTimeout(() => {
+          keyboard.onkeyup(code);
+          setTimeout(() => pressNext(i + 1), keyGapMs);
+        }, keyDownMs);
+      };
+      pressNext(0);
+    }, settleMs);
+  }
+  if (timeoutSec !== undefined) {
+    setTimeout(() => doExit(`\u0432\u044B\u0445\u043E\u0434 \u043F\u043E \u0442\u0430\u0439\u043C\u0430\u0443\u0442\u0443 ${timeoutSec}\u0441`), timeoutSec * 1000);
+  }
+}
+function dumpScreen(machine) {
+  const { memory, screen } = machine;
+  const lines = [];
+  let addr = screen.video_memory_base;
+  for (let y = 0;y < screen.height; y++) {
+    let line = "";
+    for (let x = 0;x < screen.width; x++) {
+      const byte = memory.read_raw(addr++) & 127;
+      if (byte === 0 || byte === 9 || byte === 10 || byte === 13) {
+        line += ".";
+      } else {
+        line += rk86char(byte);
+      }
+    }
+    lines.push(line);
+  }
+  return lines.join(`\r
+`) + `\r
+`;
 }
 main();