rk86 2.0.17 → 2.0.20

package/README.md

@@ -62,13 +62,13 @@ bunx rk86 -l                       # список файлов встроенн
 
 ```bash
 bunx rk86 --headless \
-  --input "KeyD,Digit0,Comma,KeyF,KeyF,Enter" \
+  --input "KeyD,KeyF,Digit8,Digit0,Digit0,Comma,KeyF,Digit8,KeyF,KeyF,Enter" \
   --timeout 10 \
   --screen out.txt
 ```
 
-После выхода `out.txt` содержит приглашение `-->D0,FF` и 16 строк шестнадцатеричного
-дампа `0000..00F0`.
+После выхода `out.txt` содержит приглашение `-->DF800,F8FF` и 16 строк шестнадцатеричного
+дампа `F800..F8FF`.
 
 ### Пример 2. Запись HLT и запуск через команды `M` / `G`
 

package/package.json

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

package/rk86.js

@@ -1726,6 +1726,127 @@ var ALL_MNEMONICS = new Set([
   "END",
   "EQU"
 ]);
+var INVERT_JUMP = {
+  Z: "JNZ",
+  NZ: "JZ",
+  C: "JNC",
+  NC: "JC",
+  PO: "JPE",
+  PE: "JPO",
+  P: "JM",
+  M: "JP",
+  "==": "JNZ",
+  "<>": "JZ"
+};
+var VALID_PROC_REGS = new Set(["PSW", "B", "D", "H"]);
+function popsAndRet(regs, orig) {
+  const out = [];
+  for (let k = regs.length - 1;k >= 0; k--) {
+    out.push({ text: `	POP ${regs[k]}`, orig });
+  }
+  out.push({ text: `	RET`, orig });
+  return out;
+}
+function preprocess(source) {
+  const lines = source.split(`
+`);
+  const out = [];
+  const stack = [];
+  let counter = 0;
+  let proc = null;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const orig = i + 1;
+    const bare = stripComment(line).trim();
+    const ifMatch = bare.match(/^\.?if\s+(\S+)\s*$/i);
+    if (ifMatch) {
+      const cond = ifMatch[1].toUpperCase();
+      const jmp = INVERT_JUMP[cond];
+      if (!jmp) {
+        throw new AsmError(`unknown .if condition: ${ifMatch[1]}`, orig, line, firstNonSpaceCol(line));
+      }
+      const id = counter++;
+      stack.push({ id, sawElse: false, line: orig, source: line });
+      out.push({ text: `	${jmp} @_if_${id}_else`, orig });
+      continue;
+    }
+    if (/^\.?else\s*$/i.test(bare)) {
+      const top = stack[stack.length - 1];
+      if (!top) {
+        throw new AsmError(".else without .if", orig, line, firstNonSpaceCol(line));
+      }
+      if (top.sawElse) {
+        throw new AsmError("duplicate .else", orig, line, firstNonSpaceCol(line));
+      }
+      top.sawElse = true;
+      out.push({ text: `	JMP @_if_${top.id}_exit`, orig });
+      out.push({ text: `@_if_${top.id}_else:`, orig });
+      continue;
+    }
+    if (/^\.?endif\s*$/i.test(bare)) {
+      const top = stack.pop();
+      if (!top) {
+        throw new AsmError(".endif without .if", orig, line, firstNonSpaceCol(line));
+      }
+      const suffix = top.sawElse ? "exit" : "else";
+      out.push({ text: `@_if_${top.id}_${suffix}:`, orig });
+      continue;
+    }
+    const procMatch = bare.match(/^([A-Za-z_]\w*):?\s+\.?proc\b\s*(.*)$/i);
+    if (procMatch && !ALL_MNEMONICS.has(procMatch[1].toUpperCase())) {
+      if (proc) {
+        throw new AsmError("nested .proc not allowed", orig, line, firstNonSpaceCol(line));
+      }
+      const name = procMatch[1];
+      const regsRaw = procMatch[2].trim();
+      const regs = [];
+      if (regsRaw) {
+        for (const r of regsRaw.split(/[,\s]+/)) {
+          if (!r)
+            continue;
+          const up = r.toUpperCase();
+          if (!VALID_PROC_REGS.has(up)) {
+            throw new AsmError(`invalid .proc register: ${r} (expected PSW, B, D, or H)`, orig, line, firstNonSpaceCol(line));
+          }
+          regs.push(up);
+        }
+      }
+      proc = { regs, line: orig, source: line };
+      out.push({ text: `${name}:`, orig });
+      for (const r of regs) {
+        out.push({ text: `	PUSH ${r}`, orig });
+      }
+      continue;
+    }
+    if (/^\.proc(\s|$)/i.test(bare) || /^proc\s+\S/i.test(bare)) {
+      throw new AsmError(".proc requires a label", orig, line, firstNonSpaceCol(line));
+    }
+    if (/^\.?endp\s*$/i.test(bare)) {
+      if (!proc) {
+        throw new AsmError(".endp without .proc", orig, line, firstNonSpaceCol(line));
+      }
+      out.push(...popsAndRet(proc.regs, orig));
+      proc = null;
+      continue;
+    }
+    if (/^\.?return\s*$/i.test(bare)) {
+      if (!proc) {
+        throw new AsmError(".return outside .proc", orig, line, firstNonSpaceCol(line));
+      }
+      out.push(...popsAndRet(proc.regs, orig));
+      continue;
+    }
+    out.push({ text: line, orig });
+  }
+  if (stack.length) {
+    const top = stack[stack.length - 1];
+    throw new AsmError(".if without .endif", top.line, top.source, firstNonSpaceCol(top.source));
+  }
+  if (proc) {
+    throw new AsmError(".proc without .endp", proc.line, proc.source, firstNonSpaceCol(proc.source));
+  }
+  return out;
+}
 var MAX_STATEMENTS_PER_LINE = 10;
 function splitStatements(line) {
   const src = stripComment(line);
@@ -1847,35 +1968,46 @@ function stripDirectiveDot(s) {
   }
   return s;
 }
