jsbeeb 1.16.0 → 1.17.1

package/src/models.js

@@ -263,6 +263,8 @@ export function findModel(name) {
     return null;
 }
 
+export const DefaultModel = findModel("B-DFS1.2");
+
 export const TEST_6502 = new Model({
     name: "TEST",
     synonyms: ["TEST"],

package/src/printer.js

@@ -0,0 +1,59 @@
+"use strict";
+
+/**
+ * Centronics printer attached to the user VIA: acknowledges each character and keeps the most
+ * recent output so it can be shown whenever a printer window is opened.
+ */
+
+export const MaxBufferedChars = 64 * 1024;
+
+export class Printer {
+    /**
+     * @param {object} [handlers]
+     * @param {function(string): void} [handlers.onOutput] called with each character as it is printed
+     * @param {function(): void} [handlers.onFirstOutput] called once, when the machine first prints
+     */
+    constructor({ onOutput = () => {}, onFirstOutput = () => {} } = {}) {
+        this._onOutput = onOutput;
+        this._onFirstOutput = onFirstOutput;
+        this._uservia = null;
+        this._olderText = "";
+        this._newerText = "";
+        this._hasPrinted = false;
+    }
+
+    outputStrobe(level, output) {
+        if (!output || level) return;
+
+        const uservia = this._uservia;
+        // Ack the character by pulsing CA1 low.
+        uservia.setca1(false);
+        uservia.setca1(true);
+        this._append(String.fromCharCode(uservia.ora));
+    }
+
+    attach(uservia) {
+        this._uservia = uservia;
+        // The ack line idles high, so that each ack is a falling edge.
+        uservia.setca1(true);
+    }
+
+    /** The most recent output, at most MaxBufferedChars of it. */
+    get text() {
+        return (this._olderText + this._newerText).slice(-MaxBufferedChars);
+    }
+
+    _append(char) {
+        // Two chunks so the bound costs a trim when the text is read, not one per character.
+        this._newerText += char;
+        if (this._newerText.length >= MaxBufferedChars) {
+            this._olderText = this._newerText;
+            this._newerText = "";
+        }
+        if (!this._hasPrinted) {
+            this._hasPrinted = true;
+            this._onFirstOutput();
+        }
+        this._onOutput(char);
+    }
+}

package/src/sth.js

@@ -50,12 +50,12 @@ export class StairwayToHell {
     }
 
     async fetch(file) {
-        const name = this._baseUrl + encodePath(file);
-        console.log("Loading ZIP from " + name);
-        const response = await fetch(name);
-        if (!response.ok) throw new Error("Network response was not ok");
+        const url = this._baseUrl + encodePath(file);
+        console.log("Loading ZIP from " + url);
+        const response = await fetch(url);
+        if (!response.ok) throw new Error(`Unable to load ${url}, http code ${response.status}`);
         try {
-            return (await utils.unzipDiscImage(new Uint8Array(await response.arrayBuffer()))).data;
+            return await utils.unzipDiscImage(new Uint8Array(await response.arrayBuffer()));
         } catch (error) {
             console.error("Failed to fetch file:", error);
             throw error;

package/src/teletext_adaptor.js

@@ -35,8 +35,8 @@ Status register:
 */
 
 /**
- * Emulates the Acorn teletext adaptor. Dispatches a `showError` CustomEvent, carrying
- * `context` and `error` in its detail, when a channel's stream cannot be loaded.
+ * Emulates the Acorn teletext adaptor. Dispatches a `notice` CustomEvent, carrying a
+ * `message` in its detail, when a channel's stream cannot be loaded.
  */
 export class TeletextAdaptor extends EventTarget {
     constructor(cpu) {
@@ -79,8 +79,10 @@ export class TeletextAdaptor extends EventTarget {
             if (request !== this.streamRequest) return;
             console.error(`Teletext adaptor: failed to load channel ${channel}`, error);
             this.dispatchEvent(
-                new CustomEvent("showError", {
-                    detail: { context: `loading teletext channel ${channel}`, error },
+                new CustomEvent("notice", {
+                    detail: {
+                        message: `Teletext channel ${channel} could not be loaded (${error?.message ?? error}). The adaptor carries on with nothing to show.`,
+                    },
                 }),
             );
             return;

package/src/url-params.js

@@ -236,6 +236,34 @@ export function processAutobootParams(parsedQuery) {
     return { needsAutoboot, autoType };
 }
 
+/** Where a drive's 40/80 switch is set, `auto` leaving it to whatever disc is loaded. */
+export const DriveTracks = Object.freeze({ auto: "auto", forty: "40", eighty: "80" });
+
+const NumDrives = 2;
+
+/**
+ * Process the per-drive 40/80 track settings
+ * @param {Object} parsedQuery - The parsed query parameters
+ * @returns {{settings: string[], warnings: string[]}} One DriveTracks per drive, and what was
+ *   unusable about anything asked for that is not in there
+ */
+export function processDriveTrackParams(parsedQuery) {
+    const warnings = [];
+    const settings = [];
+    for (let driveIndex = 0; driveIndex < NumDrives; ++driveIndex) {
+        const name = `drive${driveIndex}Tracks`;
+        const asked = parsedQuery[name];
+        const setting = isDefined(asked) ? `${asked}`.toLowerCase() : DriveTracks.auto;
+        if (Object.values(DriveTracks).includes(setting)) {
+            settings.push(setting);
+        } else {
+            warnings.push(`${name}=${asked}: a drive is set to 40, 80 or auto.`);
+            settings.push(DriveTracks.auto);
+        }
+    }
+    return { settings, warnings };
+}
+
 /**
  * Guess the appropriate model based on the hostname
  * @param {string} hostname - The hostname to check

package/src/utils.js

@@ -1,7 +1,8 @@
 "use strict";
-// Minimal ZIP extractor using native DecompressionStream for deflate.
-// Supports methods 0 (stored) and 8 (deflate); other methods (bzip2,
-// lzma, etc.) will throw an error with the method number.
+// Minimal ZIP extractor. Supports methods 0 (stored) and 8 (deflate); other
+// methods (bzip2, lzma, etc.) will throw an error with the method number.
+
+import { inflate as pakoInflate, inflateRaw as pakoInflateRaw, ungzip as pakoUngzip } from "pako";
 
 const ZipLocalHeaderSig = 0x04034b50;
 const ZipCentralDirSig = 0x02014b50;
@@ -35,45 +36,17 @@ function findEocd(buf) {
     throw new Error("Not a ZIP file: EOCD not found");
 }
 
-// Pipe data through a DecompressionStream and return the result.
-// Starts the read loop before writing to avoid backpressure deadlock.
-// On error, Node's DecompressionStream rejects multiple internal promises
-// (write, close, and closed); we catch the write side to prevent unhandled
-// rejections and let the error surface through the read side.
-export async function decompress(data, format) {
-    const ds = new DecompressionStream(format);
-    const writer = ds.writable.getWriter();
-    const reader = ds.readable.getReader();
-    const chunks = [];
-    const readPromise = (async () => {
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            chunks.push(value);
-        }
-    })();
-    const writePromise = (async () => {
-        await writer.write(data);
-        await writer.close();
-    })().catch(() => {
-        // Intentionally empty.
-    });
-    // Intentionally empty: Node's DecompressionStream rejects multiple
-    // promises on error (write, close, closed). The read side surfaces
-    // the same error with proper context — catching these just prevents
-    // unhandled rejections from the write-side promises.
-    writer.closed.catch(() => {});
-    await readPromise;
-    await writePromise;
-    if (chunks.length === 1) return chunks[0];
-    const totalLen = chunks.reduce((s, c) => s + c.length, 0);
-    const out = new Uint8Array(totalLen);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
+function inflateWith(inflater, data, context) {
+    if (!(data instanceof Uint8Array)) data = new Uint8Array(data);
+    try {
+        return inflater(data);
+    } catch (cause) {
+        throw new Error(`${context}: ${cause.message || cause}`, { cause });
     }
-    return out;
+}
+
+export function inflate(data) {
+    return inflateWith(pakoInflate, data, "Unable to inflate");
 }
 
 // Extract all files from a ZIP archive.  Returns {filename: Uint8Array}.
@@ -92,6 +65,7 @@ export async function unzip(buf) {
         const flags = readU16(buf, pos + 8);
         if (flags & 0x0001) throw new Error("Encrypted ZIP entries are not supported");
         const method = readU16(buf, pos + 10);
+        const expectedCrc = readU32(buf, pos + 16);
         const compressedSize = readU32(buf, pos + 20);
         const nameLen = readU16(buf, pos + 28);
         const extraLen = readU16(buf, pos + 30);
@@ -112,25 +86,25 @@ export async function unzip(buf) {
         if (method === ZipMethodStored) {
             files[name] = raw.slice();
         } else if (method === ZipMethodDeflate) {
-            files[name] = await decompress(raw, "deflate-raw");
+            files[name] = inflateWith(pakoInflateRaw, raw, `Unable to inflate ZIP entry ${name}`);
         } else {
             throw new Error(`Unsupported ZIP compression method ${method} for ${name}`);
         }
+        if (crc32(files[name]) >>> 0 !== expectedCrc) throw new Error(`Corrupt ZIP entry ${name}: CRC32 mismatch`);
     }
     return files;
 }
 
 // Standard CRC-32/ISO-HDLC.
+const Crc32Table = new Uint32Array(256).map((_, index) => {
+    let crc = index;
+    for (let bit = 0; bit < 8; ++bit) crc = crc & 1 ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1;
+    return crc;
+});
+
 export function crc32(data) {
     let crc = 0xffffffff;
-    for (let i = 0; i < data.length; ++i) {
-        crc ^= data[i];
-        for (let j = 0; j < 8; ++j) {
-            const doEor = crc & 1;
-            crc = crc >>> 1;
-            if (doEor) crc ^= 0xedb88320;
-        }
-    }
+    for (let i = 0; i < data.length; ++i) crc = (crc >>> 8) ^ Crc32Table[(crc ^ data[i]) & 0xff];
     return ~crc;
 }
 
@@ -1112,11 +1086,7 @@ export function readFloat32(data, offset) {
 }
 
 export async function ungzip(data) {
-    try {
-        return await decompress(data, "gzip");
-    } catch (cause) {
-        throw new Error("Unable to ungzip: " + (cause.message || cause), { cause });
-    }
+    return inflateWith(pakoUngzip, data, "Unable to ungzip");
 }
 
 export class DataStream {
@@ -1216,7 +1186,10 @@ const knownDiscExtensions = {
     uef: true,
     ssd: true,
     dsd: true,
+    adf: true,
+    adm: true,
     adl: true,
+    hfe: true,
 };
 
 const knownRomExtensions = {

package/src/via.js

@@ -154,6 +154,11 @@ class Via {
                 }
                 this.updateIFR();
 
+                // The strobe is "data ready": the port settles before CA2 falls.
+                // http://archive.6502.org/datasheets/wdc_w65c22s_mar_2004.pdf figures 3-6 and 3-7.
+                this.ora = val;
+                this.recalculatePortAPins();
+
                 mode = this.pcr & 0x0e;
                 if (mode === 8) {
                     // Handshake mode
@@ -163,7 +168,8 @@ class Via {
                     this.setca2(false);
                     this.setca2(true);
                 }
-            /* falls through */
+                break;
+
             case ORAnh:
                 this.ora = val;
                 this.recalculatePortAPins();

package/src/wd-fdc.js

@@ -1414,8 +1414,15 @@ export class WdFdc {
      * @param {Number} drive
      * @param {Disc} disc
      */
-    loadDisc(drive, disc) {
+    /**
+     * @param {Number} drive
+     * @param {Disc} disc
+     * @param {Number} [tracksPerStep] where to leave the drive's 40/80 switch, which by default
+     *   follows the disc, since no drive can tell what pitch the disc in it was written at
+     */
+    loadDisc(drive, disc, tracksPerStep = disc?.is40Track ? 2 : 1) {
         this._drives[drive].setDisc(disc);
+        this._drives[drive].tracksPerStep = tracksPerStep;
     }
 
     get motorOn() {

package/src/web/audio-handler.js

@@ -4,6 +4,7 @@ import { RelayNoise, FakeRelayNoise } from "../relaynoise.js";
 import { Music5000, FakeMusic5000 } from "../music5000.js";
 import { createAudioContext } from "../audio-utils.js";
 import { toggle, fadeIn, fadeOut } from "../dom-utils.js";
+import { toast } from "./toast.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
@@ -15,6 +16,7 @@ export class AudioHandler {
         this.cpuSpeed = cpuSpeed;
         this.isAtom = isAtom;
         this.warningNode = warningNode;
+        this.noAudio = false;
         toggle(this.warningNode, false);
         this.stats = {};
         if (statsNode) {
@@ -37,18 +39,19 @@ export class AudioHandler {
             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();
+            this._setup(audioFilterFreq, audioFilterQ).catch((error) => this._audioUnavailable(error));
         } else {
             if (this.audioContext && !this.audioContext.audioWorklet) {
                 this.audioContext = null;
+                this.noAudio = true;
                 console.log("Unable to initialise audio: no audio worklet API");
-                toggle(this.warningNode, true);
                 const localhost = new URL(window.location);
                 localhost.hostname = "localhost";
                 this.warningNode.innerHTML = `No audio worklet API was found - there will be no audio.
                     If you are running a local jsbeeb, you must either use a host of
                     <a href="${localhost}">localhost</a>,
                     or serve the content over <em>https</em>.`;
+                toggle(this.warningNode, true);
             }
             this.soundChip = new FakeSoundChip();
             this.ddNoise = new FakeDdNoise();
@@ -56,7 +59,6 @@ export class AudioHandler {
         }
 
         this.warningNode.addEventListener("mousedown", () => this.tryResume());
-        toggle(this.warningNode, false);
 
         // Initialise Music 5000 audio context
         this.audioContextM5000 = createAudioContext({ sampleRate: 46875 });
@@ -65,12 +67,21 @@ export class AudioHandler {
             this.audioContextM5000.onstatechange = () => this.checkStatus();
             this.music5000 = new Music5000((buffer) => this._onBufferMusic5000(buffer));
 
-            this.audioContextM5000.audioWorklet.addModule(music5000WorkletUrl).then(() => {
-                this._music5000workletnode = new AudioWorkletNode(this.audioContextM5000, "music5000", {
-                    outputChannelCount: [2],
+            this.audioContextM5000.audioWorklet
+                .addModule(music5000WorkletUrl)
+                .then(() => {
+                    this._music5000workletnode = new AudioWorkletNode(this.audioContextM5000, "music5000", {
+                        outputChannelCount: [2],
+                    });
+                    this._music5000workletnode.connect(this.audioContextM5000.destination);
+                })
+                .catch((error) => {
+                    console.error("Unable to initialise Music 5000 audio", error);
+                    toast(
+                        `The Music 5000 will be silent: its audio could not be started (${error?.message ?? error}). Reloading the page may help.`,
+                        { title: "Music 5000", quietKey: "quietMusic5000Audio" },
+                    );
                 });
-                this._music5000workletnode.connect(this.audioContextM5000.destination);
-            });
         } else {
             this.music5000 = new FakeMusic5000();
         }
@@ -115,6 +126,13 @@ export class AudioHandler {
         };
     }
 
+    _audioUnavailable(error) {
+        console.error("Unable to initialise audio", error);
+        this.noAudio = true;
+        this.warningNode.textContent = `There will be no sound: the audio system could not be started (${error?.message ?? error}). Reloading the page may help.`;
+        fadeIn(this.warningNode);
+    }
+
     _addStat(stat, info) {
         const timeSeries = new this._TimeSeries();
         this.stats[stat] = timeSeries;
@@ -145,6 +163,7 @@ export class AudioHandler {
     }
 
     checkStatus() {
+        if (this.noAudio) return;
         if (!this.audioContext && !this.audioContextM5000) return;
         const suspended =
             (this.audioContext && this.audioContext.state === "suspended") ||

package/src/web/toast.js

@@ -0,0 +1,83 @@
+import * as bootstrap from "bootstrap";
+
+/**
+ * Passing notices: something happened that is worth knowing and needs nothing doing about it.
+ * The error dialog is for the other kind.
+ */
+
+let nextQuietId = 0;
+
+function toastContainer() {
+    const existing = document.querySelector(".toast-container");
+    if (existing) return existing;
+    const container = document.createElement("div");
+    container.className = "toast-container position-fixed bottom-0 end-0 p-3";
+    document.body.appendChild(container);
+    return container;
+}
+
+// Storage can be unreachable or full, and a notice that nothing needs doing about is not worth
+// failing over: forget the answer and say the thing again.
+function remembered(key) {
+    try {
+        return !!window.localStorage.getItem(key);
+    } catch (e) {
+        console.log(`Unable to read ${key}: ${e}`);
+        return false;
+    }
+}
+
+function remember(key, wanted) {
+    try {
+        if (wanted) window.localStorage.setItem(key, "yes");
+        else window.localStorage.removeItem(key);
+    } catch (e) {
+        console.log(`Unable to remember ${key}: ${e}`);
+    }
+}
+
+/**
+ * @param {string} message
+ * @param {object} [options]
+ * @param {string} [options.title] a heading, for a notice whose message does not say where it came from
+ * @param {string} [options.quietKey] offer to stop showing this kind of notice, remembering the answer here
+ */
+export function toast(message, { title = "", quietKey = "" } = {}) {
+    if (quietKey && remembered(quietKey)) return;
+
+    const element = document.createElement("div");
+    element.className = "toast text-bg-dark";
+    element.setAttribute("role", "status");
+    element.setAttribute("aria-live", "polite");
+    element.setAttribute("aria-atomic", "true");
+    const quietId = `toast-quiet-${nextQuietId++}`;
+    element.innerHTML = `
+        <div class="toast-header text-bg-dark">
+            <strong class="me-auto"></strong>
+            <button type="button" class="btn-close btn-close-white" data-bs-dismiss="toast" aria-label="Close"></button>
+        </div>
+        <div class="toast-body">
+            <div class="message"></div>
+            <div class="form-check mt-2">
+                <input class="form-check-input" type="checkbox" id="${quietId}" />
+                <label class="form-check-label small" for="${quietId}">Stop telling me this</label>
+            </div>
+        </div>`;
+    // Disc names and the like come from the outside world, so they are set as text, never as markup.
+    element.querySelector(".message").textContent = message;
+    element.querySelector(".toast-header strong").textContent = title;
+    element.querySelector(".toast-header").hidden = !title;
+
+    const quiet = element.querySelector(".form-check");
+    quiet.hidden = !quietKey;
+    quiet.querySelector("input").addEventListener("change", (event) => remember(quietKey, event.target.checked));
+
+    toastContainer().appendChild(element);
+    // Bootstrap keys its instances by element, so one only removed stays held.
+    element.addEventListener("hidden.bs.toast", () => {
+        bootstrap.Toast.getInstance(element)?.dispose();
+        element.remove();
+    });
+    bootstrap.Toast.getOrCreateInstance(element).show();
+    return element;
+}

package/tests/test-machine.js

@@ -213,7 +213,7 @@ export class TestMachine {
 
     async loadDisc(image) {
         const data = await fdc.load(image);
-        this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, "", data));
+        this.processor.fdc.loadDisc(0, fdc.discFor(this.processor.fdc, image, data));
     }
 
     /**