jsbeeb 1.13.0 → 1.14.0

package/README.md

@@ -167,8 +167,9 @@ sudo rpm -i out/dist/jsbeeb-1.0.1.x86_64.rpm
 - `autotype` - types whatever you put after. e.g. `&autotype=PRINT"Matt is cool"%0a` (return is URI escaped to `%0a`)
 - `embed` - Remove the margins around the screen, hide most navigation entries and make the page background
   transparent (intended for use when running within an iframe in a third-party site).
-- `cpuMultiplier=X` speeds up the CPU by a factor of `X`. May be fractional or below one to slow the CPU down. NB disc
-  loads become unreliable with a too-slow CPU, and running too fast might cause the browser to hang.
+- `cpuMultiplier=X` speeds up the CPU by a factor of `X` relative to the peripherals: video, sound and the VIAs keep
+  running at their real-world rates. May be fractional or below one to slow the CPU down. NB disc loads become
+  unreliable with a too-slow CPU, and running too fast might cause the browser to hang.
 - `sbLeft` / `sbRight` / `sbBottom` - a URL to place left of, right of, or below the cub monitor. The left and right
   should be around 648 high and the bottom image should be around 896 wide. Left and right wider than 300 will run into
   problems on smaller screens; bottom taller than 100 or so similarly.

package/package.json

@@ -7,10 +7,10 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.13.0",
-  "//": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
+  "version": "1.14.0",
+  "//engines": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=24.15.0"
   },
   "type": "module",
   "main": "./src/app/app.js",
@@ -27,33 +27,37 @@
   ],
   "dependencies": {
     "@popperjs/core": "^2.11.8",
-    "argparse": "^2.0.1",
+    "argparse": "^3.0.0",
     "bootstrap": "^5.3.8",
     "bootswatch": "^5.3.8",
-    "sharp": "^0.34.5",
+    "sharp": "^0.35.3",
     "smoothie": "^1.36.1"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@vitest/coverage-v8": "^4.0.18",
-    "eslint": "^10.2.0",
+    "eslint": "^10.7.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.5",
-    "globals": "^17.5.0",
+    "eslint-plugin-prettier": "^5.5.6",
+    "globals": "^17.7.0",
     "husky": "^9.1.7",
-    "jsdom": "^29.0.2",
-    "lint-staged": "^16.4.0",
-    "npm-run-all2": "^8.0.4",
-    "pixelmatch": "^7.1.0",
-    "prettier": "^3.8.2",
-    "vite": "^8.0.8",
+    "jsdom": "^30.0.1",
+    "lint-staged": "^17.1.1",
+    "npm-run-all2": "^9.0.2",
+    "pixelmatch": "^7.2.0",
+    "prettier": "^3.9.6",
+    "vite": "^8.1.5",
     "vitest": "^4.0.10"
   },
   "optionalDependencies": {
-    "electron": "^41.2.0",
-    "electron-builder": "^26.8.1",
+    "electron": "^43.2.0",
+    "electron-builder": "^26.15.3",
     "electron-store": "^11.0.2"
   },
+  "//overrides": "brace-expansion forced to the patched version for GHSA-mh99-v99m-4gvg; the electron-builder dependency chain still pins vulnerable versions. Remove once `npm audit` is clean without it.",
+  "overrides": {
+    "brace-expansion": "^5.0.8"
+  },
   "license": "GPL-3.0-or-later",
   "build": {
     "appId": "org.godbolt.bbc",
@@ -108,5 +112,8 @@
       "prettier --write"
     ],
     "*.{md,json,yml,yaml,css,html}": "prettier --write"
+  },
+  "allowScripts": {
+    "electron-winstaller@5.4.0": true
   }
 }

package/src/6502.js

@@ -15,6 +15,9 @@ import { AtomMMC2 } from "./mmc.js";
 
 const signExtend = utils.signExtend;
 
+// Speed of the second processor relative to the host, as fitted to a Master Turbo.
+export const DefaultTubeCpuMultiplier = 2;
+
 function _set(byte, mask, set) {
     return (byte & ~mask) | (set ? mask : 0);
 }
