jsbeeb 1.16.0 → 1.17.0

package/README.md

@@ -240,10 +240,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.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"
@@ -44,6 +44,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 +105,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/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/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/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");
     }
 

package/src/disc.js

@@ -527,6 +527,13 @@ class Side {
     }
 }
 
+/** How an image's tracks are laid out on the surface, and whether that is for the loader to decide. */
+export const DiscLayout = Object.freeze({
+    auto: "auto",
+    contiguous: "contiguous",
+    expanded40: "expanded40",
+});
+
 export class DiscConfig {
     constructor() {
         // TODO is this even useful?
@@ -553,6 +560,74 @@ class SsdFormat {
     static get tracksPerDisc() {
         return 80;
     }
+
+    static get trackSize() {
+        return SsdFormat.sectorSize * SsdFormat.sectorsPerTrack;
+    }
+}
+
+/** @returns {Number} how many logical tracks of `data` hold anything, ignoring a run of trailing zeros */
+function tracksWithData(data, numSides) {
+    let lastUsed = data.length - 1;
+    while (lastUsed >= 0 && data[lastUsed] === 0) lastUsed--;
+    return Math.floor(lastUsed / (SsdFormat.trackSize * numSides)) + 1;
+}
+
+// The DFS catalogue is the first two sectors of a side. Sector 1 holds how many files there are and
+// how many sectors the disc has.
+const DfsEntryCountOffset = 0x105;
+const DfsSectorCountOffset = 0x106;
+const DfsEntrySize = 8;
+const DfsMaxEntries = 31;
+
+/**
+ * Whether an SSD or DSD image was written by a 40 track drive. Only its catalogue can say: images
+ * are routinely padded out or cut short, so their size means nothing.
+ *
+ * @param {Uint8Array} data
+ * @param {boolean} isDsd
+ * @returns {{is40Track: boolean, reason: string}}
+ */
+export function sniffDfsLayout(data, isDsd) {
+    const contiguous = (reason) => ({ is40Track: false, reason });
+    if (data.length < 2 * SsdFormat.sectorSize) return contiguous("it is smaller than a catalogue");
+    const entryBytes = data[DfsEntryCountOffset];
+    if (entryBytes % DfsEntrySize !== 0 || entryBytes > DfsMaxEntries * DfsEntrySize)
+        return contiguous(`its catalogue claims ${entryBytes} bytes of file entries`);
+    const sectors = ((data[DfsSectorCountOffset] & 3) << 8) | data[DfsSectorCountOffset + 1];
+    const reason = `its catalogue claims ${sectors} sectors`;
+    const fortyTrackSectors = (SsdFormat.tracksPerDisc / 2) * SsdFormat.sectorsPerTrack;
+    if (sectors === 0 || sectors > fortyTrackSectors) return contiguous(reason);
+    const tracks = tracksWithData(data, isDsd ? 2 : 1);
+    if (tracks > IbmDiscFormat.tracksPerDisc / 2) return contiguous(`it holds data as far as track ${tracks - 1}`);
+    return { is40Track: true, reason };
+}
+
+// One track could match by luck; a disc's worth of them could not.
+const MinDoubleSteppedTracks = 4;
+
+/**
+ * Whether a surface holds a 40 track format, going by where its sectors say they are: a track
+ * written by a 48 tpi head sits at twice the number its own headers claim, with nothing readable
+ * on the tracks between. Only a flux image can be asked this, since for any other format the
+ * layout is the loader's own doing.
+ *
+ * @param {Disc} disc
+ * @returns {{is40Track: boolean, reason: string}}
+ */
+export function sniffSurfaceLayout(disc) {
+    let doubleStepped = 0;
+    // Both heads move together, so a disc has one pitch and the side that boots can speak for it.
+    // Track 0 is where it claims to be at either pitch, so it says nothing.
+    for (let trackNum = 1; trackNum < disc.tracksUsed; ++trackNum) {
+        const sectors = disc.getTrack(false, trackNum).findSectorIds(() => {});
+        if (!sectors.length) continue;
+        if (trackNum & 1) return { is40Track: false, reason: `track ${trackNum} holds sectors of its own` };
+        if (sectors.some((sector) => sector.trackNumber === trackNum / 2)) doubleStepped++;
+    }
+    if (doubleStepped < MinDoubleSteppedTracks)
+        return { is40Track: false, reason: `only ${doubleStepped} tracks sit at twice their own number` };
+    return { is40Track: true, reason: `${doubleStepped} tracks sit at twice the number their sectors claim` };
 }
 
 /**
@@ -576,10 +651,19 @@ export function loadSsd(disc, data, isDsd, onChange) {
         throw new Error("SSD file is too large");
     }
 
+    disc.is40Track = disc.config.expandTo80;
+    const trackStep = disc.is40Track ? 2 : 1;
+    // Tracks twice as far apart are half as many, and an image can run past the last of them as
+    // far as the surface has room for.
+    const numTracks = Math.min(
+        IbmDiscFormat.tracksPerDisc / trackStep,
+        Math.max(SsdFormat.tracksPerDisc / trackStep, tracksWithData(data, numSides)),
+    );
+
     let offset = 0;
-    for (let track = 0; track < SsdFormat.tracksPerDisc; ++track) {
+    for (let track = 0; track < numTracks; ++track) {
         for (let side = 0; side < numSides; ++side) {
-            const trackBuilder = disc.buildTrack(side === 1, track);
+            const trackBuilder = disc.buildTrack(side === 1, track * trackStep);
             // Sync pattern at start of track, as the index pulse starts, aka GAP 5.
             trackBuilder
                 .appendRepeatFmByte(0xff, IbmDiscFormat.stdGap1FFs)
@@ -631,12 +715,9 @@ export function loadSsd(disc, data, isDsd, onChange) {
         dataCopy.set(data);
         disc.addTrackWriteListener(
             /** @param {Track} trackObj  */
-            (side, trackNum, trackObj) => {
-                const trackOffset =
-                    SsdFormat.sectorSize * SsdFormat.sectorsPerTrack * (trackNum * numSides + (side ? 1 : 0));
+            (side, _trackNum, trackObj) => {
                 for (const sector of trackObj.findSectors())
-                    if (!sectorShortfall(sector, trackNum))
-                        dataCopy.set(sector.sectorData, trackOffset + sector.sectorNumber * SsdFormat.sectorSize);
+                    if (!sectorShortfall(sector)) dataCopy.set(sector.sectorData, ssdOffsetOf(sector, side, numSides));
                 onChange(dataCopy);
             },
         );
@@ -720,17 +801,30 @@ export function loadAdf(disc, data, isDsd) {
 }
 
 /** Why a sector will not fit in an SSD or DSD image, or null if it will. */
-function sectorShortfall(sector, trackNum) {
+function sectorShortfall(sector) {
     if (sector.hasDataCrcError || sector.hasHeaderCrcError) return "with a CRC error";
     // A header whose data mark never arrives leaves the sector with nothing to write.
     if (!sector.sectorData) return "with no data";
     if (sector.sectorNumber >= SsdFormat.sectorsPerTrack)
         return `numbered past the ${SsdFormat.sectorsPerTrack} a track holds`;
     if (sector.sectorData.length !== SsdFormat.sectorSize) return `not ${SsdFormat.sectorSize} bytes`;
-    if (trackNum >= SsdFormat.tracksPerDisc) return `past track ${SsdFormat.tracksPerDisc}`;
+    if (sector.trackNumber >= SsdFormat.tracksPerDisc) return `past track ${SsdFormat.tracksPerDisc}`;
     return null;
 }
 
+/**
+ * Where a sector belongs in an SSD or DSD image, which is the track its own header claims rather
+ * than the one it sits on.
+ *
+ * @param {Sector} sector
+ * @param {boolean} isSideUpper
+ * @param {Number} numSides
+ */
+function ssdOffsetOf(sector, isSideUpper, numSides) {
+    const track = sector.trackNumber * numSides + (isSideUpper ? 1 : 0);
+    return track * SsdFormat.trackSize + sector.sectorNumber * SsdFormat.sectorSize;
+}
+
 /**
  * SSD and DSD images hold sector contents and nothing else, so anything a DFS sector could not
  * have held is lost. Copy protection usually shows up as one of these.
@@ -743,7 +837,7 @@ export function ssdOrDsdShortfalls(disc) {
     for (let trackNum = 0; trackNum < disc.tracksUsed; ++trackNum) {
         for (const upper of disc.isDoubleSided ? [false, true] : [false]) {
             for (const sector of disc.getTrack(upper, trackNum).findSectors()) {
-                const shortfall = sectorShortfall(sector, trackNum);
+                const shortfall = sectorShortfall(sector);
                 if (shortfall) counts.set(shortfall, (counts.get(shortfall) ?? 0) + 1);
             }
         }
@@ -770,22 +864,19 @@ export function toSsdOrDsd(disc, { force = false } = {}) {
             );
     }
     const numSides = disc.isDoubleSided ? 2 : 1;
-    const result = new Uint8Array(
-        numSides * SsdFormat.tracksPerDisc * SsdFormat.sectorsPerTrack * SsdFormat.sectorSize,
-    );
-    let offset = 0;
+    const result = new Uint8Array(numSides * SsdFormat.tracksPerDisc * SsdFormat.trackSize);
+    let numTracks = 0;
     for (let trackNum = 0; trackNum < disc.tracksUsed; ++trackNum) {
         for (let side = 0; side < numSides; ++side) {
             const trackObj = disc.getTrack(side === 1, trackNum);
             for (const sector of trackObj.findSectors()) {
-                if (sectorShortfall(sector, trackNum)) continue;
-                const sectorOffset = offset + sector.sectorNumber * SsdFormat.sectorSize;
-                for (let x = 0; x < SsdFormat.sectorSize; ++x) result[sectorOffset + x] = sector.sectorData[x];
+                if (sectorShortfall(sector)) continue;
+                result.set(sector.sectorData, ssdOffsetOf(sector, side === 1, numSides));
+                numTracks = Math.max(numTracks, sector.trackNumber + 1);
             }
-            offset += SsdFormat.sectorsPerTrack * SsdFormat.sectorSize;
         }
     }
-    return result.slice(0, offset);
+    return result.slice(0, numTracks * numSides * SsdFormat.trackSize);
 }
 
 export class Disc {
@@ -810,6 +901,8 @@ export class Disc {
         this.dirtyTrack = -1;
         this.tracksUsed = 0;
         this.isDoubleSided = false;
+        // Whether the surface holds a 48 tpi layout, which a drive reads by double stepping.
+        this.is40Track = false;
 
         this._trackWriteListeners = new Set();
         this.isWriteable = isWriteable;
@@ -944,10 +1037,11 @@ export class Disc {
         // console.log(`wrote to ${track}:${position * 32}`);
     }
 
+    /** @returns {?{isSideUpper: boolean, trackNum: Number}} the track written, if there was one */
     flushWrites() {
         if (!this.isDirty) {
             if (this.dirtySide !== -1 || this.dirtyTrack !== -1) throw new Error("Bad state in disc dirty tracking");
-            return;
+            return null;
         }
 
         const dirtySide = this.dirtySide;
@@ -958,6 +1052,24 @@ export class Disc {
         const trackObj = this.getTrack(dirtySide, dirtyTrack);
         this.setTrackUsed(dirtySide, dirtyTrack);
         for (const listener of this._trackWriteListeners) listener(dirtySide, dirtyTrack, trackObj);
+        return { isSideUpper: dirtySide, trackNum: dirtyTrack };
+    }
+
+    /**
+     * Leave a track with no flux on it at all, as an erase head does.
+     *
+     * @param {boolean} isSideUpper
+     * @param {Number} trackNum
+     */
+    eraseTrack(isSideUpper, trackNum) {
+        const trackObj = this.getTrack(isSideUpper, trackNum);
+        trackObj.pulses2Us.fill(0);
+        trackObj.length = IbmDiscFormat.bytesPerTrack;
+        const dirtyKey = trackNum | (isSideUpper ? 0x100 : 0);
+        this._snapshotDirtyTracks.add(dirtyKey);
+        this._everDirtyTracks.add(dirtyKey);
+        this.setTrackUsed(isSideUpper, trackNum);
+        for (const listener of this._trackWriteListeners) listener(isSideUpper, trackNum, trackObj);
     }
 
     /**