jsbeeb 1.11.0 → 1.13.0

package/src/utils_atom.js

@@ -0,0 +1,508 @@
+import { keyCodes, userKeymap } from "./utils.js";
+
+// Detect keyboard layout locally — mirrors the logic in utils.js but avoids
+// importing the non-exported isUKlayout. Should be replaced with an import
+// if utils.js ever exports it.
+function detectKeyboardLayout() {
+    if (typeof navigator === "undefined") return "UK";
+    if (typeof localStorage !== "undefined" && localStorage.keyboardLayout) {
+        return localStorage.keyboardLayout === "US" ? "US" : "UK";
+    }
+    if (navigator.language) {
+        if (navigator.language.toLowerCase() === "en-gb") return "UK";
+        if (navigator.language.toLowerCase() === "en-us") return "US";
+    }
+    return "UK";
+}
+
+const isUKlayout = detectKeyboardLayout() === "UK";
+
+// ATOM
+
+/*
+    Acorn Atom
+
+                  &B001 - keyboard matrix column:
+                       ~b0 : SPC  [   \   ]   ^  LCK <-> ^-v Lft Rgt
+                       ~b1 : Dwn Up  CLR ENT CPY DEL  0   1   2   3
+                       ~b2 :  4   5   6   7   8   9   :   ;   <   =
+                       ~b3 :  >   ?   @   A   B   C   D   E   F   G
+                       ~b4 :  H   I   J   K   L   M   N   O   P   Q
+                       ~b5 :  R   S   T   U   V   W   X   Y   Z  ESC
+                       ~b6 :                                          Ctrl
+                       ~b7 :                                          Shift
+                              9   8   7   6   5   4   3   2   1   0
+
+                  &B002 - REPT key
+                       ~b6 :                                          Rept
+
+     */
+
+export const ATOM = {
+    RIGHT: [0, 0],
+    LEFT: [1, 0],
+    UP_DOWN: [2, 0],
+    LEFT_RIGHT: [3, 0],
+    LOCK: [4, 0], //CAPSLOCK
+
+    UP_ARROW: [5, 0], // big uparrow next to break
+    RIGHT_SQUARE_BRACKET: [6, 0],
+    BACKSLASH: [7, 0],
+    LEFT_SQUARE_BRACKET: [8, 0],
+    SPACE: [9, 0],
+
+    K3: [0, 1],
+    K2: [1, 1],
+    K1: [2, 1],
+    K0: [3, 1],
+    DELETE: [4, 1],
+    COPY: [5, 1],
+    RETURN: [6, 1],
+    CLEAR: [7, 1],
+    UP: [8, 1],
+    DOWN: [9, 1],
+
+    MINUS_EQUALS: [0, 2],
+    COMMA_LESSTHAN: [1, 2],
+    SEMICOLON_PLUS: [2, 2],
+    COLON_STAR: [3, 2],
+    K9: [4, 2],
+    K8: [5, 2],
+    K7: [6, 2],
+    K6: [7, 2],
+    K5: [8, 2],
+    K4: [9, 2],
+
+    G: [0, 3],
+    F: [1, 3],
+    E: [2, 3],
+    D: [3, 3],
+    C: [4, 3],
+    B: [5, 3],
+    A: [6, 3],
+    AT: [7, 3],
+    SLASH_QUESTIONMARK: [8, 3], // AND QUESTION MARK
+    PERIOD_GREATERTHAN: [9, 3], // AND GREATER
+
+    Q: [0, 4],
+    P: [1, 4],
+    O: [2, 4],
+    N: [3, 4],
+    M: [4, 4],
+    L: [5, 4],
+    K: [6, 4],
+    J: [7, 4],
+    I: [8, 4],
+    H: [9, 4],
+
+    ESCAPE: [0, 5],
+    Z: [1, 5],
+    Y: [2, 5],
+    X: [3, 5],
+    W: [4, 5],
+    V: [5, 5],
+    U: [6, 5],
+    T: [7, 5],
+    S: [8, 5],
+    R: [9, 5],
+
+    // special codes
+    CTRL: [0, 6],
+    SHIFT: [0, 7],
+    REPT: [1, 6],
+};
+
+export function stringToATOMKeys(str) {
+    const array = [];
+    let shiftState = false;
+    let capsLockState = true;
+    for (let i = 0; i < str.length; ++i) {
+        const c = str.charCodeAt(i);
+        let charStr = str.charAt(i);
+        let atomKey = null;
+        let needsShift = false;
+        // Only letters care about caps lock state; non-letter characters
+        // leave it wherever it is to avoid unnecessary LOCK toggles.
+        let needsCapsLock = capsLockState;
+        if (c >= 65 && c <= 90) {
+            // A-Z
+            atomKey = ATOM[charStr];
+            needsCapsLock = true;
+        } else if (c >= 97 && c <= 122) {
+            // a-z (LOCK toggles the ROM's internal caps lock state)
+            charStr = String.fromCharCode(c - 32);
+            atomKey = ATOM[charStr];
+            needsCapsLock = false;
+        } else if (c >= 48 && c <= 57) {
+            // 0-9
+            atomKey = ATOM["K" + charStr];
+        } else if (c >= 33 && c <= 41) {
+            // ! to )
+            charStr = String.fromCharCode(c + 16);
+            atomKey = ATOM["K" + charStr];
+            needsShift = true;
+        } else {
+            switch (charStr) {
+                case "\n":
+                    atomKey = ATOM.RETURN;
+                    break;
+                case "\t":
+                    atomKey = ATOM.SPACE; // Atom has no TAB key
+                    break;
+                case " ":
+                    atomKey = ATOM.SPACE;
+                    break;
+                case "-":
+                    atomKey = ATOM.MINUS_EQUALS;
+                    break;
+                case "=":
+                    atomKey = ATOM.MINUS_EQUALS;
+                    needsShift = true;
+                    break;
+                case "\\":
+                    atomKey = ATOM.BACKSLASH;
+                    break;
+                case "@":
+                    atomKey = ATOM.AT;
+                    break;
+                case "[":
+                    atomKey = ATOM.LEFT_SQUARE_BRACKET;
+                    break;
+                case ";":
+                    atomKey = ATOM.SEMICOLON_PLUS;
+                    break;
+                case "+":
+                    atomKey = ATOM.SEMICOLON_PLUS;
+                    needsShift = true;
+                    break;
+                case ":":
+                    atomKey = ATOM.COLON_STAR;
+                    break;
+                case "*":
+                    atomKey = ATOM.COLON_STAR;
+                    needsShift = true;
+                    break;
+                case "]":
+                    atomKey = ATOM.RIGHT_SQUARE_BRACKET;
+                    break;
+                case ",":
+                    atomKey = ATOM.COMMA_LESSTHAN;
+                    break;
+                case "<":
+                    atomKey = ATOM.COMMA_LESSTHAN;
+                    needsShift = true;
+                    break;
+                case ".":
+                    atomKey = ATOM.PERIOD_GREATERTHAN;
+                    break;
+                case ">":
+                    atomKey = ATOM.PERIOD_GREATERTHAN;
+                    needsShift = true;
+                    break;
+                case "/":
+                    atomKey = ATOM.SLASH_QUESTIONMARK;
+                    break;
+                case "?":
+                    atomKey = ATOM.SLASH_QUESTIONMARK;
+                    needsShift = true;
+                    break;
+            }
+        }
+
+        if (!atomKey) continue;
+
+        if ((needsShift && !shiftState) || (!needsShift && shiftState)) {
+            array.push(ATOM.SHIFT);
+            shiftState = !shiftState;
+        }
+        if ((needsCapsLock && !capsLockState) || (!needsCapsLock && capsLockState)) {
+            array.push(ATOM.LOCK);
+            capsLockState = !capsLockState;
+        }
+        array.push(atomKey);
+    }
+
+    if (shiftState) array.push(ATOM.SHIFT);
+    if (!capsLockState) array.push(ATOM.LOCK);
+    return array;
+}
+
+export function getKeyMapAtom(keyLayout) {
+    const keys2 = [];
+
+    // shift pressed
+    keys2[true] = {};
+
+    // shift not pressed
+    keys2[false] = {};
+
+    // shiftDown MUST be true or false (not undefined)
+    function doMap(s, colRow, shiftDown) {
+        if (keys2[shiftDown][s] && keys2[shiftDown][s] !== colRow) {
+            console.log(
+                "Warning: duplicate binding for atom key",
+                (shiftDown ? "<SHIFT>" : "") + s,
+                colRow,
+                keys2[shiftDown][s],
+            );
+        }
+        keys2[shiftDown][s] = colRow;
+    }
+
+    // shiftDown undefined -> map both
+    function map(s, colRow, shiftDown) {
+        if ((!s && s !== 0) || !colRow) {
+            console.log("error binding key", s, colRow);
+        }
+        if (typeof s === "string") {
+            s = s.charCodeAt(0);
+        }
+
+        if (shiftDown === undefined) {
+            doMap(s, colRow, true);
+            doMap(s, colRow, false);
+        } else {
+            doMap(s, colRow, shiftDown);
+        }
+    }
+
+    map(keyCodes.Q, ATOM.Q);
+    map(keyCodes.W, ATOM.W);
+    map(keyCodes.E, ATOM.E);
+    map(keyCodes.R, ATOM.R);
+    map(keyCodes.T, ATOM.T);
+    map(keyCodes.Y, ATOM.Y);
+    map(keyCodes.U, ATOM.U);
+    map(keyCodes.I, ATOM.I);
+    map(keyCodes.O, ATOM.O);
+    map(keyCodes.P, ATOM.P);
+
+    map(keyCodes.A, ATOM.A);
+    map(keyCodes.S, ATOM.S);
+    map(keyCodes.D, ATOM.D);
+    map(keyCodes.F, ATOM.F);
+    map(keyCodes.G, ATOM.G);
+    map(keyCodes.H, ATOM.H);
+    map(keyCodes.J, ATOM.J);
+    map(keyCodes.K, ATOM.K);
+    map(keyCodes.L, ATOM.L);
+
+    map(keyCodes.Z, ATOM.Z);
+    map(keyCodes.X, ATOM.X);
+    map(keyCodes.C, ATOM.C);
+    map(keyCodes.V, ATOM.V);
+    map(keyCodes.B, ATOM.B);
+    map(keyCodes.N, ATOM.N);
+    map(keyCodes.M, ATOM.M);
+
+    // these keys are in the same place on PC/Mac and ATOM keyboards
+    // including shifted characters
+    // so can be the same for "natural" and "gaming"
+    map(keyCodes.COMMA, ATOM.COMMA_LESSTHAN);
+    map(keyCodes.PERIOD, ATOM.PERIOD_GREATERTHAN);
+    map(keyCodes.SLASH, ATOM.SLASH_QUESTIONMARK);
+    map(keyCodes.SPACE, ATOM.SPACE);
+    map(keyCodes.ENTER, ATOM.RETURN);
+
+    // other keys to map to these in "game" layout too
+    map(keyCodes.F9, ATOM.CLEAR); // not actually on an ATOM keyboard
+    map(keyCodes.LEFT, ATOM.LEFT); // arrow left
+    map(keyCodes.RIGHT, ATOM.LEFT_RIGHT); // arrow right
+    map(keyCodes.DOWN, ATOM.DOWN); // arrow down
+    map(keyCodes.UP, ATOM.UP_DOWN); // arrow up
+
+    map(keyCodes.BACKSPACE, ATOM.DELETE); // delete
+    map(keyCodes.DELETE, ATOM.DELETE); // delete
+
+    map(keyCodes.ESCAPE, ATOM.ESCAPE);
+    map(keyCodes.TAB, ATOM.COPY);
+
+    map(keyCodes.F10, ATOM.REPT);
+
+    map(keyCodes.F1, ATOM.LOCK); // which is better for ATOM.LOCK - use all of them?
+    map(keyCodes.WINDOWS, ATOM.LOCK);
+    map(keyCodes.ALT_LEFT, ATOM.LOCK);
+
+    if (keyLayout === "natural") {
+        // "natural" keyboard
+        // Like a PC/Mac keyboard
+
+        // US Keyboard: has Tilde on <Shift>BACK_QUOTE
+        map(keyCodes.BACK_QUOTE, ATOM.UP_ARROW); // ` on PC, § on Mac
+        map(keyCodes.APOSTROPHE, isUKlayout ? ATOM.AT : ATOM.K2, true);
+        map(keyCodes.K2, isUKlayout ? ATOM.K2 : ATOM.AT, true);
+
+        // 1st row
+        map(keyCodes.K3, ATOM.K3, true);
+        map(keyCodes.K6, ATOM.UP_ARROW, true);
+        map(keyCodes.K7, ATOM.K6, true);
+        map(keyCodes.K8, ATOM.COLON_STAR, true);
+        map(keyCodes.K9, ATOM.K8, true);
+        map(keyCodes.K0, ATOM.K9, true);
+
+        map(keyCodes.K2, ATOM.K2, false);
+        map(keyCodes.K3, ATOM.K3, false);
+        map(keyCodes.K6, ATOM.K6, false);
+        map(keyCodes.K7, ATOM.K7, false);
+        map(keyCodes.K8, ATOM.K8, false);
+        map(keyCodes.K9, ATOM.K9, false);
+        map(keyCodes.K0, ATOM.K0, false);
+
+        map(keyCodes.K1, ATOM.K1);
+        map(keyCodes.K4, ATOM.K4);
+        map(keyCodes.K5, ATOM.K5);
+
+        // 3rd row
+
+        map(keyCodes.HASH, ATOM.BACKSLASH); // Atom has no # key; map to nearest
+
+        map(keyCodes.MINUS, ATOM.MINUS_EQUALS);
+
+        // 2nd row
+        map(keyCodes.LEFT_SQUARE_BRACKET, ATOM.LEFT_SQUARE_BRACKET);
+
+        map(keyCodes.RIGHT_SQUARE_BRACKET, ATOM.RIGHT_SQUARE_BRACKET);
+
+        // 3rd row
+
+        map(keyCodes.SEMICOLON, ATOM.SEMICOLON_PLUS);
+
+        map(keyCodes.APOSTROPHE, ATOM.COLON_STAR, false);
+
+        map(keyCodes.EQUALS, ATOM.SEMICOLON_PLUS); // OK for <Shift> at least
+
+        map(keyCodes.END, ATOM.COPY);
+        map(keyCodes.F11, ATOM.COPY);
+
+        map(keyCodes.CTRL, ATOM.CTRL);
+        map(keyCodes.CTRL_LEFT, ATOM.CTRL);
+        map(keyCodes.CTRL_RIGHT, ATOM.CTRL);
+        map(keyCodes.SHIFT, ATOM.SHIFT);
+        map(keyCodes.SHIFT_LEFT, ATOM.SHIFT);
+        map(keyCodes.SHIFT_RIGHT, ATOM.SHIFT);
+
+        map(keyCodes.BACKSLASH, ATOM.BACKSLASH);
+    } else if (keyLayout === "gaming") {
+        // gaming keyboard
+
+        // 1st row
+        map(keyCodes.ESCAPE, ATOM.ESCAPE);
+
+        // 2nd row
+        map(keyCodes.BACK_QUOTE, ATOM.ESCAPE);
+        map(keyCodes.K1, ATOM.K1);
+        map(keyCodes.K2, ATOM.K2);
+        map(keyCodes.K3, ATOM.K3);
+        map(keyCodes.K4, ATOM.K4);
+        map(keyCodes.K5, ATOM.K5);
+        map(keyCodes.K6, ATOM.K6);
+        map(keyCodes.K7, ATOM.K7);
+        map(keyCodes.K8, ATOM.K8);
+        map(keyCodes.K9, ATOM.K9);
+        map(keyCodes.K0, ATOM.K0);
+        map(keyCodes.MINUS, ATOM.MINUS_EQUALS);
+        map(keyCodes.EQUALS, ATOM.UP_ARROW);
+        map(keyCodes.BACKSPACE, ATOM.BACKSLASH);
+        map(keyCodes.INSERT, ATOM.LEFT);
+        map(keyCodes.HOME, ATOM.RIGHT);
+
+        // 3rd row
+        map(keyCodes.LEFT_SQUARE_BRACKET, ATOM.AT);
+        map(keyCodes.RIGHT_SQUARE_BRACKET, ATOM.LEFT_SQUARE_BRACKET);
+        // no key for ATOM.UNDERSCORE_POUND in UK
+        // see 4th row for US mapping keyCodes.BACKSLASH
+        map(keyCodes.DELETE, ATOM.UP);
+        map(keyCodes.END, ATOM.DOWN);
+
+        // 4th row
+        // no key for ATOM.CAPSLOCK (mapped to CTRL_LEFT below)
+        map(keyCodes.CAPSLOCK, ATOM.CTRL);
+        map(keyCodes.SEMICOLON, ATOM.SEMICOLON_PLUS);
+        map(keyCodes.APOSTROPHE, ATOM.COLON_STAR);
+        // UK keyboard (key missing on US)
+        map(keyCodes.HASH, ATOM.RIGHT_SQUARE_BRACKET);
+
+        // UK has extra key \| for SHIFT
+        map(keyCodes.SHIFT_LEFT, isUKlayout ? ATOM.LOCK : ATOM.SHIFT);
+        // UK: key is between SHIFT and Z
+        // US: key is above ENTER
+        map(keyCodes.BACKSLASH, isUKlayout ? ATOM.SHIFT : ATOM.BACKSLASH);
+
+        // 5th row
+
+        // Atom uses CTRL as shift, so map PC Ctrl to Atom's LOCK key
+        map(keyCodes.CTRL_LEFT, ATOM.LOCK);
+        map(keyCodes.SHIFT, ATOM.CTRL);
+
+        // ATOM.DELETE is covered by the common mapping above
+        map(keyCodes.CTRL_RIGHT, ATOM.COPY);
+    } else {
+        // Physical, and default
+        // Like a real ATOM
+        // mainly the CTRL key is still CTRL (as CAPSLOCK locks on the MAC)
+        // UP/DOWN/LEFT/RIGHT are using arrow keys
+        // REPT is using RIGHT_SHIFT
+        // note: LOCK is on LEFT_ALT
+        map(keyCodes.K1, ATOM.K1);
+        map(keyCodes.K2, ATOM.K2);
+        map(keyCodes.K3, ATOM.K3);
+        map(keyCodes.K4, ATOM.K4);
+        map(keyCodes.K5, ATOM.K5);
+        map(keyCodes.K6, ATOM.K6);
+        map(keyCodes.K7, ATOM.K7);
+        map(keyCodes.K8, ATOM.K8);
+        map(keyCodes.K9, ATOM.K9);
+        map(keyCodes.K0, ATOM.K0);
+        map(keyCodes.MINUS, ATOM.MINUS_EQUALS); // - / _ becomes - / =
+        map(keyCodes.EQUALS, ATOM.COLON_STAR); // = / + becomes  : / *
+        //BREAK is code in 'main.js' to F12
+
+        // Q-P normal
+        map(keyCodes.LEFT_SQUARE_BRACKET, ATOM.AT); // maps to @
+        map(keyCodes.RIGHT_SQUARE_BRACKET, ATOM.BACKSLASH); // maps to \
+
+        map(keyCodes.SHIFT, ATOM.CTRL);
+        map(keyCodes.SHIFT_LEFT, ATOM.CTRL); // using CAPSLOCK for CTRL doesn't work on MAC
+        map(keyCodes.CTRL, ATOM.SHIFT);
+        map(keyCodes.CTRL_LEFT, ATOM.SHIFT);
+
+        map(keyCodes.CTRL_RIGHT, ATOM.SHIFT);
+        map(keyCodes.SHIFT_RIGHT, ATOM.REPT);
+
+        // A-L normal
+        map(keyCodes.SEMICOLON, ATOM.SEMICOLON_PLUS); // ; / +
+        map(keyCodes.APOSTROPHE, ATOM.LEFT_SQUARE_BRACKET);
+        map(keyCodes.BACKSLASH, ATOM.RIGHT_SQUARE_BRACKET); // HASH is \| key on Mac
+
+        // Z - M normal
+    }
+
+    // user keymapping
+    // do last (to override defaults)
+    while (userKeymap.length > 0) {
+        const mapping = userKeymap.pop();
+        map(keyCodes[mapping.native], ATOM[mapping.atom]);
+    }
+
+    return keys2;
+}
+
+export function remapGamepad(gamepad) {
+    //mmcdefaults
+
+    // 3-key pressed    left
+    // G-key pressed    right
+    // Q-key pressed    up
+    // =-key pressed    down
+    // rightarrow-key pressed   fire
+
+    gamepad.gamepadMapping[14] = ATOM.K3;
+    gamepad.gamepadMapping[15] = ATOM.G;
+    gamepad.gamepadMapping[13] = ATOM.MINUS_EQUALS;
+    gamepad.gamepadMapping[12] = ATOM.Q;
+
+    // button 0 = right arrow key (fire in many Atom games)
+    gamepad.gamepadMapping[0] = ATOM.RIGHT;
+    // "start" (often <Space> to start game)
+    gamepad.gamepadMapping[9] = ATOM.SPACE;
+}

