jsbeeb 1.5.0 → 1.6.0

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "//": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": "22"

package/src/6502.js

@@ -1130,6 +1130,90 @@ export class Cpu6502 extends Base6502 {
         this.resetLine = !resetOn;
     }
 
+    snapshotState() {
+        return {
+            // CPU registers
+            a: this.a,
+            x: this.x,
+            y: this.y,
+            s: this.s,
+            pc: this.pc,
+            p: this.p.asByte(),
+            nmiLevel: this._nmiLevel,
+            nmiEdge: this._nmiEdge,
+            halted: this.halted,
+            takeInt: this.takeInt,
+            // Memory control
+            romsel: this.romsel,
+            acccon: this.acccon,
+            videoDisplayPage: this.videoDisplayPage,
+            // Cycle tracking
+            currentCycles: this.currentCycles,
+            targetCycles: this.targetCycles,
+            cycleSeconds: this.cycleSeconds,
+            peripheralCycles: this.peripheralCycles,
+            videoCycles: this.videoCycles,
+            music5000PageSel: this.music5000PageSel,
+            // RAM only (ROMs don't change at runtime)
+            ram: this.ramRomOs.slice(0, this.romOffset),
+            // Sub-component state
+            scheduler: this.scheduler.snapshotState(),
+            sysvia: this.sysvia.snapshotState(),
+            uservia: this.uservia.snapshotState(),
+            video: this.video.snapshotState(),
+            soundChip: this.soundChip.snapshotState(),
+            acia: this.acia.snapshotState(),
+            adc: this.adconverter.snapshotState(),
+        };
+    }
+
+    restoreState(state) {
+        // 1. Scheduler epoch first (so task offsets resolve correctly)
+        this.scheduler.restoreState(state.scheduler);
+
+        // 2. CPU registers
+        this.a = state.a;
+        this.x = state.x;
+        this.y = state.y;
+        this.s = state.s;
+        this.pc = state.pc;
+        this.p.setFromByte(state.p);
+        // interrupt is rebuilt by sub-component restores (VIA updateIFR, ACIA updateIrq)
+        this.interrupt = 0;
+        this._nmiLevel = state.nmiLevel;
+        this._nmiEdge = state.nmiEdge;
+        this.halted = state.halted;
+        this.takeInt = state.takeInt;
+
+        // 3. Memory
+        this.ramRomOs.set(state.ram);
+        // Load ROMs if present (e.g. from BEM snapshot import)
+        if (state.roms) {
+            this.ramRomOs.set(state.roms.slice(0, 16 * 16384), this.romOffset);
+        }
+        this.videoDisplayPage = state.videoDisplayPage;
+        this.music5000PageSel = state.music5000PageSel;
+
+        // 4. Rebuild memStat/memLook from romsel/acccon
+        this.romSelect(state.romsel);
+        if (this.model.isMaster) this.writeAcccon(state.acccon);
+
+        // 5. Cycle tracking
+        this.currentCycles = state.currentCycles;
+        this.targetCycles = state.targetCycles;
+        this.cycleSeconds = state.cycleSeconds;
+        this.peripheralCycles = state.peripheralCycles;
+        this.videoCycles = state.videoCycles;
+
+        // 6. Sub-components (these re-register scheduler tasks)
+        this.sysvia.restoreState(state.sysvia);
+        this.uservia.restoreState(state.uservia);
+        this.video.restoreState(state.video);
+        this.soundChip.restoreState(state.soundChip);
+        this.acia.restoreState(state.acia);
+        this.adconverter.restoreState(state.adc);
+    }
+
     reset(hard) {
         if (hard) {
             // On the Master, opcodes executing from 0xc000 - 0xdfff can optionally have their memory accesses

package/src/acia.js

@@ -197,6 +197,48 @@ export class Acia {
         this.updateIrq();
     }
 
+    snapshotState() {
+        const scheduler = this.txCompleteTask.scheduler;
+        return {
+            sr: this.sr,
+            cr: this.cr,
+            dr: this.dr,
+            rs423Selected: this.rs423Selected,
+            motorOn: this.motorOn,
+            tapeCarrierCount: this.tapeCarrierCount,
+            tapeDcdLineLevel: this.tapeDcdLineLevel,
+            hadDcdHigh: this.hadDcdHigh,
+            serialReceiveRate: this.serialReceiveRate,
+            serialReceiveCyclesPerByte: this.serialReceiveCyclesPerByte,
+            txCompleteTaskOffset: this.txCompleteTask.scheduled()
+                ? this.txCompleteTask.expireEpoch - scheduler.epoch
+                : null,
+            runTapeTaskOffset: this.runTapeTask.scheduled() ? this.runTapeTask.expireEpoch - scheduler.epoch : null,
+            runRs423TaskOffset: this.runRs423Task.scheduled() ? this.runRs423Task.expireEpoch - scheduler.epoch : null,
+        };
+    }
+
+    restoreState(state) {
+        this.sr = state.sr;
+        this.cr = state.cr;
+        this.dr = state.dr;
+        this.rs423Selected = state.rs423Selected;
+        this.motorOn = state.motorOn;
+        this.tapeCarrierCount = state.tapeCarrierCount;
+        this.tapeDcdLineLevel = state.tapeDcdLineLevel;
+        this.hadDcdHigh = state.hadDcdHigh;
+        this.serialReceiveRate = state.serialReceiveRate;
+        this.serialReceiveCyclesPerByte = state.serialReceiveCyclesPerByte;
+        this.updateIrq();
+
+        this.txCompleteTask.cancel();
+        this.runTapeTask.cancel();
+        this.runRs423Task.cancel();
+        if (state.txCompleteTaskOffset !== null) this.txCompleteTask.schedule(state.txCompleteTaskOffset);
+        if (state.runTapeTaskOffset !== null) this.runTapeTask.schedule(state.runTapeTaskOffset);
+        if (state.runRs423TaskOffset !== null) this.runRs423Task.schedule(state.runRs423TaskOffset);
+    }
+
     setTape(tape) {
         this.tape = tape;
     }

package/src/adc.js

@@ -99,6 +99,28 @@ export class Adc {
         }
     }
 
+    snapshotState() {
+        const scheduler = this.task.scheduler;
+        return {
+            status: this.status,
+            low: this.low,
+            high: this.high,
+            taskOffset: this.task.scheduled() ? this.task.expireEpoch - scheduler.epoch : null,
+        };
+    }
+
+    restoreState(state) {
+        this.status = state.status;
+        this.low = state.low;
+        this.high = state.high;
+        this.task.cancel();
+        if (state.taskOffset !== null) {
+            this.task.schedule(state.taskOffset);
+            // Conversion in progress: CB1 should be high (set by write(), cleared by onComplete())
+            this.sysvia.setcb1(true);
+        }
+    }
+
     /**
      * Read from the ADC registers
      * @param {number} addr - The address to read from

package/src/app/app.js

@@ -230,6 +230,30 @@ const template = [
                 click: showModal("configuration"),
             },
             { type: "separator" },
+            {
+                label: "Save State...",
+                accelerator: "CmdOrCtrl+S",
+                click: sendAction("save-state"),
+            },
+            {
+                label: "Load State...",
+                accelerator: "CmdOrCtrl+O",
+                click: async (_, browserWindow) => {
+                    const result = await dialog.showOpenDialog(browserWindow, {
+                        title: "Load emulator state",
+                        filters: [
+                            { name: "Snapshot files", extensions: ["gz", "json", "snp"] },
+                            { name: "All files", extensions: ["*"] },
+                        ],
+                        properties: ["openFile"],
+                    });
+                    if (!result.canceled) {
+                        const filePath = getFileParam(result.filePaths[0]);
+                        browserWindow.webContents.send("load-state", { path: filePath });
+                    }
+                },
+            },
+            { type: "separator" },
             {
                 label: "Soft Reset",
                 click: sendAction("soft-reset"),

package/src/app/electron.js

@@ -6,7 +6,7 @@
 export let initialise = function () {};
 
 function init(args) {
-    const { loadDiscImage, loadTapeImage, processor, modals, actions, config } = args;
+    const { loadDiscImage, loadTapeImage, loadStateFile, processor, modals, actions, config } = args;
     const api = window.electronAPI;
 
     api.onLoadDisc(async (message) => {
@@ -34,6 +34,15 @@ function init(args) {
         }
     });
 
+    api.onLoadState(async (message) => {
+        if (loadStateFile) {
+            const response = await fetch(message.path);
+            const blob = await response.blob();
+            const file = new File([blob], message.path.split("/").pop());
+            await loadStateFile(file);
+        }
+    });
+
     // Observe model name changes and update window title
     const modelElement = document.querySelector(".bbc-model");
     if (modelElement) {

package/src/app/preload.js

@@ -7,6 +7,7 @@ contextBridge.exposeInMainWorld("electronAPI", {
     onLoadTape: (callback) => ipcRenderer.on("load-tape", (event, message) => callback(message)),
     onShowModal: (callback) => ipcRenderer.on("show-modal", (event, message) => callback(message)),
     onAction: (callback) => ipcRenderer.on("action", (event, message) => callback(message)),
+    onLoadState: (callback) => ipcRenderer.on("load-state", (event, message) => callback(message)),
     setTitle: (title) => ipcRenderer.send("set-title", title),
     saveSettings: (settings) => ipcRenderer.send("save-settings", settings),
 });