jsbeeb 1.11.0 → 1.13.0

package/src/keyboard.js

@@ -1,6 +1,6 @@
 "use strict";
 import * as utils from "./utils.js";
-import EventEmitter from "event-emitter-es6";
+import { ATOM } from "./utils_atom.js";
 
 const isMac = typeof window !== "undefined" && /^Mac/i.test(window.navigator?.platform || "");
 
@@ -15,7 +15,7 @@ const isMac = typeof window !== "undefined" && /^Mac/i.test(window.navigator?.pl
 /**
  * Keyboard class that handles all keyboard related functionality
  */
-export class Keyboard extends EventEmitter {
+export class Keyboard extends EventTarget {
     /**
      * Create a new Keyboard instance with specified configuration
      * @param {KeyboardConfig} config - The configuration object
@@ -29,6 +29,14 @@ export class Keyboard extends EventEmitter {
         this.inputEnabledFunction = inputEnabledFunction;
         this.dbgr = dbgr;
 
+        // Key interface: routes key events to SysVia (BBC) or PPIA (Atom).
+        // Both provide keyDown, keyUp, keyToggleRaw, setKeyLayout,
+        // clearKeys, disableKeyboard, enableKeyboard.
+        this.keyInterface = processor.model.isAtom ? processor.atomppia : processor.sysvia;
+        // The SHIFT key constant used by stringToMachineKeys in the paste key array.
+        // Compared by reference in _deliverPasteKey to avoid toggling shift off.
+        this._shiftKey = processor.model.isAtom ? ATOM.SHIFT : utils.BBC.SHIFT;
+
         // State
         this.emuKeyHandlers = {};
         this.running = false;
@@ -134,7 +142,7 @@ export class Keyboard extends EventEmitter {
      */
     setKeyLayout(layout) {
         this.keyLayout = layout;
-        this.processor.sysvia.setKeyLayout(layout);
+        this.keyInterface.setKeyLayout(layout);
     }
 
     /**
@@ -182,7 +190,7 @@ export class Keyboard extends EventEmitter {
         // Handle debugger 'g' key press
         if (this.dbgr.enabled() && code === LOWERCASE_G) {
             this.dbgr.hide();
-            this.emit("resume");
+            this.dispatchEvent(new Event("resume"));
             return;
         }
 
@@ -193,7 +201,7 @@ export class Keyboard extends EventEmitter {
                 return;
             } else if (code === LOWERCASE_N) {
                 this.requestStep();
-                this.emit("resume");
+                this.dispatchEvent(new Event("resume"));
                 return;
             }
         }
@@ -226,7 +234,7 @@ export class Keyboard extends EventEmitter {
         const isSpecialHandled = this._handleSpecialKeys(code);
         if (isSpecialHandled) return;
 
-        // Check for registered handlers first; if one fires, don't also send to the BBC.
+        // Check for registered handlers first; if one fires, don't pass to the emulator.
         // This lets Alt+key and Ctrl+key handlers cleanly own their keys without the
         // underlying key leaking through to the emulated machine.
         const handler = this._findKeyHandler(code, evt.altKey, evt.ctrlKey);
@@ -235,8 +243,8 @@ export class Keyboard extends EventEmitter {
             return;
         }
 
-        // No handler claimed the key — pass it to the BBC Micro.
-        this.processor.sysvia.keyDown(code, evt.shiftKey);
+        // No handler claimed the key; pass it to the emulated machine.
+        this.keyInterface.keyDown(code, evt.shiftKey);
     }
 
     /**
@@ -247,7 +255,7 @@ export class Keyboard extends EventEmitter {
      */
     _handleSpecialKeys(code) {
         if (code === utils.keyCodes.F12 || code === utils.keyCodes.BREAK) {
-            this.emit("break", true);
+            this.dispatchEvent(new CustomEvent("break", { detail: true }));
             this.processor.setReset(true);
             return true;
         } else if (isMac && code === utils.keyCodes.CAPSLOCK) {
@@ -269,7 +277,7 @@ export class Keyboard extends EventEmitter {
 
         // Always let the key ups come through to avoid sticky keys in the debugger
         const code = this.keyCode(evt);
-        this.processor.sysvia.keyUp(code);
+        this.keyInterface.keyUp(code);
 
         // No further special handling needed if not running
         if (!this.running) return;
@@ -278,7 +286,7 @@ export class Keyboard extends EventEmitter {
 
         // Handle special key cases
         if (code === utils.keyCodes.F12 || code === utils.keyCodes.BREAK) {
-            this.emit("break", false);
+            this.dispatchEvent(new CustomEvent("break", { detail: false }));
             this.processor.setReset(false);
             return;
         } else if (isMac && code === utils.keyCodes.CAPSLOCK) {
@@ -302,39 +310,44 @@ export class Keyboard extends EventEmitter {
 
         // Mac browsers seem to model caps lock as a physical key that's down when capslock is on, and up when it's off.
         // No event is generated when it is physically released on the keyboard. So, we simulate a "tap" here.
-        this.processor.sysvia.keyDown(utils.keyCodes.CAPSLOCK);
+        this.keyInterface.keyDown(utils.keyCodes.CAPSLOCK);
 
         // Simulate a key release after a short delay
-        setTimeout(() => this.processor.sysvia.keyUp(utils.keyCodes.CAPSLOCK), CAPS_LOCK_DELAY);
+        setTimeout(() => this.keyInterface.keyUp(utils.keyCodes.CAPSLOCK), CAPS_LOCK_DELAY);
 
         if (isMac && window.localStorage && !window.localStorage.getItem("warnedAboutRubbishMacs")) {
-            this.emit("showError", {
-                context: "handling caps lock on Mac OS X",
-                error: `Mac OS X does not generate key up events for caps lock presses. 
-                jsbeeb can only simulate a 'tap' of the caps lock key. This means it doesn't work well for games 
-                that use caps lock for left or fire, as we can't tell if it's being held down. If you need to play 
+            this.dispatchEvent(
+                new CustomEvent("showError", {
+                    detail: {
+                        context: "handling caps lock on Mac OS X",
+                        error: `Mac OS X does not generate key up events for caps lock presses.
+                jsbeeb can only simulate a 'tap' of the caps lock key. This means it doesn't work well for games
+                that use caps lock for left or fire, as we can't tell if it's being held down. If you need to play
                 such a game, please see the documentation about remapping keys.
                 Close this window to continue (you won't see this error again)`,
-            });
+                    },
+                }),
+            );
             window.localStorage.setItem("warnedAboutRubbishMacs", "true");
         }
     }
 
     /**
-     * Send raw keyboard input to the BBC
-     * @param {Array} keysToSend - Array of keys to send
+     * Send raw keyboard input to the emulated machine (for paste/autotype).
+     * @param {Array} keysToSend - Array of machine-specific key codes to send
      * @param {boolean} checkCapsAndShiftLocks - Whether to check caps and shift locks
      */
-    sendRawKeyboardToBBC(keysToSend, checkCapsAndShiftLocks) {
+    sendRawKeyboard(keysToSend, checkCapsAndShiftLocks) {
         if (this.isPasting) this.cancelPaste();
 
-        this.processor.sysvia.disableKeyboard();
-        this._pasteClocksPerMs = Math.floor(this.processor.cpuMultiplier * 2000000) / 1000;
+        this.keyInterface.disableKeyboard();
+        this._pasteClocksPerMs =
+            Math.floor(this.processor.cpuMultiplier * this.processor.peripheralCyclesPerSecond) / 1000;
 
         if (checkCapsAndShiftLocks) {
             let toggleKey = null;
-            if (!this.processor.sysvia.capsLockLight) toggleKey = utils.BBC.CAPSLOCK;
-            else if (this.processor.sysvia.shiftLockLight) toggleKey = utils.BBC.SHIFTLOCK;
+            if (!this.keyInterface.capsLockLight) toggleKey = utils.BBC.CAPSLOCK;
+            else if (this.keyInterface.shiftLockLight) toggleKey = utils.BBC.SHIFTLOCK;
             if (toggleKey) {
                 keysToSend.unshift(toggleKey);
                 keysToSend.push(toggleKey);
@@ -353,13 +366,22 @@ export class Keyboard extends EventEmitter {
      * @private
      */
     _deliverPasteKey() {
-        if (this._pasteLastChar && this._pasteLastChar !== utils.BBC.SHIFT) {
-            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+        if (this._pasteLastChar && this._pasteLastChar !== this._shiftKey) {
+            this.keyInterface.keyToggleRaw(this._pasteLastChar);
         }
 
         if (this._pasteKeys.length === 0) {
             this._pasteLastChar = undefined;
-            this.processor.sysvia.enableKeyboard();
+            this.keyInterface.enableKeyboard();
+            return;
+        }
+
+        // Atom's PPIA keyboard is polled, not interrupt-driven like the BBC's
+        // SysVIA. Insert a debounce gap after every key release so the ROM
+        // sees the key-up before the next key-down arrives.
+        if (this._pasteLastChar && this._pasteLastChar !== this._shiftKey && this.processor.model.isAtom) {
+            this._pasteLastChar = undefined;
+            this._pasteTask.schedule(30 * this._pasteClocksPerMs);
             return;
         }
 
@@ -372,12 +394,15 @@ export class Keyboard extends EventEmitter {
             return;
         }
 
-        let delayMs = 50;
+        // Atom ROM polls the keyboard once per VSync (~16ms at 60 Hz).
+        // 80ms gives the ROM ~5 scan cycles to detect, debounce, and
+        // process each keypress.
+        let delayMs = this.processor.model.isAtom ? 80 : 50;
         if (typeof this._pasteLastChar === "number") {
             delayMs = this._pasteLastChar;
             this._pasteLastChar = undefined;
         } else {
-            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+            this.keyInterface.keyToggleRaw(this._pasteLastChar);
         }
 
         this._pasteKeys.shift();
@@ -390,12 +415,12 @@ export class Keyboard extends EventEmitter {
     cancelPaste() {
         if (!this.isPasting) return;
         this._pasteTask.cancel();
-        if (this._pasteLastChar && this._pasteLastChar !== utils.BBC.SHIFT) {
-            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+        if (this._pasteLastChar && this._pasteLastChar !== this._shiftKey) {
+            this.keyInterface.keyToggleRaw(this._pasteLastChar);
         }
         this._pasteLastChar = undefined;
         this._pasteKeys = [];
-        this.processor.sysvia.enableKeyboard();
+        this.keyInterface.enableKeyboard();
     }
 
     /**
@@ -410,7 +435,7 @@ export class Keyboard extends EventEmitter {
      * Clears all pressed keys
      */
     clearKeys() {
-        this.processor.sysvia.clearKeys();
+        this.keyInterface.clearKeys();
     }
 
     /**
@@ -437,7 +462,7 @@ export class Keyboard extends EventEmitter {
      */
     pauseEmulation() {
         this.pauseEmu = true;
-        this.emit("pause");
+        this.dispatchEvent(new Event("pause"));
     }
 
     /**
@@ -445,6 +470,6 @@ export class Keyboard extends EventEmitter {
      */
     resumeEmulation() {
         this.pauseEmu = false;
-        this.emit("resume");
+        this.dispatchEvent(new Event("resume"));
     }
 }

package/src/machine-session.js

@@ -9,7 +9,7 @@ import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import path from "path";
 import { TestMachine } from "../tests/test-machine.js";
-import { InstrumentedSoundChip } from "./soundchip.js";
+import { InstrumentedSoundChip, FakeSoundChip } from "./soundchip.js";
 
 // Resolve the jsbeeb package root from our own location (src/machine-session.js
 // → go up one level).  Passed to setNodeBasePath() so the ROM loader resolves
@@ -46,22 +46,31 @@ export class MachineSession {
 
         // Create a real Video instance so we get pixel output
         const modelObj = findModel(modelName);
-        this._video = new Video(modelObj.isMaster, this._fb32, (minx, miny, maxx, maxy) => {
-            this._lastPaint = { minx, miny, maxx, maxy };
-            this._frameDirty = true;
-            // Snapshot the complete frame now, before clearPaintBuffer() wipes _fb32.
-            // This mirrors what the browser does: paint_ext fires → canvas updated → fb32 cleared.
-            this._completeFb8.set(this._fb8);
-        });
-
-        // Use a real (instrumented) sound chip so we can read registers and capture writes
-        this._soundChip = new InstrumentedSoundChip();
+        this._isAtom = modelObj.isAtom;
+        this._video = new Video(
+            modelObj.isMaster,
+            this._fb32,
+            (minx, miny, maxx, maxy) => {
+                this._lastPaint = { minx, miny, maxx, maxy };
+                this._frameDirty = true;
+                // Snapshot the complete frame now, before clearPaintBuffer() wipes _fb32.
+                // This mirrors what the browser does: paint_ext fires → canvas updated → fb32 cleared.
+                this._completeFb8.set(this._fb8);
+            },
+            { isAtom: modelObj.isAtom },
+        );
+
+        // Use a real (instrumented) sound chip so we can read registers and capture writes.
+        // Atom models use AtomSoundChip which has a different interface (speakerGenerator,
+        // toneGenerator); FakeSoundChip provides compatible no-op stubs for headless mode.
+        this._soundChip = modelObj.isAtom ? new FakeSoundChip() : new InstrumentedSoundChip();
 
         // TestMachine forwards opts.video and opts.soundChip to fake6502
         this._machine = new TestMachine(modelName, { video: this._video, soundChip: this._soundChip });
 
         // Accumulated VDU text output — drained by callers
         this._pendingOutput = [];
+        this._flushCapture = () => {};
 
         // Breakpoint management — persistent hooks that survive across run calls
         this._breakpoints = new Map(); // id → { hook, type, address, hit }
@@ -90,8 +99,9 @@ export class MachineSession {
     /**
      * Install the VDU character-output capture hook.
      *
-     * WRCHV discovery: RAM at 0x20E/0x20F initialises to 0xFFFF before the
-     * OS runs.  We read directly from cpu.ramRomOs (two array lookups — no
+     * WRCHV discovery: RAM at the OS write-character vector (0x20E on BBC,
+     * 0x208 on Atom) initialises to 0x0000 before the OS runs.  We read
+     * directly from cpu.ramRomOs (two array lookups — no
      * readmem() dispatch overhead) on every instruction, waiting for the
      * value to change from its initial 0xFFFF.  Once the OS installs a real
      * handler we use that address for the lifetime of the session.  Programs
@@ -105,7 +115,9 @@ export class MachineSession {
     _installCaptureHook() {
         const cpu = this._machine.processor;
         const ram = cpu.ramRomOs; // direct Uint8Array — no dispatch overhead
-        const initialWrchv = ram[0x20e] | (ram[0x20f] << 8); // 0xFFFF pre-boot
+        // WRCHV vector: BBC at $020E, Atom at $0208.
+        const wrchvAddr = this._isAtom ? 0x208 : 0x20e;
+        const initialWrchv = ram[wrchvAddr] | (ram[wrchvAddr + 1] << 8); // 0xFFFF pre-boot
 
         const attributes = { x: 0, y: 0, text: "", foreground: 7, background: 0, mode: 7 };
         let currentText = "";
@@ -124,6 +136,12 @@ export class MachineSession {
             currentText = "";
         }
 
+        // Expose flush so drainOutput can capture trailing text
+        // that hasn't been terminated by a control character.
+        this._flushCapture = flush;
+
+        const isAtom = this._isAtom;
+
         function onChar(c) {
             if (nextN) {
                 params.push(c);
@@ -135,9 +153,6 @@ export class MachineSession {
                 return;
             }
             switch (c) {
-                case 1: // next char to printer only
-                    nextN = 1;
-                    break;
                 case 10: // LF
                     flush();
                     attributes.y++;
@@ -151,48 +166,58 @@ export class MachineSession {
                     flush();
                     attributes.x = 0;
                     break;
-                case 17: // COLOUR n
-                    nextN = 1;
-                    vduProc = (p) => {
-                        if (p[0] & 0x80) attributes.background = p[0] & 0xf;
-                        else attributes.foreground = p[0] & 0xf;
-                    };
-                    break;
-                case 18: // GCOL
-                    nextN = 2;
-                    break;
-                case 19: // define logical colour
-                    nextN = 5;
-                    break;
-                case 22: // MODE n
-                    nextN = 1;
-                    vduProc = (p) => {
-                        flush();
-                        attributes.mode = p[0];
-                        attributes.x = 0;
-                        attributes.y = 0;
-                        attributes.foreground = 7;
-                        attributes.background = 0;
-                    };
-                    break;
-                case 25: // PLOT
-                    nextN = 5;
-                    break;
-                case 28: // define text window
-                    nextN = 4;
-                    break;
-                case 29: // define graphics origin
-                    nextN = 4;
-                    break;
-                case 31: // TAB(x,y)
-                    nextN = 2;
-                    vduProc = (p) => {
-                        flush();
-                        attributes.x = p[0];
-                        attributes.y = p[1];
-                    };
-                    break;
                 default:
+                    // BBC VDU control codes (multi-byte sequences).
+                    // The Atom doesn't use these; skip them to avoid
+                    // swallowing printable characters.
+                    if (!isAtom) {
+                        switch (c) {
+                            case 1: // next char to printer only
+                                nextN = 1;
+                                return;
+                            case 17: // COLOUR n
+                                nextN = 1;
+                                vduProc = (p) => {
+                                    if (p[0] & 0x80) attributes.background = p[0] & 0xf;
+                                    else attributes.foreground = p[0] & 0xf;
+                                };
+                                return;
+                            case 18: // GCOL
+                                nextN = 2;
+                                return;
+                            case 19: // define logical colour
+                                nextN = 5;
+                                return;
+                            case 22: // MODE n
+                                nextN = 1;
+                                vduProc = (p) => {
+                                    flush();
+                                    attributes.mode = p[0];
+                                    attributes.x = 0;
+                                    attributes.y = 0;
+                                    attributes.foreground = 7;
+                                    attributes.background = 0;
+                                };
+                                return;
+                            case 25: // PLOT
+                                nextN = 5;
+                                return;
+                            case 28: // define text window
+                                nextN = 4;
+                                return;
+                            case 29: // define graphics origin
+                                nextN = 4;
+                                return;
+                            case 31: // TAB(x,y)
+                                nextN = 2;
+                                vduProc = (p) => {
+                                    flush();
+                                    attributes.x = p[0];
+                                    attributes.y = p[1];
+                                };
+                                return;
+                        }
+                    }
                     if (c >= 32 && c < 0x7f) {
                         currentText += String.fromCharCode(c);
                     } else {
@@ -207,7 +232,7 @@ export class MachineSession {
             // Once the OS sets WRCHV (it changes from 0xFFFF), we start
             // capturing.  Programs that install a custom VDU driver mid-run
             // are handled transparently because we re-read on every call.
-            const wrchv = ram[0x20e] | (ram[0x20f] << 8);
+            const wrchv = ram[wrchvAddr] | (ram[wrchvAddr + 1] << 8);
             if (wrchv !== initialWrchv && addr === wrchv) {
                 onChar(cpu.a);
             }
@@ -391,6 +416,7 @@ export class MachineSession {
      * Also includes a flat `screenText` reconstruction.
      */
     drainOutput({ clear = true } = {}) {
+        this._flushCapture();
         const elements = clear ? this._pendingOutput.splice(0) : [...this._pendingOutput];
         return {
             elements,