@moonbase-machines/player 0.0.0-stage → 0.8.0

package/remake/events.js

@@ -0,0 +1,79 @@
+// What a step is, as an event: the same words for the original, where the pilot's observer sees
+// the engine's routine called, and for the remake, where a script's step runs. Two runs are the
+// same when their events are.
+
+// the registers each routine takes, in order
+export const TAKES = {
+  box: 'axy', object: 'axy', 'object-keep': 'axy', 'object-mode': 'axy', objects: 'xy', span: 'axy', random: 'a', beep: 'a',
+  'key-at': 'axy', key: 'a', multiply: 'ax', divide: 'axy', ask: 'a', 'ask-mode': 'a', 'ask-escape': 'a', rectangle: 'axy', 'read-dot': 'xy',
+  problem: 'a', dot: 'axy', 'fill-rows': 'axy', part: 'a', 'rectangle-outline': 'axy', 'key-panel': 'a', 'keep-span': 'xy',
+  'put-span': 'xy', 'white-lines': 'y', 'invert-span': 'xy',
+  // Animal Rescue's problems: PROB1, the chimps' tree, a box by its letter
+  label: 'a', 'flip-box': 'a', 'flash-box': 'a',
+  // PROB2, the elephants: a mark on the path by its place, and a jump by how far it goes
+  path: 'ax', jump: 'a',
+  // PROB3, the parrots' food: a box of the grid by its column and row, what shows in it, and a pair
+  cell: 'axy', 'cell-box': 'axy', pair: 'a',
+  // PROB4, the puzzle box: a piece by its edges, where it goes, and its color in $11
+  piece: 'axy',
+  // Nature Park's PROB1, the colour pattern: a shape coloured in with a pen, the shape in $0E15
+  colour: 'a',
+  // PROB3, the truck: a turn of its loop, which gives the key down then, or 0
+  tick: '',
+  // Detect-A-Pet's card toolkit (its title's map): print takes its x in X and Y, its y in A, and
+  // the carry for XDRAW; HPOSN its y in A and x in X and Y; HLIN its x in A and X and y in Y
+  print: 'axyc', arrow: 'a', unpack: 'y', 'load-picture': 'a', 'action-cards': 'a', 'return-key': 'a', 'space-key': 'a',
+  'wipe-rows': 'a', 'wipe-columns': 'a', 'text-card': 'a', 'fill-left': 'a', 'put-object': 'axy', 'draw-room-objects': 'yc', take: 'y',
+  drop: 'y', effect: 'a', outport: 'a', cout: 'a',
+  // Pieces of Eight's text: a character at the cursor, a message by its number, and a room's
+  // description from one of three tables
+  char: 'a', message: 'xy', describe: 'axy',
+  // the Commodore 64's KERNAL (Zoopak): a character out, the cursor's place, a file's number,
+  // device and secondary address, its name, a load or save, and the serial bus's bytes
+  chrout: 'a', plot: 'xyc', close: 'a', chkin: 'x', chkout: 'x', setlfs: 'axy', setnam: 'axy', load: 'axy', save: 'axy', listen: 'a', second: 'a', ciout: 'a', talk: 'a', tksa: 'a', setmsg: 'a', tone: 'xy', 'load-objects': 'axy', hposn: 'axy', hlin: 'axy', hcolor: 'x', pause: 'a', 'bag-put': 'a',
+};
+
+// the inputs some problems' routines take from their own memory, at fixed addresses
+const MEMORY = { colour: { shape: 0x0e15 }, 'card-frame': { x: 0x4078, high: 0x4079, y: 0x407a, width: 0x407b, height: 0x407c } };
+
+// the inputs some routines take from the zero page rather than the registers: the line's ends
+// and color, and a rectangle's width and height
+const ZERO = { line: { x0: 0x00, x1: 0x01, y0: 0x02, y1: 0x03, color: 0x11 }, piece: { color: 0x11 }, rectangle: { width: 0x0e, height: 0x0f }, 'rectangle-outline': { width: 0x0e, height: 0x0f } };
+
+// A step as an event: its name, any fixed input (a panel's number), the registers it takes,
+// the zero page inputs, read through `read`, and the data it had inline (a text, a picture's
+// name, a sound).
+export function describe(name, fixed, regs, inline, read, peek) {
+  const e = { step: name };
+  if (fixed.length) e.n = fixed.map(Number);
+  const takes = TAKES[name];
+  if (name === 'objects') e.table = '$' + ((regs.x | regs.y << 8).toString(16).toUpperCase().padStart(4, '0'));
+  // object 0 or 1 puts back the ground kept under an object, where it was: what is left in X and Y
+  // then is whatever the steps before left there, and is no input
+  else if (name.startsWith('object') && regs.a < 2) e.a = regs.a;
+  else if (takes) for (const r of takes) e[r] = regs[r];
+  if ((name === 'key-at' || name === 'key') && e.a !== undefined) e.a = String.fromCharCode(e.a & 0x7f);
+  if (ZERO[name] && read) for (const [k, at] of Object.entries(ZERO[name])) e[k] = read(at);
+  if (MEMORY[name] && peek) for (const [k, at] of Object.entries(MEMORY[name])) e[k] = peek(at);
+  if (inline !== undefined) e.words = inline;
+  return e;
+}
+
+// the outputs of a routine that a scene goes on to use, recorded as it returns
+export const GIVES = { random: 'a', ask: 'ax', 'ask-mode': 'ax', 'ask-escape': 'axc', 'wait-or-escape': 'c', problem: 'c', 'read-key': 'a', 'read-dot': 'a', multiply: 'ax', divide: 'ax', 'blink-key': 'a', 'which-box': 'xy', tick: 'a', 'choose-action': 'a', take: 'a', drop: 'a', 'show-bag': 'a', 'bag-choose': 'a', getin: 'a', acptr: 'a', readst: 'a', load: 'cxy', chrin: 'a' };
+
+// A call that does nothing is no step: the beep returns at once for A 0 ($6831 in Animal Rescue,
+// $5D12 in Nature Park), and a scene that reads keys by polling beeps each one, 0 for none, until
+// one comes. As steps those would be as many as the polls, which is how long the machine was
+// watched, not what the title did.
+export const nothing = (name, a) => name === 'beep' && a === 0;
+
+// routines that poll for a key: each is a step only when it gives one
+export const POLLS = new Set(['read-key', 'blink-key']);
+// routines that wait for keys; any other, while it runs, is busy, and a key pressed then is not for it
+export const WAITS = new Set(['wait', 'wait-erase', 'wait-or-escape', 'ask', 'ask-mode', 'ask-escape', 'which-box', 'tick', 'choose-action', 'take', 'drop', 'show-bag', 'bag-choose']);
+export function result(name, regs) {
+  const e = { result: name };
+  for (const r of GIVES[name]) e[r] = regs[r];
+  return e;
+}

