jsbeeb 1.22.3 → 1.23.0

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.22.3",
+  "version": "1.23.0",
   "//engines": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": ">=24.15.0"
@@ -29,6 +29,7 @@
     "@popperjs/core": "^2.11.8",
     "argparse": "^3.0.0",
     "bootstrap": "^5.3.8",
+    "bootstrap-icons": "^1.13.1",
     "bootswatch": "^5.3.8",
     "pako": "^3.0.1",
     "sharp": "^0.35.3",
@@ -52,7 +53,7 @@
     "vitest": "^4.0.10"
   },
   "optionalDependencies": {
-    "electron": "^43.2.0",
+    "electron": "^44.0.0",
     "electron-builder": "^26.15.3",
     "electron-store": "^11.0.2"
   },

package/src/6502.js

@@ -1195,6 +1195,7 @@ export class Cpu6502 extends Base6502 {
             while (this.model.swram[romIndex]) {
                 romIndex--;
             }
+            if (romIndex < 0) throw new Error("Too many extra ROMs (no free sideways ROM banks)");
 
             awaiting.push(this.loadRom(extraRoms[i_2], this.romOffset + romIndex * 16384));
         }
@@ -1823,7 +1824,11 @@ export class AtomCpu6502 extends Cpu6502 {
 
     // Override loadRom to accept 4KB ROMs
     async loadRom(name, offset) {
-        const data = await utils.loadData("roms/" + name);
+        if (name.indexOf("http") !== 0) name = "roms/" + name;
+        let data = await utils.loadData(name);
+        if (/\.zip/i.test(name)) {
+            data = (await utils.unzipRomImage(data)).data;
+        }
         const len = data.length;
         if (len !== 16384 && len !== 8192 && len !== 4096) {
             throw new Error(`Broken ROM file ${name} (length=${len})`);

package/src/6502.opcodes.js

@@ -525,254 +525,269 @@ function getOp(op, arg) {
     throw new Error(`Unrecognised operation '${op}'`);
 }
 
-const opcodes6502 = {
+// Undocumented opcodes carry a leading "*", as 6502 listings conventionally show them.
+function splitUndocumented(markedOpcodes) {
+    const opcodes = {};
+    const undocumented = new Set();
+    for (const [op, text] of Object.entries(markedOpcodes)) {
+        if (text.startsWith("*")) {
+            undocumented.add(Number(op));
+            opcodes[op] = text.slice(1);
+        } else {
+            opcodes[op] = text;
+        }
+    }
+    return { opcodes, undocumented };
+}
+
+const { opcodes: opcodes6502, undocumented: undocumented6502 } = splitUndocumented({
     0x00: "BRK",
     0x01: "ORA (,x)",
-    0x03: "SLO (,x)",
-    0x04: "NOP zp",
+    0x03: "*SLO (,x)",
+    0x04: "*NOP zp",
     0x05: "ORA zp",
     0x06: "ASL zp",
-    0x07: "SLO zp",
+    0x07: "*SLO zp",
     0x08: "PHP",
     0x09: "ORA imm",
     0x0a: "ASL A",
-    0x0b: "ANC imm",
-    0x0c: "NOP abs",
+    0x0b: "*ANC imm",
+    0x0c: "*NOP abs",
     0x0d: "ORA abs",
     0x0e: "ASL abs",
-    0x0f: "SLO abs",
+    0x0f: "*SLO abs",
     0x10: "BPL branch",
     0x11: "ORA (),y",
-    0x13: "SLO (),y",
-    0x14: "NOP zp,x",
+    0x13: "*SLO (),y",
+    0x14: "*NOP zp,x",
     0x15: "ORA zp,x",
     0x16: "ASL zp,x",
-    0x17: "SLO zp,x",
+    0x17: "*SLO zp,x",
     0x18: "CLC",
     0x19: "ORA abs,y",
-    0x1a: "NOP",
-    0x1b: "SLO abs,y",
-    0x1c: "NOP abs,x",
+    0x1a: "*NOP",
+    0x1b: "*SLO abs,y",
+    0x1c: "*NOP abs,x",
     0x1d: "ORA abs,x",
     0x1e: "ASL abs,x",
-    0x1f: "SLO abs,x",
+    0x1f: "*SLO abs,x",
     0x20: "JSR abs",
     0x21: "AND (,x)",
-    0x23: "RLA (,x)",
+    0x23: "*RLA (,x)",
     0x24: "BIT zp",
     0x25: "AND zp",
     0x26: "ROL zp",
-    0x27: "RLA zp",
+    0x27: "*RLA zp",
     0x28: "PLP",
     0x29: "AND imm",
     0x2a: "ROL A",
-    0x2b: "ANC imm",
+    0x2b: "*ANC imm",
     0x2c: "BIT abs",
     0x2d: "AND abs",
     0x2e: "ROL abs",
-    0x2f: "RLA abs",
+    0x2f: "*RLA abs",
     0x30: "BMI branch",
     0x31: "AND (),y",
-    0x33: "RLA (),y",
-    0x34: "NOP zp,x",
+    0x33: "*RLA (),y",
+    0x34: "*NOP zp,x",
     0x35: "AND zp,x",
     0x36: "ROL zp,x",
-    0x37: "RLA zp,x",
+    0x37: "*RLA zp,x",
     0x38: "SEC",
     0x39: "AND abs,y",
-    0x3a: "NOP",
-    0x3b: "RLA abs,y",
-    0x3c: "NOP abs,x",
+    0x3a: "*NOP",
+    0x3b: "*RLA abs,y",
+    0x3c: "*NOP abs,x",
     0x3d: "AND abs,x",
     0x3e: "ROL abs,x",
-    0x3f: "RLA abs,x",
+    0x3f: "*RLA abs,x",
     0x40: "RTI",
     0x41: "EOR (,x)",
-    0x43: "SRE (,x)",
-    0x44: "NOP zp",
+    0x43: "*SRE (,x)",
+    0x44: "*NOP zp",
     0x45: "EOR zp",
     0x46: "LSR zp",
-    0x47: "SRE zp",
+    0x47: "*SRE zp",
     0x48: "PHA",
     0x49: "EOR imm",
     0x4a: "LSR A",
-    0x4b: "ASR imm",
+    0x4b: "*ASR imm",
     0x4c: "JMP abs",
     0x4d: "EOR abs",
     0x4e: "LSR abs",
-    0x4f: "SRE abs",
+    0x4f: "*SRE abs",
     0x50: "BVC branch",
     0x51: "EOR (),y",
-    0x53: "SRE (),y",
-    0x54: "NOP zp,x",
+    0x53: "*SRE (),y",
+    0x54: "*NOP zp,x",
     0x55: "EOR zp,x",
     0x56: "LSR zp,x",
-    0x57: "SRE zp,x",
+    0x57: "*SRE zp,x",
     0x58: "CLI",
     0x59: "EOR abs,y",
-    0x5a: "NOP",
-    0x5b: "SRE abs,y",
-    0x5c: "NOP abs,x",
+    0x5a: "*NOP",
+    0x5b: "*SRE abs,y",
+    0x5c: "*NOP abs,x",
     0x5d: "EOR abs,x",
     0x5e: "LSR abs,x",
-    0x5f: "SRE abs,x",
+    0x5f: "*SRE abs,x",
     0x60: "RTS",
     0x61: "ADC (,x)",
-    0x63: "RRA (,x)",
-    0x64: "NOP zp",
+    0x63: "*RRA (,x)",
+    0x64: "*NOP zp",
     0x65: "ADC zp",
     0x66: "ROR zp",
-    0x67: "RRA zp",
+    0x67: "*RRA zp",
     0x68: "PLA",
     0x69: "ADC imm",
     0x6a: "ROR A",
-    0x6b: "ARR imm",
+    0x6b: "*ARR imm",
     0x6c: "JMP (abs)",
     0x6d: "ADC abs",
     0x6e: "ROR abs",
-    0x6f: "RRA abs",
+    0x6f: "*RRA abs",
     0x70: "BVS branch",
     0x71: "ADC (),y",
-    0x73: "RRA (),y",
-    0x74: "NOP zp,x",
+    0x73: "*RRA (),y",
+    0x74: "*NOP zp,x",
     0x75: "ADC zp,x",
     0x76: "ROR zp,x",
-    0x77: "RRA zp,x",
+    0x77: "*RRA zp,x",
     0x78: "SEI",
     0x79: "ADC abs,y",
-    0x7a: "NOP",
-    0x7b: "RRA abs,y",
-    0x7c: "NOP abs,x",
+    0x7a: "*NOP",
+    0x7b: "*RRA abs,y",
+    0x7c: "*NOP abs,x",
     0x7d: "ADC abs,x",
     0x7e: "ROR abs,x",
-    0x7f: "RRA abs,x",
-    0x80: "NOP imm",
+    0x7f: "*RRA abs,x",
+    0x80: "*NOP imm",
     0x81: "STA (,x)",
-    0x82: "NOP imm",
-    0x83: "SAX (,x)",
+    0x82: "*NOP imm",
+    0x83: "*SAX (,x)",
     0x84: "STY zp",
     0x85: "STA zp",
     0x86: "STX zp",
-    0x87: "SAX zp",
+    0x87: "*SAX zp",
     0x88: "DEY",
-    0x89: "NOP imm",
+    0x89: "*NOP imm",
     0x8a: "TXA",
-    0x8b: "ANE imm",
+    0x8b: "*ANE imm",
     0x8c: "STY abs",
     0x8d: "STA abs",
     0x8e: "STX abs",
-    0x8f: "SAX abs",
+    0x8f: "*SAX abs",
     0x90: "BCC branch",
     0x91: "STA (),y",
-    0x93: "SHA (),y",
+    0x93: "*SHA (),y",
     0x94: "STY zp,x",
     0x95: "STA zp,x",
     0x96: "STX zp,y",
-    0x97: "SAX zp,y",
+    0x97: "*SAX zp,y",
     0x98: "TYA",
     0x99: "STA abs,y",
     0x9a: "TXS",
-    0x9b: "SHS abs,y",
-    0x9c: "SHY abs,x",
+    0x9b: "*SHS abs,y",
+    0x9c: "*SHY abs,x",
     0x9d: "STA abs,x",
-    0x9e: "SHX abs,y",
-    0x9f: "SHA abs,y",
+    0x9e: "*SHX abs,y",
+    0x9f: "*SHA abs,y",
     0xa0: "LDY imm",
     0xa1: "LDA (,x)",
     0xa2: "LDX imm",
-    0xa3: "LAX (,x)",
+    0xa3: "*LAX (,x)",
     0xa4: "LDY zp",
     0xa5: "LDA zp",
     0xa6: "LDX zp",
-    0xa7: "LAX zp",
+    0xa7: "*LAX zp",
     0xa8: "TAY",
     0xa9: "LDA imm",
     0xaa: "TAX",
-    0xab: "LXA imm",
+    0xab: "*LXA imm",
     0xac: "LDY abs",
     0xad: "LDA abs",
     0xae: "LDX abs",
-    0xaf: "LAX abs",
+    0xaf: "*LAX abs",
     0xb0: "BCS branch",
     0xb1: "LDA (),y",
-    0xb3: "LAX (),y",
+    0xb3: "*LAX (),y",
     0xb4: "LDY zp,x",
     0xb5: "LDA zp,x",
     0xb6: "LDX zp,y",
-    0xb7: "LAX zp,y",
+    0xb7: "*LAX zp,y",
     0xb8: "CLV",
     0xb9: "LDA abs,y",
     0xba: "TSX",
-    0xbb: "LAS abs,y",
+    0xbb: "*LAS abs,y",
     0xbc: "LDY abs,x",
     0xbd: "LDA abs,x",
     0xbe: "LDX abs,y",
-    0xbf: "LAX abs,y",
+    0xbf: "*LAX abs,y",
     0xc0: "CPY imm",
     0xc1: "CMP (,x)",
-    0xc2: "NOP imm",
-    0xc3: "DCP (,x)",
+    0xc2: "*NOP imm",
+    0xc3: "*DCP (,x)",
     0xc4: "CPY zp",
     0xc5: "CMP zp",
     0xc6: "DEC zp",
-    0xc7: "DCP zp",
+    0xc7: "*DCP zp",
     0xc8: "INY",
     0xc9: "CMP imm",
     0xca: "DEX",
-    0xcb: "SBX imm",
+    0xcb: "*SBX imm",
     0xcc: "CPY abs",
     0xcd: "CMP abs",
     0xce: "DEC abs",
-    0xcf: "DCP abs",
+    0xcf: "*DCP abs",
     0xd0: "BNE branch",
     0xd1: "CMP (),y",
-    0xd3: "DCP (),y",
-    0xd4: "NOP zp,x",
+    0xd3: "*DCP (),y",
+    0xd4: "*NOP zp,x",
     0xd5: "CMP zp,x",
     0xd6: "DEC zp,x",
-    0xd7: "DCP zp,x",
+    0xd7: "*DCP zp,x",
     0xd8: "CLD",
     0xd9: "CMP abs,y",
-    0xda: "NOP",
-    0xdb: "DCP abs,y",
-    0xdc: "NOP abs,x",
+    0xda: "*NOP",
+    0xdb: "*DCP abs,y",
+    0xdc: "*NOP abs,x",
     0xdd: "CMP abs,x",
     0xde: "DEC abs,x",
-    0xdf: "DCP abs,x",
+    0xdf: "*DCP abs,x",
     0xe0: "CPX imm",
     0xe1: "SBC (,x)",
-    0xe2: "NOP imm",
-    0xe3: "ISB (,x)",
+    0xe2: "*NOP imm",
+    0xe3: "*ISB (,x)",
     0xe4: "CPX zp",
     0xe5: "SBC zp",
     0xe6: "INC zp",
-    0xe7: "ISB zp",
+    0xe7: "*ISB zp",
     0xe8: "INX",
     0xe9: "SBC imm",
     0xea: "NOP",
-    0xeb: "SBC imm",
+    0xeb: "*SBC imm",
     0xec: "CPX abs",
     0xed: "SBC abs",
     0xee: "INC abs",
-    0xef: "ISB abs",
+    0xef: "*ISB abs",
     0xf0: "BEQ branch",
     0xf1: "SBC (),y",
-    0xf3: "ISB (),y",
-    0xf4: "NOP zpx",
+    0xf3: "*ISB (),y",
+    0xf4: "*NOP zp,x",
     0xf5: "SBC zp,x",
     0xf6: "INC zp,x",
-    0xf7: "ISB zp,x",
+    0xf7: "*ISB zp,x",
     0xf8: "SED",
     0xf9: "SBC abs,y",
-    0xfa: "NOP",
-    0xfb: "ISB abs,y",
-    0xfc: "NOP abs,x",
+    0xfa: "*NOP",
+    0xfb: "*ISB abs,y",
+    0xfc: "*NOP abs,x",
     0xfd: "SBC abs,x",
     0xfe: "INC abs,x",
-    0xff: "ISB abs,x",
-};
+    0xff: "*ISB abs,x",
+});
 
-const opcodes65c12 = {
+const { opcodes: opcodes65c12, undocumented: undocumented65c12 } = splitUndocumented({
     0x00: "BRK",
     0x01: "ORA (,x)",
     0x04: "TSB zp",
@@ -952,9 +967,9 @@ const opcodes65c12 = {
     0xfa: "PLX",
     0xfd: "SBC abs,x",
     0xfe: "INC abs,x",
-};
+});
 
-const opcodes65c02 = {
+const { opcodes: opcodes65c02, undocumented: undocumented65c02 } = splitUndocumented({
     ...opcodes65c12,
     0x07: "RMB0 zp",
     0x17: "RMB1 zp",
@@ -988,12 +1003,20 @@ const opcodes65c02 = {
     0xdf: "BBS5 zp,branch",
     0xef: "BBS6 zp,branch",
     0xff: "BBS7 zp,branch",
-};
+});
+
+const PrevInstructionWindow = 64;
 
 class Disassemble6502 {
-    constructor(cpu, opcodes) {
+    constructor(cpu, opcodes, undocumented) {
         this.cpu = cpu;
         this.opcodes = opcodes;
+        this.undocumented = undocumented;
+    }
+
+    isDocumented(addr) {
+        const op = this.cpu.peekmem(addr);
+        return op in this.opcodes && !this.undocumented.has(op);
     }
 
     disassemble(addr, plain) {
@@ -1003,13 +1026,15 @@ class Disassemble6502 {
             formatAddr = hexword;
             formatJumpAddr = hexword;
         }
-        const opcode = this.opcodes[this.cpu.peekmem(addr)];
+        const opcodeByte = this.cpu.peekmem(addr);
+        const opcode = this.opcodes[opcodeByte];
         if (!opcode) {
             return ["???", addr + 1];
         }
-        const split = opcode.split(" ");
+        const [mnemonic, ...rest] = opcode.split(" ");
+        const split = [(this.undocumented.has(opcodeByte) ? "*" : "") + mnemonic, ...rest];
         if (!split[1]) {
-            return [opcode, addr + 1];
+            return [split[0], addr + 1];
         }
         let param = split[1] || "";
         let suffix = "";
@@ -1034,6 +1059,14 @@ class Disassemble6502 {
             }
             case "zp":
                 return [`${split[0]} $${hexbyte(this.cpu.peekmem(addr + 1))}${suffix}`, addr + 2];
+            case "zp,branch": {
+                const destAddr = addr + signExtend(this.cpu.peekmem(addr + 2)) + 3;
+                return [
+                    `${split[0]} $${hexbyte(this.cpu.peekmem(addr + 1))}, $${formatJumpAddr(destAddr)}`,
+                    addr + 3,
+                    destAddr,
+                ];
+            }
             case "(,x)":
                 return [`${split[0]} ($${hexbyte(this.cpu.peekmem(addr + 1))}, X)${suffix}`, addr + 2];
             case "()": {
@@ -1056,11 +1089,60 @@ class Disassemble6502 {
                 return [`${split[0]} ($${formatJumpAddr(destAddr)},x)${suffix}`, addr + 3, indDest];
             }
         }
-        return [opcode, addr + 1];
+        return [split.join(" "), addr + 1];
+    }
+
+    nextInstruction(address) {
+        return this.disassemble(address)[1] & 0xffff;
+    }
+
+    /**
+     * Guesses the address of the instruction before the given one by scoring
+     * each run of instructions in the preceding window that lands exactly on
+     * it: a point per "common" instruction (loads, stores, branches, compares,
+     * arithmetic and carry-set/clear that avoid unusual indexing modes) and a
+     * large boost for a run that passes through pc. Runs through undocumented
+     * opcodes are discarded. The highest-scoring run's last instruction wins;
+     * any run beats none, since a wrong parse resynchronises within a few
+     * instructions and so nearly always shares the true stream's last one.
+     * Good test cases:
+     *   Repton 2 @ 2cbb
+     *   MOS @ cfc8, and the unrolled STA abs,X screen clear @ cc63
+     * also, just starting from the back of ROM and going up...
+     */
+    prevInstruction(address, pc) {
+        const commonInstructions =
+            /(RTS|B..|JMP|JSR|LD[AXY]|ST[AXY]|TA[XY]|T[XY]A|AD[DC]|SUB|SBC|CLC|SEC|CMP|EOR|ORA|AND|INC|DEC).*/;
+        const uncommonInstructions = /.*,\s*([XY]|X\))$/;
+
+        address &= 0xffff;
+        let bestAddr = address - 1;
+        let bestScore = -1;
+        for (let startingPoint = address - PrevInstructionWindow; startingPoint !== address; startingPoint++) {
+            let score = 0;
+            let addr = startingPoint & 0xffff;
+            while (addr < address) {
+                if (!this.isDocumented(addr)) break;
+                const result = this.disassemble(addr);
+                if (addr === pc) score += 10;
+                if (result[0].match(commonInstructions) && !result[0].match(uncommonInstructions)) {
+                    score++;
+                }
+                if (result[1] === address) {
+                    if (score > bestScore) {
+                        bestScore = score;
+                        bestAddr = addr;
+                    }
+                    break;
+                }
+                addr = result[1];
+            }
+        }
+        return bestAddr & 0xffff;
     }
 }
 
-function makeCpuFunctions(cpu, opcodes, is65c12, cycleAccurate = true) {
+function makeCpuFunctions(cpu, opcodes, undocumented, is65c12, cycleAccurate = true) {
     function getInstruction(opcodeString, needsReg) {
         const split = opcodeString.split(" ");
         const opcode = split[0];
@@ -1097,7 +1179,6 @@ function makeCpuFunctions(cpu, opcodes, is65c12, cycleAccurate = true) {
                 return ig.render();
 
             case "zp":
-            case "zpx": // Seems to be enough to keep tests happy, but needs investigation.
             case "zp,x":
             case "zp,y":
                 if (arg === "zp") {
@@ -1409,7 +1490,7 @@ ${indent}`)
     Runner.prototype.run = generate6502JumpTable();
 
     return {
-        disassembler: new Disassemble6502(cpu, opcodes),
+        disassembler: new Disassemble6502(cpu, opcodes, undocumented),
         runInstruction: new Runner(),
         opcodes: opcodes,
         getInstruction: getInstruction,
@@ -1417,13 +1498,13 @@ ${indent}`)
 }
 
 export function Cpu6502(cpu, { cycleAccurate = true } = {}) {
-    return makeCpuFunctions(cpu, opcodes6502, false, cycleAccurate);
+    return makeCpuFunctions(cpu, opcodes6502, undocumented6502, false, cycleAccurate);
 }
 
 export function Cpu65c12(cpu, { cycleAccurate = true } = {}) {
-    return makeCpuFunctions(cpu, opcodes65c12, true, cycleAccurate);
+    return makeCpuFunctions(cpu, opcodes65c12, undocumented65c12, true, cycleAccurate);
 }
 
 export function Cpu65c02(cpu, { cycleAccurate = true } = {}) {
-    return makeCpuFunctions(cpu, opcodes65c02, true, cycleAccurate);
+    return makeCpuFunctions(cpu, opcodes65c02, undocumented65c02, true, cycleAccurate);
 }

package/src/cmos.js

@@ -9,11 +9,11 @@
 // STNICC-beeb to hang on the Master 128 because the WD1770 seek overran the
 // vsync window.  Confirmed by @tom-seddon (b2 emulator):
 // https://github.com/mattgodbolt/jsbeeb/issues/576
-const defaultCmos = [
+const defaultCmos = Object.freeze([
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0xeb, 0x00,
     0xc9, 0xff, 0xff, 0x12, 0x00, 0x17, 0xc8, 0x1e, 0x05, 0x00, 0x35, 0xa6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-];
+]);
 
 let timeOffset = 0;
 
@@ -82,7 +82,7 @@ export class Cmos {
         this.cmosAddr = 0;
 
         if (!this.store) {
-            this.store = defaultCmos;
+            this.store = [...defaultCmos];
         }
         if (cmosOverride) {
             this.store = cmosOverride(this.store);

package/src/jsbeeb.css

@@ -560,6 +560,39 @@ small {
   flex: none;
 }
 
+#header-bar .navbar-brand img {
+  display: block;
+}
+
+#header-bar [data-icon] > svg {
+  width: 1.15em;
+  height: 1.15em;
+  vertical-align: -0.2em;
+}
+
+/* Shrunk, the menu list wraps onto a second row; the promo yields instead, by truncating. */
+#header-bar .navbar-nav {
+  flex-shrink: 0;
+}
+
+#header-bar .navbar-text {
+  flex: 0 1 auto;
+  min-width: 0;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+#paste-form {
+  flex: 1 0 6rem;
+  min-width: 0;
+  max-width: 14rem;
+}
+
+#paste-text {
+  min-width: 0;
+}
+
 /* The only item in the header with no bound on its width, so it is the one that yields. */
 #disc-name {
   flex: 1;

package/src/main.js

@@ -9,6 +9,7 @@ import * as utils_atom from "./utils_atom.js";
 import { GamePad } from "./gamepads.js";
 import { initialise as electron } from "./app/electron.js";
 import { AudioHandler } from "./web/audio-handler.js";
+import { installIcons } from "./web/icons.js";
 import { QuickSettings } from "./web/quick-settings.js";
 import { toast } from "./web/toast.js";
 import { BuiltInImages, MediaLoader } from "./web/media-loader.js";
@@ -37,6 +38,8 @@ import { DiscVisualiser } from "./web/disc-visualiser.js";
 import { downloadDriveData } from "./dom-utils.js";
 import { parseMediaParams, processAutobootParams, processDriveTrackParams, processInputParams } from "./url-params.js";
 
+installIcons();
+
 // ------------------------------------------------------------------------
 // What the URL asked for.
 // ------------------------------------------------------------------------
@@ -50,6 +53,7 @@ let secondDiscImage = null;
 const { discImage: queryDiscImage, secondDiscImage: querySecondDisc, mmcImage } = parseMediaParams(parsedQuery);
 if (queryDiscImage) discImage = queryDiscImage;
 if (querySecondDisc) secondDiscImage = querySecondDisc;
+const defaultBootDisc = queryDiscImage ? undefined : discImage;
 const { settings: driveTracks, warnings: driveTrackWarnings } = processDriveTrackParams(parsedQuery);
 
 const extraRoms = [];
@@ -195,6 +199,7 @@ const keys = new KeyboardSetup({
         openPrinter: () => frontPanel.checkPrinterWindow(),
         pause: () => loop.stop(false),
         resume: () => loop.go(),
+        paste: (text) => keys.sendRawKeyboard(autoBoot.stringToMachineKeys(text), true),
         onAnyKeyDown: () => {
             audioHandler.tryResume();
             inputs.ensureMicrophoneRunning();
@@ -276,6 +281,7 @@ const snapshots = new SnapshotUI({
     urlState,
     modals,
     loop,
+    defaultBootDisc,
 });
 
 const inputs = new AnalogueInputs({
@@ -330,12 +336,7 @@ settings.wire({ audioHandler, display, layout, quickSettings, machine, keys, inp
 
 for (const el of document.querySelectorAll(".initially-hidden")) el.classList.remove("initially-hidden");
 
-const pastetext = document.getElementById("paste-text");
-pastetext.closest("form").addEventListener("submit", (event) => event.preventDefault());
-pastetext.addEventListener("paste", function (event) {
-    const text = event.clipboardData.getData("text/plain");
-    keys.sendRawKeyboard(autoBoot.stringToMachineKeys(text), true);
-});
+document.getElementById("paste-form").addEventListener("submit", (event) => event.preventDefault());
 
 window.addEventListener("blur", function () {
     keys.clearKeys();
@@ -392,6 +393,7 @@ document.getElementById("soft-reset").addEventListener("click", function (event)
 });
 
 document.getElementById("download-filestore-link").addEventListener("click", function () {
+    if (!processor.filestore) return;
     downloadDriveData(processor.filestore.scsi, "scsi", ".dat");
 });
 

package/src/models.js

@@ -19,9 +19,23 @@ const CpuModel = Object.freeze({
  * to any number of machines without one session's settings leaking into the next.
  */
 class Model {
-    constructor({ name, synonyms, os, cpuModel, isMaster, isAtom, swram, fdc, cmosOverride, banks, clockMhz } = {}) {
+    constructor({
+        name,
+        shortName = name,
+        synonyms,
+        os,
+        cpuModel,
+        isMaster,
+        isAtom,
+        swram,
+        fdc,
+        cmosOverride,
+        banks,
+        clockMhz,
+    } = {}) {
         if (!(clockMhz > 0)) throw new Error(`Model ${name} has no clock speed`);
         this.name = name;
+        this.shortName = shortName;
         this.synonyms = synonyms;
         this.os = os;
         this.clockMhz = clockMhz;
@@ -79,6 +93,7 @@ function pickDfs(cmos) {
 function atomModel({ name, synonyms, os, banks }) {
     return new Model({
         name,
+        shortName: "Atom",
         synonyms,
         os,
         cpuModel: CpuModel.MOS6502,
@@ -132,6 +147,7 @@ const masterSwram = [
 export const allModels = [
     new Model({
         name: "BBC B with 8271 (DFS 1.2)",
+        shortName: "BBC B",
         synonyms: ["B-DFS1.2", "BBC B with DFS 1.2"],
         os: ["os.rom", "BASIC.ROM", "b/DFS-1.2.rom"],
         cpuModel: CpuModel.MOS6502,
@@ -142,6 +158,7 @@ export const allModels = [
     }),
     new Model({
         name: "BBC B with 8271 (DFS 0.9)",
+        shortName: "BBC B",
         synonyms: ["B-DFS0.9", "B", "BBC B with DFS 0.9"],
         os: ["os.rom", "BASIC.ROM", "b/DFS-0.9.rom"],
         cpuModel: CpuModel.MOS6502,
@@ -152,6 +169,7 @@ export const allModels = [
     }),
     new Model({
         name: "BBC B with 1770 (DFS)",
+        shortName: "BBC B",
         synonyms: ["B1770"],
         os: ["os.rom", "BASIC.ROM", "b1770/dfs1770.rom", "b1770/zADFS.ROM"],
         cpuModel: CpuModel.MOS6502,
@@ -163,6 +181,7 @@ export const allModels = [
     // putting ADFS in a higher ROM slot gives it priority
     new Model({
         name: "BBC B with 1770 (ADFS)",
+        shortName: "BBC B",
         synonyms: ["B1770A"],
         os: ["os.rom", "BASIC.ROM", "b1770/zADFS.ROM", "b1770/dfs1770.rom"],
         cpuModel: CpuModel.MOS6502,
@@ -173,6 +192,7 @@ export const allModels = [
     }),
     new Model({
         name: "BBC Master 128 (DFS)",
+        shortName: "Master 128",
         synonyms: ["Master"],
         os: ["master/mos3.20"],
         cpuModel: CpuModel.CMOS65C12,
@@ -184,6 +204,7 @@ export const allModels = [
     }),
     new Model({
         name: "BBC Master 128 (ADFS)",
+        shortName: "Master 128",
         synonyms: ["MasterADFS"],
         os: ["master/mos3.20"],
         cpuModel: CpuModel.CMOS65C12,
@@ -195,6 +216,7 @@ export const allModels = [
     }),
     new Model({
         name: "BBC Master 128 (ANFS)",
+        shortName: "Master 128",
         synonyms: ["MasterANFS"],
         os: ["master/mos3.20"],
         cpuModel: CpuModel.CMOS65C12,

package/src/web/config.js

@@ -216,6 +216,9 @@ export class Config extends EventTarget {
     setModel(modelName) {
         this.model = findModel(modelName);
         for (const el of document.querySelectorAll(".bbc-model")) el.textContent = this.model.name;
+        for (const el of document.querySelectorAll(".bbc-model-short")) el.textContent = this.model.shortName;
+        const settingsLink = document.getElementById("model-settings");
+        if (settingsLink) settingsLink.title = `${this.model.name}: emulation settings`;
     }
 
     setKeyLayout(keyLayout) {

package/src/web/debug.js

@@ -382,42 +382,7 @@ export class Debugger {
     }
 
     prevInstruction(address) {
-        // Some attempt at making prevInstruction more accurate; score the sequence of instructions leading
-        // up to the target by counting all "common" instructions as a point. The highest-scoring run of
-        // instructions is picked as the most likely, and the previous from that is used. Common instructions
-        // here mean loads, stores, branches, compares, arithmetic and carry-set/clear that don't use "unusual"
-        // indexing modes like abs,X, abs,Y and (zp,X).
-        // Good test cases:
-        //   Repton 2 @ 2cbb
-        //   MOS @ cfc8
-        // also, just starting from the back of ROM and going up...
-        const commonInstructions =
-            /(RTS|B..|JMP|JSR|LD[AXY]|ST[AXY]|TA[XY]|T[XY]A|AD[DC]|SUB|SBC|CLC|SEC|CMP|EOR|ORR|AND|INC|DEC).*/;
-        const uncommonInstrucions = /.*,\s*([XY]|X\))$/;
-
-        address &= 0xffff;
-        let bestAddr = address - 1;
-        let bestScore = 0;
-        for (let startingPoint = address - 20; startingPoint !== address; startingPoint++) {
-            let score = 0;
-            let addr = startingPoint & 0xffff;
-            while (addr < address) {
-                const result = this.disassemble(addr);
-                if (result[0] === this.cpu.pc) score += 10; // huge boost if this instruction was executed
-                if (result[0].match(commonInstructions) && !result[0].match(uncommonInstrucions)) {
-                    score++;
-                }
-                if (result[1] === address) {
-                    if (score > bestScore) {
-                        bestScore = score;
-                        bestAddr = addr;
-                        break;
-                    }
-                }
-                addr = result[1];
-            }
-        }
-        return bestAddr;
+        return this.cpu.disassembler.prevInstruction(address, this.cpu.pc);
     }
 
     updatePrevMem() {
@@ -476,7 +441,7 @@ export class Debugger {
     }
 
     nextInstruction(address) {
-        return this.disassemble(address)[1] & 0xffff;
+        return this.cpu.disassembler.nextInstruction(address);
     }
 
     instrClick(e) {

package/src/web/google-drive-picker.js

@@ -28,10 +28,13 @@ export class GoogleDrivePicker {
             this.authEl.style.display = "none";
             e.preventDefault();
             const authed = await this.auth(false);
-            if (authed) this.authResolve();
-            else this.authReject(new Error("Unable to authorize Google Drive"));
+            if (authed) this.authResolve?.(true);
+            else this.authReject?.(new Error("Unable to authorize Google Drive"));
         });
 
+        // Closing the loading dialog while the auth panel waits is a cancellation, not an error.
+        document.getElementById("loading-dialog").addEventListener("hidden.bs.modal", () => this.authResolve?.(false));
+
         // Loading the Google client holds the main thread for ~100ms, so it waits for
         // someone to ask for Drive.
         document.getElementById("open-drive-link").addEventListener("click", async (e) => {
@@ -74,11 +77,21 @@ export class GoogleDrivePicker {
             console.log("Google Drive authed=", authed);
 
             if (!authed) {
-                await new Promise((resolve, reject) => {
-                    this.authResolve = resolve;
-                    this.authReject = reject;
-                    this.authEl.style.display = "";
-                });
+                let granted;
+                try {
+                    granted = await new Promise((resolve, reject) => {
+                        this.authResolve = resolve;
+                        this.authReject = reject;
+                        this.authEl.style.display = "";
+                    });
+                } finally {
+                    this.authResolve = this.authReject = null;
+                }
+                if (!granted) {
+                    console.log("Google Drive authorization dismissed");
+                    this.modals.loadingFinished();
+                    return null;
+                }
             }
 
             const ssd = await this.googleDrive.load(this.processor.fdc, cat.id, layout);
@@ -93,7 +106,8 @@ export class GoogleDrivePicker {
             return ssd;
         } catch (error) {
             console.error("Google Drive loading error:", error);
-            this.modals.loadingFinished(`Unable to load ${cat.name} from Google Drive: ${errorText(error)}`);
+            this.modals.loadingFinished();
+            throw error;
         }
     }
 
@@ -122,8 +136,14 @@ export class GoogleDrivePicker {
                 utils.noteEvent("google-drive", "click", item.name);
                 this.media.setDisc1Image(`gd:${item.id}/${item.name}`);
                 this.modal.hide();
-                const ssd = await this.load(item, this.drives.layoutForDrive(0));
-                if (ssd) this.drives.putDiscIn(0, ssd);
+                try {
+                    const ssd = await this.load(item, this.drives.layoutForDrive(0));
+                    if (ssd) this.drives.putDiscIn(0, ssd);
+                } catch (error) {
+                    toast(`Unable to load ${item.name} from Google Drive: ${errorText(error)}`, {
+                        title: "Google Drive",
+                    });
+                }
             });
         }
     }

package/src/web/icons.js

@@ -0,0 +1,42 @@
+import arrowCounterclockwise from "bootstrap-icons/icons/arrow-counterclockwise.svg?raw";
+import cassette from "bootstrap-icons/icons/cassette.svg?raw";
+import clockHistory from "bootstrap-icons/icons/clock-history.svg?raw";
+import display from "bootstrap-icons/icons/display.svg?raw";
+import floppy from "bootstrap-icons/icons/floppy.svg?raw";
+import gear from "bootstrap-icons/icons/gear.svg?raw";
+import headphones from "bootstrap-icons/icons/headphones.svg?raw";
+import pauseFill from "bootstrap-icons/icons/pause-fill.svg?raw";
+import playFill from "bootstrap-icons/icons/play-fill.svg?raw";
+import soundwave from "bootstrap-icons/icons/soundwave.svg?raw";
+import stars from "bootstrap-icons/icons/stars.svg?raw";
+import threeDots from "bootstrap-icons/icons/three-dots.svg?raw";
+import tv from "bootstrap-icons/icons/tv.svg?raw";
+import volumeUp from "bootstrap-icons/icons/volume-up.svg?raw";
+
+/** The Bootstrap Icons the page uses, by their upstream names; nothing else of the set is bundled. */
+const Icons = {
+    "arrow-counterclockwise": arrowCounterclockwise,
+    cassette,
+    "clock-history": clockHistory,
+    display,
+    floppy,
+    gear,
+    headphones,
+    "pause-fill": pauseFill,
+    "play-fill": playFill,
+    soundwave,
+    stars,
+    "three-dots": threeDots,
+    tv,
+    "volume-up": volumeUp,
+};
+
+export const IconNames = Object.freeze(Object.keys(Icons));
+
+/** Puts the named SVG inside every `[data-icon]` element under `root`; an unknown name leaves them all untouched. */
+export function installIcons(root = document) {
+    const placeholders = [...root.querySelectorAll("[data-icon]")];
+    const unknown = placeholders.find((el) => !(el.dataset.icon in Icons));
+    if (unknown) throw new Error(`No icon named ${unknown.dataset.icon}`);
+    for (const el of placeholders) el.innerHTML = Icons[el.dataset.icon];
+}

package/src/web/keyboard-setup.js

@@ -2,19 +2,22 @@ import * as utils from "../utils.js";
 import { Keyboard } from "../keyboard.js";
 import { showNotice } from "./reporting.js";
 
+const PasteBoxId = "paste-text";
+const TypingTargets = 'input, textarea, select, [contenteditable]:not([contenteditable="false"])';
+
 /** The page's keyboard: the emulated one and the browser shortcuts around it. */
 export class KeyboardSetup {
     /**
      * @param {object} opts
      * @param {object} opts.actions what each shortcut does, supplied late-bound:
      *   enterDebugger, reload, toggleFast, openRewind, openPrinter,
-     *   pause, resume, onAnyKeyDown
+     *   pause, resume, paste, onAnyKeyDown
      * @param {import("./accessibility-switches.js").AccessibilitySwitches} opts.accessibilitySwitches
      */
     constructor({ actions, accessibilitySwitches, processor, dbgr, keyLayout }) {
         const keyboard = (this.keyboard = new Keyboard({
             processor,
-            inputEnabledFunction: () => document.activeElement && document.activeElement.id === "paste-text",
+            inputEnabledFunction: () => document.activeElement && document.activeElement.id === PasteBoxId,
             keyLayout,
             dbgr,
         }));
@@ -62,6 +65,12 @@ export class KeyboardSetup {
         });
         document.addEventListener("keypress", (evt) => keyboard.keyPress(evt));
         document.addEventListener("keyup", (evt) => keyboard.keyUp(evt));
+        document.addEventListener("paste", (evt) => {
+            const target = document.activeElement;
+            if (target && target.id !== PasteBoxId && target.matches(TypingTargets)) return;
+            const text = evt.clipboardData?.getData("text/plain");
+            if (text) actions.paste(text);
+        });
     }
 
     sendRawKeyboard(keysToSend, checkCapsAndShiftLocks) {

package/src/web/machine.js

@@ -162,15 +162,17 @@ export class Machine {
         }
 
         if (discImage) {
-            startImageLoad(`disc ${discImage}`, async () =>
-                drives.putDiscIn(0, await media.loadDiscImage(discImage, drives.layoutForDrive(0))),
-            );
+            startImageLoad(`disc ${discImage}`, async () => {
+                const loadedDisc = await media.loadDiscImage(discImage, drives.layoutForDrive(0));
+                if (loadedDisc) drives.putDiscIn(0, loadedDisc);
+            });
         }
 
         if (secondDiscImage) {
-            startImageLoad(`disc ${secondDiscImage}`, async () =>
-                drives.putDiscIn(1, await media.loadDiscImage(secondDiscImage, drives.layoutForDrive(1))),
-            );
+            startImageLoad(`disc ${secondDiscImage}`, async () => {
+                const loadedDisc = await media.loadDiscImage(secondDiscImage, drives.layoutForDrive(1));
+                if (loadedDisc) drives.putDiscIn(1, loadedDisc);
+            });
         }
 
         if (tape) {

package/src/web/media-loader.js

@@ -210,8 +210,9 @@ export class MediaLoader extends EventTarget {
     }
 
     async loadSCSIFile(file) {
-        const binaryData = await readFileAsBinaryString(file);
         const { processor } = this;
+        if (!processor.filestore) return;
+        const binaryData = await readFileAsBinaryString(file);
         processor.filestore.scsi = utils.stringToUint8Array(binaryData);
 
         processor.filestore.PC = 0x400;

package/src/web/snapshot-ui.js

@@ -1,7 +1,6 @@
 import * as disc from "../fdc.js";
 import { DiscLayout } from "../disc.js";
 import { downloadBlob } from "../dom-utils.js";
-import { toast } from "./toast.js";
 import {
     createSnapshot,
     restoreSnapshot,
@@ -58,9 +57,14 @@ async function readSnapshot(arrayBuffer) {
  * where they have one, the image bytes where they do not, and CRCs for
  * saying when a source has changed underneath a state.
  */
-export function snapshotMedia(fdcDrives, params) {
+export function snapshotMedia(fdcDrives, params, defaultBootDisc) {
     const manifest = {};
+    const drive0Disc = fdcDrives[0].disc;
     if (params.disc1 || params.disc) manifest.disc1 = params.disc1 || params.disc;
+    // A default boot loads the built-in disc without naming it in the URL; record it by
+    // name so the state can reload it, but only while that disc is still in the drive.
+    else if (defaultBootDisc && drive0Disc && drive0Disc.name === defaultBootDisc && !drive0Disc.originalImageData)
+        manifest.disc1 = defaultBootDisc;
     if (params.disc2) manifest.disc2 = params.disc2;
 
     // For each drive with a disc loaded, include CRC32 for verification
@@ -84,7 +88,7 @@ export function snapshotMedia(fdcDrives, params) {
 
 /** Saving and restoring states: the menu item, the file input and the reload across a model change. */
 export class SnapshotUI {
-    constructor({ processor, model, video, media, drives, urlState, modals, loop }) {
+    constructor({ processor, model, video, media, drives, urlState, modals, loop, defaultBootDisc }) {
         this.processor = processor;
         this.model = model;
         this.video = video;
@@ -93,6 +97,7 @@ export class SnapshotUI {
         this.urlState = urlState;
         this.modals = modals;
         this.loop = loop;
+        this.defaultBootDisc = defaultBootDisc;
 
         document.getElementById("save-state").addEventListener("click", async (event) => {
             event.preventDefault();
@@ -110,22 +115,27 @@ export class SnapshotUI {
     async saveState() {
         const wasRunning = this.loop.isRunning();
         if (wasRunning) this.loop.stop(false);
+        let failure = null;
         try {
-            const manifest = snapshotMedia(this.processor.fdc.drives, this.urlState.params);
+            const manifest = snapshotMedia(this.processor.fdc.drives, this.urlState.params, this.defaultBootDisc);
             const snapshot = createSnapshot(this.processor, this.model, manifest);
             const json = snapshotToJSON(snapshot);
             const blob = await compressBlob(new Blob([json]));
             const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
             downloadBlob(blob, `jsbeeb-${this.model.name}-${timestamp}.json.gz`);
         } catch (e) {
-            this.modals.showError("saving state", e);
+            failure = e;
         }
+        // Resume before reporting failure: the error dialog pauses a running
+        // loop itself, and resumes it on close.
         if (wasRunning) this.loop.go();
+        if (failure) this.modals.showError("saving state", failure);
     }
 
     async loadStateFromFile(file, preReadBuffer) {
         const wasRunning = this.loop.isRunning();
         if (wasRunning) this.loop.stop(false);
+        let failure = null;
         try {
             const arrayBuffer = preReadBuffer || (await file.arrayBuffer());
             const snapshot = await readSnapshot(arrayBuffer);
@@ -142,9 +152,10 @@ export class SnapshotUI {
             // Force a repaint so the display updates even while paused
             this.video.paint();
         } catch (e) {
-            this.modals.showError("loading state", e);
+            failure = e;
         }
         if (wasRunning) this.loop.go();
+        if (failure) this.modals.showError("loading state", failure);
     }
 
     /** Picks up the state a cross-model reload stashed, once the matching machine is up. */
@@ -192,16 +203,38 @@ export class SnapshotUI {
                 // Retain the image bytes so subsequent saves can re-embed them.
                 loadedDisc.setOriginalImage(imageData);
             }
-            if (!loadedDisc) continue;
-
-            // Verify CRC32 if present
-            if (savedMedia[crcKey] != null && loadedDisc.originalImageCrc32 != null) {
-                if (loadedDisc.originalImageCrc32 !== savedMedia[crcKey]) {
-                    toast(
-                        `${loadedDisc.name} has changed since this state was saved. The state has been restored anyway and may not run correctly.`,
-                        { title: "Restoring state" },
+            if (!loadedDisc) {
+                if (savedMedia[crcKey] != null) {
+                    // A state may name no source (older default-boot saves); the disc
+                    // already in the drive can still satisfy the CRC, but only laid out
+                    // the way the state's dirty tracks expect.
+                    const currentDisc = this.processor.fdc.drives[driveIndex].disc;
+                    const currentLayout = currentDisc?.is40Track ? DiscLayout.expanded40 : DiscLayout.contiguous;
+                    if (
+                        currentDisc &&
+                        currentDisc.originalImageCrc32 === savedMedia[crcKey] &&
+                        currentLayout === layout
+                    )
+                        continue;
+                    const problem = savedMedia[discKey]
+                        ? `The disc for drive ${driveIndex} (${savedMedia[discKey]}) could not be reloaded`
+                        : `This state does not record where the disc in drive ${driveIndex} came from`;
+                    throw new Error(
+                        `${problem}, and the drive does not hold a matching disc. ` +
+                            `Load the right disc, then load the state again.`,
                     );
                 }
+                continue;
+            }
+
+            if (
+                savedMedia[crcKey] != null &&
+                loadedDisc.originalImageCrc32 != null &&
+                loadedDisc.originalImageCrc32 !== savedMedia[crcKey]
+            ) {
+                throw new Error(
+                    `${loadedDisc.name} has changed since this state was saved, so the state cannot be restored over it.`,
+                );
             }
 
             this.drives.putDiscIn(driveIndex, loadedDisc);