jsbeeb 1.22.0 → 1.22.2

package/src/web/hfe-picker.js

@@ -0,0 +1,156 @@
+import * as utils from "../utils.js";
+import * as bootstrap from "bootstrap";
+import { BbcDiscArchive, Provenance, describe as describeHfe, matches, provenancesIn } from "../bbcdiscs.js";
+import { errorText } from "./reporting.js";
+import { clearArchiveList, showArchiveMessage } from "./archive-list.js";
+
+const HfeProvenanceLabels = {
+    [Provenance.Captured]: ["Captured", "Direct from disc"],
+    [Provenance.Reconstructed]: ["Reconstructed", "Rebuilt from a sector dump"],
+};
+
+const showHfeRow = (row, file, filter, shown) => (row.style.display = matches(file, filter, shown) ? "" : "none");
+
+/**
+ * The HFE archive picker: the catalogue with its filter and provenance
+ * choices, rendered a batch at a time under a ticket so a list that has been
+ * emptied is not appended to by a stale chain.
+ */
+export class HfePicker {
+    constructor({ media, drives, modals, urlState, processor, autoboot }) {
+        this.media = media;
+        this.drives = drives;
+        this.modals = modals;
+        this.urlState = urlState;
+        this.processor = processor;
+        this.autoboot = autoboot;
+
+        // Rendering is spread over several turns of the event loop, so a list that has
+        // been emptied may still have a chain of appends heading for it. Anything that
+        // clears the list takes a new ticket; a chain whose ticket is stale gives up.
+        this.renderTicket = 0;
+
+        this.archive = new BbcDiscArchive(
+            () => {
+                this.renderTicket++;
+                showArchiveMessage("hfe", "hfe-list", "Loading catalogue from HFE archive");
+            },
+            (catalogue) => this.renderCatalogue(catalogue),
+            () => {
+                this.renderTicket++;
+                showArchiveMessage("hfe", "hfe-list", "There was an error accessing the HFE archive");
+            },
+        );
+
+        this.modal = new bootstrap.Modal(document.getElementById("hfe"));
+        document.getElementById("hfe").addEventListener("shown.bs.modal", () => {
+            document.getElementById("hfe-filter").focus();
+        });
+        document.getElementById("hfe").addEventListener("show.bs.modal", () => this.archive.populate());
+
+        this.filter = document.getElementById("hfe-filter");
+        this.provenance = document.getElementById("hfe-provenance");
+        const onFilter = () => this.applyFilter();
+        this.filter.addEventListener("change", onFilter);
+        this.filter.addEventListener("keyup", onFilter);
+    }
+
+    async pick(file) {
+        utils.noteEvent("hfe", "click", file.path);
+        this.media.setDisc1Image("hfe:" + file.path);
+        const needsAutoboot = this.urlState.params.autoboot !== undefined;
+        if (needsAutoboot) this.processor.reset(true);
+
+        const name = describeHfe(file).title;
+        this.modals.popupLoading("Loading " + name);
+        try {
+            const loaded = await this.media.loadDiscImage(this.urlState.params.disc1, this.drives.layoutForDrive(0));
+            this.drives.putDiscIn(0, loaded);
+            this.modals.loadingFinished();
+            if (needsAutoboot) this.autoboot(name);
+        } catch (err) {
+            console.error("Error loading disc image:", err);
+            this.modals.loadingFinished(`Unable to load ${name} from the HFE archive: ${errorText(err)}`);
+        }
+    }
+
+    renderCatalogue(catalogue) {
+        const ticket = ++this.renderTicket;
+        clearArchiveList("hfe-list");
+        const list = document.getElementById("hfe-list");
+        document.querySelector("#hfe .loading").style.display = "none";
+        const template = list.querySelector(".template");
+        this.showProvenanceChoices(catalogue);
+
+        const addSome = (remaining) => {
+            if (ticket !== this.renderTicket) return;
+            const MaxAtATime = 100;
+            const Delay = 30;
+            // Read per batch: both can be changed while this is still going.
+            const filter = this.filter.value.toLowerCase();
+            const shown = this.shownProvenances();
+            for (const file of remaining.slice(0, MaxAtATime)) {
+                const { title, publisher, detail } = describeHfe(file);
+                const row = template.cloneNode(true);
+                row.classList.remove("template");
+                row.querySelector(".name").textContent = title;
+                row.querySelector(".publisher").textContent = publisher;
+                row.querySelector(".detail").textContent = detail;
+                row.querySelector(".provenance").textContent =
+                    file.provenance === Provenance.Reconstructed ? "reconstructed" : "";
+                if (file.notes) row.title = file.notes;
+                // The row is an anchor, and letting it navigate to "#" would push a
+                // history entry of its own on top of the one updateUrl pushes.
+                row.addEventListener("click", (event) => {
+                    event.preventDefault();
+                    this.pick(file);
+                    this.modal.hide();
+                });
+                row.hfeFile = file;
+                list.appendChild(row);
+                showHfeRow(row, file, filter, shown);
+            }
+            if (remaining.length > MaxAtATime) setTimeout(() => addSome(remaining.slice(MaxAtATime)), Delay);
+        };
+        addSome(catalogue);
+    }
+
+    /** Which provenances the picker is showing, or null when it is not offering the choice. */
+    shownProvenances() {
+        const boxes = [...this.provenance.querySelectorAll("input")];
+        return boxes.length ? new Set(boxes.filter((box) => box.checked).map((box) => box.value)) : null;
+    }
+
+    // Offer one tick per provenance the archive actually holds, rather than naming
+    // them here: a source added later should appear without this having to change.
+    showProvenanceChoices(catalogue) {
+        const present = provenancesIn(catalogue);
+        // Nothing to choose between: no ticks, and shownProvenances says "all".
+        if (present.length < 2) {
+            this.provenance.replaceChildren();
+            return;
+        }
+        const wasShown = this.shownProvenances();
+        this.provenance.replaceChildren(
+            ...present.map((provenance) => {
+                const [text, why] = HfeProvenanceLabels[provenance] ?? [provenance, ""];
+                const label = document.createElement("label");
+                label.title = why;
+                const box = document.createElement("input");
+                box.type = "checkbox";
+                box.value = provenance;
+                box.checked = !wasShown || wasShown.has(provenance);
+                box.addEventListener("change", () => this.applyFilter());
+                label.append(box, text);
+                return label;
+            }),
+        );
+    }
+
+    applyFilter() {
+        const filter = this.filter.value.toLowerCase();
+        const shown = this.shownProvenances();
+        for (const row of document.querySelectorAll("#hfe-list li:not(.template)"))
+            showHfeRow(row, row.hfeFile, filter, shown);
+    }
+}