package/src/video.js

@@ -2,6 +2,7 @@
 import { Teletext } from "./teletext.js";
 import * as utils from "./utils.js";
 import { BbcDefaultPalette as NulaDefaultPalette } from "./bbc-palette.js";
+import { Video6847 } from "./6847.js";
 
 export const VDISPENABLE = 1 << 0;
 export const HDISPENABLE = 1 << 1;
@@ -326,7 +327,7 @@ function table4bppOffset(ulamode, byte) {
 ////////////////////
 // The video class
 export class Video {
-    constructor(isMaster, fb32_param, paint_ext_param) {
+    constructor(isMaster, fb32_param, paint_ext_param, { isAtom = false } = {}) {
         this.isMaster = isMaster;
         this.fb32 = utils.makeFast32(fb32_param);
         this.collook = utils.makeFast32(
@@ -422,6 +423,13 @@ export class Video {
         this.crtc = new Crtc(this);
         this.ula = new Ula(this);
 
+        // Atom: attach the MC6847 VDG and use its polltime
+        this.video6847 = null;
+        if (isAtom) {
+            this.video6847 = new Video6847(this);
+            this.polltime = this.video6847.polltimeFacade;
+        }
+
         this.reset(null);
         this.clearPaintBuffer();
         this.paint();
@@ -536,6 +544,9 @@ export class Video {
         this.cpu = cpu;
         this.sysvia = via;
         if (via) via.cb2changecallback = this.cb2changed.bind(this);
+        if (this.video6847 && cpu) {
+            this.video6847.reset(cpu, cpu.atomppia);
+        }
     }
 
     paint() {

package/src/web/audio-handler.js

@@ -1,5 +1,4 @@
-import { SmoothieChart, TimeSeries } from "smoothie";
-import { FakeSoundChip, SoundChip } from "../soundchip.js";
+import { FakeSoundChip, SoundChip, AtomSoundChip } from "../soundchip.js";
 import { DdNoise, FakeDdNoise } from "../ddnoise.js";
 import { RelayNoise, FakeRelayNoise } from "../relaynoise.js";
 import { Music5000, FakeMusic5000 } from "../music5000.js";
@@ -12,25 +11,27 @@ const rendererUrl = new URL("./audio-renderer.js", import.meta.url).href;
 const music5000WorkletUrl = new URL("../music5000-worklet.js", import.meta.url).href;
 
 export class AudioHandler {
-    constructor({ warningNode, statsNode, audioFilterFreq, audioFilterQ, noSeek } = {}) {
+    constructor({ warningNode, statsNode, audioFilterFreq, audioFilterQ, noSeek, cpuSpeed, isAtom } = {}) {
+        this.cpuSpeed = cpuSpeed;
+        this.isAtom = isAtom;
         this.warningNode = warningNode;
         toggle(this.warningNode, false);
-        this.chart = new SmoothieChart({
-            tooltip: true,
-            labels: { precision: 0 },
-            yRangeFunction: (range) => {
-                return { min: 0, max: range.max };
-            },
-        });
         this.stats = {};
-        this._addStat("queueSize", { strokeStyle: "rgb(51,126,108)" });
-        this._addStat("queueAge", { strokeStyle: "rgb(162,119,22)" });
-        this.chart.streamTo(statsNode, 100);
+        if (statsNode) {
+            this._initStats(statsNode).catch((error) => {
+                console.error("Unable to initialise audio stats", error);
+                this.stats = {};
+                toggle(statsNode, false);
+            });
+        }
         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));
+            const onBuffer = (buffer, time) => this._onBuffer(buffer, time);
+            this.soundChip = this.isAtom
+                ? new AtomSoundChip(onBuffer, { cpuSpeed: this.cpuSpeed })
+                : new SoundChip(onBuffer);
             // Master gain node for all sample-based audio (disc, relay, etc.).
             this.masterGain = this.audioContext.createGain();
             this.masterGain.connect(this.audioContext.destination);
@@ -75,6 +76,22 @@ export class AudioHandler {
         }
     }
 
+    // Lazily load smoothie and set up the audio stats chart.
+    async _initStats(statsNode) {
+        const { SmoothieChart, TimeSeries } = await import("smoothie");
+        this._TimeSeries = TimeSeries;
+        this.chart = new SmoothieChart({
+            tooltip: true,
+            labels: { precision: 0 },
+            yRangeFunction: (range) => {
+                return { min: 0, max: range.max };
+            },
+        });
+        this._addStat("queueSize", { strokeStyle: "rgb(51,126,108)" });
+        this._addStat("queueAge", { strokeStyle: "rgb(162,119,22)" });
+        this.chart.streamTo(statsNode, 100);
+    }
+
     async _setup(audioFilterFreq, audioFilterQ) {
         await this.audioContext.audioWorklet.addModule(rendererUrl);
         if (audioFilterFreq !== 0) {
@@ -99,7 +116,7 @@ export class AudioHandler {
     }
 
     _addStat(stat, info) {
-        const timeSeries = new TimeSeries();
+        const timeSeries = new this._TimeSeries();
         this.stats[stat] = timeSeries;
         info.tooltipLabel = stat;
         this.chart.addTimeSeries(timeSeries, info);
@@ -110,9 +127,14 @@ export class AudioHandler {
     }
 
     // Recent browsers, particularly Safari and Chrome, require a user interaction in order to enable sound playback.
+    // Errors are swallowed — resume() can fail due to autoplay policy and callers can't do anything about it.
     async tryResume() {
-        if (this.audioContext) await this.audioContext.resume();
-        if (this.audioContextM5000) await this.audioContextM5000.resume();
+        try {
+            if (this.audioContext) await this.audioContext.resume();
+            if (this.audioContextM5000) await this.audioContextM5000.resume();
+        } catch {
+            // Autoplay policy prevented resume; will retry on next user gesture.
+        }
     }
 
     _onBufferMusic5000(buffer) {