jsbeeb 1.19.1 → 1.19.2

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.19.1",
+  "version": "1.19.2",
   "//engines": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": ">=24.15.0"

package/src/teletext.js

@@ -16,7 +16,11 @@ export class Teletext {
         this.flashTime = 0;
         this.heldChar = 0;
         this.holdChar = false;
-        this.dataQueue = [0, 0, 0, 0];
+        this.cellGlyphIndex = 0;
+        this.cellFlash = false;
+        this.cellConceal = false;
+        this.cellPalette = 0;
+        this.dataQueue = new Uint8Array(4);
         this.scanlineCounter = 0;
         this.levelDEW = false;
         this.levelDISPTMG = false;
@@ -204,7 +208,7 @@ export class Teletext {
         this.flashTime = state.flashTime;
         this.heldChar = state.heldChar;
         this.holdChar = state.holdChar;
-        this.dataQueue = [...state.dataQueue];
+        this.dataQueue.set(state.dataQueue);
         this.scanlineCounter = state.scanlineCounter;
         this.levelDEW = state.levelDEW;
         this.levelDISPTMG = state.levelDISPTMG;
@@ -308,8 +312,11 @@ export class Teletext {
     }
 
     fetchData(data) {
-        this.dataQueue.shift();
-        this.dataQueue.push(data & 0x7f);
+        // `copyWithin` over four bytes costs more than the moves it saves.
+        this.dataQueue[0] = this.dataQueue[1];
+        this.dataQueue[1] = this.dataQueue[2];
+        this.dataQueue[2] = this.dataQueue[3];
+        this.dataQueue[3] = data & 0x7f;
     }
 
     setDEW(level) {
@@ -386,14 +393,13 @@ export class Teletext {
         this.levelRA0 = level;
     }
 
-    render(buf, offset) {
+    /**
+     * Clock one character through the chip: take the oldest byte in the pipeline, apply it
+     * to the character state, and latch how the resulting cell should look.
+     */
+    advance() {
         let data = this.dataQueue[0];
 
-        let scanline = this.scanlineCounter << 1;
-        if (this.levelRA0) {
-            scanline++;
-        }
-
         this.oldDbl = this.dbl;
 
         this.prevCol = this.col;
@@ -412,28 +418,49 @@ export class Teletext {
             this.heldChar = 32;
         }
 
+        // Flash (code 8) is "Set After" — flashThisCell retains the pre-control-code state.
+        // Steady (code 9) is "Set At" — update so this cell stops flashing immediately.
+        if (flashThisCell && !this.flash) flashThisCell = false;
+
+        // Conceal (code 24) is "Set At", and a colour code only reveals from the cell after itself.
+        if (this.conceal) concealThisCell = true;
+
+        this.cellGlyphIndex = (data - 32) * 20;
+        this.cellFlash = flashThisCell;
+        this.cellConceal = concealThisCell;
+        this.cellPalette = ((this.bg & 7) << 5) | ((this.prevCol & 7) << 2);
+    }
+
+    glyphScanline() {
+        let scanline = this.scanlineCounter << 1;
+        if (this.levelRA0) {
+            scanline++;
+        }
+
         if (this.oldDbl) {
             scanline = scanline >>> 1;
             if (this.secondHalfOfDouble) {
                 scanline += 10;
             }
         }
-        let chardef = this.curGlyphs[(data - 32) * 20 + scanline];
-
-        // Flash (code 8) is "Set After" — flashThisCell retains the pre-control-code state.
-        // Steady (code 9) is "Set At" — update so this cell stops flashing immediately.
-        if (flashThisCell && !this.flash) flashThisCell = false;
+        return scanline;
+    }
 
-        // Conceal (code 24) is "Set At", and a colour code only reveals from the cell after itself.
-        if (this.conceal) concealThisCell = true;
+    /**
+     * Paint the cell most recently latched by `advance`. Everything else read here changes
+     * per scanline or per field, not per character.
+     */
+    emit(buf, offset) {
+        const scanline = this.glyphScanline();
 
-        if (concealThisCell || (flashThisCell && this.hideFlashing) || (this.secondHalfOfDouble && !this.dbl)) {
-            const backgroundColour = this.colour[(this.bg & 7) << 5];
+        if (this.cellConceal || (this.cellFlash && this.hideFlashing) || (this.secondHalfOfDouble && !this.dbl)) {
+            const backgroundColour = this.colour[this.cellPalette & 0xe0];
             for (let i = 0; i < 16; ++i) {
                 buf[offset++] = backgroundColour;
             }
         } else {
-            const paletteIndex = ((this.bg & 7) << 5) | ((this.prevCol & 7) << 2);
+            let chardef = this.curGlyphs[this.cellGlyphIndex + scanline];
+            const paletteIndex = this.cellPalette;
 
             for (let pixel = 0; pixel < 16; ++pixel) {
                 buf[offset + pixel] = this.colour[paletteIndex + (chardef & 3)];
@@ -441,4 +468,27 @@ export class Teletext {
             }
         }
     }
+
+    // The second half of the cell `emit` last painted, for the ULA's 1MHz repaint.
+    emitSecondHalf(buf, offset) {
+        const scanline = this.glyphScanline();
+        if (this.cellConceal || (this.cellFlash && this.hideFlashing) || (this.secondHalfOfDouble && !this.dbl)) {
+            const backgroundColour = this.colour[this.cellPalette & 0xe0];
+            for (let pixel = 8; pixel < 16; ++pixel) {
+                buf[offset + pixel] = backgroundColour;
+            }
+        } else {
+            let chardef = this.curGlyphs[this.cellGlyphIndex + scanline] >>> 16;
+            const paletteIndex = this.cellPalette;
+            for (let pixel = 8; pixel < 16; ++pixel) {
+                buf[offset + pixel] = this.colour[paletteIndex + (chardef & 3)];
+                chardef >>>= 2;
+            }
+        }
+    }
+
+    render(buf, offset) {
+        this.advance();
+        this.emit(buf, offset);
+    }
 }

package/src/video.js

@@ -84,6 +84,7 @@ class Ula {
                 this._writeNulaPalette(val);
                 break;
         }
+        this.video.repaintSecondHalfOfCell();
     }
 
     snapshotState() {
@@ -385,7 +386,9 @@ export class Video {
         this.cursorOff = false;
         this.cursorOnThisFrame = false;
         this.cursorDrawIndex = 0;
+        this.cursorInvertedOffset = -1;
         this.cursorPos = 0;
+        this.cellData = 0;
         this.interlacedSyncAndVideo = false;
         this.doubledScanlines = true;
         this.frameSkipCount = 0;
@@ -546,6 +549,8 @@ export class Video {
         this.cursorOn = state.cursorOn;
         this.cursorOff = state.cursorOff;
         this.cursorOnThisFrame = state.cursorOnThisFrame;
+        this.cursorInvertedOffset = -1;
+        this.cellData = 0;
         this.cursorDrawIndex = state.cursorDrawIndex;
         this.cursorPos = state.cursorPos;
         this.interlacedSyncAndVideo = state.interlacedSyncAndVideo;
@@ -599,6 +604,7 @@ export class Video {
             if (this.frameCount % this.frameSkipCount) enable = 0;
         }
         this.dispEnabled |= enable;
+        this.cursorInvertedOffset = -1;
 
         this.bitmapY = 0;
         // Interlace even frame fires vsync midway through a scanline.
@@ -650,11 +656,7 @@ export class Video {
         destOffset |= 0;
         const offset = table4bppOffset(this.ulaMode, dat);
         const fb32 = this.fb32;
-        // In NULA palette mode, bypass the ULA palette (ulaPal) and look up
-        // pixel colours directly from the NULA 12-bit colour table (collook).
-        // This skips the XOR-7 logical↔physical colour mapping that the
-        // standard ULA applies.  Reference: b-em src/video.c lines 1083, 1117.
-        const colourLookup = this.ula.paletteMode ? this.ula.collook : this.ulaPal;
+        const colourLookup = this.pixelColours();
         const table4bpp = this.table4bpp;
         // Take advantage of numPixels being either 8 or 16
         if (numPixels === 8) {
@@ -668,20 +670,70 @@ export class Video {
         }
     }
 
+    // The second half of a 16 pixel cell, for the 1MHz repaint.
+    blitFbSecondHalf(dat, destOffset) {
+        const offset = table4bppOffset(this.ulaMode, dat);
+        const colourLookup = this.pixelColours();
+        for (let i = 8; i < 16; ++i) {
+            this.fb32[destOffset + i] = colourLookup[this.table4bpp[offset + i]];
+        }
+    }
+
+    // In NULA palette mode, bypass the ULA palette (ulaPal) and look up
+    // pixel colours directly from the NULA 12-bit colour table (collook).
+    // This skips the XOR-7 logical↔physical colour mapping that the
+    // standard ULA applies.  Reference: b-em src/video.c lines 1083, 1117.
+    pixelColours() {
+        return this.ula.paletteMode ? this.ula.collook : this.ulaPal;
+    }
+
     handleCursor(offset) {
         if (this.cursorOnThisFrame && this.ulactrl & this.cursorTable[this.cursorDrawIndex]) {
-            for (let i = 0; i < this.pixelsPerChar; ++i) {
-                this.fb32[offset + i] ^= 0x00ffffff;
-            }
-            if (this.doubledScanlines && !this.interlacedSyncAndVideo) {
-                for (let i = 0; i < this.pixelsPerChar; ++i) {
-                    this.fb32[offset + 1024 + i] ^= 0x00ffffff;
-                }
-            }
+            this.invertForCursor(offset, 0);
+            this.cursorInvertedOffset = offset;
+        } else {
+            this.cursorInvertedOffset = -1;
         }
         if (++this.cursorDrawIndex === 7) this.cursorDrawIndex = 0;
     }
 
+    invertForCursor(offset, fromPixel) {
+        for (let i = fromPixel; i < this.pixelsPerChar; ++i) {
+            this.fb32[offset + i] ^= 0x00ffffff;
+        }
+        if (this.doubledScanlines && !this.interlacedSyncAndVideo) {
+            for (let i = fromPixel; i < this.pixelsPerChar; ++i) {
+                this.fb32[offset + 1024 + i] ^= 0x00ffffff;
+            }
+        }
+    }
+
+    // The render loop paints a whole 1MHz cell on one 2MHz tick and skips the next, but the ULA
+    // output stage switches at 2MHz: a register write landing on the skipped tick changes the
+    // second half of the cell just painted. See https://github.com/mattgodbolt/jsbeeb/issues/766
+    repaintSecondHalfOfCell() {
+        if (!this.halfClock || !this.oddClock) return;
+        if ((this.dispEnabled & EVERYTHINGENABLED) !== EVERYTHINGENABLED) return;
+        if (this.bitmapX < 0 || this.bitmapX >= 1024 || this.bitmapY < 0 || this.bitmapY >= 625) return;
+        // The same line doubling decision as the render loop, which inlines it for speed.
+        const doubledLines =
+            (this.doubledScanlines && !this.interlacedSyncAndVideo) || this.isEvenRender === this.lastRenderWasEven;
+        const bitmapRow = doubledLines ? this.bitmapY & ~1 : this.bitmapY;
+        const offset = bitmapRow * 1024 + this.bitmapX;
+        const halfCell = this.pixelsPerChar >>> 1;
+        if (this.teletextMode) {
+            this.teletext.emitSecondHalf(this.fb32, offset);
+        } else {
+            this.blitFbSecondHalf(this.cellData, offset);
+        }
+        if (doubledLines) {
+            this.fb32.copyWithin(offset + 1024 + halfCell, offset + halfCell, offset + this.pixelsPerChar);
+        }
+        if (this.cursorInvertedOffset === offset) {
+            this.invertForCursor(offset, halfCell);
+        }
+    }
+
     setScreenHwScroll(viaScreenHwScroll) {
         this.screenSubtract = this.screenAddrSubtract[viaScreenHwScroll];
     }
@@ -984,11 +1036,15 @@ export class Video {
                 // Read data from address pointer if both horizontal and vertical display enabled.
                 const dat = this.readVideoMem();
                 if (insideBorder) {
-                    // Always feed the SAA5050 pipeline: on real hardware IC15
-                    // permanently connects the video bus to the SAA5050 inputs
-                    // regardless of ULA mode. Required for the "TTX trick".
+                    // Always clock the SAA5050, whatever the ULA mode: IC15 latches the video bus
+                    // into the chip and it is MA13, not the ULA's teletext bit, that gates it. We
+                    // do not model the MA13 gate yet, so this feeds unconditionally. The chip is
+                    // clocked here and painted later, so a control code seen while the ULA shows
+                    // bitmap still takes effect.
                     // See https://github.com/mattgodbolt/jsbeeb/issues/546
+                    // and https://github.com/mattgodbolt/jsbeeb/issues/832
                     this.teletext.fetchData(dat);
+                    this.teletext.advance();
 
                     // Check cursor start.
                     if (
@@ -1018,6 +1074,7 @@ export class Video {
                     }
 
                     const offset = bitmapRow * 1024 + this.bitmapX;
+                    this.cellData = dat;
 
                     if ((this.dispEnabled & EVERYTHINGENABLED) === EVERYTHINGENABLED) {
                         // Note this row's logical pixel size for display
@@ -1033,24 +1090,24 @@ export class Video {
                         if (this.teletextMode) {
                             if (this.halfClock) {
                                 // Proper MODE 7 (1MHz clock + teletext): render SAA5050 output normally.
-                                this.teletext.render(this.fb32, offset);
+                                this.teletext.emit(this.fb32, offset);
                             } else {
-                                // 2MHz clock + teletext bit set (the "TTX trick"): the Video ULA
-                                // forces DISPEN to the SAA5050 to 0 in 2MHz modes (0/1/2/3), so
-                                // the SAA5050 outputs black. Confirmed by Rich Talbot-Watkins (RTW)
-                                // at ABUG 2026-03-13.
+                                // 2MHz clock + teletext bit set (the "TTX trick"): the SAA5050
+                                // outputs black. Behaviour confirmed by Rich Talbot-Watkins (RTW)
+                                // at ABUG 2026-03-13; the mechanism is not established, as the
+                                // Model B ULA has no connection to the SAA5050 at all.
                                 // See https://github.com/mattgodbolt/jsbeeb/issues/546
                                 this.fb32.fill(OPAQUE_BLACK, offset, offset + this.pixelsPerChar);
                             }
                         } else {
-                            this.blitFb(dat, offset, this.pixelsPerChar, doubledLines);
+                            this.blitFb(dat, offset, this.pixelsPerChar);
                         }
                         if (doubledLines) {
                             this.fb32.copyWithin(offset + 1024, offset, offset + this.pixelsPerChar);
                         }
                     }
                     if (this.cursorDrawIndex) {
-                        this.handleCursor(offset, doubledLines);
+                        this.handleCursor(offset);
                     }
                 }
             }
@@ -1059,6 +1116,10 @@ export class Video {
             // the SAA5050 pipeline with the video bus data, forcing bit 6 high.
             // On real hardware IC37/IC36 operates regardless of ULA mode —
             // it is wired to the CRTC DISPEN signal, not the ULA teletext bit.
+            // Hardware also clocks the chip here, which we do not: our row reset fires
+            // too early relative to the pipeline for that to come out right, and adding
+            // `advance()` alone moves three of the hardware reference pages. See
+            // https://github.com/mattgodbolt/jsbeeb/issues/874
             if (!(this.dispEnabled & HDISPENABLE) && this.dispEnabled & VDISPENABLE) {
                 this.teletext.fetchData(this.readVideoMem() | 0x40);
             }

package/src/basic/multiline-tetris

@@ -1,9 +0,0 @@
-0d=d:IFd VDUd:p=POINT(64*POS,1E3-VPOS*32):RETURN ELSEMODE2:GCOL0,-9:CLG
-1d=9:REPEATVDU30:REPEATGOSUBFALSE:IFPOS=15VDU28,5,VPOS,14;11,26:IF0ELSEIFp=0PRINT:UNTIL0ELSEUNTILVPOS=25
-2b=ABSRND MOD7:k=0:VDU31,9,3
-3REPEATg=9-INKEY6MOD3
-4FORl=TRUE TO1:o=l ANDSGNo
-5IFo=l COLOURb-15:VDUl EORg:k=k+(g=7AND9-6*l)
-6IF0ELSEFORf=0TO11:d=f/3OR2EORd:GOSUBFALSE
-7IF2^((f+k)MOD12)AND975AND&C2590EC/8^b VDU2080*ABSl;:o=o+p:IF0ELSENEXT,
-8VDU20:UNTILo*LOGg:UNTIL0