jsbeeb 1.15.0 → 1.16.0

package/src/sth.js

@@ -2,30 +2,33 @@
 
 import * as utils from "./utils.js";
 
-const catalogUrl = "reclist.php?sort=name&filter=.zip";
-const sthArchive = "www.stairwaytohell.com/bbc/archive";
+// Always https, whatever the page was loaded over: the mirror redirects plain
+// http, so following the page's protocol would cost a redirect on every request
+// when developing over http, and Electron reports "file:" anyway.
+const mirrorBase = "https://bbc.xania.org/archive/sth";
 
-async function _fetchAndParseCatalog(url) {
+async function _fetchManifest(url) {
     const response = await fetch(url);
     if (!response.ok) {
-        throw new Error("Network response was not ok");
+        throw new Error(`Network response was not ok (${response.status})`);
     }
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(await response.text(), "text/html");
-    const result = [];
-    doc.querySelectorAll("tr td:nth-child(3) a").forEach((link) => {
-        const href = link.getAttribute("href");
-        if (href.indexOf(".zip") > 0) result.push(href);
-    });
-    result.sort();
-    return result;
+    const data = await response.json();
+    if (!Array.isArray(data?.files)) {
+        throw new Error("Invalid manifest: missing files array");
+    }
+    return data.files.map((f) => f.path).sort();
+}
+
+// Each path component is encoded individually so slashes survive but special
+// characters in filenames (e.g. brackets in "Daxis[droids]-demo.zip") don't
+// produce a malformed URL.
+function encodePath(path) {
+    return path.split("/").map(encodeURIComponent).join("/");
 }
 
 export class StairwayToHell {
     constructor(onStart, onCat, onError, tape) {
-        // Use https explicitly - document.location.protocol is 'file:' in Electron
-        const protocol = document.location.protocol === "file:" ? "https:" : document.location.protocol;
-        this._baseUrl = `${protocol}//${sthArchive}/${tape ? "tape" : "disk"}images/`;
+        this._baseUrl = `${mirrorBase}/${tape ? "tape" : "disk"}images/`;
         this._catalog = [];
         this._onStart = onStart;
         this._onCat = onCat;
@@ -36,7 +39,7 @@ export class StairwayToHell {
         this._onStart();
         if (this._catalog.length === 0) {
             try {
-                this._catalog = await _fetchAndParseCatalog(this._baseUrl + catalogUrl);
+                this._catalog = await _fetchManifest(this._baseUrl + "manifest.json");
             } catch (error) {
                 console.error("Failed to fetch catalog:", error);
                 if (this._onError) this._onError();
@@ -47,7 +50,7 @@ export class StairwayToHell {
     }
 
     async fetch(file) {
-        const name = this._baseUrl + 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");

package/src/tapes.js

@@ -1,9 +1,6 @@
 "use strict";
 import * as utils from "./utils.js";
 
-const BbcCpuSpeed = 2 * 1000 * 1000;
-const AtomCpuSpeed = 1 * 1000 * 1000;
-
 function secsToClocks(secs, cpuSpeed) {
     return (cpuSpeed * secs) | 0;
 }
@@ -25,11 +22,11 @@ function parityOf(curByte) {
 const ParityN = "N".charCodeAt(0);
 
 class UefTape {
-    constructor(stream, isAtom = false) {
+    constructor(stream, model) {
         this.stream = stream;
         this.baseFrequency = 1200;
-        this.isAtom = isAtom;
-        this.cpuSpeed = isAtom ? AtomCpuSpeed : BbcCpuSpeed;
+        this.isAtom = model.isAtom;
+        this.cpuSpeed = model.cyclesPerSecond;
         this.rewind();
 
         this.curChunk = this.readChunk();
@@ -265,9 +262,10 @@ class UefTape {
 const dividerTable = [1, 16, 64, -1];
 
 class TapefileTape {
-    constructor(stream) {
+    constructor(stream, model) {
         this.count = 0;
         this.stream = stream;
+        this.cpuSpeed = model.cyclesPerSecond;
     }
 
     rate(acia) {
@@ -278,7 +276,7 @@ class TapefileTape {
         const divider = dividerTable[acia.cr & 0x03];
         // http://beebwiki.mdfs.net/index.php/Serial_ULA says the serial rate is ignored
         // for cassette mode.
-        const cpp = (2 * 1000 * 1000) / (19200 / divider);
+        const cpp = this.cpuSpeed / (19200 / divider);
         return Math.floor(bitsPerByte * cpp);
     }
 
@@ -297,7 +295,7 @@ class TapefileTape {
             } else if (byte === 0x04) {
                 acia.setTapeCarrier(true);
                 // Simulate 5 seconds of carrier.
-                return 5 * 2 * 1000 * 1000;
+                return secsToClocks(5, this.cpuSpeed);
             } else if (byte !== 0xff) {
                 throw "Got a weird byte in the tape";
             }
@@ -307,15 +305,15 @@ class TapefileTape {
     }
 }
 
-export async function loadTapeFromData(name, data, isAtom = false) {
+export async function loadTapeFromData(name, data, model) {
     const stream = await utils.DataStream.create(name, data);
     if (stream.readByte(0) === 0xff && stream.readByte(1) === 0x04) {
         console.log("Detected a 'tapefile' tape");
-        return new TapefileTape(stream);
+        return new TapefileTape(stream, model);
     }
     if (stream.readNulString(0) === "UEF File!") {
         console.log("Detected a UEF tape");
-        return new UefTape(stream, isAtom);
+        return new UefTape(stream, model);
     }
     console.log("Unknown tape format");
     return null;

package/src/touchscreen.js

@@ -3,7 +3,6 @@
 import * as utils from "./utils.js";
 
 const PollHz = 8; // Made up
-const PollCycles = (2 * 1000 * 1000) / PollHz;
 
 function doScale(val, scale, margin) {
     val = (val - margin) / (1 - 2 * margin);
@@ -11,13 +10,14 @@ function doScale(val, scale, margin) {
 }
 
 export class TouchScreen {
-    constructor(scheduler) {
+    constructor(scheduler, cyclesPerSecond) {
         this.scheduler = scheduler;
-        this.mouse = [];
+        this.pollCycles = cyclesPerSecond / PollHz;
+        this.mouse = { x: 0, y: 0, button: 0 };
         this.outBuffer = new utils.Fifo(16);
         this.delay = 0;
         this.mode = 0;
-        this.pollTask = this.scheduler.newTask(this.poll);
+        this.pollTask = this.scheduler.newTask(() => this.poll());
     }
 
     tryReceive(rts) {
@@ -47,7 +47,7 @@ export class TouchScreen {
 
     poll() {
         this.doRead();
-        this.pollTask.reschedule(PollCycles);
+        this.pollTask.reschedule(this.pollCycles);
     }
 
     store(byte) {
@@ -81,6 +81,6 @@ export class TouchScreen {
                 if (this.mode === 1) this.doRead();
                 break;
         }
-        this.pollTask.ensureScheduled(this.mode === 129 || this.mode === 130, PollCycles);
+        this.pollTask.ensureScheduled(this.mode === 129 || this.mode === 130, this.pollCycles);
     }
 }

package/src/tube.js

@@ -36,6 +36,11 @@ const TUBE_ULA_FLAG_STATUS_PARASITE_RESET_ACTIVE_LOW = TUBE_ULA_FLAG_STATUS_P;
 const TUBE_ULA_FLAG_STATUS_CLEAR_ALL_TUBE_REGISTERS = TUBE_ULA_FLAG_STATUS_T;
 const TUBE_ULA_FLAG_STATUS_SET_CONTROL_FLAGS = TUBE_ULA_FLAG_STATUS_S;
 const TUBE_ULA_R1_PARASITE_BYTE_COUNT = 24;
+//  the control flags live in the bottom six bits of the register 1 status registers, which both
+//  sides see merged with their own flow control bits
+const TUBE_ULA_CONTROL_FLAG_MASK = 0x3f;
+//  every status register except register 1's reads its unused bits as ones
+const TUBE_ULA_STATUS_UNUSED_BITS = 0x3f;
 
 export class Tube {
     constructor(hostCpu, parasiteCpu) {
@@ -54,6 +59,7 @@ export class Tube {
         this.parasiteToHostFifoByteCount1 = 0;
         this.parasiteToHostFifoByteCount3 = 0;
         this.hostToParasiteFifoByteCount3 = 0;
+        this.parasiteNmi = false;
         this.debug = false;
     }
     reset(updateInternalStatusRegister = true) {
@@ -61,8 +67,10 @@ export class Tube {
             this.internalStatusRegister = 0;
         }
         for (let i = 0; i < 4; i++) {
-            this.hostStatus[i] = TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
-            this.parasiteStatus[i] = TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+            //  register 1's spare bits carry the control flags instead, merged in when either side reads it
+            const unused = i === TUBE_ULA_R1 ? 0 : TUBE_ULA_STATUS_UNUSED_BITS;
+            this.hostStatus[i] = TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL | unused;
+            this.parasiteStatus[i] = TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL | unused;
             if (i === TUBE_ULA_R3) {
                 //  register 3 has one valid but insignificant byte in the parasite to host FIFO (this is to prevent an immediate PNMI state after PRST)
                 this.hostStatus[i] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
@@ -73,8 +81,39 @@ export class Tube {
         //  see info in the loop above from Tube Application Note about R3
         this.parasiteToHostFifoByteCount3 = 1;
         this.hostToParasiteFifoByteCount3 = 0;
+        this.parasiteNmi = false;
         this.updateInterrupts();
     }
+
+    /**
+     * The register 3 condition the ULA raises an NMI from, before the M flag gates it: the host has
+     * queued a whole transfer for the parasite, or the parasite has nothing queued back to the host.
+     *
+     * @returns {boolean} whether the condition currently holds
+     */
+    r3NmiCondition() {
+        const bytesPerTransfer = this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_2_BYTE_R3_DATA ? 2 : 1;
+        return this.hostToParasiteFifoByteCount3 >= bytesPerTransfer || this.parasiteToHostFifoByteCount3 === 0;
+    }
+
+    /** @returns {boolean} whether that condition is currently allowed to reach the parasite's NMI pin. */
+    parasiteNmiEnabled() {
+        return !!(this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_PARASITE_NMI_FROM_R3_DATA);
+    }
+
+    /** Drops the NMI request once the parasite has vectored through it. */
+    acknowledgeNmi() {
+        this.parasiteNmi = false;
+        this.updateInterrupts();
+    }
+
+    /**
+     * Withdraws a pending NMI whose register 3 condition has since gone away. Only the parasite's own
+     * accesses can do this: a transfer it has satisfied no longer needs servicing.
+     */
+    clearNmiIfSatisfied() {
+        if (!this.r3NmiCondition()) this.parasiteNmi = false;
+    }
     updateInterrupts() {
         //  host IRQ
         if (
@@ -97,21 +136,11 @@ export class Tube {
             this.parasiteCpu.interrupt = false;
         }
         //  parasite NMI
-        //  (from Tube Application Note)
-        //  either: M = 1, V = 0, 1 or 2 bytes in host to parasite register 3 FIFO or 0 bytes in parasite
-        //  to host register 3 FIFO (this allows single byte transfers across
-        //  register 3)
-        //  or: M = 1, V = 1, 2 bytes in host to parasite register 3 FIFO or 0 bytes in parasite to host
-        //  register 3 FIFO. (this allows two byte transfers across register 3)
-        const r3Size = this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_2_BYTE_R3_DATA ? 2 : 1;
-        if (
-            this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_PARASITE_NMI_FROM_R3_DATA &&
-            (this.hostToParasiteFifoByteCount3 >= r3Size || this.parasiteToHostFifoByteCount3 === 0)
-        ) {
-            this.parasiteCpu.NMI(true);
-        } else {
-            this.parasiteCpu.NMI(false);
-        }
+        //  The ULA latches its NMI request rather than presenting the register 3 condition as a level:
+        //  each host access to register 3 that gives the parasite something to do raises a request, and
+        //  only the parasite can retire one, by servicing the transfer or by taking the NMI. Recomputing
+        //  the condition here instead would lose every request raised while an earlier one still stood.
+        this.parasiteCpu.NMI(this.parasiteNmi && this.parasiteNmiEnabled());
         //  parasite CPU RESET held low - not implemented in the CPU - the CPU should be frozen until this signal is released
         this.parasiteCpu.resetHeldLow = this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_PARASITE_RESET_ACTIVE_LOW;
     }
@@ -122,8 +151,7 @@ export class Tube {
                 result =
                     (this.hostStatus[TUBE_ULA_R1] &
                         (TUBE_ULA_FLAG_DATA_AVAILABLE | TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL)) |
-                    (this.internalStatusRegister &
-                        ~(TUBE_ULA_FLAG_DATA_AVAILABLE | TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL));
+                    (this.internalStatusRegister & TUBE_ULA_CONTROL_FLAG_MASK);
                 break;
             case TUBE_ULA_R1_DATA_ADDRESS:
                 result = this.parasiteToHostData[TUBE_ULA_R1][0];
@@ -143,8 +171,10 @@ export class Tube {
                 break;
             case TUBE_ULA_R2_DATA_ADDRESS:
                 result = this.parasiteToHostData[TUBE_ULA_R2][0];
-                this.parasiteStatus[TUBE_ULA_R2] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
-                this.hostStatus[TUBE_ULA_R2] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                if (this.hostStatus[TUBE_ULA_R2] & TUBE_ULA_FLAG_DATA_AVAILABLE) {
+                    this.parasiteStatus[TUBE_ULA_R2] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    this.hostStatus[TUBE_ULA_R2] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                }
                 break;
             case TUBE_ULA_R3_STATUS_ADDRESS:
                 result = this.hostStatus[TUBE_ULA_R3];
@@ -157,6 +187,8 @@ export class Tube {
                     this.parasiteToHostFifoByteCount3--;
                     if (this.parasiteToHostFifoByteCount3 === 0) {
                         this.hostStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                        //  the parasite owes the host a byte, so ask it for one
+                        this.parasiteNmi = true;
                     }
                 }
                 break;
@@ -165,8 +197,10 @@ export class Tube {
                 break;
             case TUBE_ULA_R4_DATA_ADDRESS:
                 result = this.parasiteToHostData[TUBE_ULA_R4][0];
-                this.parasiteStatus[TUBE_ULA_R4] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
-                this.hostStatus[TUBE_ULA_R4] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                if (this.hostStatus[TUBE_ULA_R4] & TUBE_ULA_FLAG_DATA_AVAILABLE) {
+                    this.parasiteStatus[TUBE_ULA_R4] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    this.hostStatus[TUBE_ULA_R4] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                }
                 break;
         }
         this.updateInterrupts();
@@ -180,14 +214,13 @@ export class Tube {
             console.log("TUBE ULA: host write " + utils.hexword(address) + " = " + utils.hexbyte(value));
         }
         switch (address & 7) {
-            case TUBE_ULA_R1_STATUS_ADDRESS:
+            case TUBE_ULA_R1_STATUS_ADDRESS: {
+                //  M and V both feed the NMI, so a write here can raise or drop the request on its own
+                const nmiBefore = this.parasiteNmiEnabled() && this.r3NmiCondition();
                 if (value & TUBE_ULA_FLAG_STATUS_SET_CONTROL_FLAGS) {
-                    this.internalStatusRegister |=
-                        value & ~(TUBE_ULA_FLAG_DATA_AVAILABLE | TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL);
+                    this.internalStatusRegister |= value & TUBE_ULA_CONTROL_FLAG_MASK;
                 } else {
-                    this.internalStatusRegister &= ~(
-                        value & ~(TUBE_ULA_FLAG_DATA_AVAILABLE | TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL)
-                    );
+                    this.internalStatusRegister &= ~(value & TUBE_ULA_CONTROL_FLAG_MASK);
                 }
                 if (value & TUBE_ULA_FLAG_STATUS_CLEAR_ALL_TUBE_REGISTERS) {
                     this.reset(false);
@@ -200,7 +233,11 @@ export class Tube {
                         this.parasiteCpu.reset(true); //  this in turn calls our this.reset(true)
                     }
                 }
+                const nmiAfter = this.parasiteNmiEnabled() && this.r3NmiCondition();
+                if (!nmiBefore && nmiAfter) this.parasiteNmi = true;
+                if (!nmiAfter) this.parasiteNmi = false;
                 break;
+            }
             case TUBE_ULA_R1_DATA_ADDRESS:
                 if (this.hostStatus[TUBE_ULA_R1] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
                     this.hostToParasiteData[TUBE_ULA_R1][0] = value;
@@ -224,12 +261,15 @@ export class Tube {
                         if (this.hostToParasiteFifoByteCount3 === 2) {
                             this.parasiteStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
                             this.hostStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                            //  a whole transfer is waiting, so ask the parasite to take it
+                            this.parasiteNmi = true;
                         }
                     } else {
                         this.hostToParasiteData[TUBE_ULA_R3][0] = value;
                         this.hostToParasiteFifoByteCount3 = 1;
                         this.parasiteStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
                         this.hostStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                        this.parasiteNmi = true;
                     }
                 }
                 break;
@@ -250,20 +290,24 @@ export class Tube {
         let result = 0;
         switch (address & 7) {
             case TUBE_ULA_R1_STATUS_ADDRESS:
-                result = this.parasiteStatus[TUBE_ULA_R1];
+                result = this.parasiteStatus[TUBE_ULA_R1] | (this.internalStatusRegister & TUBE_ULA_CONTROL_FLAG_MASK);
                 break;
             case TUBE_ULA_R1_DATA_ADDRESS:
                 result = this.hostToParasiteData[TUBE_ULA_R1][0];
-                this.hostStatus[TUBE_ULA_R1] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
-                this.parasiteStatus[TUBE_ULA_R1] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                if (this.parasiteStatus[TUBE_ULA_R1] & TUBE_ULA_FLAG_DATA_AVAILABLE) {
+                    this.hostStatus[TUBE_ULA_R1] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    this.parasiteStatus[TUBE_ULA_R1] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                }
                 break;
             case TUBE_ULA_R2_STATUS_ADDRESS:
                 result = this.parasiteStatus[TUBE_ULA_R2];
                 break;
             case TUBE_ULA_R2_DATA_ADDRESS:
                 result = this.hostToParasiteData[TUBE_ULA_R2][0];
-                this.hostStatus[TUBE_ULA_R2] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
-                this.parasiteStatus[TUBE_ULA_R2] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                if (this.parasiteStatus[TUBE_ULA_R2] & TUBE_ULA_FLAG_DATA_AVAILABLE) {
+                    this.hostStatus[TUBE_ULA_R2] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    this.parasiteStatus[TUBE_ULA_R2] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                }
                 break;
             case TUBE_ULA_R3_STATUS_ADDRESS:
                 result = this.parasiteStatus[TUBE_ULA_R3];
@@ -277,6 +321,7 @@ export class Tube {
                         this.hostStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
                         this.parasiteStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
                     }
+                    this.clearNmiIfSatisfied();
                 }
                 break;
             case TUBE_ULA_R4_STATUS_ADDRESS:
@@ -284,8 +329,10 @@ export class Tube {
                 break;
             case TUBE_ULA_R4_DATA_ADDRESS:
                 result = this.hostToParasiteData[TUBE_ULA_R4][0];
-                this.hostStatus[TUBE_ULA_R4] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
-                this.parasiteStatus[TUBE_ULA_R4] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                if (this.parasiteStatus[TUBE_ULA_R4] & TUBE_ULA_FLAG_DATA_AVAILABLE) {
+                    this.hostStatus[TUBE_ULA_R4] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    this.parasiteStatus[TUBE_ULA_R4] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                }
                 break;
         }
         this.updateInterrupts();
@@ -304,13 +351,15 @@ export class Tube {
             parasiteToHostFifoByteCount1: this.parasiteToHostFifoByteCount1,
             parasiteToHostFifoByteCount3: this.parasiteToHostFifoByteCount3,
             hostToParasiteFifoByteCount3: this.hostToParasiteFifoByteCount3,
+            parasiteNmi: this.parasiteNmi,
         };
     }
 
     /**
      * The interrupt and reset lines are not saved: they are derived from the status registers
      * and FIFO counts, in the same way the host's `interrupt` is rebuilt by the VIA and ACIA
-     * restores.
+     * restores. The latched NMI request is saved, as nothing else records whether the parasite
+     * still owes the host a transfer.
      */
     restoreState(state) {
         this.internalStatusRegister = state.internalStatusRegister;
@@ -323,6 +372,8 @@ export class Tube {
         this.parasiteToHostFifoByteCount1 = state.parasiteToHostFifoByteCount1;
         this.parasiteToHostFifoByteCount3 = state.parasiteToHostFifoByteCount3;
         this.hostToParasiteFifoByteCount3 = state.hostToParasiteFifoByteCount3;
+        //  snapshots taken before the ULA latched its NMI have to fall back on the condition itself
+        this.parasiteNmi = state.parasiteNmi ?? this.r3NmiCondition();
         this.updateInterrupts();
     }
 
@@ -366,6 +417,7 @@ export class Tube {
                         this.hostStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
                         this.parasiteStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
                     }
+                    this.clearNmiIfSatisfied();
                 }
                 break;
             case TUBE_ULA_R4_DATA_ADDRESS:

package/src/video-filters/pal-composite.js

@@ -14,12 +14,9 @@
 
 import VERT_SHADER from "./shaders/pal-composite.vert.glsl?raw";
 import FRAG_SHADER from "./shaders/pal-composite.frag.glsl?raw";
+import { compileProgram } from "./shader-program.js";
 
 export class PALCompositeFilter {
-    static requiresGl() {
-        return true;
-    }
-
     static getDisplayConfig() {
         return {
             name: "PAL TV",
@@ -31,57 +28,26 @@ export class PALCompositeFilter {
             canvasTop: 70,
             visibleWidth: 800,
             visibleHeight: 600,
+            canvasWidth: 896,
+            canvasHeight: 600,
         };
     }
 
     constructor(gl) {
         this.gl = gl;
-        this.program = null;
-        this.locations = {};
-
-        this._init();
-    }
-
-    _init() {
-        const gl = this.gl;
-
-        // Compile shaders
-        const vertShader = this._compileShader(gl.VERTEX_SHADER, VERT_SHADER);
-        const fragShader = this._compileShader(gl.FRAGMENT_SHADER, FRAG_SHADER);
-
-        // Link program
-        this.program = gl.createProgram();
-        gl.attachShader(this.program, vertShader);
-        gl.attachShader(this.program, fragShader);
-        gl.linkProgram(this.program);
-
-        if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
-            const info = gl.getProgramInfoLog(this.program);
-            throw new Error("Failed to link PAL shader program: " + info);
-        }
-
-        // Get uniform locations
-        this.locations.uFramebuffer = gl.getUniformLocation(this.program, "uFramebuffer");
-        this.locations.uResolution = gl.getUniformLocation(this.program, "uResolution");
-        this.locations.uTexelSize = gl.getUniformLocation(this.program, "uTexelSize");
-        this.locations.uFrameCount = gl.getUniformLocation(this.program, "uFrameCount");
-
-        console.log("PAL composite filter initialized");
+        this.program = compileProgram(gl, VERT_SHADER, FRAG_SHADER, "PAL composite");
+        this.locations = {
+            uFramebuffer: gl.getUniformLocation(this.program, "uFramebuffer"),
+            uResolution: gl.getUniformLocation(this.program, "uResolution"),
+            uTexelSize: gl.getUniformLocation(this.program, "uTexelSize"),
+            uFrameCount: gl.getUniformLocation(this.program, "uFrameCount"),
+        };
     }
 
-    _compileShader(type, source) {
-        const gl = this.gl;
-        const shader = gl.createShader(type);
-        gl.shaderSource(shader, source);
-        gl.compileShader(shader);
-
-        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-            const info = gl.getShaderInfoLog(shader);
-            const typeName = type === gl.VERTEX_SHADER ? "vertex" : "fragment";
-            throw new Error(`Failed to compile ${typeName} shader: ${info}`);
-        }
-
-        return shader;
+    /** Release the GL objects this filter owns. */
+    dispose() {
+        this.gl.deleteProgram(this.program);
+        this.program = null;
     }
 
     setUniforms(params) {

package/src/video-filters/passthrough-filter.js

@@ -2,12 +2,9 @@
 
 import VERT_SHADER from "./shaders/passthrough.vert.glsl?raw";
 import FRAG_SHADER from "./shaders/passthrough.frag.glsl?raw";
+import { compileProgram } from "./shader-program.js";
 
 export class PassthroughFilter {
-    static requiresGl() {
-        return false;
-    }
-
     static getDisplayConfig() {
         return {
             name: "RGB Monitor",
@@ -19,48 +16,23 @@ export class PassthroughFilter {
             canvasTop: 8,
             visibleWidth: 896,
             visibleHeight: 600,
+            canvasWidth: 896,
+            canvasHeight: 600,
         };
     }
 
     constructor(gl) {
         this.gl = gl;
-        this.program = null;
-        this.locations = {};
-
-        this._init();
-    }
-
-    _init() {
-        const gl = this.gl;
-
-        const vertexShader = this._compileShader(gl.VERTEX_SHADER, VERT_SHADER);
-        const fragmentShader = this._compileShader(gl.FRAGMENT_SHADER, FRAG_SHADER);
-
-        this.program = gl.createProgram();
-        gl.attachShader(this.program, vertexShader);
-        gl.attachShader(this.program, fragmentShader);
-        gl.linkProgram(this.program);
-
-        if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
-            throw new Error("Failed to link passthrough shader program: " + gl.getProgramInfoLog(this.program));
-        }
-
-        this.locations.tex = gl.getUniformLocation(this.program, "tex");
+        this.program = compileProgram(gl, VERT_SHADER, FRAG_SHADER, "passthrough");
+        this.locations = {
+            tex: gl.getUniformLocation(this.program, "tex"),
+        };
     }
 
-    _compileShader(type, source) {
-        const gl = this.gl;
-        const shader = gl.createShader(type);
-        gl.shaderSource(shader, source);
-        gl.compileShader(shader);
-
-        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-            const error = gl.getShaderInfoLog(shader);
-            gl.deleteShader(shader);
-            throw new Error("Shader compilation failed: " + error);
-        }
-
-        return shader;
+    /** Release the GL objects this filter owns. */
+    dispose() {
+        this.gl.deleteProgram(this.program);
+        this.program = null;
     }
 
     setUniforms(_params) {

package/src/video-filters/pixel-grid.js

@@ -0,0 +1,55 @@
+"use strict";
+
+// Describing the logical pixel grid of jsbeeb's framebuffer, which is a
+// 1024-wide *raster* rather than a grid of BBC pixels: one logical pixel covers
+// up to eight texels across and two down. Filters need to know that, and only
+// the video chips do, so they record one descriptor byte per row and this
+// module owns the encoding.
+//
+// See docs/xbr-display-mode.md for why an upscaler that samples raw texels
+// achieves nothing at all.
+
+/**
+ * Rows in the line grid. The framebuffer is 625 rows, but the GL texture it is
+ * uploaded into is 1024 square, and the shader indexes the grid with the same
+ * coordinate it uses for the picture — so the two must agree.
+ */
+export const LineGridRows = 1024;
+
+// Row descriptor bits, as stored in `Video.lineGrid`. The width is held less
+// one, so it needs no logarithm to write and no exponential to read, and any
+// width from one to eight can be described — the 6847 uses widths the BBC's ULA
+// never selects.
+const LineGridRendered = 0x80;
+const LineGridVerticalDouble = 0x08;
+const LineGridWidthMask = 0x07;
+
+/**
+ * How many framebuffer texels wide one logical pixel is, given the ULA's
+ * colour-select bits. The ULA writes 8 pixels per byte at `ulaMode` 3 and
+ * halves the count for each step down, which `Video.table4bpp` implements by
+ * indexing its 1bpp entries with `i >> (3 - ulaMode)`. This holds for the 1MHz
+ * modes too: `pixelsPerChar` is 16 there rather than 8, and the same shift over
+ * twice as many texels gives the same width — MODE 4 is two, MODE 5 is four.
+ *
+ * @param {number} ulaMode 0..3, the ULA control register's colour bits
+ * @returns {number} 1, 2, 4 or 8; the standard modes use 1, 2 and 4
+ */
+export function texelsPerPixel(ulaMode) {
+    return 8 >> ulaMode;
+}
+
+/**
+ * Pack a row's grid description into the byte the video chips store.
+ *
+ * @param {number} texelsWide 1 to 8 (see {@link texelsPerPixel})
+ * @param {boolean} doubledLines whether this scanline was written to two rows
+ */
+export function encodeLineGrid(texelsWide, doubledLines) {
+    // A width of 9 would set the doubling bit and read back as a doubled width
+    // of 1 — a silent lie rather than an error. The widths come from mode-table
+    // arithmetic, so check.
+    if (texelsWide < 1 || texelsWide > LineGridWidthMask + 1)
+        throw new Error(`Logical pixel width ${texelsWide} cannot be described in a line grid descriptor`);
+    return LineGridRendered | (texelsWide - 1) | (doubledLines ? LineGridVerticalDouble : 0);
+}