package/src/web/keyboard-setup.js

@@ -0,0 +1,125 @@
+import * as utils from "../utils.js";
+import { Keyboard } from "../keyboard.js";
+import { showNotice } from "./reporting.js";
+
+/**
+ * The page's keyboard: the emulated one, the browser shortcuts around it, and
+ * the accessibility switches on the user port. Built in two steps because the
+ * user port has to exist before the processor does, and the keyboard after.
+ */
+export class KeyboardSetup {
+    /**
+     * @param {object} actions what each shortcut does, supplied late-bound:
+     *   enterDebugger, reload, toggleFast, openRewind, openPrinter,
+     *   pause, resume, onAnyKeyDown
+     */
+    constructor(actions) {
+        this.actions = actions;
+        this.keyboard = null;
+
+        // Accessibility switch state: bits 0-7 correspond to switches 1-8.
+        // Active low: 0xff = no switches pressed; clearing a bit = that switch is pressed.
+        this.switchState = 0xff;
+        const setup = this;
+        this.userPort = {
+            write() {},
+            read() {
+                return setup.switchState;
+            },
+        };
+    }
+
+    /** Initialise keyboard now that processor exists */
+    attach({ processor, dbgr, keyLayout }) {
+        const { actions } = this;
+        const keyboard = (this.keyboard = new Keyboard({
+            processor,
+            inputEnabledFunction: () => document.activeElement && document.activeElement.id === "paste-text",
+            keyLayout,
+            dbgr,
+        }));
+        keyboard.addEventListener("notice", showNotice);
+        keyboard.addEventListener("pause", () => actions.pause());
+        keyboard.addEventListener("resume", () => actions.resume());
+        keyboard.addEventListener("break", (e) => {
+            // F12/Break: Reset processor
+            if (e.detail) utils.noteEvent("keyboard", "press", "break");
+        });
+
+        const onDown = (note, action) => (down) => {
+            if (down) {
+                if (note) utils.noteEvent("keyboard", "press", note);
+                action();
+            }
+        };
+        const alt = { alt: true, ctrl: false };
+        const ctrl = { alt: false, ctrl: true };
+        keyboard.registerKeyHandler(utils.keyCodes.S, onDown("S", actions.enterDebugger), alt);
+        keyboard.registerKeyHandler(utils.keyCodes.R, onDown(null, actions.reload), alt);
+        keyboard.registerKeyHandler(utils.keyCodes.HOME, onDown("home", actions.enterDebugger), ctrl);
+        keyboard.registerKeyHandler(utils.keyCodes.INSERT, onDown("insert", actions.toggleFast), ctrl);
+        keyboard.registerKeyHandler(
+            utils.keyCodes.END,
+            onDown("end", () => keyboard.pauseEmulation()),
+            ctrl,
+        );
+        keyboard.registerKeyHandler(utils.keyCodes.PAGEDOWN, onDown("pagedown", actions.openRewind), alt);
+        keyboard.registerKeyHandler(utils.keyCodes.B, onDown(null, actions.openPrinter), ctrl);
+
+        // Register accessibility switch key handlers.
+        // Keys 1-8 (K1-K8) and function keys F1-F8 both map to user port bits 0-7
+        // (active low: pressing the key clears the corresponding bit in &FE60).
+        //
+        // On real hardware, the Brilliant Computing switch interface box and special-ed
+        // joystick connect to the User Port only; they do not touch the analogue port
+        // or the System VIA fire buttons (PB4/PB5), which belong to the standard
+        // analogue joystick connector.  So we only update switchState here.
+        const handleSwitch = (bit) => (down) => {
+            if (down) this.switchState &= ~(1 << bit);
+            else this.switchState |= 1 << bit;
+        };
+
+        // Alt+1-8 and Alt+F1-F8 trigger the switches.  Using Alt means the underlying
+        // key is never forwarded to the BBC Micro (keyboard.js bails out early when a
+        // handler fires), so typing numbers or using function keys works normally.
+        for (let i = 0; i < 8; i++) {
+            keyboard.registerKeyHandler(utils.keyCodes.K1 + i, handleSwitch(i), alt);
+            keyboard.registerKeyHandler(utils.keyCodes.F1 + i, handleSwitch(i), alt);
+        }
+
+        document.addEventListener("keydown", (evt) => {
+            actions.onAnyKeyDown();
+            keyboard.keyDown(evt);
+        });
+        document.addEventListener("keypress", (evt) => keyboard.keyPress(evt));
+        document.addEventListener("keyup", (evt) => keyboard.keyUp(evt));
+    }
+
+    sendRawKeyboard(keysToSend, checkCapsAndShiftLocks) {
+        if (this.keyboard) {
+            this.keyboard.sendRawKeyboard(keysToSend, checkCapsAndShiftLocks);
+        } else {
+            console.warn("Tried to send keys before keyboard was initialised");
+        }
+    }
+
+    clearKeys() {
+        this.keyboard.clearKeys();
+    }
+
+    setKeyLayout(keyLayout) {
+        this.keyboard.setKeyLayout(keyLayout);
+    }
+
+    resumeEmulation() {
+        this.keyboard.resumeEmulation();
+    }
+
+    setRunning(running) {
+        this.keyboard.setRunning(running);
+    }
+
+    postFrameShouldPause() {
+        return this.keyboard.postFrameShouldPause();
+    }
+}