package/remake/layout.js

@@ -0,0 +1,144 @@
+// A text laid out as the engine's text routine ($6CE2) lays it out, for the view to draw and for
+// the screen model to paint. `pen` is the text state that lasts from text to text: the pen's x and
+// y, the margin, centring, the spacing, the gap between lines, the ink and the paper. It is changed
+// here as the engine changes it.
+//
+//   {0:x} the pen's x and the margin   {1:y} its y, or from $C0 the line height
+//   {2:n} the spacing   {3:n} the gap between lines   {4:c} the ink   {5:c} the paper
+//   {7} and {8} centring on and off   {9} and {a} tall on and off   {f:ch,n} a character n times
+//   {d} and {e} ink 0 and ink 1 from here on   {10} and {11} the big digits and back
+//
+// Returns the lines, each { top, tall, height, paper, ink, chars }, and each character { ch, x, ink },
+// its x in dots. A character's ink is undefined before the line's first color: the engine draws
+// that part in the ink the whole line ends with, which is the line's `ink`. A byte below a space
+// is a spacer, a few dots of room and nothing drawn.
+import { width, start } from '@moonbase-machines/vector/font.js';
+
+// the screen's layout by $03E3: the window's last row, and the tops of the two boxes below it
+export const LAYOUT = { 0x41: [116, 116, 174], 0x32: [116, 116, 160], 0x31: [130, 130, 174], 0x22: [130, 130, 160], 0x11: [158, 158, 174] };
+// the panels: the layout they set, the rows of the box they clear, from its two white rows down,
+// and its color, and the text state they leave; `more`, white rows drawn below as well. 1 to 6 are
+// Animal Rescue's, $6299 to $6395; Nature Park has the same six and eighteen more, $5712 to $58A6,
+// in families that share a body and differ in the gap and the row they leave (its title's map).
+const gray = (layout, rows, gap, y, more) => ({ layout, rows, fill: 10, paper: 10, ink: 0, gap, y, more });
+const blue = (layout, rows, gap, y) => ({ layout, rows, fill: 5, paper: 5, ink: 15, gap, y });
+export const PANELS = {
+  1: gray(0x32, [116, 159], 7, 128), 2: gray(0x32, [116, 159], 33, 135),
+  3: gray(0x22, [130, 159], 5, 135), 4: gray(0x22, [130, 159], 19, 142),
+  5: blue(0x22, [160, 189], 5, 166), 6: blue(0x22, [160, 189], 19, 172),
+  7: gray(0x41, [116, 173], 5, 121), 8: gray(0x41, [116, 173], 6, 128), 9: gray(0x41, [116, 173], 7, 134), 10: gray(0x41, [116, 173], 47, 142),
+  11: gray(0x32, [116, 159], 5, 121),
+  12: gray(0x31, [130, 173], 5, 135), 13: gray(0x31, [130, 173], 7, 142), 14: gray(0x31, [130, 173], 33, 149),
+  15: gray(0x11, [158, 173], 5, 163, [174]),
+  16: blue(0x32, [160, 189], 19, 172), 17: blue(0x42, [160, 189], 19, 172),
+  18: blue(0x32, [160, 189], 5, 166), 19: blue(0x42, [160, 189], 5, 166),
+  20: blue(0x23, [160, 189], 0, 163), 21: blue(0x33, [160, 189], 0, 163), 22: blue(0x43, [160, 189], 0, 163),
+  23: blue(0x31, [174, 189], 5, 179), 24: blue(0x41, [174, 189], 5, 179),
+};
+
+// code 6: a word from a table of words, each its length then its letters, the index given or
+// read from memory
+export function word(mem, [lo, hi, vlo, vhi]) {
+  let at = lo | hi << 8, n = vhi === 0xff ? vlo : mem[vlo | vhi << 8];
+  while (n-- > 0) at += mem[at] + 1;
+  let s = ''; for (let k = 1; k <= mem[at]; k++) s += String.fromCharCode(mem[at + k] & 0x7f);
+  return s;
+}
+// a text's words with the words code 6 takes put in, from memory as it is now
+export const resolve = (words, mem) => words.replace(/\{6:([0-9a-f,]+)\}/g, (all, b) => word(mem, b.split(',').map(v => parseInt(v, 16))));
+
+export function layout(words, pen) {
+  const t = pen, lines = [];
+  t.tall = false; t.margin = t.x; let height = 9, big = false;
+  let line = [], ink = t.ink, marked = false;
+  const flush = newline => {
+    if (line.length) {
+      let x = start(line.map(c => c.ch), t.spacing, t.x, t.centre);
+      const chars = [];
+      for (const c of line) {
+        const w = width(c.ch);
+        chars.push({ ch: c.ch, x, ink: c.ink });
+        x += c.ch.charCodeAt(0) < 0x20 ? w : w + t.spacing;
+      }
+      lines.push({ top: t.y, tall: t.tall, height, paper: t.paper, ink: t.ink, chars });
+      t.x = x;
+    }
+    line = [];
+    if (newline) { t.y += (t.tall ? 2 * height : height) + t.gap; t.x = t.margin; }
+  };
+  // a digit in the big set is its own character, $80 and on (@moonbase-machines/vector/font.js)
+  const put = ch => line.push({ ch: big && ch >= '0' && ch <= '9' ? String.fromCharCode(0x80 + ch.charCodeAt(0) - 0x30) : ch, ink: marked ? ink : undefined });
+  for (let i = 0; i < words.length; i++) {
+    const c = words[i];
+    if (c === '\n') { flush(true); continue; }
+    if (c === '{') {
+      const end = words.indexOf('}', i), [code, rest] = words.slice(i + 1, end).split(':'), b = (rest ?? '').split(',').map(v => parseInt(v, 16));
+      i = end;
+      switch (parseInt(code, 16)) {
+        case 0: t.x = t.margin = b[0]; break;
+        case 1: if (b[0] < 0xc0) t.y = b[0]; else height = b[0] - 0xc0; break;
+        case 2: t.spacing = b[0]; break;
+        case 3: t.gap = b[0]; break;
+        case 4: t.ink = ink = b[0]; marked = true; break;
+        case 5: t.paper = b[0]; break;
+        case 7: t.centre = true; break;
+        case 8: t.centre = false; break;
+        case 9: t.tall = true; break;
+        case 10: t.tall = false; break;
+        case 13: ink = 0; marked = true; break;
+        case 14: ink = 1; marked = true; break;
+        case 16: big = true; break;
+        case 17: big = false; break;
+        case 15: for (let k = 0; k < (b[1] || 256); k++) put(String.fromCharCode(b[0] & 0x7f)); break;
+      }
+      continue;
+    }
+    put(c);
+  }
+  flush(false);
+  return lines;
+}
+
+// The same codes on the text screen, where the menus and the teacher's controls are ($573D puts
+// the machine in 40 columns of text): {0:x} is the column and the margin, {1:y} the row, a new
+// line the next row at the margin, {7} centres each line in the 40 columns, and {d} and {e} turn
+// inverse on and off. Inverse has capitals only, as the text page's inverse codes do. The
+// spacing, the gap, the colors and tall mean nothing there.
+// Returns the characters as { row, col, ch, inverse }, and leaves the pen where the text ended.
+export function textLayout(words, pen) {
+  const cells = [];
+  pen.inverse = false;   // each text starts out of inverse ($6D02)
+  let line = [];
+  const flush = newline => {
+    const col = pen.centre ? (40 - line.length) >> 1 : pen.x;
+    line.forEach((c, k) => cells.push({ row: pen.y, col: col + k, ch: c.ch, inverse: c.inverse }));
+    if (line.length) pen.x = col + line.length;
+    line = [];
+    if (newline) { pen.y++; pen.x = pen.margin; }
+  };
+  const put = ch => line.push({ ch: pen.inverse ? ch.toUpperCase() : ch, inverse: pen.inverse });
+  for (let i = 0; i < words.length; i++) {
+    const c = words[i];
+    if (c === '\n') { flush(true); continue; }
+    if (c === '{') {
+      const end = words.indexOf('}', i), [code, rest] = words.slice(i + 1, end).split(':'), b = (rest ?? '').split(',').map(v => parseInt(v, 16));
+      i = end;
+      switch (parseInt(code, 16)) {
+        case 0: flush(false); pen.x = pen.margin = b[0]; break;
+        case 1: flush(false); if (b[0] < 0xc0) pen.y = b[0]; break;
+        case 7: pen.centre = true; break;
+        case 8: pen.centre = false; break;
+        case 13: pen.inverse = true; break;
+        case 14: pen.inverse = false; break;
+        case 15: for (let k = 0; k < (b[1] || 256); k++) put(String.fromCharCode(b[0] & 0x7f)); break;
+      }
+      continue;
+    }
+    put(c);
+  }
+  flush(false);
+  return cells;
+}
+// the text state at the start, and the empty screen
+export const textPen = () => ({ x: 0, y: 0, margin: 0, centre: false, inverse: false });
+export const textPage = () => Array.from({ length: 24 }, () => Array.from({ length: 40 }, () => ({ ch: ' ', inverse: false })));

