jsbeeb 1.22.4 → 1.24.0

package/src/web/config.js

@@ -1,6 +1,5 @@
-"use strict";
 import { allModels, findModel, tubeModelFor } from "../models.js";
-import { getFilterForMode } from "../canvas.js";
+import { getFilterForMode } from "./canvas.js";
 import { AudioOutputs } from "../audio-output.js";
 
 const round = (value) => Number(value.toFixed(2));
@@ -50,45 +49,45 @@ export function restartPending(settings, running) {
     return RestartRequiredFields.some((field) => settings[field] !== running[field]);
 }
 
+/**
+ * The Settings dialog: shows the settings, applies the ones the machine can
+ * follow live as they are picked, and saves the rest when it closes. Dispatches
+ * "restart-required" after saving a change the running machine cannot follow.
+ */
 export class Config extends EventTarget {
-    /**
-     * @param {function(object)} onChange called as soon as a setting the emulator can follow live changes
-     * @param {function(object)} onClose called with the settings to apply and persist
-     * @param {function()} onRestartRequired called after the settings have been saved, when some of them
-     *     will only take effect once the machine is rebuilt
-     */
-    constructor(onChange, onClose, onRestartRequired) {
+    constructor(settings) {
         super();
-        this.onChange = onChange;
-        this.onClose = onClose;
-        this.onRestartRequired = onRestartRequired;
+        this.settings = settings;
         this.changed = {};
-        this.model = null;
-        for (const { field } of CheckboxSettings) this[field] = false;
-        this.runningSettings = null;
+        // Built before anything can change, so this is what the running machine was built with.
+        this.runningSettings = this.proposedSettings();
+        this.setModel(settings.model);
+        this.setKeyLayout(settings.keyLayout);
+        this.setMicrophoneChannel(settings.microphoneChannel);
+        this.setDisplayMode(settings.displayMode);
+        this.setAudioOutput(settings.audioOutput);
+        this.setSpeakerAmount(settings.speakerAmount);
+        settings.on("audioOutput", (audioOutput) => this.setAudioOutput(audioOutput));
+        settings.on("speakerAmount", (speakerAmount) => this.setSpeakerAmount(speakerAmount));
+        settings.on("displayMode", (displayMode) => this.setDisplayMode(displayMode));
+
         const configuration = document.getElementById("configuration");
         configuration.addEventListener("show.bs.modal", () => {
             this.changed = {};
-            // The startup settings are pushed in after construction, so what the running machine was
-            // built with is only knowable from the first time the dialog is opened.
-            if (!this.runningSettings) this.runningSettings = this.proposedSettings();
-            this.setDropdownText(this.model.name);
-            this.setTubeCpuMultiplier(this.tubeCpuMultiplier);
-            this.setCheckboxes(this);
+            this.setDropdownText(settings.model.name);
+            this.setTubeCpuMultiplier(settings.tubeCpuMultiplier);
+            this.setCheckboxes(settings);
             this.showRestartPending();
         });
 
         configuration.addEventListener("hide.bs.modal", () => {
             const changed = this.changed;
-            // Not setModel: that also renames the machine in the title bar, which has not changed yet.
-            if (changed.model !== undefined) this.model = findModel(changed.model);
-            this.setCheckboxes(changed);
-            this.onClose(changed);
+            this.changed = {};
             if (Object.keys(changed).length === 0) return;
-            this.dispatchEvent(new CustomEvent("settings-changed", { detail: changed }));
+            settings.set(changed);
             // changed records which controls were touched, so a value in it can be what is already running.
             if (needsRestart(changed) && restartPending(this.proposedSettings(), this.runningSettings))
-                this.onRestartRequired();
+                this.dispatchEvent(new Event("restart-required"));
         });
 
         const modelMenu = document.querySelector(".model-menu");
@@ -108,7 +107,10 @@ export class Config extends EventTarget {
             if (!link) return;
             this.changed.model = link.dataset.target;
             this.setDropdownText(link.textContent);
-            this.showTubeCpuMultiplier(this.tubeCpuMultiplier, findModel(link.dataset.target));
+            this.showTubeCpuMultiplier(
+                this.changed.tubeCpuMultiplier ?? this.settings.tubeCpuMultiplier,
+                findModel(link.dataset.target),
+            );
             this.showRestartPending();
         });
 
@@ -149,23 +151,18 @@ export class Config extends EventTarget {
         for (const option of document.querySelectorAll(".audio-output-option")) {
             option.addEventListener("click", (e) => {
                 e.preventDefault();
-                const audioOutput = e.currentTarget.dataset.output;
-                this.changed.audioOutput = audioOutput;
-                this.onChange({ audioOutput });
+                settings.set({ audioOutput: e.currentTarget.dataset.output });
             });
         }
 
         document.getElementById("speakerAmountSetting").addEventListener("input", (e) => {
-            this.onChange({ speakerAmount: parseFloat(e.currentTarget.value) });
+            settings.set({ speakerAmount: parseFloat(e.currentTarget.value) });
         });
 
         for (const option of document.querySelectorAll(".display-mode-option")) {
             option.addEventListener("click", (e) => {
                 e.preventDefault();
-                const mode = e.currentTarget.dataset.mode;
-                this.changed.displayMode = mode;
-                this.setDisplayMode(mode);
-                this.onChange({ displayMode: mode });
+                settings.set({ displayMode: e.currentTarget.dataset.mode });
             });
         }
     }
@@ -175,7 +172,7 @@ export class Config extends EventTarget {
      * menu and the URL use: the model by synonym rather than resolved, the fittings as booleans.
      */
     proposedSettings() {
-        const saved = (field) => (field === "model" ? this.model.synonyms[0] : this[field]);
+        const saved = (field) => (field === "model" ? this.settings.model.synonyms[0] : this.settings[field]);
         return Object.fromEntries(RestartRequiredFields.map((field) => [field, this.changed[field] ?? saved(field)]));
     }
 
@@ -184,13 +181,12 @@ export class Config extends EventTarget {
         document.getElementById("restart-pending").classList.toggle("d-none", !pending);
     }
 
-    /** Ticks the boxes named in `values` and adopts them, leaving any the object does not mention alone. */
+    /** Ticks the boxes named in `values`, leaving any the object does not mention alone. */
     setCheckboxes(values) {
         for (const { id, field, enables } of CheckboxSettings) {
             if (values[field] === undefined) continue;
             const checked = !!values[field];
             document.getElementById(id).checked = checked;
-            this[field] = checked;
             if (enables) document.getElementById(enables).disabled = !checked;
         }
     }
@@ -213,9 +209,12 @@ export class Config extends EventTarget {
         for (const el of document.querySelectorAll(".display-mode-text")) el.textContent = config.name;
     }
 
-    setModel(modelName) {
-        this.model = findModel(modelName);
-        for (const el of document.querySelectorAll(".bbc-model")) el.textContent = this.model.name;
+    /** Names the running machine everywhere the page shows it. */
+    setModel(model) {
+        for (const el of document.querySelectorAll(".bbc-model")) el.textContent = model.name;
+        for (const el of document.querySelectorAll(".bbc-model-short")) el.textContent = model.shortName;
+        const settingsLink = document.getElementById("model-settings");
+        if (settingsLink) settingsLink.title = `${model.name}: emulation settings`;
     }
 
     setKeyLayout(keyLayout) {
@@ -224,12 +223,11 @@ export class Config extends EventTarget {
     }
 
     setTubeCpuMultiplier(value) {
-        this.tubeCpuMultiplier = value;
         document.getElementById("tubeCpuMultiplier").value = value;
         this.showTubeCpuMultiplier(value);
     }
 
-    showTubeCpuMultiplier(value, model = this.model) {
+    showTubeCpuMultiplier(value, model = this.settings.model) {
         document.getElementById("tubeCpuMultiplierValue").textContent = tubeCpuSpeedLabel(value, model);
     }
 
@@ -237,32 +235,4 @@ export class Config extends EventTarget {
         const el = document.querySelector("#bbc-model-dropdown .bbc-model");
         if (el) el.textContent = modelName;
     }
-
-    get extraRoms() {
-        return fittedRoms(this);
-    }
-
-    mapLegacyModels(parsedQuery) {
-        if (!parsedQuery.model) {
-            return;
-        }
-
-        // "MasterTurbo" = Master + 6502 second processor
-        if (parsedQuery.model.toLowerCase() === "masterturbo") {
-            parsedQuery.model = "Master";
-            parsedQuery.coProcessor = true;
-        }
-
-        // "BMusic5000" = BBC DFS 1.2 + Music 5000
-        if (parsedQuery.model.toLowerCase() === "bmusic5000") {
-            parsedQuery.model = "B-DFS1.2";
-            parsedQuery.hasMusic5000 = true;
-        }
-
-        // "BTeletext" = BBC DFS 1.2 + Teletext adaptor
-        if (parsedQuery.model.toLowerCase() === "bteletext") {
-            parsedQuery.model = "B-DFS1.2";
-            parsedQuery.hasTeletextAdaptor = true;
-        }
-    }
 }

package/src/web/console-surface.js

@@ -0,0 +1,25 @@
+import { hd } from "../hex.js";
+import { debounce } from "../debounce.js";
+
+/**
+ * The debugging surface the wiki documents, put on `target` (window in the
+ * app). The bench/profile calls are debounced so that they can be safely run
+ * from the JS console in firefox.
+ */
+export function exposeConsoleSurface(target, { loop, processor, video, audioHandler }) {
+    target.benchmarkCpu = debounce((numCycles) => loop.benchmarkCpu(numCycles), 1);
+    target.profileCpu = debounce((arg) => loop.profileCpu(arg), 1);
+    target.benchmarkVideo = debounce((numCycles) => loop.benchmarkVideo(numCycles), 1);
+    target.profileVideo = debounce((arg) => loop.profileVideo(arg), 1);
+    target.go = () => loop.go();
+    target.stop = (debug) => loop.stop(debug);
+    target.soundChip = audioHandler.soundChip;
+    target.processor = processor;
+    target.video = video;
+    target.hd = (start, end) => {
+        console.log(hd((x) => processor.readmem(x), start, end));
+    };
+    target.m7dump = () => {
+        console.log(hd((x) => processor.readmem(x) & 0x7f, 0x7c00, 0x7fe8, { width: 40, gap: false }));
+    };
+}

package/src/web/debug.js

@@ -1,6 +1,7 @@
-"use strict";
-import { hexbyte, hexword, noop, parseAddr } from "../utils.js";
-import { toggle } from "../dom-utils.js";
+import { toggle } from "./dom-utils.js";
+import { hexbyte, hexword, parseAddr } from "../hex.js";
+
+const noop = () => {};
 
 const numToShow = 16;
 
@@ -60,7 +61,7 @@ class MemoryView {
         }
     }
 
-    // todo extract memory part from view part and reuse in disassembler etc. also peekmem can go then
+    // TODO(#1062) extract memory part from view part and reuse in disassembler etc. also peekmem can go then
     dump(from, to) {
         const hex = [];
         const asc = [];
@@ -89,48 +90,6 @@ class MemoryView {
     }
 }
 
-/**
- * Guesses the address of the instruction before the given one by scoring each
- * possible run of instructions leading up to it: a point per "common"
- * instruction (loads, stores, branches, compares, arithmetic and
- * carry-set/clear that avoid unusual indexing modes) and a large boost for a
- * run that passes through the current program counter. The highest-scoring
- * run wins and its last instruction is the answer.
- * Good test cases:
- *   Repton 2 @ 2cbb
- *   MOS @ cfc8
- * also, just starting from the back of ROM and going up...
- */
-export function prevInstruction(disassemble, pc, address) {
-    const commonInstructions =
-        /(RTS|B..|JMP|JSR|LD[AXY]|ST[AXY]|TA[XY]|T[XY]A|AD[DC]|SUB|SBC|CLC|SEC|CMP|EOR|ORR|AND|INC|DEC).*/;
-    const uncommonInstrucions = /.*,\s*([XY]|X\))$/;
-
-    address &= 0xffff;
-    let bestAddr = address - 1;
-    let bestScore = 0;
-    for (let startingPoint = address - 20; startingPoint !== address; startingPoint++) {
-        let score = 0;
-        let addr = startingPoint & 0xffff;
-        while (addr < address) {
-            const result = disassemble(addr);
-            if (addr === pc) score += 10;
-            if (result[0].match(commonInstructions) && !result[0].match(uncommonInstrucions)) {
-                score++;
-            }
-            if (result[1] === address) {
-                if (score > bestScore) {
-                    bestScore = score;
-                    bestAddr = addr;
-                    break;
-                }
-            }
-            addr = result[1];
-        }
-    }
-    return bestAddr;
-}
-
 export class Debugger {
     constructor() {
         this.patchInstructions = new Map();
@@ -424,7 +383,7 @@ export class Debugger {
     }
 
     prevInstruction(address) {
-        return prevInstruction((addr) => this.disassemble(addr), this.cpu.pc, address);
+        return this.cpu.disassembler.prevInstruction(address, this.cpu.pc);
     }
 
     updatePrevMem() {
@@ -436,7 +395,7 @@ export class Debugger {
     }
 
     stepUntil(f) {
-        this.cpu.targetCycles = this.cpu.currentCycles; // TODO: this prevents the cpu from running any residual cycles. look into a better solution
+        this.cpu.targetCycles = this.cpu.currentCycles; // TODO(#1062) this prevents the cpu from running any residual cycles. look into a better solution
         for (let i = 0; i < 65536; i++) {
             this.cpu.execute(1);
             if (f()) break;
@@ -483,7 +442,7 @@ export class Debugger {
     }
 
     nextInstruction(address) {
-        return this.disassemble(address)[1] & 0xffff;
+        return this.cpu.disassembler.nextInstruction(address);
     }
 
     instrClick(e) {

package/src/web/disc-visualiser.js

@@ -1,5 +1,3 @@
-"use strict";
-
 import { IbmDiscFormat } from "../disc.js";
 import {
     DensityPalette,

package/src/web/display.js

@@ -1,7 +1,12 @@
-import * as canvasLib from "../canvas.js";
+import * as canvasLib from "./canvas.js";
 import { FakeVideo, Video } from "../video.js";
 import { toast } from "./toast.js";
 
+// While running fast the state machines still run accurately, but painting is
+// the most expensive part of jsbeeb, so most frames are skipped. Odd, so that
+// interlaced modes (MODE 7) alternate fields across the frames that do paint.
+const SpeedyFrameSkip = 9;
+
 /**
  * The picture: the canvas and its filter, the video chip that paints into a
  * framebuffer of our own, and the animation frame that presents it. A stalled
@@ -64,10 +69,22 @@ export class Display {
         this.setCrtPic();
     }
 
+    /**
+     * While running fast the skip moves into the video chip, which skips the
+     * render as well as the present; the deeper of the chip's skip and any
+     * configured frameSkip wins, so the two never multiply together.
+     */
+    setSpeedy(speedy) {
+        const skip = Math.max(SpeedyFrameSkip, this.frameSkip);
+        this.video.frameSkipCount = speedy ? (skip % 2 ? skip : skip + 1) : 0;
+    }
+
     onPaint(video, minx, miny, maxx, maxy) {
-        this.frames++;
-        if (this.frames < this.frameSkip) return;
-        this.frames = 0;
+        if (!video.frameSkipCount) {
+            this.frames++;
+            if (this.frames < this.frameSkip) return;
+            this.frames = 0;
+        }
         const start = performance.now();
         this.canvas.fb32.set(this.videoFb32.subarray(miny * 1024, maxy * 1024), miny * 1024);
         if (this.pendingFrame.lineGrid.length !== video.lineGrid.length)

package/src/{dom-utils.js → web/dom-utils.js}

@@ -1,17 +1,7 @@
-"use strict";
-
-import { replaceOrAddExtension } from "./utils.js";
+import { replaceOrAddExtension } from "../archive.js";
 
 // Minimal DOM helpers to replace jQuery usage.
 
-export function show(el) {
-    el.style.display = "";
-}
-
-export function hide(el) {
-    el.style.display = "none";
-}
-
 export function toggle(el, visible) {
     el.style.display = visible ? "" : "none";
 }

package/src/web/drives.js

@@ -1,7 +1,7 @@
 import { toast } from "./toast.js";
 import { DiscLayout, toSsdOrDsd } from "../disc.js";
 import { toHfe } from "../disc-hfe.js";
-import { downloadDriveData } from "../dom-utils.js";
+import { downloadDriveData } from "./dom-utils.js";
 import { DriveTracks } from "../url-params.js";
 
 const tracksPerStepFor = (tracks) => (tracks === "40" ? 2 : 1);

package/src/web/emulation-loop.js

@@ -1,4 +1,4 @@
-import * as utils from "../utils.js";
+import { noteEvent } from "./analytics.js";
 
 // A timer, not requestAnimationFrame: a display presentation stall withholds
 // animation frames, and with them the sound chip's samples (issue #885).
@@ -49,9 +49,14 @@ class VirtualSpeedUpdater {
 
 /**
  * Runs the machine in real time: the tick that turns wall-clock time into
- * cycles, starting and stopping, the audio lead, fast-forward, rewind capture
- * and the speed readout. Owns `running`, and dispatches a "running" event
- * whenever it changes hands.
+ * cycles, starting and stopping, the audio lead, fast-forward and the speed
+ * readout. Owns `running`, and dispatches a "running" event whenever it
+ * changes hands, "tick" on every tick while running (the first only takes the
+ * time), and "rewind-capture" every RewindCaptureInterval frames for whoever
+ * keeps the rewind history. Anything that needs the machine held still while
+ * it works (a dialog, a snapshot, the rewind panel, a hidden tab) takes a
+ * `pause()`; the loop runs again once every hold has let go, provided the user
+ * still wants it running.
  */
 export class EmulationLoop extends EventTarget {
     constructor({
@@ -61,9 +66,6 @@ export class EmulationLoop extends EventTarget {
         dbgr,
         gamepad,
         keyboard,
-        syncLights,
-        rewindBuffer,
-        onRewindCaptured,
         clocksPerSecond,
         cpuSpeed,
         fastTape,
@@ -76,9 +78,6 @@ export class EmulationLoop extends EventTarget {
         this.dbgr = dbgr;
         this.gamepad = gamepad;
         this.keyboard = keyboard;
-        this.syncLights = syncLights;
-        this.rewindBuffer = rewindBuffer;
-        this.onRewindCaptured = onRewindCaptured;
         this.clocksPerSecond = clocksPerSecond;
         this.maxCyclesPerTick = clocksPerSecond / 10;
         this.rewindCaptureCycles = (RewindCaptureInterval * clocksPerSecond) / 50;
@@ -92,7 +91,9 @@ export class EmulationLoop extends EventTarget {
         this.tickToken = null;
         this.emulationLeadMs = 0;
         this.rewindCycleCounter = 0;
-        this.wasPreviouslyRunning = false;
+        this.wanted = false;
+        this.holds = new Set();
+        this.resumeOnVisible = null;
 
         this.virtualSpeedUpdater = new VirtualSpeedUpdater(cpuSpeed);
         this.audioDebugLog = { start: 0, ticks: 0, cycles: 0, maxIdle: 0, maxExecute: 0, maxPaint: 0, maxSnapshot: 0 };
@@ -105,17 +106,47 @@ export class EmulationLoop extends EventTarget {
     }
 
     go() {
+        this.wanted = true;
+        if (this.holds.size === 0) this.start();
+        else
+            console.warn(
+                `Emulator held by ${[...this.holds].map((hold) => hold.reason).join(", ")}; it runs when they let go`,
+            );
+    }
+
+    stop(debug) {
+        this.wanted = false;
+        this.halt();
+        if (debug) this.dbgr.debug(this.processor.pc);
+    }
+
+    /**
+     * Holds the machine stopped until the returned function is called. Holds
+     * nest, and letting go twice counts once. `reason` names the holder when a
+     * go() has to wait, so a hold that is never released can be found.
+     */
+    pause(reason) {
+        if (this.holds.size === 0 && this.running) this.halt();
+        const hold = { reason };
+        this.holds.add(hold);
+        return () => {
+            if (!this.holds.delete(hold)) return;
+            if (this.holds.size === 0 && this.wanted) this.start();
+        };
+    }
+
+    start() {
+        if (this.running) return;
         this.audioHandler.unmute();
         this.running = true;
         this.dispatchEvent(new Event("running"));
         this.run();
     }
 
-    stop(debug) {
+    halt() {
         this.running = false;
         this.dispatchEvent(new Event("running"));
         this.processor.stop();
-        if (debug) this.dbgr.debug(this.processor.pc);
         this.audioHandler.mute();
     }
 
@@ -146,20 +177,15 @@ export class EmulationLoop extends EventTarget {
         const now = performance.now();
 
         const { processor, display, audioHandler } = this;
-        const motorOn = processor.acia.motorOn;
+        const motorOn = processor.tapeInterface.motorOn;
         const speedy = this.fastAsPossible || (this.fastTape && motorOn);
 
-        // In speedy mode, we still run all the state machines accurately
-        // but we paint less often because painting is the most expensive
-        // part of jsbeeb at this time.
-        // We need need to paint per odd number of frames so that interlace
-        // modes, i.e. MODE 7, still look ok.
-        display.video.frameSkipCount = speedy ? 9 : 0;
+        display.setSpeedy(speedy);
 
         this.scheduleTick(speedy ? 0 : TickMs);
 
         this.gamepad.update(processor.sysvia);
-        this.syncLights();
+        this.dispatchEvent(new Event("tick"));
         if (this.last !== 0) {
             let cycles;
             if (!speedy) {
@@ -182,8 +208,7 @@ export class EmulationLoop extends EventTarget {
                 this.rewindCycleCounter += cycles;
                 if (this.rewindCycleCounter >= this.rewindCaptureCycles) {
                     this.rewindCycleCounter -= this.rewindCaptureCycles;
-                    this.rewindBuffer.push(processor.snapshotState());
-                    this.onRewindCaptured();
+                    this.dispatchEvent(new Event("rewind-capture"));
                     snapshotMs = performance.now() - end;
                 }
                 if (this.audioStatsNode)
@@ -197,7 +222,7 @@ export class EmulationLoop extends EventTarget {
                     );
             } catch (e) {
                 this.running = false;
-                utils.noteEvent("exception", "thrown", e.stack);
+                noteEvent("exception", "thrown", e.stack);
                 this.dbgr.debug(processor.pc);
                 throw e;
             }
@@ -227,16 +252,12 @@ export class EmulationLoop extends EventTarget {
     handleVisibilityChange() {
         const { processor } = this;
         if (document.visibilityState === "hidden") {
-            this.wasPreviouslyRunning = this.running;
             const keepRunningWhenHidden =
-                processor.acia.motorOn || processor.fdc.motorOn[0] || processor.fdc.motorOn[1];
-            if (this.running && !keepRunningWhenHidden) {
-                this.stop(false);
-            }
-        } else {
-            if (this.wasPreviouslyRunning) {
-                this.go();
-            }
+                processor.tapeInterface.motorOn || processor.fdc.motorOn[0] || processor.fdc.motorOn[1];
+            if (!keepRunningWhenHidden && !this.resumeOnVisible) this.resumeOnVisible = this.pause("the hidden tab");
+        } else if (this.resumeOnVisible) {
+            this.resumeOnVisible();
+            this.resumeOnVisible = null;
         }
     }
 

package/src/web/front-panel.js

@@ -18,12 +18,20 @@ class Light {
  * controls, and the pop-up window the printer prints into.
  */
 export class FrontPanel {
-    constructor({ processor, model, printer }) {
+    constructor({ processor, model, printer, loop }) {
         this.processor = processor;
         this.model = model;
         this.printer = printer;
         this.printerWindow = null;
         this.printerTextArea = null;
+        loop.addEventListener("tick", () => this.syncLights());
+        printer.addEventListener("output", (event) => this.printChar(event.detail));
+        printer.addEventListener("first-output", () =>
+            toast("Printer output is being kept. Press Ctrl-B to open the printer window.", {
+                title: "Printer",
+                quietKey: "quietPrinterOutput",
+            }),
+        );
 
         for (const link of document.querySelectorAll("#tape-menu a")) {
             link.addEventListener("click", (e) => {
@@ -32,13 +40,8 @@ export class FrontPanel {
 
                 if (type === "rewind") {
                     console.log("Rewinding tape to the start");
-                    if (model.isAtom) {
-                        processor.atomppia.stopTape();
-                        processor.atomppia.rewindTape();
-                        this.updateTapeButton();
-                    } else {
-                        processor.acia.rewindTape();
-                    }
+                    processor.tapeInterface.rewindTape();
+                    this.updateTapeButton();
                 }
             });
         }
@@ -92,14 +95,12 @@ export class FrontPanel {
 
     syncLights() {
         const { processor } = this;
-        if (this.model.isAtom) {
-            this.cassette.update(processor.atomppia.motorOn);
-        } else {
+        this.cassette.update(processor.tapeInterface.motorOn);
+        if (!this.model.isAtom) {
             this.caps.update(processor.sysvia.capsLockLight);
             this.shift.update(processor.sysvia.shiftLockLight);
             this.drive0.update(processor.fdc.motorOn[0]);
             this.drive1.update(processor.fdc.motorOn[1]);
-            this.cassette.update(processor.acia.motorOn);
             if (processor.econet) {
                 this.network.update(processor.econet.activityLight());
             }

package/src/{gamepads.js → web/gamepads.js}

@@ -1,7 +1,4 @@
-"use strict";
-import * as utils from "./utils.js";
-
-const BBC = utils.BBC;
+import { BBC, isFirefox } from "../keymap.js";
 
 export class GamePad {
     constructor() {
@@ -201,8 +198,7 @@ export class GamePad {
         // process gamepad buttons
         if (this.gamepad0) {
             // these two lines needed in Chrome to update state, not Firefox
-            // TODO: what about IE? (can't get Gamepads to work in IE11/IE12. Mike)
-            if (!utils.isFirefox()) {
+            if (!isFirefox()) {
                 this.gamepad0 = navigator.getGamepads()[0];
             }