package/src/web/layout.js

@@ -0,0 +1,156 @@
+import { toast } from "./toast.js";
+import { errorText } from "./reporting.js";
+
+/** Steps the drawing buffer grows in, as a multiple of the base canvas size. */
+const CanvasScaleStep = 0.25;
+
+/**
+ * Where everything goes for a given window: the monitor picture, the canvas
+ * within it, and (for a mode with maxCanvasScale) how large a drawing buffer
+ * to ask for. Pure, so the geometry is testable on its own.
+ */
+export function fitMonitor(displayConfig, viewport, canvasNative) {
+    const imageOrigHeight = displayConfig.imageHeight;
+    const imageOrigWidth = displayConfig.imageWidth;
+    const desiredAspectRatio = imageOrigWidth / imageOrigHeight;
+    const minWidth = imageOrigWidth / 4;
+    const minHeight = imageOrigHeight / 4;
+
+    let width = Math.max(minWidth, viewport.innerWidth - viewport.borderReservedSize * 2);
+    let height = Math.max(minHeight, viewport.innerHeight - viewport.navbarHeight - viewport.bottomReservedSize);
+    if (width / height <= desiredAspectRatio) {
+        height = width / desiredAspectRatio;
+    } else {
+        width = height * desiredAspectRatio;
+    }
+
+    const containerScale = width / imageOrigWidth;
+    const scaledVisibleWidth = displayConfig.visibleWidth * containerScale;
+    const scaledVisibleHeight = displayConfig.visibleHeight * containerScale;
+
+    const canvasAspect = canvasNative.width / canvasNative.height;
+    const visibleAspect = scaledVisibleWidth / scaledVisibleHeight;
+
+    let finalCanvasWidth, finalCanvasHeight;
+    if (canvasAspect > visibleAspect) {
+        finalCanvasWidth = scaledVisibleWidth;
+        finalCanvasHeight = scaledVisibleWidth / canvasAspect;
+    } else {
+        finalCanvasHeight = scaledVisibleHeight;
+        finalCanvasWidth = scaledVisibleHeight * canvasAspect;
+    }
+
+    // A mode that reconstructs detail wants to draw at the size it will be
+    // seen at, up to the limit it asks for. Drawing more than the display
+    // can show costs fragments and buys nothing, and for an expensive
+    // shader that is the difference between comfortable and not.
+    let backing = null;
+    if (displayConfig.maxCanvasScale) {
+        const wanted = (finalCanvasWidth * viewport.devicePixelRatio) / displayConfig.canvasWidth;
+        // Quantised, because resize fires continuously while a window is
+        // dragged and every distinct value reallocates the drawing buffer.
+        const quantised = Math.round(wanted / CanvasScaleStep) * CanvasScaleStep;
+        const scale = Math.min(displayConfig.maxCanvasScale, Math.max(1, quantised));
+        backing = {
+            width: Math.round(displayConfig.canvasWidth * scale),
+            height: Math.round(displayConfig.canvasHeight * scale),
+        };
+    }
+
+    return {
+        monitor: { width, height },
+        canvas: {
+            width: finalCanvasWidth,
+            height: finalCanvasHeight,
+            left: displayConfig.canvasLeft * containerScale,
+            top: displayConfig.canvasTop * containerScale,
+        },
+        backing,
+    };
+}
+
+/** Keeps the monitor and canvas fitted to the window, and wires the page furniture around them. */
+export class Layout {
+    constructor({ screenCanvas, display, embed, sidebars = {} }) {
+        this.screenCanvas = screenCanvas;
+        this.display = display;
+        this.cubMonitor = document.getElementById("cub-monitor");
+        this.cubMonitorPic = document.getElementById("cub-monitor-pic");
+        this.borderReservedSize = embed ? 0 : 100;
+        this.bottomReservedSize = embed ? 0 : 68;
+
+        window.addEventListener("resize", () => this.resize());
+        window.setTimeout(() => this.resize(), 1);
+        window.setTimeout(() => this.resize(), 500);
+
+        this.bindSidebar(".sidebar.left", sidebars.left, (div, img) => {
+            div.style.left = -img.naturalWidth - 5 + "px";
+        });
+        this.bindSidebar(".sidebar.right", sidebars.right, (div, img) => {
+            div.style.right = -img.naturalWidth - 5 + "px";
+        });
+        this.bindSidebar(".sidebar.bottom", sidebars.bottom, (div, img) => {
+            div.style.bottom = -img.naturalHeight + "px";
+        });
+
+        const fullscreenItem = document.getElementById("fs");
+        if (document.fullscreenEnabled) {
+            fullscreenItem.addEventListener("click", async (event) => {
+                event.preventDefault();
+                try {
+                    await screenCanvas.requestFullscreen();
+                } catch (error) {
+                    toast(`Could not go fullscreen: ${errorText(error)}`, { title: "Fullscreen" });
+                }
+            });
+        } else {
+            fullscreenItem.closest("li").hidden = true;
+        }
+    }
+
+    resize() {
+        // The display config can change when the display mode switches.
+        const displayConfig = this.display.filterClass.getDisplayConfig();
+        const fitted = fitMonitor(
+            displayConfig,
+            {
+                innerWidth: window.innerWidth,
+                innerHeight: window.innerHeight,
+                navbarHeight: document.getElementById("header-bar")?.offsetHeight || 0,
+                borderReservedSize: this.borderReservedSize,
+                bottomReservedSize: this.bottomReservedSize,
+                devicePixelRatio: window.devicePixelRatio || 1,
+            },
+            { width: this.screenCanvas.getAttribute("width"), height: this.screenCanvas.getAttribute("height") },
+        );
+
+        this.cubMonitor.style.height = fitted.monitor.height + "px";
+        this.cubMonitor.style.width = fitted.monitor.width + "px";
+        this.cubMonitorPic.style.height = fitted.monitor.height + "px";
+        this.cubMonitorPic.style.width = fitted.monitor.width + "px";
+
+        if (fitted.backing && this.screenCanvas.width !== fitted.backing.width) {
+            this.screenCanvas.width = fitted.backing.width;
+            this.screenCanvas.height = fitted.backing.height;
+            // Resizing threw the drawing buffer away.
+            this.display.video.paint();
+        }
+
+        this.screenCanvas.style.width = fitted.canvas.width + "px";
+        this.screenCanvas.style.height = fitted.canvas.height + "px";
+        this.screenCanvas.style.left = fitted.canvas.left + "px";
+        this.screenCanvas.style.top = fitted.canvas.top + "px";
+    }
+
+    bindSidebar(selector, url, onload) {
+        const div = document.querySelector(selector);
+        const img = div.querySelector("img");
+        img.style.display = "none";
+        if (!url) return;
+        img.addEventListener("load", () => {
+            onload(div, img);
+            img.style.display = "";
+        });
+        img.src = url;
+    }
+}