package/remake/lift.js

@@ -0,0 +1,197 @@
+// The lifter: a file's 6502 walked from its entries into a scene script, a step to a line
+// (a tool prints them; the remake lifts at need in the browser, card.js).
+import { OPS, SIZE, operand, hex } from '@moonbase-machines/mos6502/disasm.js';
+import { INLINE as READERS } from '@moonbase-machines/vector/inline.js';
+import { TAKES } from './events.js';
+
+// the data after a call, read from the file, with the text quoted so that it reads as one word
+export const readers = from => Object.fromEntries(Object.entries(from).map(([k, f]) => [k, (b, at) => { const r = f(i => b[i], at); return { length: r.length, words: k === 'text' || k === 'print' || k === 'say' ? JSON.stringify(r.value) : r.value }; }]));
+const INLINE = readers(READERS);
+
+// `stops` are addresses where data begins that is not a table of code addresses, the objects'
+// tables and the objects themselves, so that a table of addresses read from the code ends there.
+export function lift(bytes, origin, entries, routines, stops = new Set(), inline = INLINE) {
+  const INLINE = inline;
+  // `seen`: every byte an instruction or its data takes, for what is left as data; an instruction
+  // is walked from where it starts, which may be inside another's bytes (the BIT that skips)
+  const lines = new Map(), targets = new Set(entries), seen = new Set(), queue = [...entries];
+  const inFile = a => a >= origin && a < origin + bytes.length;
+  while (queue.length) {
+    let pc = queue.pop();
+    const regs = {};
+    while (inFile(pc) && !lines.has(pc)) {
+      seen.add(pc);
+      const at = pc - origin, op = OPS[bytes[at]];
+      if (op.name === '???') { lines.set(pc, { line: '.byte $' + hex(bytes[at], 2) + '   ; not an instruction', end: pc + 1 }); break; }
+      const size = SIZE[op.mode], word = bytes[at + 1] | bytes[at + 2] << 8, ins = bytes.subarray(at, at + size);
+      let line = (op.name + ' ' + operand(op.mode, ins, pc)).trim(), next = pc + size, stop = false;
+      if (op.mode === 'imm' && 'LDA LDX LDY'.includes(op.name)) regs[op.name[2]] = bytes[at + 1];
+      else if (op.name.startsWith('T') || op.name.startsWith('IN') || op.name.startsWith('DE') || op.name.startsWith('LD') || op.name === 'PLA') delete regs[op.name.at(-1)];
+      if (op.name === 'JSR' && routines[word]) {
+        const r = routines[word], data = INLINE[r]?.(bytes, next - origin);
+        const args = ['A', 'X', 'Y'].map(k => regs[k] === undefined ? '' : k + '=' + regs[k]).filter(Boolean).join(' ');
+        line = r + (data ? ' ' + data.words : '') + (args && !data ? '   ; ' + args : '');
+        if (data) next += data.length;
+        for (const k in regs) delete regs[k];
+      } else if (op.name === 'JSR') { if (inFile(word)) { targets.add(word); queue.push(word); } for (const k in regs) delete regs[k]; }
+      else if (op.name === 'JMP' && op.mode === 'abs') { if (inFile(word)) { targets.add(word); queue.push(word); } else line += '   ; into PART0' + (routines[word] ? ', ' + routines[word] : ''); stop = true; }
+      else if (op.name === 'JMP' || op.name === 'RTS' || op.name === 'RTI' || op.name === 'BRK') stop = true;
+      else if (op.mode === 'rel') { const t = (pc + 2 + (bytes[at + 1] << 24 >> 24)) & 0xffff; targets.add(t); queue.push(t); }
+      // a table of addresses, read low byte then high byte, LDA t,X or t,Y and then LDA t+1 the same
+      // way within a few instructions: every address in it that is in the file is code to follow
+      if ((op.mode === 'abx' || op.mode === 'aby') && op.name === 'LDA' && inFile(word)) {
+        for (let k = at + 3; k < at + 12 && k + 2 < bytes.length; k++) {
+          if (bytes[k] !== bytes[at] || (bytes[k + 1] | bytes[k + 2] << 8) !== word + 1) continue;
+          const table = [];
+          for (let e = word - origin; e + 1 < bytes.length && table.length < 64; e += 2) { if (table.length && stops.has(origin + e)) break; const t = bytes[e] | bytes[e + 1] << 8; if (!inFile(t)) break; table.push(t); }
+          line += '   ; a table of ' + table.length + ' addresses';
+          for (const t of table) { targets.add(t); queue.push(t); }
+          break;
+        }
+      }
+      lines.set(pc, { line, end: next, op: op.name, mode: op.mode, value: size === 2 ? bytes[at + 1] : word, call: op.name === 'JSR' && routines[word] ? { name: routines[word], words: INLINE[routines[word]]?.(bytes, pc + 3 - origin)?.words } : null, stop });
+      for (let a = pc + 1; a < next; a++) seen.add(a);
+      if (stop) break;
+      pc = next;
+    }
+  }
+  const out = [];
+  let last = null;
+  for (const pc of [...lines.keys()].sort((a, b) => a - b)) {
+    if (last !== null && pc !== last) out.push('');
+    if (targets.has(pc)) out.push('L' + hex(pc, 4) + ':');
+    out.push(hex(pc, 4) + '  ' + lines.get(pc).line);
+    last = lines.get(pc).end;
+  }
+  // what the walk never reached: tables, data, and code reached only through a table
+  const left = [];
+  for (let a = origin; a < origin + bytes.length; ) { if (seen.has(a)) { a++; continue; } const s = a; while (a < origin + bytes.length && !seen.has(a)) a++; left.push([s, a - s]); }
+  return { listing: out.join('\n'), left, reached: seen.size, size: bytes.length, lines, targets };
+}
+
+// The lifted code as a scene script, a step to a line, each line starting with the address it
+// came from. A call into the engine is a step with its inputs, the loads before it folded in.
+// Everything else is a statement on the registers a, x and y, the flags, and memory, written
+// $866A for an address, $86E4[y] for one indexed, and ($12)[y] for one through the zero page.
+// Each statement sets the flags as its instruction did, so a branch means what it meant:
+// a compare and the branch after it are one `if a == 1 goto L8157`, and a branch alone tests a
+// flag, `if zero goto L8157`. A jump through a table that the code writes into its own JMP is
+// `goto [$86EC y]`. The bytes the walk never reached are kept as `data` lines, up to where the
+// objects' tables begin: the objects come from those tables instead.
+export function script({ lines, targets, left }, bytes, origin, { stops = new Set(), selfModified = false, memory = false, moved = [] } = {}) {
+  const H = (n, w = 4) => '$' + hex(n, w);
+  // With `selfModified`, an instruction whose operand the code writes as it runs takes it from
+  // memory: an immediate is the byte at its own address, an address is [$0D19], the one the code
+  // keeps there, and a jump or a call goes through it. The places written are every address a
+  // store, an increment or a shift names; and `moved`, the bytes of instructions seen to change
+  // as the original ran (as the pilots find them), however the code wrote them (through a pointer, as
+  // Find Me does)
+  const written = new Set(moved);
+  if (selfModified) for (const r of lines.values()) if (/^(STA|STX|STY|INC|DEC|ASL|LSR|ROL|ROR)$/.test(r.op) && /^(abs|abx|aby)$/.test(r.mode)) written.add(r.value);
+  let here = null;   // the address of the instruction being written
+  // `memory`: code that other files write into, as the variables' file LIB.VARS, whose every
+  // instruction takes its operand from memory
+  const own = () => here !== null && (memory || written.has(here + 1) || written.has(here + 2));
+  const place = r => {
+    const v = r.value;
+    if (own() && r.mode === 'imm' && (memory || written.has(here + 1))) return H(here + 1);
+    if (own() && /^(abs|abx|aby)$/.test(r.mode)) return '[' + H(here + 1) + ']' + (r.mode === 'abs' ? '' : '[' + r.mode.at(-1) + ']');
+    switch (r.mode) {
+      case 'imm': return String(v);
+      case 'zp': return H(v, 2);
+      case 'zpx': return H(v, 2) + '[x]';
+      case 'zpy': return H(v, 2) + '[y]';
+      case 'abs': return H(v);
+      case 'abx': return H(v) + '[x]';
+      case 'aby': return H(v) + '[y]';
+      case 'izy': return '(' + H(v, 2) + ')[y]';
+      case 'izx': return '(' + H(v, 2) + '[x])';
+      case 'acc': return 'a';
+      default: return '?';
+    }
+  };
+  const label = a => 'L' + hex(a, 4);
+  const branch = { BEQ: 'zero', BNE: 'not zero', BCS: 'carry', BCC: 'not carry', BMI: 'negative', BPL: 'not negative', BVS: 'overflow', BVC: 'not overflow' };
+  const fused = { BEQ: '==', BNE: '!=', BCS: '>=', BCC: '<' };
+  const target = (pc, r) => (pc + 2 + (r.value << 24 >> 24)) & 0xffff;
+  const pcs = [...lines.keys()].sort((a, b) => a - b), out = [];
+  // An instruction that runs on into the bytes of another, as BIT $01A9 runs over the LDA #1 that
+  // a jump to its second byte finds: the next line is not where it goes on, so a goto says where.
+  const stopsHere = r => ['JMP', 'RTS', 'RTI'].includes(r.op);
+  targets = new Set(targets);
+  pcs.forEach((pc, i) => { const r = lines.get(pc); if (r.op && !stopsHere(r) && i + 1 < pcs.length && r.end !== pcs[i + 1] && lines.has(r.end)) targets.add(r.end); });
+  let loads = [];   // immediate loads waiting to be folded into the next call
+  const flush = () => { for (const [pc, reg, v] of loads) out.push(hex(pc, 4) + '  ' + reg + ' = ' + v); loads = []; };
+  let last = null;   // the instruction before, and where it goes on
+  for (let i = 0; i < pcs.length; i++) {
+    const pc = pcs[i], r = lines.get(pc), next = lines.get(pcs[i + 1]), put = s => out.push(hex(pc, 4) + '  ' + s);
+    here = pc;
+    if (last && last.op && !stopsHere(last) && last.end !== pc && lines.has(last.end)) { flush(); out.push(hex(last.pc, 4) + '  goto ' + label(last.end)); }
+    last = { ...r, pc: pcs[i] };
+    if (targets.has(pc)) { flush(); out.push(label(pc) + ':'); }
+    if (!r.op) { flush(); put('asm ' + r.line); continue; }
+    const reg = r.op.at(-1).toLowerCase();
+    if (r.call) {
+      const [name, ...fixed] = r.call.name.split(' ');
+      const takes = TAKES[name] || '';
+      const given = Object.fromEntries(loads.map(([, g, v]) => [g, v]));
+      // loads the call does not take stay as statements, before it
+      const kept = loads.filter(([, g]) => !takes.includes(g)); loads = kept; flush();
+      const args = [...fixed, ...[...takes].map(g => given[g] ?? g)];
+      if (name === 'objects' && given.x !== undefined && given.y !== undefined) args.splice(fixed.length, 2, H(given.x | given.y << 8));
+      if (name === 'key-at' || name === 'key') args[0] = given.a !== undefined ? JSON.stringify(String.fromCharCode(given.a & 0x7f)) : args[0];
+      put([name, ...args, r.call.words ?? ''].join(' ').trim());
+      continue;
+    }
+    switch (r.op) {
+      case 'LDA': case 'LDX': case 'LDY':
+        if (r.mode === 'imm' && !own()) { loads = loads.filter(([, g]) => g !== reg); loads.push([pc, reg, r.value]); break; }
+        // the jump through a table: LDA T,Y  STA J+1  LDA T+1,Y  STA J+2  J: JMP
+        if (r.mode === 'aby' || r.mode === 'abx') {
+          const [s1, l2, s2, j] = [1, 2, 3, 4].map(k => lines.get(pcs[i + k]));
+          if (s1?.op === 'STA' && l2?.op === 'LDA' && l2.value === r.value + 1 && s2?.op === 'STA' && j?.op === 'JMP' && s1.value === pcs[i + 4] + 1 && s2.value === pcs[i + 4] + 2) {
+            flush(); put('goto [' + H(r.value) + ' ' + r.mode.at(-1) + ']'); i += 4; last = null; break;
+          }
+        }
+        flush(); put(reg + ' = ' + place(r)); break;
+      case 'STA': case 'STX': case 'STY': flush(); put(place(r) + ' = ' + reg); break;
+      case 'TAX': case 'TAY': case 'TXA': case 'TYA': flush(); put(r.op[2].toLowerCase() + ' = ' + r.op[1].toLowerCase()); break;
+      case 'INX': case 'INY': case 'DEX': case 'DEY': flush(); put(reg + (r.op[0] === 'I' ? ' += 1' : ' -= 1')); break;
+      case 'INC': case 'DEC': flush(); put(place(r) + (r.op === 'INC' ? ' += 1' : ' -= 1')); break;
+      case 'CLC': case 'SEC': flush(); put('carry = ' + (r.op === 'SEC' ? 1 : 0)); break;
+      case 'ADC': flush(); put('a += ' + place(r) + ' + carry'); break;
+      case 'SBC': flush(); put('a -= ' + place(r) + ' + borrow'); break;
+      case 'AND': flush(); put('a &= ' + place(r)); break;
+      case 'ORA': flush(); put('a |= ' + place(r)); break;
+      case 'EOR': flush(); put('a ^= ' + place(r)); break;
+      case 'ASL': case 'LSR': case 'ROL': case 'ROR': flush(); put(place(r) + ' ' + { ASL: '<<= 1', LSR: '>>= 1', ROL: 'rotate left', ROR: 'rotate right' }[r.op]); break;
+      case 'BIT': flush(); put('test ' + place(r)); break;
+      case 'CMP': case 'CPX': case 'CPY': {
+        flush();
+        const who = r.op === 'CMP' ? 'a' : r.op[2].toLowerCase();
+        if (next && fused[next.op] && !targets.has(pcs[i + 1])) { put('if ' + who + ' ' + fused[next.op] + ' ' + place(r) + ' goto ' + label(target(pcs[i + 1], next))); i++; last = { ...next, pc: pcs[i] }; }
+        else put('compare ' + who + ' ' + place(r));
+        break;
+      }
+      case 'JMP': flush(); if (r.mode === 'abs' && own()) { put('goto (' + H(pc + 1) + ')'); break; } put(r.mode === 'abs' ? (r.value >= origin && r.value < origin + bytes.length ? 'goto ' + label(r.value) : 'goto-engine ' + H(r.value)) : 'goto (' + H(r.value) + ')'); break;
+      case 'JSR': flush(); if (own()) { put('call (' + H(pc + 1) + ')'); break; } put(r.value >= origin && r.value < origin + bytes.length ? 'call ' + label(r.value) : 'call-engine ' + H(r.value)); break;
+      case 'RTS': flush(); put('return'); break;
+      case 'PHA': case 'PLA': case 'PHP': case 'PLP': flush(); put({ PHA: 'push a', PLA: 'pull a', PHP: 'push flags', PLP: 'pull flags' }[r.op]); break;
+      case 'NOP': break;
+      default:
+        if (branch[r.op]) { flush(); put('if ' + branch[r.op] + ' goto ' + label(target(pc, r))); break; }
+        flush(); put('asm ' + r.line);
+    }
+  }
+  flush();
+  // each run of bytes the walk never reached, up to where the objects begin
+  for (const [a, whole] of left) {
+    let n = 0; while (n < whole && !(n && stops.has(a + n)) && !stops.has(a)) n++;
+    if (!n) continue;
+    const row = [];
+    for (let k = 0; k < n; k += 16) row.push('data ' + H(a + k) + ' ' + Array.from(bytes.subarray(a - origin + k, a - origin + Math.min(n, k + 16)), b => hex(b, 2)).join(' '));
+    out.push('', ...row);
+  }
+  return out.join('\n') + '\n';
+}
+

