jsbeeb 1.17.1 → 1.18.0

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.17.1",
+  "version": "1.18.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"
@@ -106,10 +106,11 @@
     "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": "node tools/mirror-bbcdiscs.js --csv .bbcdiscs-sheet.csv --fsd .bbcdiscs-mirror/cache-fsd --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:preflight": "node tools/mirror-bbcdiscs.js --preflight --out .bbcdiscs-mirror",
+    "mirror-bbcdiscs:upload": "npm-run-all mirror-bbcdiscs:preflight 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 .",

package/src/6502.js

@@ -709,6 +709,7 @@ export class Cpu6502 extends Base6502 {
         this.acia = new Acia(this, this.soundChip.toneGenerator, this.scheduler, this.relayNoise);
         this.serial = new Serial(this.acia);
         this.adconverter = new Adc(this.sysvia, this.scheduler);
+        this.touchScreen = new TouchScreen(this.scheduler, this.model.cyclesPerSecond);
         this.soundChip.setScheduler(this.scheduler);
         this.fdc = new this.model.Fdc(this, this.ddNoise, this.scheduler, this.debugFlags);
     }
@@ -1240,7 +1241,9 @@ export class Cpu6502 extends Base6502 {
             soundChip: this.soundChip.snapshotState(),
             acia: this.acia.snapshotState(),
             adc: this.adconverter.snapshotState(),
+            touchScreen: this.touchScreen.snapshotState(),
             fdc: this.fdc.snapshotState(),
+            teletextAdaptor: this.teletextAdaptor ? this.teletextAdaptor.snapshotState() : undefined,
             tube: this.hasTube ? this.tube.snapshotState({ includeRoms }) : undefined,
         };
     }
