jsbeeb 1.24.1 → 1.25.0

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.24.1",
+  "version": "1.25.0",
   "//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/app/electron.js

@@ -1,20 +1,30 @@
 // Electron integration for jsbeeb desktop application.
 // Handles IPC communication for loading disc/tape images and showing modals from Electron's main process.
 
+import { reportLoadFailure } from "../web/reporting.js";
+
 function init(args) {
-    const { loadDiscImage, loadTapeImage, loadStateFile, processor, modals, actions, settings, media } = args;
+    const { loadStateFile, modals, actions, settings, media, drives } = args;
     const api = window.electronAPI;
 
     api.onLoadDisc(async (message) => {
         const { drive, path } = message;
-        const image = await loadDiscImage(path);
-        processor.fdc.loadDisc(drive, image);
+        try {
+            drives.putDiscIn(drive, await media.loadDiscImage(path, drives.layoutForDrive(drive)));
+            media.setDiscImage(drive, path);
+        } catch (error) {
+            reportLoadFailure(`disc ${path}`, error);
+        }
     });
 
     api.onLoadTape(async (message) => {
         const { path } = message;
-        const tape = await loadTapeImage(path);
-        processor.tapeInterface.setTape(tape);
+        try {
+            media.setProcessorTape(await media.loadTapeImage(path));
+            media.setTapeImage(path);
+        } catch (error) {
+            reportLoadFailure(`tape ${path}`, error);
+        }
     });
 
     api.onShowModal((message) => {

package/src/disc.js

@@ -604,6 +604,39 @@ export function sniffDfsLayout(data, isDsd) {
     return { is40Track: true, reason };
 }
 
+// The title is split across the two catalogue sectors, and the cycle number follows its second half.
+const DfsTitleFirstHalf = 8;
+const DfsTitleSecondHalf = 4;
+const DfsCycleOffset = 4;
+const DfsEntryCountInSector1 = DfsEntryCountOffset - SsdFormat.sectorSize;
+
+const isPrintableAscii = (byte) => byte >= 0x20 && byte < 0x7f;
+
+/**
+ * What the DFS catalogue on one side of a loaded disc says it is called, and how many times it
+ * has been written to, which between them are what was on the sticker.
+ *
+ * @param {Disc} disc
+ * @param {boolean} [isSideUpper]
+ * @returns {{title: string, cycle: string}|null} null when the side holds no DFS catalogue
+ */
+export function dfsCatalogue(disc, isSideUpper = false) {
+    const sectors = new Map();
+    for (const sector of disc.getTrack(isSideUpper, 0).findSectors(() => {})) {
+        const usable =
+            !sector.hasHeaderCrcError && !sector.hasDataCrcError && sector.sectorData?.length === SsdFormat.sectorSize;
+        if (usable && !sectors.has(sector.sectorNumber)) sectors.set(sector.sectorNumber, sector.sectorData);
+    }
+    const sector0 = sectors.get(0);
+    const sector1 = sectors.get(1);
+    if (!sector0 || !sector1) return null;
+    const entryBytes = sector1[DfsEntryCountInSector1];
+    if (entryBytes % DfsEntrySize !== 0 || entryBytes > DfsMaxEntries * DfsEntrySize) return null;
+    const titleBytes = [...sector0.subarray(0, DfsTitleFirstHalf), ...sector1.subarray(0, DfsTitleSecondHalf)];
+    const title = String.fromCharCode(...titleBytes.filter(isPrintableAscii)).trimEnd();
+    return { title, cycle: hexbyte(sector1[DfsCycleOffset]) };
+}
+
 // One track could match by luck; a disc's worth of them could not.
 const MinDoubleSteppedTracks = 4;
 

package/src/machine-session.js

@@ -28,6 +28,9 @@ import { setNodeBasePath } from "./loader.js";
 const FB_WIDTH = 1024;
 const FB_HEIGHT = 625;
 
+// Bit X of ACCCON: shadow RAM in place of main at &3000 to &7FFF.
+const AccconShadowBit = 4;
+
 // Five times a frame, so only a machine that has stopped painting hits it.
 const BackstopSecondsPerFrame = 0.1;
 
@@ -115,19 +118,88 @@ export class MachineSession {
         return this.drainOutput();
     }
 
+    get _keyboard() {
+        return this._machine.processor.keyboardInterface;
+    }
+
+    /**
+     * The keyboard is the typist's until everything from type() has been
+     * delivered, and a key pressed meanwhile would be silently dropped.
+     */
+    _requireKeyboard() {
+        if (this.typingPending) {
+            throw new Error(
+                "Text from type() is still being typed: await type(), or if a breakpoint stopped it " +
+                    "run the machine on to finish it, or cancelTyping() first",
+            );
+        }
+    }
+
     /**
      * Press a key (by browser keyCode).
-     * Use utils.keyCodes for named keys, or ASCII charCode for letters/digits.
+     * Use keyCodes from keymap.js for named keys, or ASCII charCode for letters/digits.
      */
     keyDown(keyCode, shiftDown = false) {
-        this._machine.processor.sysvia.keyDown(keyCode, shiftDown);
+        this._requireKeyboard();
+        this._keyboard.keyDown(keyCode, shiftDown);
     }
 
     /**
      * Release a key (by browser keyCode).
      */
     keyUp(keyCode) {
-        this._machine.processor.sysvia.keyUp(keyCode);
+        this._requireKeyboard();
+        this._keyboard.keyUp(keyCode);
+    }
+
+    /**
+     * Press a key by its place in the keyboard matrix, as the model's key
+     * table (BBC or ATOM in the keymaps) gives it, with no host key map in
+     * between: a game reading the matrix sees exactly this key.
+     * @param {[number, number]} colRow
+     */
+    keyDownRaw(colRow) {
+        this._requireKeyboard();
+        this._keyboard.keyDownRaw(colRow);
+    }
+
+    /**
+     * Release a key pressed by matrix position.
+     * @param {[number, number]} colRow
+     */
+    keyUpRaw(colRow) {
+        this._requireKeyboard();
+        this._keyboard.keyUpRaw(colRow);
+    }
+
+    /**
+     * Every key currently down, as matrix positions keyDownRaw takes.
+     * @returns {Array<[number, number]>}
+     */
+    heldKeys() {
+        const held = [];
+        this._keyboard.keys.forEach((column, col) => {
+            column.forEach((down, row) => {
+                if (down) held.push([col, row]);
+            });
+        });
+        return held;
+    }
+
+    /** Whether text from type() is still to be delivered, which a breakpoint stopping the run leaves behind. */
+    get typingPending() {
+        return this._machine.typist.isTyping;
+    }
+
+    /** Drop any text from type() still to be delivered, and give the keyboard back. */
+    cancelTyping() {
+        this._machine.typist.cancel();
+    }
+
+    /** Release every key, and drop any typing still pending, so the keyboard is in a known state. */
+    releaseAllKeys() {
+        this.cancelTyping();
+        this._keyboard.clearKeys();
     }
 
     /**
@@ -196,11 +268,15 @@ export class MachineSession {
     }
 
     /**
-     * Run for an exact number of emulated CPU cycles.
-     * Useful for timing-sensitive code.
+     * Run for an exact number of emulated CPU cycles, or until something stops
+     * the CPU first: a breakpoint, or the paint runFrames stops at. `completed`
+     * is false if it was stopped short.
+     * @returns {Promise<{cyclesRun: number, completed: boolean}>}
      */
     async runFor(cycles) {
-        await this._machine.runFor(cycles);
+        const startCycles = this.elapsedCycles;
+        const stopped = await this._machine.runFor(cycles);
+        return { cyclesRun: this.elapsedCycles - startCycles, completed: !stopped };
     }
 
     /** Emulated cycles since power-on */
@@ -226,25 +302,15 @@ export class MachineSession {
         const cpu = this._machine.processor;
         const backstop = maxCycles ?? count * BackstopSecondsPerFrame * cpu.model.cyclesPerSecond;
         const startFrame = this._frameCount;
-        const startCycles = this.elapsedCycles;
-        // execute() adds each request to a running targetCycles, so budget left
-        // unspent by an early stop would silently lengthen the caller's next run.
-        const unspentBefore = cpu.targetCycles - cpu.currentCycles;
 
         this._stopAtFrame = startFrame + count;
         try {
-            await this._machine.runFor(backstop);
+            const { cyclesRun } = await this.runFor(backstop);
+            const framesRun = this._frameCount - startFrame;
+            return { framesRun, cyclesRun, completed: framesRun >= count };
         } finally {
             this._stopAtFrame = Infinity;
-            cpu.targetCycles = cpu.currentCycles + unspentBefore;
         }
-
-        const framesRun = this._frameCount - startFrame;
-        return {
-            framesRun,
-            cyclesRun: this.elapsedCycles - startCycles,
-            completed: framesRun >= count,
-        };
     }
 
     /** Frames painted since the session was created; a hard reset does not zero it */
@@ -398,22 +464,74 @@ export class MachineSession {
         };
     }
 
-    /** Read `length` bytes from emulator memory starting at `address` */
-    readMemory(address, length = 16) {
-        const bytes = [];
-        for (let i = 0; i < length; i++) {
-            bytes.push(this._machine.readbyte(address + i));
-        }
-        return bytes;
+    /**
+     * What the memory map has paged in: `romsel`, the sideways bank at
+     * &8000 to &BFFF, and on a Master `acccon`, whose bit 2 puts shadow
+     * RAM at &3000 to &7FFF.
+     * @returns {{romsel: number, acccon?: number}}
+     */
+    pagingState() {
+        const cpu = this._machine.processor;
+        const state = { romsel: cpu.romsel };
+        if (cpu.model.isMaster) state.acccon = cpu.acccon;
+        return state;
     }
 
-    /** Write an array of byte values into emulator memory at `address` */
-    writeMemory(address, bytes) {
-        for (let i = 0; i < bytes.length; i++) {
-            this._machine.writebyte(address + i, bytes[i]);
+    /**
+     * Runs `fn` with `bank` paged at &8000, or shadow RAM paged (or not)
+     * at &3000, putting the map back afterwards. Either left undefined
+     * leaves the map as the machine has it.
+     */
+    _withPaging({ bank, shadow }, fn) {
+        const cpu = this._machine.processor;
+        const { romsel, acccon } = cpu;
+        if (bank !== undefined) {
+            if (!Number.isInteger(bank) || bank < 0 || bank > 15) throw new Error(`Bank ${bank} is not 0 to 15`);
+            cpu.romSelect(bank);
+        }
+        if (shadow !== undefined) {
+            if (!cpu.model.isMaster) throw new Error("Only a Master has shadow RAM");
+            cpu.writeAcccon(shadow ? acccon | AccconShadowBit : acccon & ~AccconShadowBit);
+        }
+        try {
+            return fn();
+        } finally {
+            if (bank !== undefined) cpu.romSelect(romsel);
+            if (shadow !== undefined) cpu.writeAcccon(acccon);
         }
     }
 
+    /**
+     * Read `length` bytes from emulator memory starting at `address`, from
+     * whatever is paged in unless `bank` or `shadow` says otherwise.
+     * @param {number} address
+     * @param {number} [length=16]
+     * @param {Object} [opts]
+     * @param {number} [opts.bank] sideways bank to read at &8000 to &BFFF
+     * @param {boolean} [opts.shadow] on a Master, read shadow RAM (true) or main RAM (false) at &3000 to &7FFF
+     */
+    readMemory(address, length = 16, { bank, shadow } = {}) {
+        return this._withPaging({ bank, shadow }, () => {
+            const bytes = [];
+            for (let i = 0; i < length; i++) {
+                bytes.push(this._machine.readbyte(address + i));
+            }
+            return bytes;
+        });
+    }
+
+    /**
+     * Write an array of byte values into emulator memory at `address`;
+     * `bank` and `shadow` pick where, as for readMemory.
+     */
+    writeMemory(address, bytes, { bank, shadow } = {}) {
+        this._withPaging({ bank, shadow }, () => {
+            for (let i = 0; i < bytes.length; i++) {
+                this._machine.writebyte(address + i, bytes[i]);
+            }
+        });
+    }
+
     /** Read the current 6502 CPU registers */
     registers() {
         const cpu = this._machine.processor;

package/src/main.js

@@ -389,11 +389,9 @@ exposeConsoleSurface(window, { loop, processor, video, audioHandler });
 
 // Hooks for electron.
 electron({
-    loadDiscImage: media.loadDiscImage.bind(media),
-    loadTapeImage: media.loadTapeImage.bind(media),
-    processor,
     settings,
     media,
+    drives,
     modals: {
         show: (modalId, sthType) => {
             if (modalId === "sth" && sthType) {

package/src/models.js

@@ -50,9 +50,10 @@ class Model {
         this.stringToKeys = this.isAtom ? stringToATOMKeys : stringToBBCKeys;
         // The OS write-character vector, watched to capture what the machine prints.
         this.wrchvAddress = this.isAtom ? 0x0208 : 0x020e;
-        // Where the machine sits waiting for a key: the Atom kernel's keyboard scan, which its
-        // line editor calls straight (the OSRDCH entry at $FE94 is only passed at boot), or BASIC's.
-        this.idleAddress = this.isAtom ? 0xfe71 : isMaster ? 0xe7e6 : 0xe581;
+        // Where the machine sits waiting for a key: BASIC's read loop, or on the Atom the kernel's
+        // wait-for-key scan at $FEA7. The scan before it at $FE9F only checks every key is up, and a
+        // 100 ms debounce delay follows, during which a key pressed is not seen.
+        this.idleAddress = this.isAtom ? 0xfea7 : isMaster ? 0xe7e6 : 0xe581;
         // The Atom ROM polls its keyboard once per VSync, so pasted keys need longer apart.
         this.pasteKeyDelayMs = this.isAtom ? 80 : 50;
         // Two of those 60 Hz scans, 33 ms, with margin: the ROM wants a key seen up

package/src/test-machine.js

@@ -95,16 +95,24 @@ export class TestMachine {
             .join("");
     }
 
+    /**
+     * Run for `cycles` emulated cycles, or until something stops the CPU.
+     * Resolves true if it was stopped short.
+     */
     runFor(cycles) {
         let left = cycles;
         let stopped = false;
+        const cpu = this.processor;
         return new Promise((resolve) => {
             const runAnIter = () => {
                 const todo = Math.max(0, Math.min(left, MaxCyclesPerIter));
                 if (todo) {
-                    stopped = !this.processor.execute(todo);
+                    stopped = !cpu.execute(todo);
                     left -= todo;
                 }
+                // execute() adds each request to a running targetCycles, so budget
+                // left unspent by an early stop would silently lengthen the next run.
+                if (stopped) cpu.targetCycles = cpu.currentCycles;
                 // Not truthiness: a negative or NaN request clamps todo to zero,
                 // so left would never move and the loop never end.
                 if (left > 0 && !stopped) {

package/src/web/drives.js

@@ -7,11 +7,13 @@ import { DriveTracks } from "../url-params.js";
 const tracksPerStepFor = (tracks) => (tracks === "40" ? 2 : 1);
 
 /**
- * The disc drives as the page sees them: putting a disc in, the 40/80 track
- * switches on the Discs menu, and downloading what is in drive 0.
+ * The disc drives as the page sees them: putting a disc in and taking it out,
+ * the 40/80 track switches on the Discs menu, and downloading what is in drive 0.
+ * Raises "disc-changed" with the drive index and what it now holds.
  */
-export class Drives {
+export class Drives extends EventTarget {
     constructor({ fdc, driveTracks, confirm }) {
+        super();
         this.fdc = fdc;
         this.driveTracks = driveTracks;
         this.saidWritesAreNotKept = false;
@@ -34,7 +36,7 @@ export class Drives {
         }
 
         document.getElementById("download-drive-link").addEventListener("click", async () => {
-            const disc = this.discToDownload();
+            const disc = this.discToDownload(0);
             if (!disc) return;
             const save = (options) =>
                 downloadDriveData(toSsdOrDsd(disc, options), disc.name, disc.isDoubleSided ? ".dsd" : ".ssd");
@@ -47,16 +49,16 @@ export class Drives {
         });
 
         document.getElementById("download-drive-hfe-link").addEventListener("click", () => {
-            const disc = this.discToDownload();
+            const disc = this.discToDownload(0);
             if (!disc) return;
             downloadDriveData(toHfe(disc), disc.name, ".hfe");
         });
     }
 
-    /** @returns {import("../disc.js").Disc|null} the disc in drive 0, saying so when there is nothing to download */
-    discToDownload() {
-        const disc = this.fdc?.drives[0].disc;
-        if (!disc) toast("There is no disc in drive 0 to download.", { title: "Disc" });
+    /** @returns {import("../disc.js").Disc|null} the disc in the drive, saying so when there is nothing to download */
+    discToDownload(driveIndex) {
+        const disc = this.fdc?.drives[driveIndex].disc;
+        if (!disc) toast(`There is no disc in drive ${driveIndex} to download.`, { title: "Disc" });
         return disc ?? null;
     }
 
@@ -80,6 +82,13 @@ export class Drives {
         this.noteUnsavedWrites(loadedDisc);
         // A switch the user fixed does not move, so anything it does is not news.
         if (fixed === undefined && drive.tracksPerStep !== was) this.noteDriveTracks(driveIndex, loadedDisc.name);
+        this.dispatchEvent(new CustomEvent("disc-changed", { detail: { driveIndex, disc: loadedDisc } }));
+    }
+
+    eject(driveIndex) {
+        this.fdc.loadDisc(driveIndex, undefined, this.tracksPerStepForDrive(driveIndex));
+        this.showDriveTracks(driveIndex);
+        this.dispatchEvent(new CustomEvent("disc-changed", { detail: { driveIndex, disc: undefined } }));
     }
 
     noteUnsavedWrites(loadedDisc) {

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

@@ -139,11 +139,13 @@ export class GoogleDrivePicker {
             row.querySelector(".name").textContent = item.name;
             row.addEventListener("click", async () => {
                 noteEvent("google-drive", "click", item.name);
-                this.media.setDisc1Image(`gd:${item.id}/${item.name}`);
                 this.modal.hide();
                 try {
                     const ssd = await this.load(item, this.drives.layoutForDrive(0));
-                    if (ssd) this.drives.putDiscIn(0, ssd);
+                    if (ssd) {
+                        this.drives.putDiscIn(0, ssd);
+                        this.media.setDiscImage(0, `gd:${item.id}/${item.name}`);
+                    }
                 } catch (error) {
                     toast(`Unable to load ${item.name} from Google Drive: ${errorText(error)}`, {
                         title: "Google Drive",
@@ -189,9 +191,9 @@ export class GoogleDrivePicker {
         }
 
         try {
-            const result = await this.googleDrive.create(name, data);
-            this.media.setDisc1Image("gd:" + result.fileId + "/" + name);
+            const result = await this.googleDrive.create(name, data, this.drives.layoutForDrive(0));
             this.drives.putDiscIn(0, result.disc);
+            this.media.setDiscImage(0, "gd:" + result.fileId + "/" + name);
             this.modals.loadingFinished();
         } catch (error) {
             console.error(`Error creating Google Drive disc: ${error}`, error);

package/src/web/google-drive.js

@@ -137,11 +137,11 @@ export class GoogleDriveLoader {
         });
     }
 
-    async create(name, data) {
+    async create(name, data, layout) {
         console.log(`Google Drive: creating disc image: '${name}'`);
         const response = await this.saveFile(name, data);
         const meta = response.result;
-        return { fileId: meta.id, disc: this.makeDisc(data, meta) };
+        return { fileId: meta.id, disc: this.makeDisc(data, meta, layout) };
     }
 
     makeDisc(data, meta, layout) {

package/src/web/hfe-picker.js

@@ -59,7 +59,6 @@ export class HfePicker {
     async pick(file) {
         noteEvent("hfe", "click", file.path);
         const image = "hfe:" + file.path;
-        this.media.setDisc1Image(image);
         const needsAutoboot = this.urlState.params.autoboot !== undefined;
         if (needsAutoboot) this.processor.reset(true);
 
@@ -68,6 +67,7 @@ export class HfePicker {
         try {
             const loaded = await this.media.loadDiscImage(image, this.drives.layoutForDrive(0));
             this.drives.putDiscIn(0, loaded);
+            this.media.setDiscImage(0, image);
             this.modals.loadingFinished();
             if (needsAutoboot) this.autoboot(name);
         } catch (err) {

package/src/web/media-loader.js

@@ -144,10 +144,10 @@ export class MediaLoader extends EventTarget {
             elem.querySelector(".description").textContent = image.desc;
             elem.addEventListener("click", async () => {
                 noteEvent("images", "click", image.file);
-                this.setDisc1Image(image.file);
                 modals.hide("discs");
                 try {
-                    drives.putDiscIn(0, await this.loadDiscImage(this.params.disc1, drives.layoutForDrive(0)));
+                    drives.putDiscIn(0, await this.loadDiscImage(image.file, drives.layoutForDrive(0)));
+                    this.setDiscImage(0, image.file);
                 } catch (error) {
                     reportLoadFailure(`${image.name} (${image.file})`, error);
                 }
@@ -165,18 +165,29 @@ export class MediaLoader extends EventTarget {
         else this.resolver.addSource(schema, fetcher);
     }
 
+    /** Puts a tape in the deck, or empties it; raises "tape-changed" with what the deck now holds. */
     setProcessorTape(tape) {
         this.processor.tapeInterface.setTape(tape);
+        this.dispatchEvent(new CustomEvent("tape-changed", { detail: { tape } }));
     }
 
-    setDisc1Image(name) {
-        this.urlState.set({ disc: undefined, disc1: name });
-        this.dispatchEvent(new CustomEvent("media-changed", { detail: { disc1: name } }));
+    ejectDisc(driveIndex) {
+        this.drives.eject(driveIndex);
+        this.setDiscImage(driveIndex, undefined);
     }
 
-    setDisc2Image(name) {
-        this.urlState.set({ disc2: name });
-        this.dispatchEvent(new CustomEvent("media-changed", { detail: { disc2: name } }));
+    ejectTape() {
+        this.setProcessorTape(undefined);
+        this.setTapeImage(undefined);
+    }
+
+    /** Names the disc in a drive for the URL and the settings store, or unnames it. */
+    setDiscImage(driveIndex, name) {
+        // The URL has always called the drives disc1 and disc2, and a bare disc means disc1.
+        const changes = driveIndex === 0 ? { disc: undefined, disc1: name } : { disc2: name };
+        this.urlState.set(changes);
+        const detail = driveIndex === 0 ? { disc1: name } : { disc2: name };
+        this.dispatchEvent(new CustomEvent("media-changed", { detail }));
     }
 
     setTapeImage(name) {

package/src/web/snapshot-ui.js

@@ -235,10 +235,7 @@ export class SnapshotUI {
             // Only update the URL/query for URL-sourced discs. For embedded
             // (local-file) discs, setting parsedQuery would put a bogus source
             // in the URL and break subsequent saves/reloads.
-            if (savedMedia[discKey]) {
-                if (driveIndex === 0) this.media.setDisc1Image(savedMedia[discKey]);
-                else this.media.setDisc2Image(savedMedia[discKey]);
-            }
+            if (savedMedia[discKey]) this.media.setDiscImage(driveIndex, savedMedia[discKey]);
         }
     }
 }

package/src/web/sth-picker.js

@@ -71,7 +71,6 @@ export class SthPicker {
     async pickDisc(item) {
         noteEvent("sth", "click", item);
         const image = "sth:" + item;
-        this.media.setDisc1Image(image);
         const needsAutoboot = this.urlState.params.autoboot !== undefined;
         if (needsAutoboot) {
             this.processor.reset(true);
@@ -81,6 +80,7 @@ export class SthPicker {
         try {
             const loaded = await this.media.loadDiscImage(image, this.drives.layoutForDrive(0));
             this.drives.putDiscIn(0, loaded);
+            this.media.setDiscImage(0, image);
             this.modals.loadingFinished();
 
             if (needsAutoboot) {
@@ -95,12 +95,11 @@ export class SthPicker {
     async pickTape(item) {
         noteEvent("sth", "clickTape", item);
         const image = "sth:" + item;
-        this.media.setTapeImage(image);
-
         this.modals.popupLoading("Loading " + item);
         try {
             const tape = await this.media.loadTapeImage(image);
             this.media.setProcessorTape(tape);
+            this.media.setTapeImage(image);
             this.modals.loadingFinished();
         } catch (err) {
             console.error("Error loading tape image:", err);