@@ -407,11 +410,11 @@ class Base6502 {
 }
 
 class Tube6502 extends Base6502 {
-    constructor(model, cpu) {
+    constructor(model, cpu, { cpuMultiplier = DefaultTubeCpuMultiplier } = {}) {
         super(model, { cycleAccurate: false });
 
         this.cycles = 0;
-        this.cpuMultiplier = 2;
+        this.cpuMultiplier = cpuMultiplier;
         this.romPaged = true;
         this.memory = new Uint8Array(65536);
         this.rom = new Uint8Array(4096);
@@ -424,6 +427,10 @@ class Tube6502 extends Base6502 {
         this.pc = this.readmem(0xfffc) | (this.readmem(0xfffd) << 8);
         this.p.i = true;
         this.s = (this.s - 3) & 0xff; // Simulate 3 dummy pushes during reset
+        // A latched NMI would otherwise survive the reset and be taken on the first instruction
+        // after it, defeating the empty R3 FIFO the ULA seeds for exactly that reason.
+        this._nmiLevel = this._nmiEdge = false;
+        this.takeInt = false;
         this.tube.reset(hard);
     }
 
@@ -482,6 +489,46 @@ class Tube6502 extends Base6502 {
         }
     }
 
+    snapshotState({ includeRoms = false } = {}) {
+        return {
+            a: this.a,
+            x: this.x,
+            y: this.y,
+            s: this.s,
+            pc: this.pc,
+            p: this.p.asByte(),
+            nmiLevel: this._nmiLevel,
+            nmiEdge: this._nmiEdge,
+            takeInt: this.takeInt,
+            // The parasite has no scheduler of its own, so this is not relative to any epoch.
+            cycles: this.cycles,
+            romPaged: this.romPaged,
+            memory: this.memory.slice(),
+            rom: includeRoms ? this.rom.slice() : undefined,
+            ula: this.tube.snapshotState(),
+        };
+    }
+
+    restoreState(state) {
+        this.a = state.a;
+        this.x = state.x;
+        this.y = state.y;
+        this.s = state.s;
+        this.pc = state.pc;
+        this.p.setFromByte(state.p);
+        this._nmiLevel = state.nmiLevel;
+        this._nmiEdge = state.nmiEdge;
+        this.takeInt = state.takeInt;
+        this.cycles = state.cycles;
+        this.romPaged = state.romPaged;
+        this.memory.set(state.memory);
+        if (state.rom) this.rom.set(state.rom);
+
+        // After the registers, so the edge-triggered NMI moves from its saved level to the one
+        // the ULA implies: no edge if they agree, and the edge it is owed if they do not.
+        this.tube.restoreState(state.ula);
+    }
+
     async loadOs() {
         console.log("Loading tube rom from roms/" + this.model.os);
         const tubeRom = this.rom;
@@ -620,10 +667,12 @@ export class Cpu6502 extends Base6502 {
         this.cpuMultiplier = this.config.cpuMultiplier;
         this.videoCyclesBatch = this.config.videoCyclesBatch | 0;
         this.peripheralCyclesPerSecond = 2 * 1000 * 1000;
-        this.tube = model.tube ? new Tube6502(model.tube, this) : new FakeTube();
-        if (model.tube && this.config.tubeCpuMultiplier) {
-            this.tube.cpuMultiplier = this.config.tubeCpuMultiplier;
-        }
+        this.hasTube = !!this.config.tube;
+        this.hasMusic5000 = !!this.config.hasMusic5000;
+        this.hasTeletextAdaptor = !!this.config.hasTeletextAdaptor;
+        this.tube = this.hasTube
+            ? new Tube6502(this.config.tube, this, { cpuMultiplier: this.config.tubeCpuMultiplier })
+            : new FakeTube();
         this.music5000PageSel = 0;
         this.econet = econet;
 
@@ -799,7 +848,7 @@ export class Cpu6502 extends Base6502 {
 
         switch (addr & ~0x0003) {
             case 0xfc10:
-                if (this.model.hasTeletextAdaptor) return this.teletextAdaptor.read(addr - 0xfc10);
+                if (this.hasTeletextAdaptor) return this.teletextAdaptor.read(addr - 0xfc10);
                 break;
             case 0xfc20:
             case 0xfc24:
@@ -822,7 +871,7 @@ export class Cpu6502 extends Base6502 {
                 // IDE
                 break;
             case 0xfcfc:
-                if (addr === 0xfcff && this.model.hasMusic5000) return this.music5000PageSel;
+                if (addr === 0xfcff && this.hasMusic5000) return this.music5000PageSel;
                 break;
             case 0xfe00:
             case 0xfe04:
@@ -909,7 +958,7 @@ export class Cpu6502 extends Base6502 {
                 return this.tube.read(addr);
         }
 
-        if (this.model.hasMusic5000) {
+        if (this.hasMusic5000) {
             if ((this.music5000PageSel & 0xf0) === 0x30 && (addr & 0xff00) === 0xfd00) {
                 return this.music5000.read(this.music5000PageSel, addr);
             }
@@ -966,14 +1015,14 @@ export class Cpu6502 extends Base6502 {
         addr &= 0xffff;
         b |= 0;
 
-        if (this.model.hasMusic5000 && (addr & 0xff00) === 0xfd00 && (this.music5000PageSel & 0xf0) === 0x30) {
+        if (this.hasMusic5000 && (addr & 0xff00) === 0xfd00 && (this.music5000PageSel & 0xf0) === 0x30) {
             this.music5000.write(this.music5000PageSel, addr, b);
             return;
         }
 
         switch (addr & ~0x0003) {
             case 0xfc10:
-                if (this.model.hasTeletextAdaptor) return this.teletextAdaptor.write(addr - 0xfc10, b);
+                if (this.hasTeletextAdaptor) return this.teletextAdaptor.write(addr - 0xfc10, b);
                 break;
             case 0xfc20:
             case 0xfc24:
@@ -996,7 +1045,7 @@ export class Cpu6502 extends Base6502 {
                 // IDE
                 break;
             case 0xfcfc:
-                if (addr === 0xfcff && this.model.hasMusic5000) {
+                if (addr === 0xfcff && this.hasMusic5000) {
                     this.music5000PageSel = b;
                 }
                 break;
@@ -1183,6 +1232,7 @@ export class Cpu6502 extends Base6502 {
             acia: this.acia.snapshotState(),
             adc: this.adconverter.snapshotState(),
             fdc: this.fdc.snapshotState(),
+            tube: this.hasTube ? this.tube.snapshotState({ includeRoms }) : undefined,
         };
     }
 
@@ -1243,6 +1293,13 @@ export class Cpu6502 extends Base6502 {
         if (state.fdc) {
             this.fdc.restoreState(state.fdc);
         }
+
+        // Tube state (v3+). Rather than leave the parasite running on state the host knows
+        // nothing about, reset it; restoreSnapshot() rejects such a pairing before reaching here.
+        if (this.hasTube) {
+            if (state.tube) this.tube.restoreState(state.tube);
+            else this.tube.reset(true);
+        }
     }
 
     reset(hard) {
@@ -1304,7 +1361,7 @@ export class Cpu6502 extends Base6502 {
         this.adconverter.reset();
 
         this.touchScreen = new TouchScreen(this.scheduler);
-        if (this.model.hasTeletextAdaptor) this.teletextAdaptor = new TeletextAdaptor(this);
+        if (this.hasTeletextAdaptor) this.teletextAdaptor = new TeletextAdaptor(this);
         if (this.econet) this.filestore = new Filestore(this, this.econet);
     }
 
@@ -1364,8 +1421,9 @@ export class Cpu6502 extends Base6502 {
     // Builds common code between polltimeSlow and polltimeFast
     buildPolltime() {
         const nop = (_cycles) => {};
-        const tubeStuff = (cycles) => (this.model.tube ? this.tube.execute(cycles) : nop);
-        const teletextStuff = this.teletextAdaptor ? (cycles) => this.teletextAdaptor.polltime(cycles) : nop;
+        const tubeStuff = this.hasTube ? (cycles) => this.tube.execute(cycles) : nop;
+        // The adaptor itself does not exist until reset() runs, so branch on the fitting, not the object.
+        const teletextStuff = this.hasTeletextAdaptor ? (cycles) => this.teletextAdaptor.polltime(cycles) : nop;
         const musicStuff = this.music5000 ? (cycles) => this.music5000.polltime(cycles) : nop;
         const econetStuff = this.econet
             ? (cycles) => {
@@ -1506,7 +1564,7 @@ export class Cpu6502 extends Base6502 {
         if (this.model.os.length) {
             await this.loadOs.apply(this, this.model.os);
         }
-        if (this.model.tube) {
+        if (this.hasTube) {
             await this.tube.loadOs();
         }
         this.reset(true);

package/src/app/app.js

@@ -5,6 +5,8 @@ import * as fs from "fs";
 import * as path from "path";
 import { ArgumentParser } from "argparse";
 
+import { getArguments } from "./args.js";
+
 const store = new Store();
 
 ipcMain.on("set-title", (event, title) => {
@@ -20,21 +22,6 @@ ipcMain.on("save-settings", (event, settings) => {
 
 const isMac = process.platform === "darwin";
 
-function getArguments() {
-    // Heinous hack to get "built" versions working
-    let args;
-    if (path.basename(process.argv[0]) === "jsbeeb")
-        // Is this ia "built" version?
-        args = process.argv.slice(1);
-    else args = process.argv.slice(2);
-
-    // Filter out Chrome switches that appear in process.argv. The snap wrapper
-    // adds --no-sandbox for compatibility, and `--disable-gpu` might be useful.
-    // Note that we don't support snap any more, but these seemed useful to leave.
-    const ignoredChromeFlags = ["--no-sandbox", "--disable-gpu"];
-    return args.filter((arg) => !ignoredChromeFlags.includes(arg));
-}
-
 const parser = new ArgumentParser({
     prog: "jsbeeb",
     add_help: true,

package/src/app/args.js

@@ -0,0 +1,26 @@
+"use strict";
+
+/**
+ * Returns the command-line arguments the user actually passed to jsbeeb, with
+ * the Electron binary path(s) and known runtime-injected flags stripped.
+ *
+ * @param {string[]} [argv=process.argv] Full argv array.
+ * @param {boolean} [defaultApp=process.defaultApp]
+ *   True when running under `electron .` (dev). Electron only sets
+ *   process.defaultApp in that case, so we use it instead of comparing
+ *   basename(argv[0]) === "jsbeeb" (the previous check), which failed on
+ *   Windows where the binary is jsbeeb.exe, silently dropping the first
+ *   user argument. See issue #684.
+ * @returns {string[]}
+ */
+export function getArguments(argv = process.argv, defaultApp = process.defaultApp) {
+    // In a packaged Electron app argv is [appBinary, ...userArgs]; when running
+    // under `electron .` (dev) it is [electronBinary, appPath, ...userArgs].
+    const args = defaultApp ? argv.slice(2) : argv.slice(1);
+
+    // Filter out Chrome switches that appear in argv. The snap wrapper adds
+    // --no-sandbox for compatibility, and --disable-gpu might be useful. We
+    // don't support snap any more, but these seemed useful to leave.
+    const ignoredChromeFlags = ["--no-sandbox", "--disable-gpu"];
+    return args.filter((arg) => !ignoredChromeFlags.includes(arg));
+}

package/src/bem-snapshot.js

@@ -255,7 +255,145 @@ function readString(data, pos) {
     return str;
 }
 
-function parseBemV3(buffer) {
+// b-em writes the tube ULA as a raw struct dump. Version 2 is all single-byte fields, so it has
+// no padding and can be read directly; version 1 used native ints and is not supported here.
+const BemTubeUlaVersion = 2;
+const BemTubeUlaOffsets = {
+    ph1: 0,
+    ph2: 24,
+    ph3: 25,
+    ph4: 27,
+    hp1: 29, // phl (byte 28) is a latch jsbeeb does not model
+    hp2: 30,
+    hp3: 31,
+    hp4: 33,
+    hstat: 35, // hpl (byte 34) likewise unmodelled
+    pstat: 39,
+    r1stat: 43,
+    ph1head: 45, // ph1tail (byte 44) matters only to b-em, which appends there
+    ph1count: 46,
+    ph3pos: 47,
+    hp3pos: 48,
+};
+const BemTubeUlaSize = 49;
+const BemPh1Size = 24;
+// 9 bytes of registers, then RAM, then ROM.
+const BemTubeRegisterBytes = 9;
+const BemTubeRamSize = 65536;
+// b-em's other co-processors are different CPUs, and its "6502 Turbo" has 16MB of RAM.
+const BemSupportedTubes = ["6502 Internal", "6502 External"];
+
+/**
+ * Convert b-em's tube sections into jsbeeb tube state.
+ * @param {object} sections - parsed v3 sections
+ * @param {string|null} tubeName - co-processor name from the model section
+ * @returns {Promise<object|null>} jsbeeb tube state, or null if no usable co-processor
+ */
+async function parseBemTube(sections, tubeName) {
+    // b-em names the model's co-processor even when it failed to start one, so naming a tube but
+    // carrying no state for it is valid. Carrying only one of the two sections is not.
+    if (!sections["T"] && !sections["P"]) return null;
+    if (!sections["T"] || !sections["P"]) {
+        throw new Error("Truncated b-em snapshot: it holds only one of the two co-processor sections");
+    }
+    // b-em only writes these sections for a co-processor it started, which it always names.
+    if (!tubeName) {
+        throw new Error("Corrupt b-em snapshot: it holds co-processor state but names no co-processor");
+    }
+    if (!BemSupportedTubes.includes(tubeName)) {
+        throw new Error(
+            `Unsupported b-em co-processor "${tubeName}": jsbeeb only emulates the 64K 65C02 second processor`,
+        );
+    }
+
+    const ulaSection = sections["T"].data;
+    if (ulaSection[0] !== BemTubeUlaVersion) {
+        throw new Error(`Unsupported b-em tube ULA state version ${ulaSection[0]}`);
+    }
+    if (ulaSection.length < 2 + BemTubeUlaSize) {
+        throw new Error(
+            `Truncated b-em tube ULA state: expected ${2 + BemTubeUlaSize} bytes, got ${ulaSection.length}`,
+        );
+    }
+    const romPaged = !!ulaSection[1];
+    const ula = ulaSection.slice(2, 2 + BemTubeUlaSize);
+    const at = (field) => ula[BemTubeUlaOffsets[field]];
+
+    // b-em keeps the R1 FIFO as a circular buffer; jsbeeb shifts its contents down on read, so
+    // the bytes have to be linearised into the order jsbeeb expects to read them.
+    const ph1Count = at("ph1count");
+    const ph1Head = at("ph1head");
+    // Out-of-range counts would restore a FIFO jsbeeb's own reads could never have produced.
+    if (ph1Count > BemPh1Size || ph1Head >= BemPh1Size || at("ph3pos") > 2 || at("hp3pos") > 2) {
+        throw new Error("Corrupt b-em tube ULA state: FIFO counts out of range");
+    }
+    const ph1 = new Uint8Array(BemPh1Size);
+    for (let i = 0; i < ph1Count; i++) {
+        ph1[i] = ula[BemTubeUlaOffsets.ph1 + ((ph1Head + i) % BemPh1Size)];
+    }
+
+    // Those names come from a config file, so size is the real check. It cannot be exact: the
+    // trailing ROM's size comes from that same config, and b-em records it as zero if unset.
+    const parasite = await decompress(sections["P"].data, "deflate");
+    const romBytes = parasite.length - BemTubeRegisterBytes - BemTubeRamSize;
+    if (romBytes < 0 || romBytes > BemTubeRamSize) {
+        throw new Error(
+            `Unsupported b-em co-processor: expected ${BemTubeRamSize} bytes of parasite RAM, ` +
+                `but the state section holds ${parasite.length - BemTubeRegisterBytes}`,
+        );
+    }
+
+    return {
+        a: parasite[2],
+        x: parasite[3],
+        y: parasite[4],
+        p: parasite[5] | 0x30,
+        s: parasite[6],
+        pc: parasite[7] | (parasite[8] << 8),
+        // b-em's oldnmi is the NMI level as of the parasite's last instruction, so it may lag the
+        // line its ULA state implies. b-em's skipint has no jsbeeb equivalent and is dropped.
+        nmiLevel: !!parasite[1],
+        nmiEdge: false,
+        takeInt: false,
+        cycles: 0,
+        romPaged,
+        memory: parasite.slice(BemTubeRegisterBytes, BemTubeRegisterBytes + BemTubeRamSize),
+        // The parasite ROM is loaded from file at boot, so b-em's copy is not needed.
+        ula: {
+            internalStatusRegister: at("r1stat"),
+            hostStatus: ula.slice(BemTubeUlaOffsets.hstat, BemTubeUlaOffsets.hstat + 4),
+            parasiteStatus: ula.slice(BemTubeUlaOffsets.pstat, BemTubeUlaOffsets.pstat + 4),
+            parasiteToHostData: [
+                ph1,
+                Uint8Array.of(at("ph2")),
+                ula.slice(BemTubeUlaOffsets.ph3, BemTubeUlaOffsets.ph3 + 2),
+                Uint8Array.of(at("ph4")),
+            ],
+            hostToParasiteData: [
+                Uint8Array.of(at("hp1")),
+                Uint8Array.of(at("hp2")),
+                ula.slice(BemTubeUlaOffsets.hp3, BemTubeUlaOffsets.hp3 + 2),
+                Uint8Array.of(at("hp4")),
+            ],
+            parasiteToHostFifoByteCount1: ph1Count,
+            parasiteToHostFifoByteCount3: at("ph3pos"),
+            hostToParasiteFifoByteCount3: at("hp3pos"),
+        },
+    };
+}
+
+/**
+ * Read the co-processor name from b-em's model section, if one was fitted.
+ * @returns {string|null}
+ */
+function readBemTubeName(data, pos) {
+    for (let i = 0; i < 4; i++) readString(data, pos); // os, cmos, rom setup, fdc names
+    pos.offset += 6; // model flag bytes
+    const fitted = data[pos.offset++];
+    return fitted ? readString(data, pos) : null;
+}
+
+async function parseBemV3(buffer) {
     const bytes = new Uint8Array(buffer);
     let offset = 8; // Skip "BEMSNAP3" signature
 
@@ -281,11 +419,13 @@ function parseBemV3(buffer) {
     // Parse model section to determine jsbeeb model name.
     // Use jsbeeb synonyms (from models.js) so findModel() resolves them.
     let modelName = "B";
+    let tubeName = null;
     if (sections["m"]) {
         const pos = { offset: 0 };
         const data = sections["m"].data;
         readVar(data, pos); // curmodel index (skip)
         const name = readString(data, pos);
+        tubeName = readBemTubeName(data, pos);
         if (name.includes("Master")) {
             if (name.includes("ADFS")) modelName = "MasterADFS";
             else if (name.includes("ANFS")) modelName = "MasterANFS";
@@ -311,23 +451,21 @@ function parseBemV3(buffer) {
     if (memSection) {
         // Memory is zlib-compressed; decompression is async.
         // Decompressed layout: 2 bytes (fe30, fe34) + 64KB RAM + 256KB ROM
-        return decompress(memSection.data, "deflate").then((memData) => {
-            cpuState.fe30 = memData[0];
-            cpuState.fe34 = memData[1];
-            const ramStart = 2;
-            const ramSize = 64 * 1024;
-            ram.set(memData.slice(ramStart, ramStart + ramSize));
-            const romStart = ramStart + ramSize;
-            if (memData.length > romStart) {
-                roms = memData.slice(romStart, romStart + 262144);
-            }
-            return finishV3Parse(modelName, cpuState, ram, roms, sections);
-        });
+        const memData = await decompress(memSection.data, "deflate");
+        cpuState.fe30 = memData[0];
+        cpuState.fe34 = memData[1];
+        const ramStart = 2;
+        const ramSize = 64 * 1024;
+        ram.set(memData.slice(ramStart, ramStart + ramSize));
+        const romStart = ramStart + ramSize;
+        if (memData.length > romStart) {
+            roms = memData.slice(romStart, romStart + 262144);
+        }
     }
-    return finishV3Parse(modelName, cpuState, ram, roms, sections);
+    return finishV3Parse(modelName, cpuState, ram, roms, sections, await parseBemTube(sections, tubeName));
 }
 
-function finishV3Parse(modelName, cpuState, ram, roms, sections) {
+function finishV3Parse(modelName, cpuState, ram, roms, sections, tube) {
     // Parse system VIA
     let sysvia = convertViaState(
         {
@@ -466,5 +604,6 @@ function finishV3Parse(modelName, cpuState, ram, roms, sections) {
         uservia,
         buildVideoState(ulaControl, ulaPalette, crtcRegs, nulaCollook, crtcCounters),
         soundChip,
+        tube,
     );
 }