jsbeeb 1.22.3 → 1.22.4

package/package.json

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

package/src/6502.js

@@ -1195,6 +1195,7 @@ export class Cpu6502 extends Base6502 {
             while (this.model.swram[romIndex]) {
                 romIndex--;
             }
+            if (romIndex < 0) throw new Error("Too many extra ROMs (no free sideways ROM banks)");
 
             awaiting.push(this.loadRom(extraRoms[i_2], this.romOffset + romIndex * 16384));
         }
@@ -1823,7 +1824,11 @@ export class AtomCpu6502 extends Cpu6502 {
 
     // Override loadRom to accept 4KB ROMs
     async loadRom(name, offset) {
-        const data = await utils.loadData("roms/" + name);
+        if (name.indexOf("http") !== 0) name = "roms/" + name;
+        let data = await utils.loadData(name);
+        if (/\.zip/i.test(name)) {
+            data = (await utils.unzipRomImage(data)).data;
+        }
         const len = data.length;
         if (len !== 16384 && len !== 8192 && len !== 4096) {
             throw new Error(`Broken ROM file ${name} (length=${len})`);

package/src/cmos.js

@@ -9,11 +9,11 @@
 // STNICC-beeb to hang on the Master 128 because the WD1770 seek overran the
 // vsync window.  Confirmed by @tom-seddon (b2 emulator):
 // https://github.com/mattgodbolt/jsbeeb/issues/576
-const defaultCmos = [
+const defaultCmos = Object.freeze([
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0xeb, 0x00,
     0xc9, 0xff, 0xff, 0x12, 0x00, 0x17, 0xc8, 0x1e, 0x05, 0x00, 0x35, 0xa6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-];
+]);
 
 let timeOffset = 0;
 
@@ -82,7 +82,7 @@ export class Cmos {
         this.cmosAddr = 0;
 
         if (!this.store) {
-            this.store = defaultCmos;
+            this.store = [...defaultCmos];
         }
         if (cmosOverride) {
             this.store = cmosOverride(this.store);

package/src/main.js

@@ -50,6 +50,7 @@ let secondDiscImage = null;
 const { discImage: queryDiscImage, secondDiscImage: querySecondDisc, mmcImage } = parseMediaParams(parsedQuery);
 if (queryDiscImage) discImage = queryDiscImage;
 if (querySecondDisc) secondDiscImage = querySecondDisc;
+const defaultBootDisc = queryDiscImage ? undefined : discImage;
 const { settings: driveTracks, warnings: driveTrackWarnings } = processDriveTrackParams(parsedQuery);
 
 const extraRoms = [];
@@ -276,6 +277,7 @@ const snapshots = new SnapshotUI({
     urlState,
     modals,
     loop,
+    defaultBootDisc,
 });
 
 const inputs = new AnalogueInputs({
@@ -392,6 +394,7 @@ document.getElementById("soft-reset").addEventListener("click", function (event)
 });
 
 document.getElementById("download-filestore-link").addEventListener("click", function () {
+    if (!processor.filestore) return;
     downloadDriveData(processor.filestore.scsi, "scsi", ".dat");
 });
 

package/src/web/debug.js

@@ -89,6 +89,48 @@ class MemoryView {
     }
 }
 
+/**
+ * Guesses the address of the instruction before the given one by scoring each
+ * possible run of instructions leading up to it: a point per "common"
+ * instruction (loads, stores, branches, compares, arithmetic and
+ * carry-set/clear that avoid unusual indexing modes) and a large boost for a
+ * run that passes through the current program counter. The highest-scoring
+ * run wins and its last instruction is the answer.
+ * Good test cases:
+ *   Repton 2 @ 2cbb
+ *   MOS @ cfc8
+ * also, just starting from the back of ROM and going up...
+ */
+export function prevInstruction(disassemble, pc, address) {
+    const commonInstructions =
+        /(RTS|B..|JMP|JSR|LD[AXY]|ST[AXY]|TA[XY]|T[XY]A|AD[DC]|SUB|SBC|CLC|SEC|CMP|EOR|ORR|AND|INC|DEC).*/;
+    const uncommonInstrucions = /.*,\s*([XY]|X\))$/;
+
+    address &= 0xffff;
+    let bestAddr = address - 1;
+    let bestScore = 0;
+    for (let startingPoint = address - 20; startingPoint !== address; startingPoint++) {
+        let score = 0;
+        let addr = startingPoint & 0xffff;
+        while (addr < address) {
+            const result = disassemble(addr);
+            if (addr === pc) score += 10;
+            if (result[0].match(commonInstructions) && !result[0].match(uncommonInstrucions)) {
+                score++;
+            }
+            if (result[1] === address) {
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestAddr = addr;
+                    break;
+                }
+            }
+            addr = result[1];
+        }
+    }
+    return bestAddr;
+}
+
 export class Debugger {
     constructor() {
         this.patchInstructions = new Map();
@@ -382,42 +424,7 @@ export class Debugger {
     }
 
     prevInstruction(address) {
-        // Some attempt at making prevInstruction more accurate; score the sequence of instructions leading
-        // up to the target by counting all "common" instructions as a point. The highest-scoring run of
-        // instructions is picked as the most likely, and the previous from that is used. Common instructions
-        // here mean loads, stores, branches, compares, arithmetic and carry-set/clear that don't use "unusual"
-        // indexing modes like abs,X, abs,Y and (zp,X).
-        // Good test cases:
-        //   Repton 2 @ 2cbb
-        //   MOS @ cfc8
-        // also, just starting from the back of ROM and going up...
-        const commonInstructions =
-            /(RTS|B..|JMP|JSR|LD[AXY]|ST[AXY]|TA[XY]|T[XY]A|AD[DC]|SUB|SBC|CLC|SEC|CMP|EOR|ORR|AND|INC|DEC).*/;
-        const uncommonInstrucions = /.*,\s*([XY]|X\))$/;
-
-        address &= 0xffff;
-        let bestAddr = address - 1;
-        let bestScore = 0;
-        for (let startingPoint = address - 20; startingPoint !== address; startingPoint++) {
-            let score = 0;
-            let addr = startingPoint & 0xffff;
-            while (addr < address) {
-                const result = this.disassemble(addr);
-                if (result[0] === this.cpu.pc) score += 10; // huge boost if this instruction was executed
-                if (result[0].match(commonInstructions) && !result[0].match(uncommonInstrucions)) {
-                    score++;
-                }
-                if (result[1] === address) {
-                    if (score > bestScore) {
-                        bestScore = score;
-                        bestAddr = addr;
-                        break;
-                    }
-                }
-                addr = result[1];
-            }
-        }
-        return bestAddr;
+        return prevInstruction((addr) => this.disassemble(addr), this.cpu.pc, address);
     }
 
     updatePrevMem() {

package/src/web/google-drive-picker.js

@@ -28,10 +28,13 @@ export class GoogleDrivePicker {
             this.authEl.style.display = "none";
             e.preventDefault();
             const authed = await this.auth(false);
-            if (authed) this.authResolve();
-            else this.authReject(new Error("Unable to authorize Google Drive"));
+            if (authed) this.authResolve?.(true);
+            else this.authReject?.(new Error("Unable to authorize Google Drive"));
         });
 
+        // Closing the loading dialog while the auth panel waits is a cancellation, not an error.
+        document.getElementById("loading-dialog").addEventListener("hidden.bs.modal", () => this.authResolve?.(false));
+
         // Loading the Google client holds the main thread for ~100ms, so it waits for
         // someone to ask for Drive.
         document.getElementById("open-drive-link").addEventListener("click", async (e) => {
@@ -74,11 +77,21 @@ export class GoogleDrivePicker {
             console.log("Google Drive authed=", authed);
 
             if (!authed) {
-                await new Promise((resolve, reject) => {
-                    this.authResolve = resolve;
-                    this.authReject = reject;
-                    this.authEl.style.display = "";
-                });
+                let granted;
+                try {
+                    granted = await new Promise((resolve, reject) => {
+                        this.authResolve = resolve;
+                        this.authReject = reject;
+                        this.authEl.style.display = "";
+                    });
+                } finally {
+                    this.authResolve = this.authReject = null;
+                }
+                if (!granted) {
+                    console.log("Google Drive authorization dismissed");
+                    this.modals.loadingFinished();
+                    return null;
+                }
             }
 
             const ssd = await this.googleDrive.load(this.processor.fdc, cat.id, layout);
@@ -93,7 +106,8 @@ export class GoogleDrivePicker {
             return ssd;
         } catch (error) {
             console.error("Google Drive loading error:", error);
-            this.modals.loadingFinished(`Unable to load ${cat.name} from Google Drive: ${errorText(error)}`);
+            this.modals.loadingFinished();
+            throw error;
         }
     }
 
@@ -122,8 +136,14 @@ export class GoogleDrivePicker {
                 utils.noteEvent("google-drive", "click", item.name);
                 this.media.setDisc1Image(`gd:${item.id}/${item.name}`);
                 this.modal.hide();
-                const ssd = await this.load(item, this.drives.layoutForDrive(0));
-                if (ssd) this.drives.putDiscIn(0, ssd);
+                try {
+                    const ssd = await this.load(item, this.drives.layoutForDrive(0));
+                    if (ssd) this.drives.putDiscIn(0, ssd);
+                } catch (error) {
+                    toast(`Unable to load ${item.name} from Google Drive: ${errorText(error)}`, {
+                        title: "Google Drive",
+                    });
+                }
             });
         }
     }

package/src/web/machine.js

@@ -162,15 +162,17 @@ export class Machine {
         }
 
         if (discImage) {
-            startImageLoad(`disc ${discImage}`, async () =>
-                drives.putDiscIn(0, await media.loadDiscImage(discImage, drives.layoutForDrive(0))),
-            );
+            startImageLoad(`disc ${discImage}`, async () => {
+                const loadedDisc = await media.loadDiscImage(discImage, drives.layoutForDrive(0));
+                if (loadedDisc) drives.putDiscIn(0, loadedDisc);
+            });
         }
 
         if (secondDiscImage) {
-            startImageLoad(`disc ${secondDiscImage}`, async () =>
-                drives.putDiscIn(1, await media.loadDiscImage(secondDiscImage, drives.layoutForDrive(1))),
-            );
+            startImageLoad(`disc ${secondDiscImage}`, async () => {
+                const loadedDisc = await media.loadDiscImage(secondDiscImage, drives.layoutForDrive(1));
+                if (loadedDisc) drives.putDiscIn(1, loadedDisc);
+            });
         }
 
         if (tape) {

package/src/web/media-loader.js

@@ -210,8 +210,9 @@ export class MediaLoader extends EventTarget {
     }
 
     async loadSCSIFile(file) {
-        const binaryData = await readFileAsBinaryString(file);
         const { processor } = this;
+        if (!processor.filestore) return;
+        const binaryData = await readFileAsBinaryString(file);
         processor.filestore.scsi = utils.stringToUint8Array(binaryData);
 
         processor.filestore.PC = 0x400;

package/src/web/snapshot-ui.js

@@ -1,7 +1,6 @@
 import * as disc from "../fdc.js";
 import { DiscLayout } from "../disc.js";
 import { downloadBlob } from "../dom-utils.js";
-import { toast } from "./toast.js";
 import {
     createSnapshot,
     restoreSnapshot,
@@ -58,9 +57,14 @@ async function readSnapshot(arrayBuffer) {
  * where they have one, the image bytes where they do not, and CRCs for
  * saying when a source has changed underneath a state.
  */
-export function snapshotMedia(fdcDrives, params) {
+export function snapshotMedia(fdcDrives, params, defaultBootDisc) {
     const manifest = {};
+    const drive0Disc = fdcDrives[0].disc;
     if (params.disc1 || params.disc) manifest.disc1 = params.disc1 || params.disc;
+    // A default boot loads the built-in disc without naming it in the URL; record it by
+    // name so the state can reload it, but only while that disc is still in the drive.
+    else if (defaultBootDisc && drive0Disc && drive0Disc.name === defaultBootDisc && !drive0Disc.originalImageData)
+        manifest.disc1 = defaultBootDisc;
     if (params.disc2) manifest.disc2 = params.disc2;
 
     // For each drive with a disc loaded, include CRC32 for verification
@@ -84,7 +88,7 @@ export function snapshotMedia(fdcDrives, params) {
 
 /** Saving and restoring states: the menu item, the file input and the reload across a model change. */
 export class SnapshotUI {
-    constructor({ processor, model, video, media, drives, urlState, modals, loop }) {
+    constructor({ processor, model, video, media, drives, urlState, modals, loop, defaultBootDisc }) {
         this.processor = processor;
         this.model = model;
         this.video = video;
@@ -93,6 +97,7 @@ export class SnapshotUI {
         this.urlState = urlState;
         this.modals = modals;
         this.loop = loop;
+        this.defaultBootDisc = defaultBootDisc;
 
         document.getElementById("save-state").addEventListener("click", async (event) => {
             event.preventDefault();
@@ -110,22 +115,27 @@ export class SnapshotUI {
     async saveState() {
         const wasRunning = this.loop.isRunning();
         if (wasRunning) this.loop.stop(false);
+        let failure = null;
         try {
-            const manifest = snapshotMedia(this.processor.fdc.drives, this.urlState.params);
+            const manifest = snapshotMedia(this.processor.fdc.drives, this.urlState.params, this.defaultBootDisc);
             const snapshot = createSnapshot(this.processor, this.model, manifest);
             const json = snapshotToJSON(snapshot);
             const blob = await compressBlob(new Blob([json]));
             const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
             downloadBlob(blob, `jsbeeb-${this.model.name}-${timestamp}.json.gz`);
         } catch (e) {
-            this.modals.showError("saving state", e);
+            failure = e;
         }
+        // Resume before reporting failure: the error dialog pauses a running
+        // loop itself, and resumes it on close.
         if (wasRunning) this.loop.go();
+        if (failure) this.modals.showError("saving state", failure);
     }
 
     async loadStateFromFile(file, preReadBuffer) {
         const wasRunning = this.loop.isRunning();
         if (wasRunning) this.loop.stop(false);
+        let failure = null;
         try {
             const arrayBuffer = preReadBuffer || (await file.arrayBuffer());
             const snapshot = await readSnapshot(arrayBuffer);
@@ -142,9 +152,10 @@ export class SnapshotUI {
             // Force a repaint so the display updates even while paused
             this.video.paint();
         } catch (e) {
-            this.modals.showError("loading state", e);
+            failure = e;
         }
         if (wasRunning) this.loop.go();
+        if (failure) this.modals.showError("loading state", failure);
     }
 
     /** Picks up the state a cross-model reload stashed, once the matching machine is up. */
@@ -192,16 +203,38 @@ export class SnapshotUI {
                 // Retain the image bytes so subsequent saves can re-embed them.
                 loadedDisc.setOriginalImage(imageData);
             }
-            if (!loadedDisc) continue;
-
-            // Verify CRC32 if present
-            if (savedMedia[crcKey] != null && loadedDisc.originalImageCrc32 != null) {
-                if (loadedDisc.originalImageCrc32 !== savedMedia[crcKey]) {
-                    toast(
-                        `${loadedDisc.name} has changed since this state was saved. The state has been restored anyway and may not run correctly.`,
-                        { title: "Restoring state" },
+            if (!loadedDisc) {
+                if (savedMedia[crcKey] != null) {
+                    // A state may name no source (older default-boot saves); the disc
+                    // already in the drive can still satisfy the CRC, but only laid out
+                    // the way the state's dirty tracks expect.
+                    const currentDisc = this.processor.fdc.drives[driveIndex].disc;
+                    const currentLayout = currentDisc?.is40Track ? DiscLayout.expanded40 : DiscLayout.contiguous;
+                    if (
+                        currentDisc &&
+                        currentDisc.originalImageCrc32 === savedMedia[crcKey] &&
+                        currentLayout === layout
+                    )
+                        continue;
+                    const problem = savedMedia[discKey]
+                        ? `The disc for drive ${driveIndex} (${savedMedia[discKey]}) could not be reloaded`
+                        : `This state does not record where the disc in drive ${driveIndex} came from`;
+                    throw new Error(
+                        `${problem}, and the drive does not hold a matching disc. ` +
+                            `Load the right disc, then load the state again.`,
                     );
                 }
+                continue;
+            }
+
+            if (
+                savedMedia[crcKey] != null &&
+                loadedDisc.originalImageCrc32 != null &&
+                loadedDisc.originalImageCrc32 !== savedMedia[crcKey]
+            ) {
+                throw new Error(
+                    `${loadedDisc.name} has changed since this state was saved, so the state cannot be restored over it.`,
+                );
             }
 
             this.drives.putDiscIn(driveIndex, loadedDisc);