+var LABEL_RE = /^(?:[A-Za-z_]\w*|@\w+|\.\w+)$/;
+function isMnemonic(tok) {
+  return ALL_MNEMONICS.has(stripDirectiveDot(tok).toUpperCase());
+}
 function parseLine(line) {
   let s = stripComment(line).trim();
   if (!s)
     return { operands: [] };
   let label;
   const ci = s.indexOf(":");
-  if (ci > 0 && /^[A-Za-z_]\w*$/.test(s.slice(0, ci).trim())) {
+  if (ci > 0 && LABEL_RE.test(s.slice(0, ci).trim())) {
     label = s.slice(0, ci).trim();
     s = s.slice(ci + 1).trim();
   }
   if (!s)
     return { label, operands: [] };
-  const si = s.search(/\s/);
-  const first = si < 0 ? s : s.slice(0, si);
-  const rest = si < 0 ? "" : s.slice(si).trim();
-  if (!label && rest) {
-    const parts = rest.split(/\s+/);
-    if (stripDirectiveDot(parts[0]).toUpperCase() === "EQU") {
-      return {
-        label: first,
-        mnemonic: "EQU",
-        operands: [parts.slice(1).join(" ")],
-        isEqu: true
-      };
+  let si = s.search(/\s/);
+  let first = si < 0 ? s : s.slice(0, si);
+  let rest = si < 0 ? "" : s.slice(si).trim();
+  if (!label && rest && LABEL_RE.test(first) && !isMnemonic(first)) {
+    const nextTok = rest.match(/^\S+/)?.[0] ?? "";
+    if (isMnemonic(nextTok)) {
+      label = first;
+      si = rest.search(/\s/);
+      first = si < 0 ? rest : rest.slice(0, si);
+      rest = si < 0 ? "" : rest.slice(si).trim();
     }
   }
+  const mnemonic = stripDirectiveDot(first);
+  if (label && mnemonic.toUpperCase() === "EQU") {
+    return {
+      label,
+      mnemonic: "EQU",
+      operands: [rest],
+      isEqu: true
+    };
+  }
   return {
     label,
-    mnemonic: stripDirectiveDot(first),
+    mnemonic,
     operands: rest ? splitOperands(rest) : []
   };
 }
@@ -1893,6 +2025,31 @@ function tokenizeExpr(expr) {
       i += 3;
       continue;
     }
+    if (c === "$") {
+      tokens.push({ kind: "id", val: "$" });
+      i++;
+      continue;
+    }
+    if (c === "@") {
+      let j = i + 1;
+      while (j < expr.length && /\w/.test(expr[j]))
+        j++;
+      if (j === i + 1)
+        throw new Error("expected identifier after '@'");
+      tokens.push({ kind: "id", val: expr.slice(i, j) });
+      i = j;
+      continue;
+    }
+    if (c === ".") {
+      let j = i + 1;
+      while (j < expr.length && /\w/.test(expr[j]))
+        j++;
+      if (j === i + 1)
+        throw new Error("expected identifier after '.'");
+      tokens.push({ kind: "id", val: expr.slice(i, j) });
+      i = j;
+      continue;
+    }
     if (/[0-9]/.test(c)) {
       let j = i;
       while (j < expr.length && /[0-9A-Fa-f]/.test(expr[j]))
@@ -1933,7 +2090,7 @@ function tokenizeExpr(expr) {
   }
   return tokens;
 }
-function evalExpr(expr, symbols) {
+function evalExpr(expr, symbols, pc = 0, lastLabel = "") {
   const tokens = tokenizeExpr(expr);
   let pos = 0;
   function peek() {
@@ -1956,20 +2113,30 @@ function evalExpr(expr, symbols) {
     }
     if (t.kind === "id") {
       next();
-      const k = t.val.toUpperCase();
-      if (k === "LOW" || k === "HIGH") {
+      const raw = t.val;
+      if (raw === "$")
+        return pc;
+      const upper = raw.toUpperCase();
+      if (upper === "LOW" || upper === "HIGH") {
         if (!isOp("("))
-          throw new Error(`${k} requires parentheses`);
+          throw new Error(`${upper} requires parentheses`);
         next();
         const v = parseOr();
         if (!isOp(")"))
           throw new Error("expected ')'");
         next();
-        return k === "LOW" ? v & 255 : v >> 8 & 255;
+        return upper === "LOW" ? v & 255 : v >> 8 & 255;
+      }
+      let name = raw;
+      if (name.startsWith("@") || name.startsWith(".")) {
+        if (!lastLabel)
+          throw new Error(`local label without scope: ${raw}`);
+        name = lastLabel + name;
       }
+      const k = name.toUpperCase();
       if (symbols.has(k))
         return symbols.get(k);
-      throw new Error(`unknown symbol: ${t.val}`);
+      throw new Error(`unknown symbol: ${raw}`);
     }
     if (t.kind === "op" && t.val === "(") {
       next();
@@ -2057,15 +2224,15 @@ function evalExpr(expr, symbols) {
     throw new Error(`unexpected token: ${tokens[pos].val}`);
   return result;
 }
-function encode(m, ops, symbols) {
+function encode(m, ops, symbols, pc = 0, lastLabel = "") {
   if (m in IMPLIED)
     return [IMPLIED[m]];
   if (m in ALU_REG)
     return [ALU_REG[m] | REG8[ops[0].toUpperCase()]];
   if (m in ALU_IMM)
-    return [ALU_IMM[m], evalExpr(ops[0], symbols) & 255];
+    return [ALU_IMM[m], evalExpr(ops[0], symbols, pc, lastLabel) & 255];
   if (m in ADDR16) {
-    const v = evalExpr(ops[0], symbols);
+    const v = evalExpr(ops[0], symbols, pc, lastLabel);
     return [ADDR16[m], v & 255, v >> 8 & 255];
   }
   if (m === "MOV")
@@ -2073,7 +2240,7 @@ function encode(m, ops, symbols) {
       64 | REG8[ops[0].toUpperCase()] << 3 | REG8[ops[1].toUpperCase()]
     ];
   if (m === "MVI") {
-    const v = evalExpr(ops[1], symbols);
+    const v = evalExpr(ops[1], symbols, pc, lastLabel);
     return [6 | REG8[ops[0].toUpperCase()] << 3, v & 255];
   }
   if (m === "INR")
@@ -2081,7 +2248,7 @@ function encode(m, ops, symbols) {
   if (m === "DCR")
     return [5 | REG8[ops[0].toUpperCase()] << 3];
   if (m === "LXI") {
-    const v = evalExpr(ops[1], symbols);
+    const v = evalExpr(ops[1], symbols, pc, lastLabel);
     return [
       1 | REG_PAIR[ops[0].toUpperCase()] << 4,
       v & 255,
@@ -2103,31 +2270,31 @@ function encode(m, ops, symbols) {
   if (m === "STAX")
     return [2 | REG_PAIR[ops[0].toUpperCase()] << 4];
   if (m === "IN")
-    return [219, evalExpr(ops[0], symbols) & 255];
+    return [219, evalExpr(ops[0], symbols, pc, lastLabel) & 255];
   if (m === "OUT")
-    return [211, evalExpr(ops[0], symbols) & 255];
+    return [211, evalExpr(ops[0], symbols, pc, lastLabel) & 255];
   if (m === "RST") {
-    const n = evalExpr(ops[0], symbols);
+    const n = evalExpr(ops[0], symbols, pc, lastLabel);
     return [199 | n << 3];
   }
   throw new Error(`cannot encode: ${m} ${ops.join(", ")}`);
 }
-function dbBytes(operands, symbols) {
+function dbBytes(operands, symbols, pc = 0, lastLabel = "") {
   const out = [];
   for (const op of operands) {
     if (op.startsWith('"') && op.endsWith('"') || op.startsWith("'") && op.endsWith("'")) {
       for (const ch of op.slice(1, -1))
         out.push(ch.charCodeAt(0));
     } else {
-      out.push(evalExpr(op, symbols) & 255);
+      out.push(evalExpr(op, symbols, pc, lastLabel) & 255);
     }
   }
   return out;
 }
-function dwBytes(operands, symbols) {
+function dwBytes(operands, symbols, pc = 0, lastLabel = "") {
   const out = [];
   for (const op of operands) {
-    const v = evalExpr(op, symbols) & 65535;
+    const v = evalExpr(op, symbols, pc, lastLabel) & 65535;
     out.push(v & 255, v >> 8 & 255);
   }
   return out;
@@ -2140,15 +2307,15 @@ function parseDs(operands) {
     return { count: m[1], fill: m[2] };
   return { count: operands[0], fill: "0" };
 }
-function dsBytes(operands, symbols) {
+function dsBytes(operands, symbols, pc = 0, lastLabel = "") {
   const { count, fill } = parseDs(operands);
-  const n = evalExpr(count, symbols);
-  const f = evalExpr(fill, symbols) & 255;
+  const n = evalExpr(count, symbols, pc, lastLabel);
+  const f = evalExpr(fill, symbols, pc, lastLabel) & 255;
   return new Array(n).fill(f);
 }
-function countDs(operands, symbols) {
+function countDs(operands, symbols, pc = 0, lastLabel = "") {
   const { count } = parseDs(operands);
-  return evalExpr(count, symbols);
+  return evalExpr(count, symbols, pc, lastLabel);
 }
 function countDb(operands) {
   let n = 0;
@@ -2161,22 +2328,30 @@ function countDb(operands) {
   return n;
 }
 function asm(source) {
-  const lines = source.split(`
-`);
+  const pp = preprocess(source);
   const symbols = new Map;
   let pc = 0;
+  let lastLabel = "";
   let ended = false;
-  for (let idx = 0;idx < lines.length && !ended; idx++) {
-    const line = lines[idx];
+  for (let idx = 0;idx < pp.length && !ended; idx++) {
+    const { text: line, orig } = pp[idx];
     try {
       for (const stmt of splitStatements(line)) {
         const parts = parseLine(stmt);
         if (parts.label) {
+          let labelName = parts.label;
+          if (labelName.startsWith("@") || labelName.startsWith(".")) {
+            if (!lastLabel)
+              throw new Error(`local label without preceding normal label: ${labelName}`);
+            labelName = lastLabel + labelName;
+          } else if (!parts.isEqu) {
+            lastLabel = parts.label;
+          }
           if (parts.isEqu) {
-            symbols.set(parts.label.toUpperCase(), evalExpr(parts.operands[0], symbols));
+            symbols.set(labelName.toUpperCase(), evalExpr(parts.operands[0], symbols, pc, lastLabel));
             continue;
           }
-          symbols.set(parts.label.toUpperCase(), pc);
+          symbols.set(labelName.toUpperCase(), pc);
         }
         if (!parts.mnemonic)
           continue;
@@ -2184,7 +2359,7 @@ function asm(source) {
         if (m === "EQU")
           continue;
         if (m === "ORG") {
-          pc = evalExpr(parts.operands[0], symbols);
+          pc = evalExpr(parts.operands[0], symbols, pc, lastLabel);
           continue;
         }
         if (m === "SECTION")
@@ -2202,7 +2377,7 @@ function asm(source) {
           continue;
         }
         if (m === "DS") {
-          pc += countDs(parts.operands, symbols);
+          pc += countDs(parts.operands, symbols, pc, lastLabel);
           continue;
         }
         pc += instrSize(m);
@@ -2210,29 +2385,34 @@ function asm(source) {
     } catch (e) {
       if (e instanceof AsmError)
         throw e;
-      throw new AsmError(e.message, idx + 1, line, firstNonSpaceCol(line));
+      throw new AsmError(e.message, orig, line, firstNonSpaceCol(line));
     }
   }
   const sections = [];
   let current = null;
   const sectionNames = new Set;
+  let lastLabel2 = "";
   let endedPass2 = false;
-  for (let idx = 0;idx < lines.length && !endedPass2; idx++) {
-    const line = lines[idx];
+  for (let idx = 0;idx < pp.length && !endedPass2; idx++) {
+    const { text: line, orig } = pp[idx];
     try {
       for (const stmt of splitStatements(line)) {
         const parts = parseLine(stmt);
+        if (parts.label && !parts.label.startsWith("@") && !parts.label.startsWith(".") && !parts.isEqu) {
+          lastLabel2 = parts.label;
+        }
         if (parts.isEqu || !parts.mnemonic)
           continue;
         const m = parts.mnemonic.toUpperCase();
         if (m === "EQU")
           continue;
+        const curPc = current ? current.start + current.data.length : 0;
         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);
+          const addr = evalExpr(parts.operands[0], symbols, curPc, lastLabel2);
           current = { start: addr, end: addr, data: [] };
           continue;
         }
@@ -2254,13 +2434,13 @@ function asm(source) {
         }
         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);
+        const bytes = m === "DB" ? dbBytes(parts.operands, symbols, curPc, lastLabel2) : m === "DW" ? dwBytes(parts.operands, symbols, curPc, lastLabel2) : m === "DS" ? dsBytes(parts.operands, symbols, curPc, lastLabel2) : encode(m, parts.operands, symbols, curPc, lastLabel2);
         current.data.push(...bytes);
       }
     } catch (e) {
       if (e instanceof AsmError)
         throw e;
-      throw new AsmError(e.message, idx + 1, line, firstNonSpaceCol(line));
+      throw new AsmError(e.message, orig, line, firstNonSpaceCol(line));
     }
   }
   if (current && current.data.length) {
@@ -2277,7 +2457,7 @@ import { readFile, writeFile } from "fs/promises";
 // packages/rk86/package.json
 var package_default = {
   name: "rk86",
-  version: "2.0.16",
+  version: "2.0.19",
   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"
@@ -3707,16 +3887,19 @@ class Runner {
   init_sound(enabled) {
     if (enabled && this.sound == null && this.sound_factory) {
       this.sound = this.sound_factory();
-      console.log("\u0437\u0432\u0443\u043A \u0432\u043A\u043B\u044E\u0447\u0435\u043D");
+      this.machine.log("\u0437\u0432\u0443\u043A \u0432\u043A\u043B\u044E\u0447\u0435\u043D");
     } else if (!enabled) {
       this.sound = null;
-      console.log("\u0437\u0432\u0443\u043A \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D");
+      this.machine.log("\u0437\u0432\u0443\u043A \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D");
     }
   }
   execute(options = {}) {
-    const { terminate_address, on_terminate, exit_on_halt, armed } = options;
+    const { terminate_address, on_terminate, exit_on_halt, on_batch_complete, turbo } = options;
     clearTimeout(this.execute_timer);
-    if (!this.paused) {
+    const bursts = turbo ? 100 : 1;
+    for (let burst = 0;burst < bursts; burst++) {
+      if (this.paused)
+        break;
       let batch_ticks = 0;
       let batch_instructions = 0;
       while (batch_ticks < this.TICK_PER_MS) {
@@ -3742,8 +3925,6 @@ class Runner {
           this.machine.ui.on_visualizer_hit(this.machine.memory.read_raw(this.machine.cpu.pc));
         }
         batch_instructions += 1;
-        if (armed?.value === false)
-          continue;
         if (terminate_address !== undefined && this.machine.cpu.pc === terminate_address) {
           on_terminate?.();
           return;
@@ -3758,8 +3939,10 @@ class Runner {
       this.previous_batch_time = now;
       this.instructions_per_millisecond = batch_instructions / elapsed;
       this.ticks_per_millisecond = batch_ticks / elapsed;
+      this.machine.screen.tick_cursor(this.total_ticks, this.FREQ * (this.machine.screen.cursor_rate / 1000));
+      on_batch_complete?.();
     }
-    this.execute_timer = setTimeout(() => this.execute(options), 10);
+    this.execute_timer = setTimeout(() => this.execute(options), turbo ? 0 : 10);
   }
   pause() {
     this.paused = true;
@@ -3845,9 +4028,15 @@ class Screen {
   start(renderer) {
     this.renderer = renderer;
     this.renderer.connect(this.machine);
-    this.flip_cursor();
     this.render_loop();
   }
+  last_flip_ticks = 0;
+  tick_cursor(total_ticks, ticks_per_flip) {
+    while (total_ticks - this.last_flip_ticks >= ticks_per_flip) {
+      this.cursor_state = !this.cursor_state;
+      this.last_flip_ticks += ticks_per_flip;
+    }
+  }
   render_loop() {
     if (this.ready)
       this.renderer.update();
@@ -3862,7 +4051,7 @@ class Screen {
     this.machine.ui.update_screen_geometry(this.width, this.height);
     if (this.last_width === this.width && this.last_height === this.height)
       return;
-    console.log(`\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u0440\u0430\u0437\u043C\u0435\u0440 \u044D\u043A\u0440\u0430\u043D\u0430: ${width} x ${height}`);
+    this.machine.log(`\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u0440\u0430\u0437\u043C\u0435\u0440 \u044D\u043A\u0440\u0430\u043D\u0430: ${width} x ${height}`);
     this.last_width = this.width;
     this.last_height = this.height;
     if (this.last_video_memory_base !== -1)
@@ -3874,7 +4063,7 @@ class Screen {
     this.machine.ui.update_video_memory_address(this.video_memory_base);
     if (this.last_video_memory_base === this.video_memory_base)
       return;
-    console.log(`\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430 \u0432\u0438\u0434\u0435\u043E\u043F\u0430\u043C\u044F\u0442\u044C \u0441 \u0430\u0434\u0440\u0435\u0441\u0430`, `${hex16(this.video_memory_base)}`, `\u0440\u0430\u0437\u043C\u0435\u0440\u043E\u043C ${hex16(this.video_memory_size)}`);
+    this.machine.log(`\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430 \u0432\u0438\u0434\u0435\u043E\u043F\u0430\u043C\u044F\u0442\u044C \u0441 \u0430\u0434\u0440\u0435\u0441\u0430`, `${hex16(this.video_memory_base)}`, `\u0440\u0430\u0437\u043C\u0435\u0440\u043E\u043C ${hex16(this.video_memory_size)}`);
     this.last_video_memory_base = this.video_memory_base;
     if (this.last_width !== -1)
       this.ready = true;
@@ -3883,13 +4072,28 @@ class Screen {
     this.cursor_x = x;
     this.cursor_y = y;
   }
-  flip_cursor() {
-    this.cursor_state = !this.cursor_state;
-    setTimeout(() => this.flip_cursor(), this.cursor_rate);
-  }
 }
 
 // src/lib/core/rk86_snapshot.ts
+function rk86_snapshot(machine, version) {
+  const { screen, cpu, keyboard, memory } = machine;
+  const h16 = (n) => "0x" + hex16(n);
+  const snapshot = {
+    id: "rk86",
+    created: new Date().toISOString(),
+    format: "1",
+    emulator: "rk86.ru",
+    version,
+    start: h16(0),
+    end: h16(65535),
+    boot: { keyboard: [] },
+    cpu: cpu.export(),
+    keyboard: keyboard.export(),
+    screen: screen.export(),
+    memory: memory.export()
+  };
+  return JSON.stringify(snapshot, null, 4);
+}
 function rk86_snapshot_restore(snapshot, machine, keys_injector) {
   try {
     const json = typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot;
@@ -4156,7 +4360,6 @@ class TerminalUI {
   terminal = { put: () => {}, history: [] };
   i8080disasm;
   visualizer;
-  toggle_assembler;
   on_visualizer_hit;
   on_pause_changed;
   refreshDebugger;
@@ -4344,15 +4547,19 @@ function printHelp() {
   -m <\u0444\u0430\u0439\u043B>                \u043C\u043E\u043D\u0438\u0442\u043E\u0440 (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E: \u0432\u0441\u0442\u0440\u043E\u0435\u043D\u043D\u044B\u0439 mon32.bin)
   -p                       \u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044C \u0444\u0430\u0439\u043B \u0431\u0435\u0437 \u0437\u0430\u043F\u0443\u0441\u043A\u0430
   -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)
+  -G <\u0430\u0434\u0440\u0435\u0441>                \u0437\u0430\u043F\u0443\u0441\u043A \u0447\u0435\u0440\u0435\u0437 \u043A\u043E\u043C\u0430\u043D\u0434\u0443 G \u043C\u043E\u043D\u0438\u0442\u043E\u0440\u0430 (\u0438\u043D\u044A\u0435\u043A\u0446\u0438\u044F \u043A\u043B\u0430\u0432\u0438\u0448)
   --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)
+  --turbo                  \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u0431\u0435\u0437 \u043E\u0433\u0440\u0430\u043D\u0438\u0447\u0435\u043D\u0438\u044F \u0441\u043A\u043E\u0440\u043E\u0441\u0442\u0438 (\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
+  --snapshot <\u0444\u0430\u0439\u043B>        \u0441\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C \u0441\u043D\u0438\u043C\u043E\u043A \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u044F (JSON) \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,...
+                           \u0442\u043E\u043A\u0435\u043D *N \u0437\u0430\u0434\u0430\u0451\u0442 \u043F\u0430\u0443\u0437\u0443 N \u043C\u0441 (\u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440 *200)
 
 \u041F\u0440\u0438\u043C\u0435\u0440\u044B:
   bunx rk86                          \u0437\u0430\u043F\u0443\u0441\u043A \u043C\u043E\u043D\u0438\u0442\u043E\u0440\u0430
@@ -4424,6 +4631,7 @@ async function main() {
   const exitAddr = exitAddrValue !== undefined;
   const monitorFile_ = arg(args, "-m");
   const headless = flag(args, "--headless");
+  const turbo = flag(args, "--turbo");
   const timeoutSec = arg(args, "--timeout", undefined, /^\d+(\.\d+)?$/, parseFloat);
   const memoryFile = arg(args, "--memory");
   const addrRe = /^(0x)?[0-9a-fA-F]+$/i;
@@ -4431,14 +4639,23 @@ async function main() {
   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 snapshotFile = arg(args, "--snapshot");
+  const goViaMonitor = arg(args, "-G", undefined, addrRe, parseAddr);
+  let inputSeq = arg(args, "--input");
+  if (goViaMonitor !== undefined) {
+    const hex2 = goViaMonitor.toString(16).toUpperCase();
+    const keys = [...hex2].map((c) => c >= "0" && c <= "9" ? `Digit${c}` : `Key${c}`);
+    const gSeq = ["KeyG", ...keys, "Enter"].join(",");
+    inputSeq = inputSeq ? `${inputSeq},${gSeq}` : gSeq;
+  }
   const programFile = args[0];
   const keyboard = new Keyboard;
   const io = new IO;
   const machineBuilder = {
     font: rk86_font_image(),
     keyboard,
-    io
+    io,
+    log: (...args2) => console.log(...args2)
   };
   const machine = machineBuilder;
   machine.ui = new TerminalUI;
@@ -4511,6 +4728,8 @@ async function main() {
       await writeFile(screenFile, dumpScreen(machine));
     if (memoryFile)
       await writeFile(memoryFile, new Uint8Array(machine.memory.buf.slice(memoryFrom, memoryTo + 1)));
+    if (snapshotFile)
+      await writeFile(snapshotFile, rk86_snapshot(machine, package_default.version));
     if (!headless)
       process.stdout.write("\x1B[?25h");
     if (message !== null && !headless) {
@@ -4524,39 +4743,49 @@ async function main() {
       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({
-    terminate_address: exitAddr ? exitAddrValue : undefined,
-    exit_on_halt: exitOnHalt,
-    on_terminate: onTerminate,
-    armed
-  });
   const armDelayMs = 500;
   if (entryPoint !== undefined && !loadOnly) {
     setTimeout(() => {
       machine.cpu.jump(entryPoint);
-      armed.value = true;
     }, armDelayMs);
   }
+  const tickEvents = [];
   if (inputSeq) {
     const keys = inputSeq.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    const TICKS_PER_MS = machine.runner.FREQ / 1000;
     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);
+    let t = settleMs * TICKS_PER_MS;
+    for (const token of keys) {
+      if (token.startsWith("*")) {
+        const delayMs = parseInt(token.slice(1), 10);
+        if (!Number.isFinite(delayMs) || delayMs < 0) {
+          console.error(`\u043D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0437\u0430\u0434\u0435\u0440\u0436\u043A\u0430 \u0432 --input: ${token}`);
+          process.exit(1);
+        }
+        t += delayMs * TICKS_PER_MS;
+        continue;
+      }
+      const code = token;
+      tickEvents.push({ at_ticks: t, action: () => keyboard.onkeydown(code) });
+      t += keyDownMs * TICKS_PER_MS;
+      tickEvents.push({ at_ticks: t, action: () => keyboard.onkeyup(code) });
+      t += keyGapMs * TICKS_PER_MS;
+    }
   }
+  machine.runner.execute({
+    terminate_address: exitAddr ? exitAddrValue : undefined,
+    exit_on_halt: exitOnHalt,
+    on_terminate: onTerminate,
+    turbo,
+    on_batch_complete: () => {
+      const now = machine.runner.total_ticks;
+      while (tickEvents.length > 0 && tickEvents[0].at_ticks <= now) {
+        tickEvents.shift().action();
+      }
+    }
+  });
   if (timeoutSec !== undefined) {
     setTimeout(() => doExit(`\u0432\u044B\u0445\u043E\u0434 \u043F\u043E \u0442\u0430\u0439\u043C\u0430\u0443\u0442\u0443 ${timeoutSec}\u0441`), timeoutSec * 1000);
   }