@@ -1297,6 +1300,11 @@ export class Cpu6502 extends Base6502 {
         this.soundChip.restoreState(state.soundChip);
         this.acia.restoreState(state.acia);
         this.adconverter.restoreState(state.adc);
+        if (this.teletextAdaptor && state.teletextAdaptor) this.teletextAdaptor.restoreState(state.teletextAdaptor);
+
+        // Touchscreen state, added without a version bump. Absent from an older snapshot, whose
+        // touchscreen keeps its current state, unpolled.
+        if (state.touchScreen) this.touchScreen.restoreState(state.touchScreen);
 
         // FDC state (v2+). If absent (v1 snapshot), FDC keeps its current state.
         if (state.fdc) {
@@ -1370,7 +1378,7 @@ export class Cpu6502 extends Base6502 {
         this.fdc.powerOnReset();
         this.adconverter.reset();
 
-        this.touchScreen = new TouchScreen(this.scheduler, this.model.cyclesPerSecond);
+        this.touchScreen.reset();
         if (this.econet) this.filestore = new Filestore(this, this.econet);
     }
 

package/src/bbcdiscs.js

@@ -2,6 +2,14 @@
 
 const mirrorBase = "https://bbc.xania.org/archive/bbcdiscs";
 
+/** How a disc came to be an image, which is the difference between the archives it came from. */
+export const Provenance = {
+    /** Read off the disc itself, by flux capture. */
+    Captured: "captured",
+    /** Rebuilt from a sector dump, so the surface around the data is inferred. */
+    Reconstructed: "reconstructed",
+};
+
 // 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" });
@@ -34,6 +42,25 @@ export function describe(file) {
     };
 }
 
+/** The provenances a catalogue actually holds, so a source added later needs no code here. */
+export const provenancesIn = (catalogue) => [...new Set(catalogue.map((file) => file.provenance))].sort();
+
+/**
+ * Whether a disc belongs in the picker as it is currently filtered.
+ *
+ * @param {object} file manifest entry
+ * @param {string} filter lower cased text to look for
+ * @param {?Set<string>} shown provenances to include, or null for all of them
+ */
+export function matches(file, filter, shown) {
+    if (shown && !shown.has(file.provenance)) return false;
+    if (!filter) return true;
+    // What the row says the disc is, rather than everything the row renders:
+    // the provenance is a word the tickboxes control, not one to search for.
+    const { title, publisher, detail } = describe(file);
+    return `${title} ${publisher} ${detail}`.toLowerCase().includes(filter);
+}
+
 export class BbcDiscArchive {
     /** @param {string} [baseUrl] where the mirror lives, to point at a test prefix */
     constructor(onStart, onCat, onError, baseUrl = mirrorBase) {
@@ -55,7 +82,10 @@ export class BbcDiscArchive {
                 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._catalogue = data.files
+                    // The captured discs were published before provenance was recorded.
+                    .map((file) => ({ ...file, provenance: file.provenance ?? Provenance.Captured }))
+                    .sort(byTitle);
                 this._loaded = true;
             } catch (error) {
                 console.error("Failed to fetch HFE archive catalogue:", error);

package/src/canvas.js

@@ -38,6 +38,11 @@ export class Canvas {
     /** Nothing to release: the 2D context owns no objects of ours. */
     dispose() {}
 
+    setFilter(filterClass) {
+        if (filterClass !== PassthroughFilter)
+            throw new Error(`${filterClass.getDisplayConfig().name} needs WebGL, which is not in use here`);
+    }
+
     paint(minx, miny, maxx, maxy, _frame) {
         const width = maxx - minx;
         const height = maxy - miny;
@@ -78,23 +83,14 @@ export class GlCanvas {
 
         checkedGl.depthMask(false);
 
-        this.filter = new filterClass(checkedGl);
-        const program = this.filter.program;
-        checkedGl.useProgram(program);
-
-        // Filters that pick their own samples want the texels they asked for,
-        // not a hardware blend of the ones either side.
-        const sampling = filterClass.getDisplayConfig().nearestSampling ? checkedGl.NEAREST : checkedGl.LINEAR;
-
         this.fb8 = new Uint8Array(width * height * 4);
         this.fb32 = new Uint32Array(this.fb8.buffer);
         this.texture = checkedGl.createTexture();
+        checkedGl.activeTexture(checkedGl.TEXTURE0);
         checkedGl.bindTexture(checkedGl.TEXTURE_2D, this.texture);
         checkedGl.pixelStorei(checkedGl.UNPACK_ALIGNMENT, 4);
         checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_WRAP_S, checkedGl.CLAMP_TO_EDGE);
         checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_WRAP_T, checkedGl.CLAMP_TO_EDGE);
-        checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_MAG_FILTER, sampling);
-        checkedGl.texParameteri(checkedGl.TEXTURE_2D, checkedGl.TEXTURE_MIN_FILTER, sampling);
         checkedGl.texImage2D(
             checkedGl.TEXTURE_2D,
             0,
@@ -106,44 +102,72 @@ export class GlCanvas {
             checkedGl.UNSIGNED_BYTE,
             this.fb8,
         );
-        checkedGl.bindTexture(checkedGl.TEXTURE_2D, null);
 
-        const vertexPositionAttrLoc = checkedGl.getAttribLocation(program, "pos");
-        checkedGl.enableVertexAttribArray(vertexPositionAttrLoc);
         this.vertexPositionBuffer = checkedGl.createBuffer();
         checkedGl.bindBuffer(checkedGl.ARRAY_BUFFER, this.vertexPositionBuffer);
         checkedGl.bufferData(checkedGl.ARRAY_BUFFER, new Float32Array([0, 0, 0, 1, 1, 0, 1, 1]), checkedGl.STATIC_DRAW);
-        checkedGl.vertexAttribPointer(vertexPositionAttrLoc, 2, checkedGl.FLOAT, false, 0, 0);
-
-        const uvAttrLoc = checkedGl.getAttribLocation(program, "uvIn");
-        checkedGl.enableVertexAttribArray(uvAttrLoc);
         this.uvBuffer = checkedGl.createBuffer();
-        checkedGl.bindBuffer(checkedGl.ARRAY_BUFFER, this.uvBuffer);
-        checkedGl.vertexAttribPointer(uvAttrLoc, 2, checkedGl.FLOAT, false, 0, 0);
-
-        checkedGl.activeTexture(gl.TEXTURE0);
-        checkedGl.bindTexture(gl.TEXTURE_2D, this.texture);
 
         this.checkedGl = checkedGl;
+        this.filter = null;
+        this.attribLocations = [];
         this.viewportWidth = this.viewportHeight = 0;
         this.uvFloatArray = new Float32Array(8);
         this.lastExtent = {};
 
+        try {
+            this.setFilter(filterClass);
+        } catch (e) {
+            this.dispose();
+            throw e;
+        }
+
         console.log("GL Canvas set up");
     }
 
     /**
-     * Release the GL objects this canvas owns.
+     * Draw with `filterClass` from here on, keeping the framebuffer texture and
+     * the vertex buffers: only the program, the texture sampling mode and the
+     * attribute locations differ between filters.
      *
-     * Switching display mode builds a new canvas over the same element, and a
-     * canvas only ever hands out one WebGL context — so the new one inherits
-     * the old one's context and the old one's objects stay resident unless
-     * they are deleted here. That is a megabytes-per-switch leak: the
-     * framebuffer texture alone is 1024x1024 RGBA.
+     * The new filter is built before the old one is disposed, so a filter that
+     * will not build leaves the canvas drawing as it was.
+     */
+    setFilter(filterClass) {
+        const gl = this.checkedGl;
+        const filter = new filterClass(gl);
+        this.filter?.dispose();
+        this.filter = filter;
+        gl.useProgram(filter.program);
+
+        // Filters that pick their own samples want the texels they asked for,
+        // not a hardware blend of the ones either side.
+        const sampling = filterClass.getDisplayConfig().nearestSampling ? gl.NEAREST : gl.LINEAR;
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this.texture);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, sampling);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, sampling);
+
+        const bindAttribute = (name, buffer) => {
+            const location = gl.getAttribLocation(filter.program, name);
+            gl.enableVertexAttribArray(location);
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.vertexAttribPointer(location, 2, gl.FLOAT, false, 0, 0);
+            return location;
+        };
+        for (const location of this.attribLocations) gl.disableVertexAttribArray(location);
+        this.attribLocations = [bindAttribute("pos", this.vertexPositionBuffer), bindAttribute("uvIn", this.uvBuffer)];
+    }
+
+    /**
+     * Release the GL objects this canvas owns. Nothing else will: a canvas
+     * element hands out one WebGL context for its lifetime, so anything created
+     * through that context stays resident however many wrappers come and go.
      */
     dispose() {
         const gl = this.checkedGl;
-        this.filter.dispose();
+        this.filter?.dispose();
+        this.filter = null;
         gl.deleteTexture(this.texture);
         gl.deleteBuffer(this.vertexPositionBuffer);
         gl.deleteBuffer(this.uvBuffer);
@@ -218,6 +242,24 @@ function fellBackBecause(canvas, reason) {
     return canvas;
 }
 
+/**
+ * Draw with `filterClass`, or with the unfiltered display if it will not build,
+ * in which case `fallbackReason` says why.
+ */
+export function useBestFilter(canvas, filterClass) {
+    let reason;
+    try {
+        canvas.setFilter(filterClass);
+        return fellBackBecause(canvas, undefined);
+    } catch (e) {
+        console.log(`Unable to use ${filterClass.getDisplayConfig().name}: ${e}`);
+        if (filterClass === PassthroughFilter) throw e;
+        reason = e?.message ?? e;
+    }
+    canvas.setFilter(PassthroughFilter);
+    return fellBackBecause(canvas, reason);
+}
+
 export function bestCanvas(canvas, filterClass) {
     let reason;
     try {

package/src/jsbeeb.css

@@ -1,5 +1,6 @@
 body {
   overflow: hidden;
+  visibility: visible !important; /* see index.html */
 }
 #outer {
   display: block;
@@ -171,7 +172,7 @@ th {
 
 #hfe-list li a {
   display: grid;
-  grid-template-columns: minmax(0, 3fr) minmax(0, 2fr) minmax(0, 2fr);
+  grid-template-columns: minmax(0, 3fr) minmax(0, 2fr) minmax(0, 2fr) 7em;
   gap: 0 1rem;
   align-items: baseline;
   padding: 3px 6px;
@@ -198,6 +199,22 @@ th {
   font-family: monospace;
 }
 
+#hfe-list .provenance {
+  font-size: 0.8em;
+  opacity: 0.6;
+  font-style: italic;
+  text-align: right;
+}
+
+.hfe-provenance label {
+  margin-left: 1.5rem;
+  opacity: 0.8;
+}
+
+.hfe-provenance input {
+  margin-right: 0.3em;
+}
+
 .hfe-credit {
   font-size: 0.9em;
   opacity: 0.75;
@@ -208,6 +225,11 @@ th {
     grid-template-columns: minmax(0, 1fr);
     padding-bottom: 6px;
   }
+
+  /* Stacked into one column, so there is no column end to sit against. */
+  #hfe-list .provenance {
+    text-align: left;
+  }
 }
 
 div.filter {

package/src/machine-session.js

@@ -25,6 +25,9 @@ import sharp from "sharp";
 const FB_WIDTH = 1024;
 const FB_HEIGHT = 625;
 
+// Five times a frame, so only a machine that has stopped painting hits it.
+const BackstopSecondsPerFrame = 0.1;
+
 export class MachineSession {
     /**
      * @param {string} modelName - e.g. "B-DFS1.2", "Master"
@@ -46,6 +49,8 @@ export class MachineSession {
         this._completeFb8 = new Uint8Array(FB_WIDTH * FB_HEIGHT * 4);
         this._lastPaint = { minx: 0, miny: 0, maxx: FB_WIDTH, maxy: FB_HEIGHT };
         this._frameDirty = false;
+        this._frameCount = 0;
+        this._stopAtFrame = Infinity;
 
         // Create a real Video instance so we get pixel output
         const modelObj = findModel(modelName);
@@ -59,6 +64,8 @@ export class MachineSession {
                 // Snapshot the complete frame now, before clearPaintBuffer() wipes _fb32.
                 // This mirrors what the browser does: paint_ext fires → canvas updated → fb32 cleared.
                 this._completeFb8.set(this._fb8);
+                this._frameCount++;
+                if (this._frameCount >= this._stopAtFrame) this._machine.processor.stop();
             },
             { isAtom: modelObj.isAtom },
         );
@@ -308,6 +315,56 @@ export class MachineSession {
         await this._machine.runFor(cycles);
     }
 
+    /** Emulated cycles since power-on, undoing the per-second rebasing execute() applies */
+    get elapsedCycles() {
+        const cpu = this._machine.processor;
+        return cpu.cycleSeconds * cpu.model.cyclesPerSecond + cpu.currentCycles;
+    }
+
+    /**
+     * Run until `count` more frames have been painted, stopping on the paint
+     * itself.  A frame is 40000 cycles interlaced, 39936 not, and whatever a
+     * program driving the CRTC makes it, so stepping by cycles instead walks
+     * the sample point through the guest's frame.
+     *
+     * `completed` is false if a breakpoint fired, or the backstop ran out
+     * first.
+     *
+     * @param {number} [count=1] frames to advance
+     * @param {Object} [opts]
+     * @param {number} [opts.maxCycles] how long to wait on a machine that is not painting
+     * @returns {Promise<{framesRun: number, cyclesRun: number, completed: boolean}>}
+     */
+    async runFrames(count = 1, { maxCycles } = {}) {
+        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);
+        } 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 */
+    get frameCount() {
+        return this._frameCount;
+    }
+
     /**
      * Run until PC reaches targetAddr (like a breakpoint), or timeout.
      */

package/src/main.js

@@ -12,7 +12,7 @@ import * as utils_atom from "./utils_atom.js";
 import { LoadSD } from "./mmc.js";
 import { Cmos, localStoragePersistence } from "./cmos.js";
 import { StairwayToHell } from "./sth.js";
-import { BbcDiscArchive, describe as describeHfe } from "./bbcdiscs.js";
+import { BbcDiscArchive, Provenance, describe as describeHfe, matches, provenancesIn } from "./bbcdiscs.js";
 import { GamePad } from "./gamepads.js";
 import * as disc from "./fdc.js";
 import { loadTapeFromData } from "./tapes.js";
@@ -397,6 +397,24 @@ function showError(context, error) {
 
 const errorText = (error) => error?.message ?? `${error}`;
 
+function reportLoadFailure(description, error) {
+    console.error(`Error loading ${description}:`, error);
+    toast(`Could not load ${description}: ${errorText(error)}`, { title: "Loading" });
+}
+
+function reportIgnoredFiles(name, ignored) {
+    if (!ignored.length) return;
+    toast(`Loaded ${name}. The archive also holds ${ignored.join(", ")}, and only one file is loaded from it.`, {
+        title: "Archive",
+    });
+}
+
+async function unzipAndReport(data) {
+    const unzipped = await utils.unzipDiscImage(data);
+    reportIgnoredFiles(unzipped.name, unzipped.ignored);
+    return unzipped;
+}
+
 function showNotice(event) {
     const { message, title, quietKey } = event.detail;
     toast(message, { title, quietKey });
@@ -471,59 +489,57 @@ function noteDriveTracks(driveIndex, discName) {
     });
 }
 
-function createCanvasForFilter(filterClass) {
+// Test which filter is actually in use, not merely whether we got WebGL: a
+// filter can decline a context that works perfectly well for other modes, in
+// which case we are quietly left with an unfiltered display.
+function reportAnyFallback(displayCanvas, filterClass) {
+    if (displayCanvas.filterClass === filterClass) return;
+    const reason = displayCanvas.fallbackReason ? ` (${displayCanvas.fallbackReason})` : "";
+    const { name } = filterClass.getDisplayConfig();
+    toast(`${name} is not available on this device, so the standard display is in use${reason}.`, {
+        title: "Display",
+        quietKey: "quietDisplayFallback",
+    });
+}
+
+function sizeCanvasFor(filterClass) {
     // Not `config`: that is the emulator's live configuration object, declared
     // at module scope and used throughout this file.
     const displayConfig = filterClass.getDisplayConfig();
-    // Each mode says how many pixels it wants to draw into. Set this before
-    // creating the context, which fixes its initial viewport.
+    if (screenCanvas.width === displayConfig.canvasWidth && screenCanvas.height === displayConfig.canvasHeight) return;
     screenCanvas.width = displayConfig.canvasWidth;
     screenCanvas.height = displayConfig.canvasHeight;
+}
 
-    const newCanvas = tryGl ? canvasLib.bestCanvas(screenCanvas, filterClass) : new canvasLib.Canvas(screenCanvas);
-
-    // Test which filter was actually built, not merely whether we got WebGL: a
-    // filter can decline a context that works perfectly well for other modes,
-    // in which case bestCanvas quietly gives us an unfiltered GL canvas.
-    if (newCanvas.filterClass !== filterClass) {
-        const reason = newCanvas.fallbackReason ? ` (${newCanvas.fallbackReason})` : "";
-        toast(`${displayConfig.name} is not available on this device, so the standard display is in use${reason}.`, {
-            title: "Display",
-            quietKey: "quietDisplayFallback",
-        });
-    }
+function createCanvasForFilter(filterClass) {
+    // Each mode says how many pixels it wants to draw into. Set this before
+    // creating the context, which fixes its initial viewport.
+    sizeCanvasFor(filterClass);
 
+    const newCanvas = tryGl ? canvasLib.bestCanvas(screenCanvas, filterClass) : new canvasLib.Canvas(screenCanvas);
+    reportAnyFallback(newCanvas, filterClass);
     return newCanvas;
 }
 
 let displayModeFilter = canvasLib.getFilterForMode(parsedQuery.displayMode || "rgb");
 function swapCanvas(newFilterClass) {
-    const oldCanvas = canvas;
-    const newCanvas = createCanvasForFilter(newFilterClass);
-    // Carry the picture over; the buffers differ in height, so copy what fits.
-    newCanvas.fb32.set(oldCanvas.fb32.subarray(0, newCanvas.fb32.length));
-    // Only once the replacement exists, so a failure to build it leaves the
-    // display we already had. The two share a GL context but no GL objects.
-    oldCanvas.dispose();
-    video.fb32 = newCanvas.fb32;
-    video.paint_ext = function paint(minx, miny, maxx, maxy) {
-        frames++;
-        if (frames < frameSkip) return;
-        frames = 0;
-        newCanvas.paint(minx, miny, maxx, maxy, { frameCount: this.frameCount, lineGrid: this.lineGrid });
-    };
-    canvas = newCanvas;
+    // Everything but the filter is the same whatever the mode: the framebuffer
+    // texture, the vertex buffers and fb32 all carry over untouched.
+    canvasLib.useBestFilter(canvas, newFilterClass);
+    reportAnyFallback(canvas, newFilterClass);
     // Follow the filter we ended up with, not the one we asked for: everything
-    // downstream — the monitor picture, the canvas geometry, how large a
-    // drawing buffer to ask for — comes from its display config.
-    displayModeFilter = newCanvas.filterClass;
+    // downstream (the monitor picture, the canvas geometry, how large a drawing
+    // buffer to ask for) comes from its display config.
+    displayModeFilter = canvas.filterClass;
+    // Back to the mode's own size, undoing any scaling the last one asked for.
+    sizeCanvasFor(displayModeFilter);
     // Nothing else will redraw: the mode is changed from a modal, which stops
     // the emulator.
     video.paint();
     window.setTimeout(() => window.dispatchEvent(new Event("resize")), 1);
 }
 
-let canvas = createCanvasForFilter(displayModeFilter);
+const canvas = createCanvasForFilter(displayModeFilter);
 displayModeFilter = canvas.filterClass;
 
 video = new Video(
@@ -641,14 +657,19 @@ pastetext.addEventListener("dragover", function (event) {
 pastetext.addEventListener("drop", async function (event) {
     utils.noteEvent("local", "drop");
     const file = event.dataTransfer.files[0];
-    const arrayBuffer = await file.arrayBuffer();
-    if (isSnapshotFile(file.name, arrayBuffer)) {
-        await loadStateFromFile(file, arrayBuffer);
-    } else if (file.name.toLowerCase().endsWith(".uef")) {
-        // Regular UEF tape image (not a BeebEm save state)
-        setProcessorTape(await loadTapeFromData(file.name, new Uint8Array(arrayBuffer), model));
-    } else {
-        await loadHTMLFile(file);
+    if (!file) return;
+    try {
+        const arrayBuffer = await file.arrayBuffer();
+        if (isSnapshotFile(file.name, arrayBuffer)) {
+            await loadStateFromFile(file, arrayBuffer);
+        } else if (file.name.toLowerCase().endsWith(".uef")) {
+            // Regular UEF tape image (not a BeebEm save state)
+            setProcessorTape(await loadTapeFromData(file.name, new Uint8Array(arrayBuffer), model));
+        } else {
+            await loadHTMLFile(file);
+        }
+    } catch (error) {
+        reportLoadFailure(file.name, error);
     }
 });
 
@@ -1211,13 +1232,15 @@ function hfeOnCat(catalogue) {
     const list = document.getElementById("hfe-list");
     document.querySelector("#hfe .loading").style.display = "none";
     const template = list.querySelector(".template");
+    showProvenanceChoices(catalogue, onHfeFilter);
 
     const addSome = (remaining) => {
         if (ticket !== hfeRender) return;
         const MaxAtATime = 100;
         const Delay = 30;
-        // Read per batch: the filter can be typed into while this is still going.
+        // Read per batch: both can be changed while this is still going.
         const filter = document.getElementById("hfe-filter").value.toLowerCase();
+        const shown = shownProvenances();
         for (const file of remaining.slice(0, MaxAtATime)) {
             const { title, publisher, detail } = describeHfe(file);
             const row = template.cloneNode(true);
@@ -1225,6 +1248,8 @@ function hfeOnCat(catalogue) {
             row.querySelector(".name").textContent = title;
             row.querySelector(".publisher").textContent = publisher;
             row.querySelector(".detail").textContent = detail;
+            row.querySelector(".provenance").textContent =
+                file.provenance === Provenance.Reconstructed ? "reconstructed" : "";
             if (file.notes) row.title = file.notes;
             // The row is an anchor, and letting it navigate to "#" would push a
             // history entry of its own on top of the one updateUrl pushes.
@@ -1233,8 +1258,9 @@ function hfeOnCat(catalogue) {
                 hfeClick(file);
                 $hfeModal.hide();
             });
-            row.style.display = row.textContent.toLowerCase().includes(filter) ? "" : "none";
+            row.hfeFile = file;
             list.appendChild(row);
+            showHfeRow(row, file, filter, shown);
         }
         if (remaining.length > MaxAtATime) setTimeout(() => addSome(remaining.slice(MaxAtATime)), Delay);
     };
@@ -1248,7 +1274,53 @@ document.getElementById("hfe").addEventListener("shown.bs.modal", () => {
 document.getElementById("hfe").addEventListener("show.bs.modal", () => hfeArchive.populate());
 
 const hfeFilter = document.getElementById("hfe-filter");
-const onHfeFilter = () => filterArchiveList("hfe-list", hfeFilter.value);
+const hfeProvenance = document.getElementById("hfe-provenance");
+
+const HfeProvenanceLabels = {
+    [Provenance.Captured]: ["Captured", "Direct from disc"],
+    [Provenance.Reconstructed]: ["Reconstructed", "Rebuilt from a sector dump"],
+};
+
+/** Which provenances the picker is showing, or null when it is not offering the choice. */
+const shownProvenances = () => {
+    const boxes = [...hfeProvenance.querySelectorAll("input")];
+    return boxes.length ? new Set(boxes.filter((box) => box.checked).map((box) => box.value)) : null;
+};
+
+// Offer one tick per provenance the archive actually holds, rather than naming
+// them here: a source added later should appear without this having to change.
+function showProvenanceChoices(catalogue, onChange) {
+    const present = provenancesIn(catalogue);
+    // Nothing to choose between: no ticks, and shownProvenances says "all".
+    if (present.length < 2) {
+        hfeProvenance.replaceChildren();
+        return;
+    }
+    const wasShown = shownProvenances();
+    hfeProvenance.replaceChildren(
+        ...present.map((provenance) => {
+            const [text, why] = HfeProvenanceLabels[provenance] ?? [provenance, ""];
+            const label = document.createElement("label");
+            label.title = why;
+            const box = document.createElement("input");
+            box.type = "checkbox";
+            box.value = provenance;
+            box.checked = !wasShown || wasShown.has(provenance);
+            box.addEventListener("change", onChange);
+            label.append(box, text);
+            return label;
+        }),
+    );
+}
+
+const showHfeRow = (row, file, filter, shown) => (row.style.display = matches(file, filter, shown) ? "" : "none");
+
+const onHfeFilter = () => {
+    const filter = hfeFilter.value.toLowerCase();
+    const shown = shownProvenances();
+    for (const row of document.querySelectorAll("#hfe-list li:not(.template)"))
+        showHfeRow(row, row.hfeFile, filter, shown);
+};
 hfeFilter.addEventListener("change", onHfeFilter);
 hfeFilter.addEventListener("keyup", onHfeFilter);
 
@@ -1385,7 +1457,8 @@ async function loadDiscImage(discImage, layout = DiscLayout.auto) {
     switch (schema) {
         case "|":
         case "sth": {
-            const { name, data } = await discSth.fetch(discImage);
+            const { name, data, ignored } = await discSth.fetch(discImage);
+            reportIgnoredFiles(name, ignored);
             return disc.discFor(processor.fdc, name, data, undefined, layout);
         }
 
@@ -1406,7 +1479,7 @@ async function loadDiscImage(discImage, layout = DiscLayout.auto) {
 
         case "data": {
             const arr = Array.prototype.map.call(atob(discImage), (x) => x.charCodeAt(0));
-            const { name, data } = await utils.unzipDiscImage(arr);
+            const { name, data } = await unzipAndReport(arr);
             return disc.discFor(processor.fdc, name, data, undefined, layout);
         }
         case "http":
@@ -1417,7 +1490,7 @@ async function loadDiscImage(discImage, layout = DiscLayout.auto) {
             discImage = new URL(asUrl).pathname;
             let discData = await utils.loadData(asUrl);
             if (/\.zip/i.test(discImage)) {
-                const unzipped = await utils.unzipDiscImage(discData);
+                const unzipped = await unzipAndReport(discData);
                 discData = unzipped.data;
                 discImage = unzipped.name;
             }
@@ -1436,13 +1509,14 @@ async function loadTapeImage(tapeImage) {
     switch (schema) {
         case "|":
         case "sth": {
-            const { name, data } = await tapeSth.fetch(tapeImage);
+            const { name, data, ignored } = await tapeSth.fetch(tapeImage);
+            reportIgnoredFiles(name, ignored);
             return await loadTapeFromData(name, data, model);
         }
 
         case "data": {
             const arr = Array.prototype.map.call(atob(tapeImage), (x) => x.charCodeAt(0));
-            const { name, data } = await utils.unzipDiscImage(arr);
+            const { name, data } = await unzipAndReport(arr);
             return await loadTapeFromData(name, data, model);
         }
 
@@ -1454,7 +1528,7 @@ async function loadTapeImage(tapeImage) {
             tapeImage = new URL(asUrl).pathname;
             let tapeData = await utils.loadData(asUrl);
             if (/\.zip/i.test(tapeImage)) {
-                const unzipped = await utils.unzipDiscImage(tapeData);
+                const unzipped = await unzipAndReport(tapeData);
                 tapeData = unzipped.data;
                 tapeImage = unzipped.name;
             }
@@ -1466,7 +1540,7 @@ async function loadTapeImage(tapeImage) {
             let tapeData = await utils.loadData(tapePath);
             let tapeName = tapeImage;
             if (/\.zip/i.test(tapeName)) {
-                const unzipped = await utils.unzipDiscImage(tapeData);
+                const unzipped = await unzipAndReport(tapeData);
                 tapeData = unzipped.data;
                 tapeName = unzipped.name;
             }
@@ -1479,7 +1553,11 @@ document.getElementById("disc_load").addEventListener("change", async function (
     if (evt.target.files.length === 0) return;
     utils.noteEvent("local", "click"); // NB no filename here
     const file = evt.target.files[0];
-    await loadHTMLFile(file);
+    try {
+        await loadHTMLFile(file);
+    } catch (error) {
+        reportLoadFailure(file.name, error);
+    }
     evt.target.value = ""; // clear so if the user picks the same file again after a reset we get a "change"
 });
 
@@ -1487,7 +1565,11 @@ document.getElementById("fs_load").addEventListener("change", async function (ev
     if (evt.target.files.length === 0) return;
     utils.noteEvent("local", "click"); // NB no filename here
     const file = evt.target.files[0];
-    await loadSCSIFile(file);
+    try {
+        await loadSCSIFile(file);
+    } catch (error) {
+        reportLoadFailure(file.name, error);
+    }
     evt.target.value = ""; // clear so if the user picks the same file again after a reset we get a "change"
 });
 
@@ -1496,17 +1578,21 @@ document.getElementById("tape_load").addEventListener("change", async function (
     const file = evt.target.files[0];
     utils.noteEvent("local", "clickTape"); // NB no filename here
 
-    let tapeData = await readFileAsBinaryString(file);
-    let tapeName = file.name;
-    if (/\.zip/i.test(tapeName)) {
-        const unzipped = await utils.unzipDiscImage(utils.stringToUint8Array(tapeData));
-        tapeData = unzipped.data;
-        tapeName = unzipped.name;
+    try {
+        let tapeData = await readFileAsBinaryString(file);
+        let tapeName = file.name;
+        if (/\.zip/i.test(tapeName)) {
+            const unzipped = await unzipAndReport(utils.stringToUint8Array(tapeData));
+            tapeData = unzipped.data;
+            tapeName = unzipped.name;
+        }
+        setProcessorTape(await loadTapeFromData(tapeName, tapeData, model));
+        delete parsedQuery.tape;
+        updateUrl();
+        bootstrap.Modal.getInstance(document.getElementById("tapes"))?.hide();
+    } catch (error) {
+        reportLoadFailure(file.name, error);
     }
-    setProcessorTape(await loadTapeFromData(tapeName, tapeData, model));
-    delete parsedQuery.tape;
-    updateUrl();
-    bootstrap.Modal.getInstance(document.getElementById("tapes"))?.hide();
 
     evt.target.value = ""; // clear so if the user picks the same file again after a reset we get a "change"
 });
@@ -1623,7 +1709,14 @@ googleDriveEl.addEventListener("show.bs.modal", async function () {
     gdLoading.textContent = "Loading...";
     gdLoading.style.display = "";
     for (const el of googleDriveEl.querySelectorAll("li:not(.template)")) el.remove();
-    const cat = await googleDrive.listFiles();
+    let cat;
+    try {
+        cat = await googleDrive.listFiles();
+    } catch (error) {
+        console.error("Error listing Google Drive files:", error);
+        gdLoading.textContent = `Unable to list your Google Drive files: ${errorText(error)}`;
+        return;
+    }
     const dbList = googleDriveEl.querySelector(".list");
     gdLoading.style.display = "none";
     const template = dbList.querySelector(".template");
@@ -1653,7 +1746,11 @@ for (const image of availableImages) {
         utils.noteEvent("images", "click", image.file);
         setDisc1Image(image.file);
         $discsModal.hide();
-        putDiscIn(0, await loadDiscImage(parsedQuery.disc1, layoutForDrive(0)));
+        try {
+            putDiscIn(0, await loadDiscImage(parsedQuery.disc1, layoutForDrive(0)));
+        } catch (error) {
+            reportLoadFailure(`${image.name} (${image.file})`, error);
+        }
     });
 }
 
@@ -1946,8 +2043,7 @@ const startPromise = (async () => {
             try {
                 await load();
             } catch (error) {
-                console.error(`Error loading ${description}:`, error);
-                toast(`Could not load ${description}: ${error?.message ?? error}`, { title: "Loading" });
+                reportLoadFailure(description, error);
             }
         })();
         imageLoads.push(loading);

package/src/teletext.js

@@ -11,6 +11,7 @@ export class Teletext {
         this.sep = false;
         this.dbl = this.oldDbl = this.secondHalfOfDouble = this.wasDbl = false;
         this.gfx = false;
+        this.conceal = false;
         this.flash = this.flashOn = false;
         this.flashTime = 0;
         this.heldChar = 0;
@@ -172,6 +173,7 @@ export class Teletext {
             secondHalfOfDouble: this.secondHalfOfDouble,
             wasDbl: this.wasDbl,
             gfx: this.gfx,
+            conceal: this.conceal,
             flash: this.flash,
             flashOn: this.flashOn,
             flashTime: this.flashTime,
@@ -198,6 +200,7 @@ export class Teletext {
         this.secondHalfOfDouble = state.secondHalfOfDouble;
         this.wasDbl = state.wasDbl;
         this.gfx = state.gfx;
+        this.conceal = state.conceal ?? false;
         this.flash = state.flash;
         this.flashOn = state.flashOn;
         this.flashTime = state.flashTime;
@@ -245,6 +248,7 @@ export class Teletext {
             case 7:
                 this.gfx = false;
                 this.col = data;
+                this.conceal = false;
                 this.setNextChars();
                 break;
             case 8:
@@ -267,10 +271,11 @@ export class Teletext {
             case 23:
                 this.gfx = true;
                 this.col = data & 7;
+                this.conceal = false;
                 this.setNextChars();
                 break;
             case 24:
-                this.col = this.prevCol = this.bg;
+                this.conceal = true;
                 break;
             case 25:
                 this.sep = false;
@@ -358,6 +363,7 @@ export class Teletext {
         this.flash = false;
         this.sep = false;
         this.gfx = false;
+        this.conceal = false;
         this.dbl = false;
 
         this.scanlineCounter++;
@@ -396,6 +402,7 @@ export class Teletext {
         this.curGlyphs = this.nextGlyphs;
 
         let flashThisCell = this.flash;
+        let concealThisCell = this.conceal;
         if (data < 0x20) {
             data = this.handleControlCode(data);
         } else if (this.gfx) {
@@ -419,7 +426,10 @@ export class Teletext {
         // Steady (code 9) is "Set At" — update so this cell stops flashing immediately.
         if (flashThisCell && !this.flash) flashThisCell = false;
 
-        if ((flashThisCell && this.flashOn) || (this.secondHalfOfDouble && !this.dbl)) {
+        // Conceal (code 24) is "Set At", and a colour code only reveals from the cell after itself.
+        if (this.conceal) concealThisCell = true;
+
+        if (concealThisCell || (flashThisCell && this.flashOn) || (this.secondHalfOfDouble && !this.dbl)) {
             const backgroundColour = this.colour[(this.bg & 7) << 5];
             for (let i = 0; i < 16; ++i) {
                 buf[offset++] = backgroundColour;

package/src/teletext_adaptor.js

@@ -94,6 +94,45 @@ export class TeletextAdaptor extends EventTarget {
         this.currentFrame = 0;
     }
 
+    updateIrq() {
+        if (this.teletextInts && this.teletextStatus & 0x80) {
+            this.cpu.interrupt |= 1 << TELETEXT_IRQ;
+        } else {
+            this.cpu.interrupt &= ~(1 << TELETEXT_IRQ);
+        }
+    }
+
+    snapshotState() {
+        return {
+            teletextStatus: this.teletextStatus,
+            teletextInts: this.teletextInts,
+            teletextEnable: this.teletextEnable,
+            channel: this.channel,
+            currentFrame: this.currentFrame,
+            rowPtr: this.rowPtr,
+            colPtr: this.colPtr,
+            pollCount: this.pollCount,
+            frameBuffer: this.frameBuffer.map((row) => row.slice()),
+        };
+    }
+
+    restoreState(state) {
+        this.teletextStatus = state.teletextStatus;
+        this.teletextInts = state.teletextInts;
+        this.teletextEnable = state.teletextEnable;
+        this.currentFrame = state.currentFrame;
+        this.rowPtr = state.rowPtr;
+        this.colPtr = state.colPtr;
+        this.pollCount = state.pollCount;
+        this.frameBuffer = state.frameBuffer.map((row) => row.slice());
+        this.updateIrq();
+        // Refetching the multi-megabyte stream on every restore would be ruinous for rewind.
+        if (this.channel !== state.channel) {
+            this.channel = state.channel;
+            this.loadChannelStream(this.channel);
+        }
+    }
+
     read(addr) {
         let data = 0x00;
 
@@ -120,11 +159,7 @@ export class TeletextAdaptor extends EventTarget {
             case 0x00:
                 // Status register
                 this.teletextInts = (value & 0x08) === 0x08;
-                if (this.teletextInts && this.teletextStatus & 0x80) {
-                    this.cpu.interrupt |= 1 << TELETEXT_IRQ; // Interrupt if INT and interrupts enabled
-                } else {
-                    this.cpu.interrupt &= ~(1 << TELETEXT_IRQ); // Clear interrupt
-                }
+                this.updateIrq();
                 this.teletextEnable = (value & 0x04) === 0x04;
                 if ((value & 0x03) !== this.channel && this.teletextEnable) {
                     this.channel = value & 0x03;

package/src/touchscreen.js

@@ -13,11 +13,32 @@ export class TouchScreen {
     constructor(scheduler, cyclesPerSecond) {
         this.scheduler = scheduler;
         this.pollCycles = cyclesPerSecond / PollHz;
-        this.mouse = { x: 0, y: 0, button: 0 };
         this.outBuffer = new utils.Fifo(16);
-        this.delay = 0;
-        this.mode = 0;
         this.pollTask = this.scheduler.newTask(() => this.poll());
+        this.reset();
+    }
+
+    reset() {
+        this.mouse = { x: 0, y: 0, button: 0 };
+        this.mode = 0;
+        this.outBuffer.clear();
+        this.pollTask.cancel();
+    }
+
+    snapshotState() {
+        return {
+            mode: this.mode,
+            outBuffer: this.outBuffer.toArray(),
+            pollTaskOffset: this.pollTask.scheduled() ? this.pollTask.expireEpoch - this.scheduler.epoch : null,
+        };
+    }
+
+    restoreState(state) {
+        this.mode = state.mode;
+        this.outBuffer.clear();
+        for (const byte of state.outBuffer) this.store(byte);
+        this.pollTask.cancel();
+        if (state.pollTaskOffset !== null) this.pollTask.schedule(state.pollTaskOffset);
     }
 
     tryReceive(rts) {

package/src/utils.js

@@ -1013,7 +1013,10 @@ function loadDataHttp(url) {
         request.open("GET", baseUrl + url, true);
         request.overrideMimeType("text/plain; charset=x-user-defined");
         request.onload = function () {
-            if (request.status !== 200) reject(new Error("Unable to load " + url + ", http code " + request.status));
+            if (request.status !== 200) {
+                reject(new Error("Unable to load " + url + ", http code " + request.status));
+                return;
+            }
             if (typeof request.response !== "string") {
                 resolve(request.response);
             } else {
@@ -1208,6 +1211,7 @@ async function unzipImage(data, knownExtensions) {
 
     let uncompressed = null;
     let loadedFile;
+    const ignored = [];
 
     for (const [filename, fileData] of Object.entries(files)) {
         const match = filename.match(/.*\.([a-z]+)/i);
@@ -1217,6 +1221,7 @@ async function unzipImage(data, knownExtensions) {
         }
         if (uncompressed) {
             console.log("Ignoring", filename, "as already found a file");
+            ignored.push(filename);
             continue;
         }
         loadedFile = filename;
@@ -1228,9 +1233,14 @@ async function unzipImage(data, knownExtensions) {
     }
 
     console.log("Unzipped '" + loadedFile + "'");
-    return { data: uncompressed, name: loadedFile };
+    return { data: uncompressed, name: loadedFile, ignored };
 }
 
+/**
+ * @param {Uint8Array|number[]} data a ZIP archive
+ * @returns {Promise<{data: Uint8Array, name: string, ignored: string[]}>} the one file loaded, and the
+ *     names of any other loadable files the archive held
+ */
 export async function unzipDiscImage(data) {
     return unzipImage(data, knownDiscExtensions);
 }
@@ -1290,4 +1300,11 @@ export class Fifo {
         this._size--;
         return res;
     }
+
+    /** @returns {number[]} pending bytes, oldest first */
+    toArray() {
+        const result = [];
+        for (let i = 0; i < this._size; ++i) result.push(this._buffer[(this._rPtr + i) % this._buffer.length]);
+        return result;
+    }
 }

package/src/via.js

@@ -24,6 +24,10 @@ const ORB = 0x0,
     INT_CB1 = 0x10,
     INT_CB2 = 0x08;
 
+// Pulse mode holds CA2/CB2 low for one 1MHz VIA cycle, here in the scheduler's 2MHz ticks.
+// Figures 3-4 and 3-6 of https://6502.org/documents/datasheets/wdc/wdc_w65c22s_mar_2004.pdf
+const PulseWidthCycles = 2;
+
 class Via {
     constructor(cpu, scheduler, irq) {
         this.cpu = cpu;
@@ -59,6 +63,8 @@ class Via {
         this.t1_pb7 = 0;
 
         this.task = this.scheduler.newTask(() => this._onTimeout());
+        this.ca2PulseTask = this.scheduler.newTask(() => this.setca2(true));
+        this.cb2PulseTask = this.scheduler.newTask(() => this.setcb2(true));
         this.lastPolltime = 0;
     }
 
@@ -72,6 +78,8 @@ class Via {
         this.t1hit = this.t2hit = true;
         this.acr = this.pcr = 0;
         this.t1_pb7 = 1;
+        this.ca2PulseTask.cancel();
+        this.cb2PulseTask.cancel();
         this.updateNextTime();
     }
 
@@ -166,7 +174,7 @@ class Via {
                 } else if (mode === 0x0a) {
                     // Pulse mode
                     this.setca2(false);
-                    this.setca2(true);
+                    this.ca2PulseTask.reschedule(PulseWidthCycles);
                 }
                 break;
 
@@ -193,7 +201,7 @@ class Via {
                 } else if (mode === 0x0a) {
                     // Pulse mode
                     this.setcb2(false);
-                    this.setcb2(true);
+                    this.cb2PulseTask.reschedule(PulseWidthCycles);
                 }
                 break;
 
@@ -408,6 +416,15 @@ class Via {
         this.portBUpdated();
     }
 
+    _taskOffset(task) {
+        return task.scheduled() ? task.expireEpoch - this.scheduler.epoch : null;
+    }
+
+    _restoreTask(task, offset) {
+        if (offset === null || offset === undefined) task.cancel();
+        else task.reschedule(offset);
+    }
+
     snapshotState() {
         return {
             ora: this.ora,
@@ -436,7 +453,9 @@ class Via {
             justhit: this.justhit,
             t1_pb7: this.t1_pb7,
             lastPolltime: this.lastPolltime,
-            taskOffset: this.task.scheduled() ? this.task.expireEpoch - this.scheduler.epoch : null,
+            taskOffset: this._taskOffset(this.task),
+            ca2PulseTaskOffset: this._taskOffset(this.ca2PulseTask),
+            cb2PulseTaskOffset: this._taskOffset(this.cb2PulseTask),
         };
     }
 
@@ -468,11 +487,9 @@ class Via {
         this.t1_pb7 = state.t1_pb7;
         this.lastPolltime = state.lastPolltime;
         this.updateIFR();
-        if (state.taskOffset !== null) {
-            this.task.reschedule(state.taskOffset);
-        } else {
-            this.task.cancel();
-        }
+        this._restoreTask(this.task, state.taskOffset);
+        this._restoreTask(this.ca2PulseTask, state.ca2PulseTaskOffset);
+        this._restoreTask(this.cb2PulseTask, state.cb2PulseTaskOffset);
     }
 
     setca1(level) {

package/tests/test-machine.js

@@ -111,7 +111,9 @@ export class TestMachine {
                     stopped = !this.processor.execute(todo);
                     left -= todo;
                 }
-                if (left && !stopped) {
+                // 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) {
                     setTimeout(runAnIter, 0);
                 } else {
                     resolve(stopped);