package/src/web/machine.js

@@ -0,0 +1,204 @@
+import { AtomCpu6502, Cpu6502 } from "../6502.js";
+import { Cmos, localStoragePersistence } from "../cmos.js";
+import { Econet } from "../econet.js";
+import { LoadSD } from "../mmc.js";
+import { tubeModelFor } from "../models.js";
+import * as utils from "../utils.js";
+import { toast } from "./toast.js";
+import { errorText, reportLoadFailure, showNotice } from "./reporting.js";
+
+/**
+ * The machine's fittings as the CPU wants them handed over. Pure, so the bank
+ * and flag decisions are testable on their own.
+ */
+export function buildEmulationConfig({ config, parsedQuery, keyLayout, cpuMultiplier, extraRoms, userPort, printer }) {
+    return {
+        keyLayout,
+        cpuMultiplier,
+        tubeCpuMultiplier: config.tubeCpuMultiplier,
+        videoCyclesBatch: parsedQuery.videoCyclesBatch,
+        tube: config.coProcessor ? tubeModelFor(config.model) : null,
+        hasMusic5000: config.hasMusic5000,
+        hasTeletextAdaptor: config.hasTeletextAdaptor,
+        // ROM order determines sideways bank allocation, and the fittings' ROMs claim banks
+        // before any the user asked for with ?rom=.
+        extraRoms: [...config.extraRoms, ...extraRoms],
+        userPort,
+        printerPort: printer,
+        getGamepads: function () {
+            // Gamepads are only available in secure contexts. If e.g. loading from http:// urls they aren't there.
+            return navigator.getGamepads ? navigator.getGamepads() : [];
+        },
+        debugFlags: {
+            logFdcCommands: parsedQuery.logFdcCommands !== undefined,
+            logFdcStateChanges: parsedQuery.logFdcStateChanges !== undefined,
+        },
+    };
+}
+
+/** The emulated machine itself: the processor with everything bolted to it, and its start-up. */
+export class Machine {
+    constructor({
+        model,
+        config,
+        parsedQuery,
+        keyLayout,
+        cpuMultiplier,
+        extraRoms,
+        stationId,
+        userPort,
+        printer,
+        speechOutput,
+        video,
+        audioHandler,
+        dbgr,
+        makeCpu = (CpuClass, ...args) => new CpuClass(...args),
+    }) {
+        this.model = model;
+        this.audioHandler = audioHandler;
+        this.speechOutput = speechOutput;
+
+        this.econet = null;
+        if (config.hasEconet) {
+            this.econet = new Econet(stationId, model.cyclesPerSecond);
+        } else {
+            document.getElementById("fsmenuitem").style.display = "none";
+        }
+
+        this.cmos = new Cmos(
+            localStoragePersistence(
+                () => window.localStorage,
+                (error) =>
+                    toast(
+                        `Settings changed with *CONFIGURE will not be kept (${errorText(error)}). Check that this site is allowed to store data, and that its storage is not full.`,
+                        { title: "Settings", quietKey: "quietCmosSave" },
+                    ),
+            ),
+            model.cmosOverride,
+            this.econet,
+        );
+
+        this.emulationConfig = buildEmulationConfig({
+            config,
+            parsedQuery,
+            keyLayout,
+            cpuMultiplier,
+            extraRoms,
+            userPort,
+            printer,
+        });
+
+        const CpuClass = model.isAtom ? AtomCpu6502 : Cpu6502;
+        this.processor = makeCpu(CpuClass, model, {
+            dbgr,
+            video,
+            soundChip: audioHandler.soundChip,
+            ddNoise: audioHandler.ddNoise,
+            relayNoise: audioHandler.relayNoise,
+            music5000: config.hasMusic5000 ? audioHandler.music5000 : null,
+            cmos: this.cmos,
+            config: this.emulationConfig,
+            econet: this.econet,
+        });
+
+        printer.attach(this.processor.uservia);
+        this.processor.teletextAdaptor?.addEventListener("notice", showNotice);
+        this.processor.acia.addEventListener("notice", showNotice);
+    }
+
+    /**
+     * Attach an RS-423 composite handler to the ACIA that combines the touchscreen
+     * (which sends position data to the BBC) with the speech output (which speaks
+     * text the BBC sends out).
+     */
+    setupRs423Handler() {
+        const { processor, speechOutput } = this;
+        processor.acia.setRs423Handler({
+            onTransmit(val) {
+                processor.touchScreen.onTransmit(val);
+                speechOutput.onTransmit(val);
+            },
+            tryReceive(rts) {
+                return processor.touchScreen.tryReceive(rts);
+            },
+        });
+    }
+
+    /**
+     * Initialises the machine and starts every image the URL asked for, each
+     * reporting its own failure without stopping the boot (#808).
+     */
+    async start({
+        media,
+        drives,
+        autoBoot,
+        discImage,
+        secondDiscImage,
+        tape,
+        mmcImage,
+        loadBasic,
+        embedBasic,
+        basicNeedsRun,
+    }) {
+        const { processor } = this;
+        await Promise.all([this.audioHandler.initialise(), processor.initialise()]);
+
+        // Wire up the composite RS-423 handler now that the touchscreen exists.
+        this.setupRs423Handler();
+
+        // Ideally would start the loads first. But their completion needs the FDC from the processor
+        const imageLoads = [];
+
+        function startImageLoad(description, load) {
+            const loading = (async () => {
+                try {
+                    await load();
+                } catch (error) {
+                    reportLoadFailure(description, error);
+                }
+            })();
+            imageLoads.push(loading);
+            return loading;
+        }
+
+        if (discImage) {
+            startImageLoad(`disc ${discImage}`, async () =>
+                drives.putDiscIn(0, await media.loadDiscImage(discImage, drives.layoutForDrive(0))),
+            );
+        }
+
+        if (secondDiscImage) {
+            startImageLoad(`disc ${secondDiscImage}`, async () =>
+                drives.putDiscIn(1, await media.loadDiscImage(secondDiscImage, drives.layoutForDrive(1))),
+            );
+        }
+
+        if (tape) {
+            startImageLoad(`tape ${tape}`, async () => media.setProcessorTape(await media.loadTapeImage(tape)));
+        }
+
+        if (mmcImage && this.model.isAtom) {
+            startImageLoad(`MMC image ${mmcImage}`, async () => processor.atommc.SetMMCData(await LoadSD(mmcImage)));
+        }
+
+        if (loadBasic) {
+            await startImageLoad(`BASIC program ${loadBasic}`, () =>
+                autoBoot.insertBasic(
+                    (async () => {
+                        const data = await utils.loadData(loadBasic);
+                        return String.fromCharCode.apply(null, data);
+                    })(),
+                    basicNeedsRun,
+                ),
+            );
+        }
+
+        if (embedBasic) {
+            await startImageLoad("the BASIC program from the URL", () =>
+                autoBoot.insertBasic(Promise.resolve(embedBasic), true),
+            );
+        }
+
+        return Promise.all(imageLoads);
+    }
+}