package/remake/load.js

@@ -0,0 +1,55 @@
+// One way to start a title's remake, for the remake's page (main.js), a replay and Node (a pilot's observer): the
+// title's title.js, from the folder it is in, with the modules it names (its problems, its paint); its scripts,
+// compiled to JavaScript (bin/moonbase-compile.mjs) or, with `scenes`, the scene files themselves to run line by line;
+// its game's data, from where the page keeps it; and an engine made from them.
+//
+//   const { title, scripts, disk, folder } = await loadTitle(folder, { data })
+//     folder   the title's folder, an absolute URL (its title.js, its scenes, compiled/, its own modules)
+//     data     its game's data, an absolute URL (<slug>.json: its disks' files, its kind, its saves)
+//   title.disk = disk; title.seed = 17                 (the caller's: a data disk, the seed)
+//   const engine = makeEngine(title, scripts)
+// With `fixed`, a title that has a version with its bugs fixed (its title.js `fixed`, a script for each it replaces)
+// runs those scripts in place of its own. A title whose engine is its own (its title.js `engine` the name of a module
+// in its folder, not 'card' or 'vector') has no scripts here: its engine is loaded with its other modules, as
+// `title.own`, and runs the game itself (main.js).
+import { Engine } from './engine.js';
+import { vectorRoutines } from './vector.js';
+import { cardRoutines } from './card.js';
+import { started } from '@moonbase-machines/apple2e/prodos.js';
+
+const ENGINES = { vector: vectorRoutines, card: cardRoutines };
+
+// a file read in the browser by fetch, and in Node from the disk (Node's own fs, asked of Node itself, so that the
+// browser's files import nothing of Node's)
+async function read(url, as) {
+  if (url.protocol === 'file:') { const text = globalThis.process.getBuiltinModule('node:fs').readFileSync(url, 'utf8'); return as === 'json' ? JSON.parse(text) : text; }
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`${url.pathname}: ${r.status}`);
+  return as === 'json' ? r.json() : r.text();
+}
+const defaultOf = async url => (await import(url.href)).default;
+
+export async function loadTitle(folder, { data, scenes = false, fixed = false } = {}) {
+  folder = new URL(folder);
+  const title = { ...(await defaultOf(new URL('title.js', folder))) };
+  // the modules a title has of its own, as its title.js names them (problems.js, paint.js), and its view's own
+  // drawing (view.js), where it says it has one
+  for (const name of title.modules ?? []) title[name] = await defaultOf(new URL(name + '.js', folder));
+  if (title.view) title.viewSteps = await defaultOf(new URL('view.js', folder));
+  if (!ENGINES[title.engine]) {
+    title.own = await import(new URL(title.engine + '.js', folder).href);
+    return { title, scripts: {}, disk: null, folder };
+  }
+  const scripts = Object.fromEntries(await Promise.all(title.scripts.map(async n =>
+    [n, scenes ? await read(new URL(n + '.scene', folder), 'text') : await defaultOf(new URL(`compiled/${(fixed && title.fixed?.[n]) || n}.js`, folder))])));
+  const disk = await read(new URL(data), 'json');
+  return { title, scripts, disk, folder };
+}
+
+export function makeEngine(title, scripts) {
+  // (a ProDOS title's memory starts with what ProDOS leaves, as the original's does)
+  const memory = { ...(title.disk?.kind === 'prodos' ? started(title.disk) : {}), ...title.memory };
+  const engine = new Engine({ routines: ENGINES[title.engine](title), scripts, start: title.start, label: title.startLabel, memory });
+  engine.title = title;
+  return engine;
+}

