jsbeeb 1.9.1 → 1.10.0

package/package.json

@@ -7,10 +7,10 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "//": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
-    "node": "22"
+    "node": ">=22.12.0"
   },
   "type": "module",
   "main": "./src/app/app.js",
@@ -51,11 +51,11 @@
     "npm-run-all2": "^8.0.4",
     "pixelmatch": "^7.1.0",
     "prettier": "^3.8.1",
-    "vite": "^7.3.1",
+    "vite": "^8.0.3",
     "vitest": "^4.0.10"
   },
   "optionalDependencies": {
-    "electron": "^40.4.1",
+    "electron": "^41.1.1",
     "electron-builder": "^26.8.1",
     "electron-store": "^11.0.2"
   },

package/src/6502.js

@@ -9,6 +9,7 @@ import { Scheduler } from "./scheduler.js";
 import { TouchScreen } from "./touchscreen.js";
 import { TeletextAdaptor } from "./teletext_adaptor.js";
 import { Filestore } from "./filestore.js";
+import { FakeRelayNoise } from "./relaynoise.js";
 
 const signExtend = utils.signExtend;
 
@@ -573,7 +574,18 @@ function is1MHzAccess(addr) {
 export class Cpu6502 extends Base6502 {
     constructor(
         model,
-        { dbgr, video, soundChip, ddNoise, music5000, cmos, config, econet, cycleAccurate = true } = {},
+        {
+            dbgr,
+            video,
+            soundChip,
+            ddNoise,
+            relayNoise = new FakeRelayNoise(),
+            music5000,
+            cmos,
+            config,
+            econet,
+            cycleAccurate = true,
+        } = {},
     ) {
         super(model, { cycleAccurate });
         this.config = fixUpConfig(config);
@@ -587,6 +599,7 @@ export class Cpu6502 extends Base6502 {
         this.soundChip = soundChip;
         this.music5000 = music5000;
         this.ddNoise = ddNoise;
+        this.relayNoise = relayNoise;
         this.memStatOffsetByIFetchBank = 0;
         this.memStatOffset = 0;
         this.memStat = new Uint8Array(512);
@@ -633,7 +646,7 @@ export class Cpu6502 extends Base6502 {
             getGamepads: this.config.getGamepads,
         });
         this.uservia = new via.UserVia(this, this.scheduler, this.model.isMaster, this.config.userPort);
-        this.acia = new Acia(this, this.soundChip.toneGenerator, this.scheduler, this.touchScreen);
+        this.acia = new Acia(this, this.soundChip.toneGenerator, this.scheduler, this.touchScreen, this.relayNoise);
         this.serial = new Serial(this.acia);
         this.adconverter = new Adc(this.sysvia, this.scheduler);
         this.soundChip.setScheduler(this.scheduler);

package/src/acia.js

@@ -5,10 +5,11 @@
 // http://www.classiccmp.org/dunfield/r/6850.pdf
 
 export class Acia {
-    constructor(cpu, toneGen, scheduler, rs423Handler) {
+    constructor(cpu, toneGen, scheduler, rs423Handler, relayNoise) {
         this.cpu = cpu;
         this.toneGen = toneGen;
         this.rs423Handler = rs423Handler;
+        this.relayNoise = relayNoise;
 
         this.sr = 0x00;
         this.cr = 0x00;
@@ -58,10 +59,12 @@ export class Acia {
     setMotor(on) {
         if (on && !this.motorOn) {
             this.runTape();
+            this.relayNoise.motorOn();
         } else if (!on && this.motorOn) {
             this.toneGen.mute();
             this.runTapeTask.cancel();
             this.setTapeCarrier(false);
+            this.relayNoise.motorOff();
         }
         this.motorOn = on;
     }

package/src/audio-utils.js

@@ -0,0 +1,13 @@
+"use strict";
+
+/**
+ * Create an AudioContext with a fallback for older WebKit browsers.
+ * @param {AudioContextOptions} [options] - passed to the AudioContext constructor
+ * @returns {AudioContext|null}
+ */
+export function createAudioContext(options) {
+    /*global webkitAudioContext*/
+    if (typeof AudioContext !== "undefined") return new AudioContext(options);
+    if (typeof webkitAudioContext !== "undefined") return new webkitAudioContext(options);
+    return null;
+}

package/src/ddnoise.js

@@ -1,26 +1,20 @@
 "use strict";
-import * as utils from "./utils.js";
-import _ from "underscore";
+import { SamplePlayer } from "./sample-player.js";
 
-const IDLE = 0;
-const SPIN_UP = 1;
-const SPINNING = 2;
-const VOLUME = 0.25;
+const Idle = 0;
+const SpinUp = 1;
+const Spinning = 2;
+const Volume = 0.25;
 
-export class DdNoise {
-    constructor(context) {
-        this.context = context;
-        this.sounds = {};
-        this.state = IDLE;
+export class DdNoise extends SamplePlayer {
+    constructor(context, destination) {
+        super(context, destination, Volume);
+        this.state = Idle;
         this.motor = null;
-        this.gain = context.createGain();
-        this.gain.gain.value = VOLUME;
-        this.gain.connect(context.destination);
-        // workaround for older safaris that GC sounds when they're playing...
-        this.playing = [];
     }
+
     async initialise() {
-        const sounds = await loadSounds(this.context, {
+        await this.loadSounds({
             motorOn: "sounds/disc525/motoron.wav",
             motorOff: "sounds/disc525/motoroff.wav",
             motor: "sounds/disc525/motor.wav",
@@ -29,63 +23,35 @@ export class DdNoise {
             seek2: "sounds/disc525/seek2.wav",
             seek3: "sounds/disc525/seek3.wav",
         });
-        this.sounds = sounds;
-    }
-    oneShot(sound) {
-        const duration = sound.duration;
-        const context = this.context;
-        if (context.state !== "running") return duration;
-        const source = context.createBufferSource();
-        source.buffer = sound;
-        source.connect(this.gain);
-        source.start();
-        return duration;
-    }
-    play(sound, loop) {
-        if (this.context.state !== "running") return Promise.reject();
-        return new Promise((resolve) => {
-            const source = this.context.createBufferSource();
-            source.loop = !!loop;
-            source.buffer = sound;
-            source.connect(this.gain);
-            source.onended = () => {
-                this.playing = _.without(this.playing, source);
-                if (!source.loop) resolve();
-            };
-            source.start();
-            this.playing.push(source);
-            if (source.loop) {
-                resolve(source);
-            }
-        });
     }
+
     spinUp() {
-        if (this.state === SPINNING || this.state === SPIN_UP) return;
-        this.state = SPIN_UP;
+        if (this.state === Spinning || this.state === SpinUp) return;
+        this.state = SpinUp;
         this.play(this.sounds.motorOn).then(
             () => {
                 // Handle race: we may have had spinDown() called on us before the
                 // spinUp() initial sound finished playing.
-                if (this.state === IDLE) {
-                    return;
-                }
+                if (this.state === Idle) return;
                 this.play(this.sounds.motor, true).then((source) => {
                     this.motor = source;
-                    this.state = SPINNING;
+                    this.state = Spinning;
                 });
             },
             () => {},
         );
     }
+
     spinDown() {
-        if (this.state === IDLE) return;
-        this.state = IDLE;
+        if (this.state === Idle) return;
+        this.state = Idle;
         if (this.motor) {
             this.motor.stop();
             this.motor = null;
             this.oneShot(this.sounds.motorOff);
         }
     }
+
     seek(diff) {
         if (diff < 0) diff = -diff;
         if (diff === 0) return 0;
@@ -94,37 +60,9 @@ export class DdNoise {
         else if (diff <= 40) return this.oneShot(this.sounds.seek2);
         else return this.oneShot(this.sounds.seek3);
     }
-    mute() {
-        this.gain.gain.value = 0;
-    }
-    unmute() {
-        this.gain.gain.value = VOLUME;
-    }
-}
-
-async function loadSounds(context, sounds) {
-    const loaded = await Promise.all(
-        _.map(sounds, async (sound) => {
-            // Safari doesn't support the Promise stuff directly, so we create
-            // our own Promise here.
-            const data = await utils.loadData(sound);
-            return await new Promise((resolve) => {
-                context.decodeAudioData(data.buffer, (decodedData) => {
-                    resolve(decodedData);
-                });
-            });
-        }),
-    );
-    const keys = _.keys(sounds);
-    const result = {};
-    for (let i = 0; i < keys.length; ++i) {
-        result[keys[i]] = loaded[i];
-    }
-    return result;
 }
 
 export class FakeDdNoise {
-    constructor() {}
     seek() {
         return 0;
     }

package/src/fake6502.js

@@ -5,6 +5,7 @@ import { FakeVideo } from "./video.js";
 import { FakeSoundChip } from "./soundchip.js";
 import { findModel, TEST_6502, TEST_65C02, TEST_65C12 } from "./models.js";
 import { FakeDdNoise } from "./ddnoise.js";
+import { FakeRelayNoise } from "./relaynoise.js";
 import { Cpu6502 } from "./6502.js";
 import { Cmos } from "./cmos.js";
 import { FakeMusic5000 } from "./music5000.js";
@@ -24,6 +25,7 @@ export function fake6502(model, opts) {
         video: opts.video || fakeVideo,
         soundChip: opts.soundChip || soundChip,
         ddNoise: new FakeDdNoise(),
+        relayNoise: new FakeRelayNoise(),
         music5000: new FakeMusic5000(),
         cmos: new Cmos(),
         cycleAccurate: opts.cycleAccurate,

package/src/keyboard.js

@@ -40,6 +40,13 @@ export class Keyboard extends EventEmitter {
         this.lastShiftLocation = 1;
         this.lastCtrlLocation = 1;
         this.lastAltLocation = 1;
+
+        // Paste state — uses a scheduler task instead of a debugInstruction
+        // hook so the CPU can remain on the fast execution path during paste.
+        this._pasteKeys = [];
+        this._pasteLastChar = undefined;
+        this._pasteClocksPerMs = 0;
+        this._pasteTask = this.processor.scheduler.newTask(() => this._deliverPasteKey());
     }
 
     /**
@@ -210,6 +217,11 @@ export class Keyboard extends EventEmitter {
         const code = this.keyCode(evt);
         evt.preventDefault();
 
+        if (this.isPasting && code === utils.keyCodes.ESCAPE) {
+            this.cancelPaste();
+            return;
+        }
+
         // Special handling cases that we always want to keep within keyboard.js
         const isSpecialHandled = this._handleSpecialKeys(code);
         if (isSpecialHandled) return;
@@ -314,10 +326,10 @@ export class Keyboard extends EventEmitter {
      * @param {boolean} checkCapsAndShiftLocks - Whether to check caps and shift locks
      */
     sendRawKeyboardToBBC(keysToSend, checkCapsAndShiftLocks) {
-        let lastChar;
-        let nextKeyMillis = 0;
+        if (this.isPasting) this.cancelPaste();
+
         this.processor.sysvia.disableKeyboard();
-        const clocksPerSecond = Math.floor(this.processor.cpuMultiplier * 2000000);
+        this._pasteClocksPerMs = Math.floor(this.processor.cpuMultiplier * 2000000) / 1000;
 
         if (checkCapsAndShiftLocks) {
             let toggleKey = null;
@@ -329,45 +341,69 @@ export class Keyboard extends EventEmitter {
             }
         }
 
-        const sendCharHook = this.processor.debugInstruction.add(() => {
-            const millis = this.processor.cycleSeconds * 1000 + this.processor.currentCycles / (clocksPerSecond / 1000);
-            if (millis < nextKeyMillis) {
-                return;
-            }
+        this._pasteKeys = keysToSend;
+        this._pasteLastChar = undefined;
+        this._pasteTask.schedule(0);
+    }
 
-            if (lastChar && lastChar !== utils.BBC.SHIFT) {
-                this.processor.sysvia.keyToggleRaw(lastChar);
-            }
+    /**
+     * Scheduler callback that delivers one key per invocation, rescheduling
+     * itself for the next key. Replaces the old debugInstruction hook so the
+     * CPU stays on the fast execution path during paste.
+     * @private
+     */
+    _deliverPasteKey() {
+        if (this._pasteLastChar && this._pasteLastChar !== utils.BBC.SHIFT) {
+            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+        }
 
-            if (keysToSend.length === 0) {
-                // Finished
-                this.processor.sysvia.enableKeyboard();
-                sendCharHook.remove();
-                return;
-            }
+        if (this._pasteKeys.length === 0) {
+            this._pasteLastChar = undefined;
+            this.processor.sysvia.enableKeyboard();
+            return;
+        }
 
-            const ch = keysToSend[0];
-            const debounce = lastChar === ch;
-            lastChar = ch;
-            if (debounce) {
-                lastChar = undefined;
-                nextKeyMillis = millis + 30;
-                return;
-            }
+        const ch = this._pasteKeys[0];
+        const debounce = this._pasteLastChar === ch;
+        this._pasteLastChar = ch;
+        if (debounce) {
+            this._pasteLastChar = undefined;
+            this._pasteTask.schedule(30 * this._pasteClocksPerMs);
+            return;
+        }
 
-            let time = 50;
-            if (typeof lastChar === "number") {
-                time = lastChar;
-                lastChar = undefined;
-            } else {
-                this.processor.sysvia.keyToggleRaw(lastChar);
-            }
+        let delayMs = 50;
+        if (typeof this._pasteLastChar === "number") {
+            delayMs = this._pasteLastChar;
+            this._pasteLastChar = undefined;
+        } else {
+            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+        }
 
-            // remove first character
-            keysToSend.shift();
+        this._pasteKeys.shift();
+        this._pasteTask.schedule(delayMs * this._pasteClocksPerMs);
+    }
 
-            nextKeyMillis = millis + time;
-        });
+    /**
+     * Cancel any in-progress paste operation.
+     */
+    cancelPaste() {
+        if (!this.isPasting) return;
+        this._pasteTask.cancel();
+        if (this._pasteLastChar && this._pasteLastChar !== utils.BBC.SHIFT) {
+            this.processor.sysvia.keyToggleRaw(this._pasteLastChar);
+        }
+        this._pasteLastChar = undefined;
+        this._pasteKeys = [];
+        this.processor.sysvia.enableKeyboard();
+    }
+
+    /**
+     * Whether a paste operation is currently in progress.
+     * @returns {boolean}
+     */
+    get isPasting() {
+        return this._pasteKeys.length > 0 || this._pasteTask.scheduled();
     }
 
     /**

package/src/main.js

@@ -480,6 +480,7 @@ async function loadSCSIFile(file) {
 }
 
 const $pastetext = $("#paste-text");
+$pastetext.closest("form").on("submit", (event) => event.preventDefault());
 $pastetext.on("paste", function (event) {
     const text = event.originalEvent.clipboardData.getData("text/plain");
     sendRawKeyboardToBBC(utils.stringToBBCKeys(text), true);
@@ -619,6 +620,7 @@ processor = new Cpu6502(model, {
     video,
     soundChip: audioHandler.soundChip,
     ddNoise: audioHandler.ddNoise,
+    relayNoise: audioHandler.relayNoise,
     music5000: model.hasMusic5000 ? audioHandler.music5000 : null,
     cmos,
     config: emulationConfig,

package/src/microphone-input.js

@@ -1,4 +1,5 @@
 import { AnalogueSource } from "./analogue-source.js";
+import { createAudioContext } from "./audio-utils.js";
 
 /**
  * Provides microphone input as an analogue source for the BBC Micro's ADC
@@ -38,7 +39,13 @@ export class MicrophoneInput extends AnalogueSource {
         if (!this.audioContext) {
             try {
                 console.log("MicrophoneInput: Creating audio context");
-                this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
+                this.audioContext = createAudioContext();
+                if (!this.audioContext) {
+                    this.errorMessage = "WebAudio is not available; could not create audio context";
+                    console.error("MicrophoneInput:", this.errorMessage);
+                    if (this.errorCallback) this.errorCallback(this.errorMessage);
+                    return false;
+                }
                 console.log("MicrophoneInput: Audio context created:", this.audioContext.state);
             } catch (error) {
                 console.error("MicrophoneInput: Error creating audio context:", error);

package/src/relaynoise.js

@@ -0,0 +1,37 @@
+"use strict";
+// Cassette motor relay click sound (issue #296).
+// Audio samples recorded from a real BBC Master cassette motor relay.
+import { SamplePlayer } from "./sample-player.js";
+
+const Volume = 0.4;
+
+export class RelayNoise extends SamplePlayer {
+    constructor(context, destination) {
+        super(context, destination, Volume);
+    }
+
+    async initialise() {
+        await this.loadSounds({
+            motorOn: "sounds/tape/motor_on.mp3",
+            motorOff: "sounds/tape/motor_off.mp3",
+        });
+    }
+
+    motorOn() {
+        this.oneShot(this.sounds.motorOn);
+    }
+
+    motorOff() {
+        this.oneShot(this.sounds.motorOff);
+    }
+}
+
+export class FakeRelayNoise {
+    initialise() {
+        return Promise.resolve();
+    }
+    motorOn() {}
+    motorOff() {}
+    mute() {}
+    unmute() {}
+}

package/src/sample-player.js

@@ -0,0 +1,91 @@
+"use strict";
+import * as utils from "./utils.js";
+
+/**
+ * Base class for audio components that load and play back sample buffers
+ * (e.g. disc drive noise, cassette relay clicks).
+ *
+ * Provides: gain node setup, sample loading, one-shot playback, and
+ * gain-based mute/unmute.  Subclasses add domain-specific behaviour.
+ */
+export class SamplePlayer {
+    constructor(context, destination, volume) {
+        this.context = context;
+        this.volume = volume;
+        this.sounds = {};
+        this.gain = context.createGain();
+        this.gain.gain.value = volume;
+        this.gain.connect(destination);
+        // Prevent older Safari from GC-ing in-flight AudioBufferSourceNodes.
+        this.playing = [];
+    }
+
+    /**
+     * Load a map of {name: path} into decoded AudioBuffers stored in this.sounds.
+     */
+    async loadSounds(pathMap) {
+        const entries = Object.entries(pathMap);
+        const decoded = await Promise.all(
+            entries.map(async ([, path]) => {
+                const data = await utils.loadData(path);
+                // Safari doesn't support the promise form of decodeAudioData.
+                return new Promise((resolve, reject) => {
+                    this.context.decodeAudioData(
+                        data.buffer,
+                        (buf) => resolve(buf),
+                        (err) => reject(err),
+                    );
+                });
+            }),
+        );
+        for (let i = 0; i < entries.length; i++) {
+            this.sounds[entries[i][0]] = decoded[i];
+        }
+    }
+
+    /**
+     * Fire-and-forget: play a buffer once, return its duration.
+     */
+    oneShot(sound) {
+        const duration = sound.duration;
+        if (this.context.state !== "running") return duration;
+        const source = this.context.createBufferSource();
+        source.buffer = sound;
+        source.connect(this.gain);
+        source.onended = () => {
+            this.playing = this.playing.filter((s) => s !== source);
+        };
+        source.start();
+        this.playing.push(source);
+        return duration;
+    }
+
+    /**
+     * Play a buffer, optionally looping.  Returns a Promise that resolves
+     * with the source node (if looping) or when playback ends (if not).
+     */
+    play(sound, loop) {
+        if (this.context.state !== "running") return Promise.reject();
+        return new Promise((resolve) => {
+            const source = this.context.createBufferSource();
+            source.loop = !!loop;
+            source.buffer = sound;
+            source.connect(this.gain);
+            source.onended = () => {
+                this.playing = this.playing.filter((s) => s !== source);
+                if (!source.loop) resolve();
+            };
+            source.start();
+            this.playing.push(source);
+            if (source.loop) resolve(source);
+        });
+    }
+
+    mute() {
+        this.gain.gain.value = 0;
+    }
+
+    unmute() {
+        this.gain.gain.value = this.volume;
+    }
+}

package/src/teletext.js

@@ -395,7 +395,7 @@ export class Teletext {
         this.prevCol = this.col;
         this.curGlyphs = this.nextGlyphs;
 
-        const prevFlash = this.flash;
+        let flashThisCell = this.flash;
         if (data < 0x20) {
             data = this.handleControlCode(data);
         } else if (this.gfx) {
@@ -415,7 +415,11 @@ export class Teletext {
         }
         let chardef = this.curGlyphs[(data - 32) * 20 + scanline];
 
-        if ((prevFlash && this.flashOn) || (this.secondHalfOfDouble && !this.dbl)) {
+        // Flash (code 8) is "Set After" — flashThisCell retains the pre-control-code state.
+        // 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)) {
             const backgroundColour = this.colour[(this.bg & 7) << 5];
             for (let i = 0; i < 16; ++i) {
                 buf[offset++] = backgroundColour;

package/src/web/audio-handler.js

@@ -1,7 +1,9 @@
 import { SmoothieChart, TimeSeries } from "smoothie";
 import { FakeSoundChip, SoundChip } from "../soundchip.js";
 import { DdNoise, FakeDdNoise } from "../ddnoise.js";
+import { RelayNoise, FakeRelayNoise } from "../relaynoise.js";
 import { Music5000, FakeMusic5000 } from "../music5000.js";
+import { createAudioContext } from "../audio-utils.js";
 
 // Using this approach means when jsbeeb is embedded in other projects, vite doesn't have a fit.
 // See https://github.com/vitejs/vite/discussions/6459
@@ -23,18 +25,16 @@ export class AudioHandler {
         this._addStat("queueSize", { strokeStyle: "rgb(51,126,108)" });
         this._addStat("queueAge", { strokeStyle: "rgb(162,119,22)" });
         this.chart.streamTo(statsNode, 100);
-        /*global webkitAudioContext*/
-        this.audioContext =
-            typeof AudioContext !== "undefined"
-                ? new AudioContext()
-                : typeof webkitAudioContext !== "undefined"
-                  ? new webkitAudioContext()
-                  : null;
+        this.audioContext = createAudioContext();
         this._jsAudioNode = null;
         if (this.audioContext && this.audioContext.audioWorklet) {
             this.audioContext.onstatechange = () => this.checkStatus();
             this.soundChip = new SoundChip((buffer, time) => this._onBuffer(buffer, time));
-            this.ddNoise = noSeek ? new FakeDdNoise() : new DdNoise(this.audioContext);
+            // Master gain node for all sample-based audio (disc, relay, etc.).
+            this.masterGain = this.audioContext.createGain();
+            this.masterGain.connect(this.audioContext.destination);
+            this.ddNoise = noSeek ? new FakeDdNoise() : new DdNoise(this.audioContext, this.masterGain);
+            this.relayNoise = new RelayNoise(this.audioContext, this.masterGain);
             this._setup(audioFilterFreq, audioFilterQ).then();
         } else {
             if (this.audioContext && !this.audioContext.audioWorklet) {
@@ -52,18 +52,14 @@ export class AudioHandler {
             }
             this.soundChip = new FakeSoundChip();
             this.ddNoise = new FakeDdNoise();
+            this.relayNoise = new FakeRelayNoise();
         }
 
         this.warningNode.on("mousedown", () => this.tryResume());
         this.warningNode.toggle(false);
 
         // Initialise Music 5000 audio context
-        this.audioContextM5000 =
-            typeof AudioContext !== "undefined"
-                ? new AudioContext({ sampleRate: 46875 })
-                : typeof webkitAudioContext !== "undefined"
-                  ? new webkitAudioContext({ sampleRate: 46875 })
-                  : null;
+        this.audioContextM5000 = createAudioContext({ sampleRate: 46875 });
 
         if (this.audioContextM5000 && this.audioContextM5000.audioWorklet) {
             this.audioContextM5000.onstatechange = () => this.checkStatus();
@@ -125,22 +121,26 @@ export class AudioHandler {
     }
 
     checkStatus() {
-        if (!this.audioContext) return;
-        if (this.audioContext.state === "suspended") this.warningNode.fadeIn();
-        if (this.audioContext.state === "running") this.warningNode.fadeOut();
+        if (!this.audioContext && !this.audioContextM5000) return;
+        const suspended =
+            (this.audioContext && this.audioContext.state === "suspended") ||
+            (this.audioContextM5000 && this.audioContextM5000.state === "suspended");
+        if (suspended) this.warningNode.fadeIn();
+        else this.warningNode.fadeOut();
     }
 
     async initialise() {
         await this.ddNoise.initialise();
+        await this.relayNoise.initialise();
     }
 
     mute() {
         this.soundChip.mute();
-        this.ddNoise.mute();
+        if (this.masterGain) this.masterGain.gain.value = 0;
     }
 
     unmute() {
         this.soundChip.unmute();
-        this.ddNoise.unmute();
+        if (this.masterGain) this.masterGain.gain.value = 1;
     }
 }

package/tests/test-machine.js

@@ -100,6 +100,19 @@ export class TestMachine {
         throw new Error(`Cursor did not reach state ${on} in time (cursorOnThisFrame=${video.cursorOnThisFrame})`);
     }
 
+    /**
+     * Run until the teletext flash state reaches the desired phase.
+     * @param {boolean} on - true for flash-on (flashing cells blanked), false for flash-off
+     */
+    async runToFlashState(on) {
+        const teletext = this.processor.video.teletext;
+        for (let i = 0; i < 100; i++) {
+            if (teletext.flashOn === on) return;
+            await this.runFor(40000);
+        }
+        throw new Error(`Flash did not reach state ${on} in time (flashOn=${teletext.flashOn})`);
+    }
+
     async runUntilVblank() {
         let hit = false;
         if (this.processor.isMaster) throw new Error("Not yet implemented");