jsbeeb 1.16.0 → 1.17.1

package/README.md

@@ -13,6 +13,7 @@ different peripherals.
 - [Keyboard Mappings](#keyboard-mappings)
 - [Remapping Keys](#remapping-keys)
 - [Emulator Shortcuts](#emulator-shortcuts)
+- [Printer Output](#printer-output)
 - [Save State and Rewind](#save-state-and-rewind)
 - [Getting Set Up to Run Locally](#getting-set-up-to-run-locally)
 - [Running as a Desktop Application](#running-as-a-desktop-application)
@@ -103,8 +104,15 @@ The definitive lists are `keyCodes` (host) and `BBC` (BBC micro) in [`src/utils.
 | `Ctrl+Home`    | Stop and enter debugger         |
 | `Ctrl+Insert`  | Toggle turbo (fast-as-possible) |
 | `Ctrl+End`     | Pause emulation                 |
+| `Ctrl+B`       | Open printer output window      |
 | `Alt+PageDown` | Open rewind scrubber            |
 
+### Printer Output
+
+Anything the machine prints is captured whether or not the printer window is open, so programs that print (with `VDU 2`, `*FX5,1` and the like) run rather than waiting for a printer that is not there.
+
+Press `Ctrl+B` to open a window showing what has been printed so far; it then keeps up with the output as it arrives. Only the most recent output is kept, roughly a dozen pages' worth, so a program printing forever cannot fill memory.
+
 ### Save State and Rewind
 
 Save and load full emulator state snapshots from the **State** menu (or `Ctrl+S` / `Ctrl+O` in the Electron app).
@@ -240,10 +248,16 @@ sudo rpm -i out/dist/jsbeeb-1.0.1.x86_64.rpm
 ## URL Parameters
 
 - `autoboot` - fakes a shift break
-- `disc1=XXX` - loads disc XXX (from the `discs/` directory) into drive 1
-- `disc2=XXX` - as above
+- `disc1=XXX` - loads disc XXX (from the `discs/` directory) into drive 0
+- `disc2=XXX` - as above, into drive 1
 - `disc1=local:YYY` - creates a local disk YYY which will be kept in browser local storage
 - `disc1=sth:ZZZ` - loads disc ZZZ from the Stairway to Hell archive
+- `drive0Tracks=40` / `drive0Tracks=80` - fixes drive 0's 40/80 track switch, as the switch on the back of a real
+  drive did. `drive1Tracks` does the same for drive 1. Left alone, each drive follows whatever disc is loaded into it:
+  a 40 track image is laid out the way a 40 track drive wrote it, on every other track of the surface, and the drive
+  double steps to read it. `40` reads an 80 track disc through a double stepping head, which is as much of a mess as it
+  was in 1985. `80` turns all of this off for that drive, loading every image the way jsbeeb did before it could tell
+  them apart. [docs/disc-track-layouts.md](docs/disc-track-layouts.md) explains how an image's layout is worked out.
 - `tape=XXX` - loads tape XXX (from the `tapes/` directory)
 - `tape=sth:ZZZ` - loads tape ZZZ from the Stairway to Hell archive
 - `KEY.X=Y` - makes host key `X` press BBC key `Y`, e.g. `KEY.ENTER=COPY`. See

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.16.0",
+  "version": "1.17.1",
   "//engines": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": ">=24.15.0"
@@ -30,6 +30,7 @@
     "argparse": "^3.0.0",
     "bootstrap": "^5.3.8",
     "bootswatch": "^5.3.8",
+    "pako": "^3.0.1",
     "sharp": "^0.35.3",
     "smoothie": "^1.36.1"
   },
@@ -44,6 +45,7 @@
     "jsdom": "^30.0.1",
     "lint-staged": "^17.1.1",
     "npm-run-all2": "^9.0.2",
+    "papaparse": "^5.5.4",
     "pixelmatch": "^7.2.0",
     "prettier": "^3.9.6",
     "vite": "^8.1.5",
@@ -104,6 +106,12 @@
     "mirror-sth:upload": "npm-run-all mirror-sth:upload:*",
     "mirror-sth:upload:blobs": "aws s3 sync .sth-mirror s3://bbc.xania.org/archive/sth/ --no-progress --exclude '*manifest.json' --exclude 'meta/*' --cache-control 'public, max-age=31536000, immutable'",
     "mirror-sth:upload:index": "aws s3 sync .sth-mirror s3://bbc.xania.org/archive/sth/ --no-progress --exclude '*' --include '*manifest.json' --include 'meta/*' --cache-control 'public, max-age=300'",
+    "mirror-bbcdiscs": "node tools/mirror-bbcdiscs.js --csv .bbcdiscs-sheet.csv --out .bbcdiscs-mirror",
+    "mirror-bbcdiscs:check": "node tools/mirror-bbcdiscs.js --csv .bbcdiscs-sheet.csv --check-only",
+    "mirror-bbcdiscs:seed": "aws s3 sync s3://bbc.xania.org/archive/bbcdiscs/hfe/ .bbcdiscs-mirror/hfe/ --no-progress",
+    "mirror-bbcdiscs:upload": "npm-run-all mirror-bbcdiscs:upload:*",
+    "mirror-bbcdiscs:upload:blobs": "aws s3 sync .bbcdiscs-mirror/hfe s3://bbc.xania.org/archive/bbcdiscs/hfe/ --no-progress --exclude 'manifest.json' --delete --content-encoding br --cache-control 'public, max-age=31536000, immutable'",
+    "mirror-bbcdiscs:upload:index": "aws s3 cp .bbcdiscs-mirror/hfe/manifest.json s3://bbc.xania.org/archive/bbcdiscs/hfe/manifest.json --cache-control 'public, max-age=300' && aws s3 cp .bbcdiscs-mirror/manifest.json s3://bbc.xania.org/archive/bbcdiscs/manifest.json --cache-control 'public, max-age=300'",
     "electron": "npm run build && ELECTRON_DISABLE_SANDBOX=1 electron .",
     "electron:build": "electron-builder"
   },

package/src/6502.js

@@ -1359,7 +1359,8 @@ export class Cpu6502 extends Base6502 {
     // Override in subclasses for different peripheral sets.
     // Only called on hard reset.
     resetPeripherals() {
-        if (this.config.printerPort) this.uservia.ca2changecallback = this.config.printerPort.outputStrobe;
+        if (this.config.printerPort)
+            this.uservia.ca2changecallback = (level, output) => this.config.printerPort.outputStrobe(level, output);
 
         this.sysvia.reset();
         this.uservia.reset();

package/src/app/app.js

@@ -172,6 +172,10 @@ const template = [
                 label: "Browse STH Disc Archive...",
                 click: showModal("sth", { sthType: "discs" }),
             },
+            {
+                label: "Browse HFE Disc Archive...",
+                click: showModal("hfe"),
+            },
             {
                 label: "Browse Example Discs...",
                 click: showModal("discs"),

package/src/bbcdiscs.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const mirrorBase = "https://bbc.xania.org/archive/bbcdiscs";
+
+// Numeric so a "Disc 2" would sort before a "Disc 10" rather than after it,
+// and case-insensitive so a lower-cased title stays with its neighbours.
+const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+
+/**
+ * Order the picker by what someone is looking for, which is the disc's name.
+ * The catalogue arrives grouped by publisher, so it has to be sorted here; the
+ * remaining keys only settle ties, keeping a title's variants together and in
+ * a stable order rather than the one the catalogue happens to list them in.
+ */
+export const byTitle = (a, b) =>
+    collator.compare(a.title || a.path, b.title || b.path) ||
+    collator.compare(a.publisher || "", b.publisher || "") ||
+    collator.compare(a.disc || "", b.disc || "") ||
+    collator.compare(a.variant || "", b.variant || "");
+
+/**
+ * How a disc reads in the picker. Several fingerprinted variants of one title
+ * sit next to each other, so the title alone doesn't identify a disc.
+ *
+ * @param {object} file manifest entry
+ * @returns {{title: string, publisher: string, detail: string}}
+ */
+export function describe(file) {
+    const detail = [file.disc, file.tracks?.join(", "), file.variant && `v${file.variant}`].filter(Boolean);
+    return {
+        title: file.title || file.path,
+        publisher: file.publisher ?? "",
+        detail: detail.join(" · "),
+    };
+}
+
+export class BbcDiscArchive {
+    /** @param {string} [baseUrl] where the mirror lives, to point at a test prefix */
+    constructor(onStart, onCat, onError, baseUrl = mirrorBase) {
+        this._baseUrl = `${baseUrl}/hfe/`;
+        this._catalogue = [];
+        this._loaded = false;
+        this._onStart = onStart;
+        this._onCat = onCat;
+        this._onError = onError;
+    }
+
+    async populate() {
+        this._onStart();
+        // Tracked separately from the catalogue: an archive can legitimately be
+        // empty, and an empty array would mean "fetch it again" every time.
+        if (!this._loaded) {
+            try {
+                const response = await fetch(`${this._baseUrl}manifest.json`);
+                if (!response.ok) throw new Error(`Network response was not ok (${response.status})`);
+                const data = await response.json();
+                if (!Array.isArray(data?.files)) throw new Error("Invalid manifest: missing files array");
+                this._catalogue = [...data.files].sort(byTitle);
+                this._loaded = true;
+            } catch (error) {
+                console.error("Failed to fetch HFE archive catalogue:", error);
+                if (this._onError) this._onError();
+                return;
+            }
+        }
+        if (this._onCat) this._onCat(this._catalogue);
+    }
+
+    /**
+     * Nothing to unzip, unlike sth.js: blobs are stored compressed and served
+     * with `Content-Encoding: br`, which the browser has undone by the time
+     * this resolves.
+     *
+     * @param {string} path a manifest entry's `path`
+     * @returns {Promise<Uint8Array>} the HFE image
+     */
+    async fetch(path) {
+        const url = this._baseUrl + encodeURIComponent(path);
+        console.log("Loading HFE from " + url);
+        const response = await fetch(url);
+        if (!response.ok) throw new Error(`Network response was not ok (${response.status})`);
+        return new Uint8Array(await response.arrayBuffer());
+    }
+}

package/src/bem-snapshot.js

@@ -1,5 +1,5 @@
 "use strict";
-import { decompress } from "./utils.js";
+import { inflate } from "./utils.js";
 
 // B-em snapshot format parser (versions 1 and 3).
 // v1 (BEMSNAP1): Fixed-size 327,885 byte packed struct. Reference: beebjit state.c
@@ -334,7 +334,7 @@ async function parseBemTube(sections, tubeName) {
 
     // Those names come from a config file, so size is the real check. It cannot be exact: the
     // trailing ROM's size comes from that same config, and b-em records it as zero if unset.
-    const parasite = await decompress(sections["P"].data, "deflate");
+    const parasite = inflate(sections["P"].data);
     const romBytes = parasite.length - BemTubeRegisterBytes - BemTubeRamSize;
     if (romBytes < 0 || romBytes > BemTubeRamSize) {
         throw new Error(
@@ -449,9 +449,8 @@ async function parseBemV3(buffer) {
     let roms = null;
     const memSection = sections["M"];
     if (memSection) {
-        // Memory is zlib-compressed; decompression is async.
         // Decompressed layout: 2 bytes (fe30, fe34) + 64KB RAM + 256KB ROM
-        const memData = await decompress(memSection.data, "deflate");
+        const memData = inflate(memSection.data);
         cpuState.fe30 = memData[0];
         cpuState.fe34 = memData[1];
         const ramStart = 2;

package/src/canvas.js

@@ -213,11 +213,18 @@ export class GlCanvas {
     }
 }
 
+function fellBackBecause(canvas, reason) {
+    canvas.fallbackReason = reason;
+    return canvas;
+}
+
 export function bestCanvas(canvas, filterClass) {
+    let reason;
     try {
         return new GlCanvas(canvas, filterClass);
     } catch (e) {
         // Either WebGL is unavailable or this particular filter declined it.
+        reason = e?.message ?? e;
         console.log(`Unable to use ${filterClass.getDisplayConfig().name} with WebGL: ${e}`);
     }
 
@@ -226,11 +233,11 @@ export function bestCanvas(canvas, filterClass) {
     // 2D fallback below would throw and take the emulator with it.
     if (filterClass !== PassthroughFilter) {
         try {
-            return new GlCanvas(canvas, PassthroughFilter);
+            return fellBackBecause(new GlCanvas(canvas, PassthroughFilter), reason);
         } catch (e) {
             console.log("Unable to fall back to the passthrough filter: " + e);
         }
     }
 
-    return new Canvas(canvas);
+    return fellBackBecause(new Canvas(canvas), reason);
 }

package/src/cmos.js

@@ -33,6 +33,44 @@ function fromBcd(value) {
 
 export { defaultCmos };
 
+/**
+ * CMOS persistence backed by a browser storage object, which can be unavailable, full or holding
+ * something other than what was last saved.
+ *
+ * @param {function(): Storage} getStorage typically `() => window.localStorage`. Reading that
+ *   property is itself what throws when a page is refused storage, so it happens per call, inside
+ *   the try.
+ * @param {function(*)} onSaveFailure called with the error the first time a save fails
+ */
+export function localStoragePersistence(getStorage, onSaveFailure) {
+    let saveFailureReported = false;
+    return {
+        load() {
+            try {
+                const stored = getStorage().cmosRam;
+                if (!stored) return null;
+                const parsed = JSON.parse(stored);
+                if (!Array.isArray(parsed) || parsed.length !== defaultCmos.length)
+                    throw new Error(`the stored settings are not ${defaultCmos.length} bytes`);
+                return parsed;
+            } catch (error) {
+                console.log(`Unable to read the stored CMOS settings: ${error?.message ?? error}`);
+                return null;
+            }
+        },
+        save(data) {
+            try {
+                getStorage().cmosRam = JSON.stringify(data);
+            } catch (error) {
+                console.log(`Unable to store the CMOS settings: ${error?.message ?? error}`);
+                if (saveFailureReported) return;
+                saveFailureReported = true;
+                onSaveFailure(error);
+            }
+        },
+    };
+}
+
 export class Cmos {
     constructor(persistence, cmosOverride, econet) {
         this.store = persistence ? persistence.load() : null;

package/src/disc-drive.js

@@ -38,6 +38,16 @@ export class BaseDiscDrive extends EventTarget {
         throw new Error("Not implemented: isSideUpper getter");
     }
 
+    /** @returns {Number} */
+    get tracksPerStep() {
+        throw new Error("Not implemented: tracksPerStep getter");
+    }
+
+    /** @param {Number} _tracksPerStep */
+    set tracksPerStep(_tracksPerStep) {
+        throw new Error("Not implemented: tracksPerStep setter");
+    }
+
     /** @returns {boolean} */
     get indexPulse() {
         throw new Error("Not implemented: indexPulse getter");
@@ -160,8 +170,10 @@ export class DiscDrive extends BaseDiscDrive {
         this._scheduler = scheduler;
         /** @type {Disc|undefined} */
         this._disc = undefined;
-        this._is40Track = false;
-        // Physically always 80 tracks even if we're in 40 track mode. 40 track mode essentially double steps.
+        // Two for a drive whose 40/80 switch is set to 40, which reaches a 48 tpi format by
+        // stepping twice for each track the controller counts.
+        this._tracksPerStep = 1;
+        // Where the head is over the 96 tpi surface, whatever the controller believes.
         this._track = 0;
         this._isSideUpper = false;
         // In units where 3125 is a normal track length.
@@ -305,6 +317,22 @@ export class DiscDrive extends BaseDiscDrive {
         this._disc = disc;
     }
 
+    /** @returns {Number} how many of the surface's tracks the head crosses for one of the format's */
+    get tracksPerStep() {
+        return this._tracksPerStep;
+    }
+
+    set tracksPerStep(tracksPerStep) {
+        if (tracksPerStep !== 1 && tracksPerStep !== 2)
+            throw new Error(`Drives step over one or two tracks at a time, not ${tracksPerStep}`);
+        this._tracksPerStep = tracksPerStep;
+    }
+
+    /** @returns {Number} the track the controller believes the head is on */
+    get logicalTrack() {
+        return (this._track / this._tracksPerStep) | 0;
+    }
+
     get indexPulse() {
         // With no disc loaded the drive asserts the index all the time.
         if (!this.disc) return true;
@@ -339,22 +367,22 @@ export class DiscDrive extends BaseDiscDrive {
      * @param {Number} delta track step delta, either 1 or -1
      */
     seekOneTrack(delta) {
-        if (this._is40Track) delta *= 2;
-        this._selectTrack(this._track + delta);
+        this._selectTrack(this._track + delta * this._tracksPerStep);
     }
 
     /**
      * Notify that an overall seek is happening to a particular track. Purely informational.
      */
     notifySeek(newTrack) {
-        this.notifySeekAmount(newTrack - this._track);
+        this.notifySeekAmount(newTrack - this.logicalTrack);
     }
 
     /**
-     * Notify that an overall seek is happening by some delta smount. Purely informational.
+     * Notify that an overall seek is happening by some delta amount. Purely informational.
      */
     notifySeekAmount(delta) {
-        this.dispatchEvent(new StepEvent(delta));
+        // The step drives the seek noise, so it counts the tracks the head crosses.
+        this.dispatchEvent(new StepEvent(delta * this._tracksPerStep));
     }
 
     /**
@@ -362,11 +390,12 @@ export class DiscDrive extends BaseDiscDrive {
      */
     _selectTrack(track) {
         this._checkTrackNeedsWrite();
+        const lastTrack = IbmDiscFormat.tracksPerDisc - this._tracksPerStep;
         if (track < 0) {
             track = 0;
             console.log("Clang! disc head stopped at track 0");
-        } else if (track >= IbmDiscFormat.tracksPerDisc) {
-            track = IbmDiscFormat.tracksPerDisc - 1;
+        } else if (track > lastTrack) {
+            track = lastTrack;
             console.log("Clang! disc head stopper at track max");
         }
         const fraction = this.positionFraction;
@@ -375,7 +404,11 @@ export class DiscDrive extends BaseDiscDrive {
     }
 
     _checkTrackNeedsWrite() {
-        if (this.disc) this.disc.flushWrites();
+        if (!this.disc) return;
+        const written = this.disc.flushWrites();
+        // A 48 tpi head writes across most of its band but not as far as the neighbouring 96 tpi
+        // track, which is left in the guard band with nothing readable on it.
+        if (written && this._tracksPerStep === 2) this.disc.eraseTrack(written.isSideUpper, written.trackNum ^ 1);
     }
 
     snapshotState() {
@@ -386,7 +419,7 @@ export class DiscDrive extends BaseDiscDrive {
             pulsePosition: this._pulsePosition,
             in32usMode: this._in32usMode,
             spinning: this._spinning,
-            is40Track: this._is40Track,
+            is40Track: this._tracksPerStep === 2,
             timerTaskOffset: this._timer.scheduled() ? this._timer.expireEpoch - this._scheduler.epoch : null,
             disc: this._disc ? this._disc.snapshotState() : null,
         };
@@ -398,7 +431,7 @@ export class DiscDrive extends BaseDiscDrive {
         this._headPosition = state.headPosition;
         this._pulsePosition = state.pulsePosition;
         this._in32usMode = state.in32usMode;
-        this._is40Track = state.is40Track;
+        this._tracksPerStep = state.is40Track ? 2 : 1;
 
         // Restore spinning state and timer
         this._timer.cancel();

package/src/disc-hfe.js

@@ -12,6 +12,7 @@ const HfeV3OpcodeSetIndex = 0xf1;
 const HfeV3OpcodeSetBitrate = 0xf2;
 const HfeV3OpcodeSkipBits = 0xf3;
 const HfeV3OpcodeRand = 0xf4;
+const HfeTrackCountOffset = 9;
 const HfeBlockSideSize = 256;
 const HfeBlockSize = HfeBlockSideSize * 2;
 const HfeShugartDdFloppyMode = 7;
@@ -52,6 +53,21 @@ function hfeGetTrackOffsetAndLength(metadata, track) {
     return { offset, length };
 }
 
+/**
+ * Whether an HFE image holds a 40 track format. A capture with no more tracks than half a surface
+ * cannot be one of an 80 track disc, whatever drive read it.
+ *
+ * @param {Uint8Array} data
+ * @returns {{is40Track: boolean, reason: string}}
+ */
+export function sniffHfeLayout(data) {
+    const numTracks = data.length > HfeTrackCountOffset ? data[HfeTrackCountOffset] : 0;
+    return {
+        is40Track: numTracks > 0 && numTracks * 2 <= IbmDiscFormat.tracksPerDisc,
+        reason: `its header declares ${numTracks} tracks`,
+    };
+}
+
 /**
  * Load a disc image in HFE format (v1 or v3)
  * @param {import("./disc.js").Disc} disc - The disc object to load into
@@ -84,11 +100,12 @@ export function loadHfe(disc, data, onChange) {
     const numSides = data[10];
     if (numSides < 1 || numSides > 2) throw new Error(`Invalid number of sides: ${numSides}`);
 
-    const numTracks = data[9];
+    const numTracks = data[HfeTrackCountOffset];
     if (numTracks > IbmDiscFormat.tracksPerDisc) throw new Error(`Too many tracks: ${numTracks}`);
     let expandShift = 0;
     if (disc.config.expandTo80 && numTracks * 2 <= IbmDiscFormat.tracksPerDisc) {
         expandShift = 1;
+        disc.is40Track = true;
         console.log("Expanding 40 tracks to 80");
     }
 
@@ -196,7 +213,7 @@ export function loadHfe(disc, data, onChange) {
             const hfeData = toHfe(disc);
             // Call the onChange handler with the updated HFE data
             onChange(hfeData);
-        });
+        }, true);
     }
 
     return disc;