package/remake/main.js

@@ -0,0 +1,51 @@
+// The remake in the browser: one player for every title. The page gives it the title's folder and its game's data;
+// the player makes its part of the page, the stage the game is drawn on and the options line under it with the
+// game's status, loads the title (load.js), puts its stylesheet in the page where it has one, and hands the game to
+// its engine: the remake's own for a title of scenes, 'card' or 'vector' (scenes.js), or the title's own, a module in
+// its folder (its title.js `engine`), given the same. A failure is said in the status line.
+//
+//   await play({ title, data, root, disk, preview, words, watch, claim, pace, route, mini, roms })
+//     title      the title's folder, an absolute URL
+//     data       its game's data, an absolute URL (for a title of its own engine, the folder its data is in)
+//     root       the page's section the player is made in
+//     disk       the title's player's disk (disk/disk.js), opened before the player starts
+//     preview    the preview's build: what only it has may be used
+//     words      the page's words the player shows: { printer: { line, print, tear } }
+//     watch      called with the game, { engine, press, quick }, for a page that follows it
+//     claim      k => true to take a key of the player's before the game does
+//     pace       how much of the original's waits: 1 all (the default), 0 none, between a part of each; read at
+//                each wait
+//   and what only a workshop has, given by its pages, never looked for here:
+//     route      a route to play first, { route, keys }: its keys, and the pilots' key handling (expand, give,
+//                petscii, pollsAt)
+//     mini       a mini view for a title with an `inset`, (at, { memory }) => { mode(m) }
+//     roms       the makers' ROMs this machine has: { chargen } for a Commodore 64 title's characters
+//
+// What the engine is handed, its own engine's or the remake's, `game`: { title, scripts, disk, folder, stage,
+// options, status, fail, kept, preview, words, ...the page's options }; `stage` is its to draw in, `options` the
+// line its own controls go on, before the status.
+import { loadTitle } from './load.js';
+import { play as scenes } from './scenes.js';
+
+export async function play(options) {
+  const { title: folder, data, root, disk: kept, preview = false, words } = options;
+  root.classList.add('remake');
+  root.innerHTML = '<div class="stage"></div><p class="options"><span id="status">Loading.</span></p>';
+  const stage = root.querySelector('.stage'), line = root.querySelector('.options'), status = root.querySelector('#status');
+  const fail = err => { status.textContent = 'The remake stopped: ' + err.message; status.className = 'error'; console.error(err); };
+  try {
+    // ?fixed: the title with its bugs fixed, for one that has such a version (its title.js `fixed`)
+    const fixed = new URLSearchParams(location.search).has('fixed');
+    const { title, scripts, disk } = await loadTitle(folder, { data, fixed });
+    title.disk = disk;
+    // the title's own styles, where it has them (its title.js `style`, a file in its folder), in place before it
+    // draws by them
+    if (title.style && !document.querySelector(`link[data-title="${title.slug}"]`)) {
+      const link = Object.assign(document.createElement('link'), { rel: 'stylesheet', href: new URL(title.style, folder).href });
+      link.dataset.title = title.slug; document.head.append(link);
+      await new Promise(done => { link.onload = link.onerror = done; });
+    }
+    const game = { ...options, title, scripts, disk, folder, data, stage, options: line, status, fail, kept, preview, words, fixed };
+    await (title.own ?? { play: scenes }).play(game);
+  } catch (err) { fail(err); }
+}

package/remake/problems.js

@@ -0,0 +1,43 @@
+// A problem, rewritten for the remake: a generator function that takes the problem's helpers
+// and yields whenever it waits for a key. Its steps are the same routines the scripts use, so
+// they give the same events; a problem's own drawing routines are steps of their own, named in
+// its title's map (`problems`), which the view draws however it likes.
+//
+//   function* (p) { yield* p.call('text', 'Hello'); const { x } = yield* p.call('ask', 202); }
+import { describe } from './events.js';
+
+export function helpers(e, routines) {
+  const zero = e.title.map.vars.zero;
+  // a step: run its routine, and wait for as long as it waits
+  function* call(name, ...args) {
+    const token = { words: [name] };   // what the view reads to know what the problem waits for
+    const words = args.map(a => typeof a === 'string' && name === 'text' ? { string: a } : typeof a === 'number' ? String(a) : a);
+    for (;;) {
+      const r = routines[name](e, words, token);
+      if (r !== 'wait') return { a: e.a, x: e.x, y: e.y, c: e.c };
+      yield 'wait';
+    }
+  }
+  // a problem's own drawing routine: its event, and what it leaves for the view
+  // and the title's painter for it, if it has one (titles/<title>/paint.js), paints it into the
+  // model of the original's screen
+  const drawn = (name, a = 0, x, y) => { e.a = a & 0xff; if (x !== undefined) e.x = x & 0xff; if (y !== undefined) e.y = y & 0xff; e.title.paint?.[name]?.(e.title.model, e); e.emit(describe(name, [], e, undefined, z => e.mem[z + zero], a => e.mem[a])); };
+  // A key, for a problem that reads keys itself: it waits, and the view shows what `kind` of wait
+  // it is, 'wait' for the space bar's button or 'ask' for the keys e.askMode asks for.
+  function* key(kind = 'wait') {
+    const token = { words: [kind] };
+    for (;;) {
+      const k = e.key();
+      // control-E: the Main Menu, from the key reader, as at any key the original read
+      if (k === 5 && e.title?.menu) e.leave(...e.title.menu);
+      // control-E or control-T in Nature Park: its menus, and back to waiting here
+      if (e.title?.visit?.[k]) { e.visit(k); e.waitingOn = token; yield 'wait'; continue; }
+      if (k !== undefined) { e.waitingOn = null; return k; }
+      e.waitingOn = token;
+      yield 'wait';
+    }
+  }
+  // steps done inside a routine of the problem's own: drawn, and no steps of the transcript
+  function* inside(run) { e.inside++; try { return yield* run; } finally { e.inside--; } }
+  return { e, mem: e.mem, call, drawn, key, inside };
+}