jsbeeb 1.6.0 → 1.8.0

package/README.md

@@ -10,6 +10,8 @@ and a 128K BBC Master, along with a number of different peripherals.
 ## Table of Contents
 
 - [Keyboard Mappings](#keyboard-mappings)
+- [Emulator Shortcuts](#emulator-shortcuts)
+- [Save State and Rewind](#save-state-and-rewind)
 - [Getting Set Up to Run Locally](#getting-set-up-to-run-locally)
 - [Running as a Desktop Application](#running-as-a-desktop-application)
 - [URL Parameters](#url-parameters)
@@ -33,6 +35,26 @@ The BBC had a somewhat different-looking keyboard to a modern PC, and so it's us
 To play right now, visit [https://bbc.xania.org/](https://bbc.xania.org/). To load the default disc image (Elite in this
 case), press shift-F12 (which is shift-Break on the BBC).
 
+### Emulator Shortcuts
+
+| Shortcut       | Action                          |
+| -------------- | ------------------------------- |
+| `Ctrl+Home`    | Stop and enter debugger         |
+| `Ctrl+Insert`  | Toggle turbo (fast-as-possible) |
+| `Ctrl+End`     | Pause emulation                 |
+| `Alt+PageDown` | Open rewind scrubber            |
+
+### Save State and Rewind
+
+Save and load full emulator state snapshots from the **State** menu (or `Ctrl+S` / `Ctrl+O` in the Electron app).
+
+The emulator continuously captures snapshots into a 30-slot rewind buffer (~1 per second). Open the rewind scrubber from **State > Rewind** or press **Alt+PageDown** to browse recent states as a visual filmstrip:
+
+- **Left/Right arrows** — navigate between snapshots (the main screen updates live)
+- **Click** a thumbnail to jump to that point
+- **Enter** — commit selection and close the panel
+- **Escape** — cancel and restore the original state
+
 ### Joystick Support
 
 jsbeeb supports both USB/Bluetooth gamepads and mouse-based analogue joystick emulation. Note that BBC Micro joysticks use inverted axes:
@@ -184,8 +206,6 @@ If you're looking to help:
   - Play lots of games and report issues either on [GitHub](https://github.com/mattgodbolt/jsbeeb/issues) or by email (
     matt@godbolt.org).
 - Core
-  - Save state ability
-    - Once we have this I'd love to get some "reverse step" debugging support
   - Get the "boo" of the boot "boo-beep" working (disabled currently as the JavaScript startup makes the sound
     dreadfully choppy on Chrome at least).
 - Save disc support

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "//": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": "22"
@@ -34,8 +34,8 @@
     "fflate": "^0.8.2",
     "jquery": "^4.0.0",
     "pako": "^2.1.0",
-    "smoothie": "^1.36.1",
     "sharp": "^0.34.5",
+    "smoothie": "^1.36.1",
     "underscore": "^1.13.7"
   },
   "devDependencies": {
@@ -46,6 +46,7 @@
     "eslint-plugin-prettier": "^5.5.5",
     "globals": "^17.3.0",
     "husky": "^9.1.7",
+    "jsdom": "^29.0.0",
     "lint-staged": "^16.2.7",
     "npm-run-all2": "^8.0.4",
     "pixelmatch": "^7.1.0",

package/src/6502.js

@@ -616,6 +616,7 @@ export class Cpu6502 extends Base6502 {
         this.videoCycles = 0;
 
         this.polltime = this.buildPolltime();
+        this.is1MHzAccess = this.buildIs1MHzAccess();
 
         this._debugRead = this._debugWrite = this._debugInstruction = null;
         this.debugInstruction = new DebugHook(this, "_debugInstruction");
@@ -1164,6 +1165,7 @@ export class Cpu6502 extends Base6502 {
             soundChip: this.soundChip.snapshotState(),
             acia: this.acia.snapshotState(),
             adc: this.adconverter.snapshotState(),
+            fdc: this.fdc.snapshotState(),
         };
     }
 
@@ -1212,6 +1214,11 @@ export class Cpu6502 extends Base6502 {
         this.soundChip.restoreState(state.soundChip);
         this.acia.restoreState(state.acia);
         this.adconverter.restoreState(state.adc);
+
+        // FDC state (v2+). If absent (v1 snapshot), FDC keeps its current state.
+        if (state.fdc) {
+            this.fdc.restoreState(state.fdc);
+        }
     }
 
     reset(hard) {
@@ -1275,6 +1282,7 @@ export class Cpu6502 extends Base6502 {
         this._nmiEdge = false;
         this._nmiLevel = false;
         this.halted = false;
+        this.breakpointResume = false;
         this.music5000PageSel = 0;
         this.video.reset(this, this.sysvia, hard);
         this.soundChip.reset(hard);
@@ -1290,15 +1298,30 @@ export class Cpu6502 extends Base6502 {
         this.sysvia.setKeyLayout(this.config.keyLayout);
     }
 
-    polltimeAddr(cycles, addr) {
+    polltimeAddr(cycles, addr, isWrite) {
         cycles = cycles | 0;
-        if (is1MHzAccess(addr)) {
+        if (this.is1MHzAccess(addr, isWrite)) {
             cycles += 1 + ((cycles ^ this.currentCycles) & 1);
         }
         this.polltime(cycles);
     }
 
-    // Builds commong code between polltimeSlow and polltimeFast
+    // Bake in the 1MHz bus check at construction time. On the Master, ACCCON
+    // TST (bit 6) remaps FRED, JIM, and SHEILA reads (&FC00-&FEFF) to the
+    // internal 2MHz bus, but writes still go through the external 1MHz bus.
+    // Non-Master machines just use the static address check with no ACCCON
+    // awareness.
+    buildIs1MHzAccess() {
+        if (this.model.isMaster) {
+            return (addr, isWrite) => {
+                if (!isWrite && this.acccon & 0x40 && addr >= 0xfc00 && addr < 0xff00) return false;
+                return is1MHzAccess(addr);
+            };
+        }
+        return is1MHzAccess;
+    }
+
+    // Builds common code between polltimeSlow and polltimeFast
     buildPolltime() {
         const nop = (_cycles) => {};
         const tubeStuff = (cycles) => (this.model.tube ? this.tube.execute(cycles) : nop);
@@ -1373,16 +1396,22 @@ export class Cpu6502 extends Base6502 {
     }
 
     executeInternal() {
-        let first = true;
+        // Skip the debug-instruction check on the very first instruction only
+        // when resuming from a previous breakpoint stop (so we don't immediately
+        // re-trigger the same breakpoint).  Previously this skipped the first
+        // instruction of every execute() chunk, which could miss breakpoints.
+        let skipNext = this.breakpointResume;
+        this.breakpointResume = false;
         while (!this.halted && this.currentCycles < this.targetCycles) {
             this.oldPcIndex = (this.oldPcIndex + 1) & 0xff;
             this.oldPcArray[this.oldPcIndex] = this.pc;
             this.memStatOffset = this.memStatOffsetByIFetchBank & (1 << (this.pc >>> 12)) ? 256 : 0;
             const opcode = this.readmem(this.pc);
-            if (this._debugInstruction && !first && this._debugInstruction(this.pc, opcode)) {
+            if (this._debugInstruction && !skipNext && this._debugInstruction(this.pc, opcode)) {
+                this.breakpointResume = true;
                 return false;
             }
-            first = false;
+            skipNext = false;
             this.incpc();
             this.runner.run(opcode);
             this.oldAArray[this.oldPcIndex] = this.a;

package/src/6502.opcodes.js

@@ -88,6 +88,7 @@ class InstructionGen {
         let op = `cpu.writemem(${addr}, ${reg});`;
         if (spurious) op += " // spurious";
         this.append(this.cycle, op, true, addr);
+        this.ops[this.cycle].isWrite = true;
     }
 
     zpReadOp(addr, reg) {
@@ -129,7 +130,8 @@ class InstructionGen {
             }
             if (this.cycleAccurate && toSkip && this.ops[i].exact) {
                 if (this.ops[i].addr) {
-                    out.push(`cpu.polltimeAddr(${toSkip}, ${this.ops[i].addr});`);
+                    const isWrite = this.ops[i].isWrite ? "true" : "false";
+                    out.push(`cpu.polltimeAddr(${toSkip}, ${this.ops[i].addr}, ${isWrite});`);
                 } else {
                     out.push(`cpu.polltime(${toSkip});`);
                 }
@@ -140,7 +142,8 @@ class InstructionGen {
         }
         if (toSkip) {
             if (this.cycleAccurate && this.ops[this.cycle] && this.ops[this.cycle].addr) {
-                out.push(`cpu.polltimeAddr(${toSkip}, ${this.ops[this.cycle].addr});`);
+                const isWrite = this.ops[this.cycle].isWrite ? "true" : "false";
+                out.push(`cpu.polltimeAddr(${toSkip}, ${this.ops[this.cycle].addr}, ${isWrite});`);
             } else {
                 out.push(`cpu.polltime(${toSkip});`);
             }
@@ -1151,7 +1154,9 @@ function makeCpuFunctions(cpu, opcodes, is65c12, cycleAccurate = true) {
                         // so I read the non-carry here.
                         if (!op.rotate) ig.ifFalse.readOp("addrNonCarry", "REG");
                         ig.readOp("addrWithCarry", "REG");
-                        ig.writeOp("addrWithCarry", "REG");
+                        // 65c12 does "two reads and one write" for RMW (not the 6502's
+                        // "one read and two writes"). The spurious cycle is a read.
+                        ig.readOp("addrWithCarry", "", true);
                     } else {
                         // For RMW we always have a spurious read and then a spurious read or write
                         ig.readOp("addrNonCarry");
@@ -1236,11 +1241,19 @@ function makeCpuFunctions(cpu, opcodes, is65c12, cycleAccurate = true) {
                     ig.readOp("addrWithCarry", "REG");
                     ig.spuriousOp("addrWithCarry", "REG");
                 } else if (op.write) {
-                    // Pure stores still exhibit a read at the non-carried address.
-                    ig.readOp("addrNonCarry");
-                    if (op.zpQuirk) {
-                        // with this quirk on undocumented instructions, a page crossing writes to 00XX
-                        ig.append("if (addrWithCarry !== addrNonCarry) addrWithCarry &= 0xff;");
+                    if (is65c12) {
+                        // On the 65c12, the dead cycle reads the Previous Bus Address (PBA)
+                        // rather than the partially-formed or target address. Since PBA is
+                        // always a zero-page or instruction-fetch address (2MHz), it never
+                        // triggers 1MHz bus stretching. We model this as tick(1).
+                        ig.tick(1);
+                    } else {
+                        // Pure stores still exhibit a read at the non-carried address.
+                        ig.readOp("addrNonCarry");
+                        if (op.zpQuirk) {
+                            // with this quirk on undocumented instructions, a page crossing writes to 00XX
+                            ig.append("if (addrWithCarry !== addrNonCarry) addrWithCarry &= 0xff;");
+                        }
                     }
                 }
                 ig.append(op.op);

package/src/app/app.js

@@ -254,6 +254,11 @@ const template = [
                 },
             },
             { type: "separator" },
+            {
+                label: "Rewind...",
+                click: sendAction("rewind"),
+            },
+            { type: "separator" },
             {
                 label: "Soft Reset",
                 click: sendAction("soft-reset"),

package/src/disc-drive.js

@@ -368,4 +368,37 @@ export class DiscDrive extends BaseDiscDrive {
     _checkTrackNeedsWrite() {
         if (this.disc) this.disc.flushWrites();
     }
+
+    snapshotState() {
+        return {
+            track: this._track,
+            isSideUpper: this._isSideUpper,
+            headPosition: this._headPosition,
+            pulsePosition: this._pulsePosition,
+            in32usMode: this._in32usMode,
+            spinning: this._spinning,
+            is40Track: this._is40Track,
+            timerTaskOffset: this._timer.scheduled() ? this._timer.expireEpoch - this._scheduler.epoch : null,
+            disc: this._disc ? this._disc.snapshotState() : null,
+        };
+    }
+
+    restoreState(state) {
+        this._track = state.track;
+        this._isSideUpper = state.isSideUpper;
+        this._headPosition = state.headPosition;
+        this._pulsePosition = state.pulsePosition;
+        this._in32usMode = state.in32usMode;
+        this._is40Track = state.is40Track;
+
+        // Restore spinning state and timer
+        this._timer.cancel();
+        this._spinning = state.spinning;
+        if (state.timerTaskOffset !== null) this._timer.schedule(state.timerTaskOffset);
+
+        // Restore disc data if present
+        if (state.disc && this._disc) {
+            this._disc.restoreState(state.disc);
+        }
+    }
 }

package/src/disc.js

@@ -3,30 +3,23 @@
 
 import * as utils from "./utils.js";
 
-/*
- * TODO: use in fingerprinting
-class Crc32Builder {
-    constructor() {
-        this._crc = 0xffffffff;
-    }
-
-    add(data) {
-        for (let i = 0; i < data.length; ++i) {
-            const byte = data[i];
-            this._crc ^= byte;
-            for (let j = 0; j < 8; ++j) {
-                const doEor = this._crc & 1;
-                this._crc = this._crc >>> 1;
-                if (doEor) this._crc ^= 0xedb88320;
-            }
+/**
+ * Compute CRC32 of a Uint8Array.
+ * @param {Uint8Array} data
+ * @returns {number} CRC32 as a signed 32-bit integer
+ */
+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;
         }
     }
-
-    get crc() {
-        return ~this._crc;
-    }
+    return ~crc;
 }
-*/
 class TrackBuilder {
     /**
      * @param {Track} track
@@ -747,6 +740,27 @@ export class Disc {
         this.writeTrackCallback = undefined;
         this.isWriteable = isWriteable;
 
+        // Track which tracks have been written since the last snapshot.
+        // Keys are numeric: (track | (isSideUpper ? 0x100 : 0)).
+        this._snapshotDirtyTracks = new Set();
+        // Cumulative set of all tracks ever written since disc load (never cleared by snapshots).
+        // Same key encoding as _snapshotDirtyTracks.
+        this._everDirtyTracks = new Set();
+        // Cache of the previous snapshot's track data for structural sharing.
+        // Keys are "side:trackNum" strings, values are {pulses2Us, length} objects.
+        this._lastTrackSnapshots = Object.create(null);
+
+        // Original disc image data, stored for embedding in save-to-file snapshots
+        // and CRC32 verification on restore. _originalImageData is only set for
+        // local-file discs (not URL-sourced ones). _originalImageCrc32 is the CRC
+        // of the image bytes at load time — it is not updated if an onChange handler
+        // mutates the backing store. This is fine because the CRC is compared against
+        // the same source that would be reloaded (the original image or URL), not the
+        // mutated copy. If a mutable source URL were added in future, CRC verification
+        // should be skipped or the CRC updated accordingly.
+        this._originalImageData = null;
+        this._originalImageCrc32 = null;
+
         this.initSurface(0);
     }
 
@@ -754,6 +768,39 @@ export class Disc {
         this.writeTrackCallback = callback;
     }
 
+    /**
+     * Record the CRC32 of the original disc image for verification on restore.
+     * Called by discFor() after loading. Does not retain the image bytes.
+     * @param {Uint8Array} data - the raw disc image bytes (used only to compute CRC32)
+     */
+    setOriginalImageCrc32(data) {
+        this._originalImageCrc32 = crc32(data);
+    }
+
+    /**
+     * Store the original disc image bytes for embedding in snapshots.
+     * Only call this for local-file discs — URL-sourced discs should use
+     * setOriginalImageCrc32() instead to avoid retaining the full image.
+     * Computes CRC32 only if not already set (e.g. by discFor).
+     * @param {Uint8Array} data - the raw disc image bytes
+     */
+    setOriginalImage(data) {
+        this._originalImageData = data;
+        if (this._originalImageCrc32 == null) {
+            this._originalImageCrc32 = crc32(data);
+        }
+    }
+
+    /** @returns {Uint8Array|null} the original disc image bytes, or null if not set */
+    get originalImageData() {
+        return this._originalImageData;
+    }
+
+    /** @returns {number|null} CRC32 of the original disc image, or null if not set */
+    get originalImageCrc32() {
+        return this._originalImageCrc32;
+    }
+
     get writeProtected() {
         return !this.isWriteable;
     }
@@ -797,7 +844,9 @@ export class Disc {
     writePulses(isSideUpper, track, position, pulses) {
         const trackObj = this.getTrack(isSideUpper, track);
         if (position >= trackObj.length)
-            throw new Error(`Attempt to write off end of track ${position} > ${track.length}`);
+            throw new Error(
+                `Attempt to write off end of track ${track}: position ${position} >= length ${trackObj.length}`,
+            );
         if (this.isDirty) {
             if (isSideUpper !== this.dirtySide || track !== this.dirtyTrack)
                 throw new Error("Switched dirty track or side");
@@ -805,6 +854,11 @@ export class Disc {
         this.isDirty = true;
         this.dirtySide = isSideUpper;
         this.dirtyTrack = track;
+        // Numeric key avoids string allocation on every pulse write.
+        // Upper bit encodes side, lower 8 bits encode track number.
+        const dirtyKey = track | (isSideUpper ? 0x100 : 0);
+        this._snapshotDirtyTracks.add(dirtyKey);
+        this._everDirtyTracks.add(dirtyKey);
         trackObj.pulses2Us[position] = pulses;
         // TODO a debug log flag for this
         // console.log(`wrote to ${track}:${position * 32}`);
@@ -827,6 +881,106 @@ export class Disc {
         this.setTrackUsed(dirtySide, dirtyTrack);
     }
 
+    /**
+     * Create a snapshot of all track data with structural sharing.
+     * Clean tracks reuse references from the previous snapshot;
+     * dirty tracks get fresh copies.
+     */
+    snapshotState() {
+        const numSides = this.isDoubleSided ? 2 : 1;
+        // Use a plain object for JSON serialization compatibility.
+        // Keys are "side:trackNum" strings.
+        const tracks = Object.create(null);
+        for (let side = 0; side < numSides; ++side) {
+            for (let trackNum = 0; trackNum < this.tracksUsed; ++trackNum) {
+                const key = `${side === 1}:${trackNum}`;
+                const dirtyKey = trackNum | (side === 1 ? 0x100 : 0);
+                const trackObj = this.getTrack(side === 1, trackNum);
+                if (this._snapshotDirtyTracks.has(dirtyKey) || !this._lastTrackSnapshots[key]) {
+                    // Dirty or first snapshot: copy the track data
+                    tracks[key] = {
+                        pulses2Us: trackObj.pulses2Us.slice(),
+                        length: trackObj.length,
+                    };
+                } else {
+                    // Clean: reuse the previous snapshot's reference
+                    tracks[key] = this._lastTrackSnapshots[key];
+                }
+            }
+        }
+
+        this._snapshotDirtyTracks.clear();
+        this._lastTrackSnapshots = tracks;
+
+        return {
+            tracksUsed: this.tracksUsed,
+            isDoubleSided: this.isDoubleSided,
+            isWriteable: this.isWriteable,
+            name: this.name,
+            tracks,
+            // Expose for save-to-file snapshots to identify dirty tracks.
+            // This is a Set and won't survive JSON serialization — it's only
+            // used by createSnapshot() before the snapshot is serialized.
+            _everDirtyTracks: new Set(this._everDirtyTracks),
+            _originalImageData: this._originalImageData,
+            _originalImageCrc32: this._originalImageCrc32,
+        };
+    }
+
+    /**
+     * Restore disc track data from a snapshot.
+     * For save-to-file snapshots, `state.tracks` is empty and `state.dirtyTracks`
+     * contains only the tracks modified since disc load. The base disc data must
+     * already be loaded before calling this method.
+     */
+    restoreState(state) {
+        this.tracksUsed = state.tracksUsed;
+        this.isDoubleSided = state.isDoubleSided;
+        this.isWriteable = state.isWriteable;
+        this.name = state.name;
+
+        // Reset write-in-progress state
+        this.isDirty = false;
+        this.dirtySide = -1;
+        this.dirtyTrack = -1;
+        this._snapshotDirtyTracks.clear();
+        // Restore _everDirtyTracks from the snapshot if present (rewind path —
+        // the Set is carried in-memory but won't survive JSON serialization).
+        // For the save-to-file path, _everDirtyTracks is rebuilt from dirtyTracks below.
+        if (state._everDirtyTracks instanceof Set) {
+            this._everDirtyTracks = new Set(state._everDirtyTracks);
+        } else {
+            this._everDirtyTracks.clear();
+        }
+
+        // Restore full track data (rewind path — tracks contains all data)
+        this._lastTrackSnapshots = state.tracks;
+        for (const key of Object.keys(state.tracks)) {
+            const trackData = state.tracks[key];
+            const [sideStr, trackNumStr] = key.split(":");
+            const isSideUpper = sideStr === "true";
+            const trackNum = parseInt(trackNumStr, 10);
+            const trackObj = this.getTrack(isSideUpper, trackNum);
+            trackObj.pulses2Us.set(trackData.pulses2Us);
+            trackObj.length = trackData.length;
+        }
+
+        // Apply dirty track overlays (save-to-file path — base disc already loaded,
+        // overlay only the tracks that were written since disc load)
+        if (state.dirtyTracks) {
+            for (const key of Object.keys(state.dirtyTracks)) {
+                const trackData = state.dirtyTracks[key];
+                const [sideStr, trackNumStr] = key.split(":");
+                const isSideUpper = sideStr === "true";
+                const trackNum = parseInt(trackNumStr, 10);
+                const trackObj = this.getTrack(isSideUpper, trackNum);
+                trackObj.pulses2Us.set(trackData.pulses2Us);
+                trackObj.length = trackData.length;
+                this._everDirtyTracks.add(trackNum | (isSideUpper ? 0x100 : 0));
+            }
+        }
+    }
+
     logSummary() {
         const maxTrack = this.tracksUsed;
         const numSides = this.isDoubleSided ? 2 : 1;

package/src/fdc.js

@@ -212,7 +212,9 @@ export function guessDiscTypeFromName(name) {
  */
 export function discFor(fdc, name, stringData, onChange) {
     const data = typeof stringData !== "string" ? stringData : utils.stringToUint8Array(stringData);
-    return guessDiscTypeFromName(name).loader(new Disc(true, new DiscConfig(), name), data, onChange);
+    const disc = guessDiscTypeFromName(name).loader(new Disc(true, new DiscConfig(), name), data, onChange);
+    disc.setOriginalImageCrc32(data instanceof Uint8Array ? data : new Uint8Array(data));
+    return disc;
 }
 
 export function localDisc(fdc, name) {

package/src/intel-fdc.js

@@ -1670,6 +1670,71 @@ export class IntelFdc {
         this._doWriteRun(callContext, 0xff);
     }
 
+    snapshotState() {
+        const scheduler = this._timerTask.scheduler;
+        return {
+            regs: this._regs.slice(),
+            status: this._status,
+            isResultReady: this._isResultReady,
+            mmioData: this._mmioData,
+            mmioClocks: this._mmioClocks,
+            driveOut: this._driveOut,
+            shiftRegister: this._shiftRegister,
+            numShifts: this._numShifts,
+            state: this._state,
+            stateCount: this._stateCount,
+            stateIsIndexPulse: this._stateIsIndexPulse,
+            crc: this._crc,
+            onDiscCrc: this._onDiscCrc,
+            paramCallback: this._paramCallback,
+            indexPulseCallback: this._indexPulseCallback,
+            timerState: this._timerState,
+            callContext: this._callContext,
+            didSeekStep: this._didSeekStep,
+            timerTaskOffset: this._timerTask.scheduled() ? this._timerTask.expireEpoch - scheduler.epoch : null,
+            drives: this._drives.map((d) => d.snapshotState()),
+        };
+    }
+
+    restoreState(state) {
+        this._regs.set(state.regs);
+        this._status = state.status;
+        this._isResultReady = state.isResultReady;
+        this._mmioData = state.mmioData;
+        this._mmioClocks = state.mmioClocks;
+        this._driveOut = state.driveOut;
+        this._shiftRegister = state.shiftRegister;
+        this._numShifts = state.numShifts;
+        this._state = state.state;
+        this._stateCount = state.stateCount;
+        this._stateIsIndexPulse = state.stateIsIndexPulse;
+        this._crc = state.crc;
+        this._onDiscCrc = state.onDiscCrc;
+        this._paramCallback = state.paramCallback;
+        this._indexPulseCallback = state.indexPulseCallback;
+        this._timerState = state.timerState;
+        this._callContext = state.callContext;
+        this._didSeekStep = state.didSeekStep;
+
+        // Restore drives
+        for (let i = 0; i < this._drives.length; i++) {
+            this._drives[i].restoreState(state.drives[i]);
+        }
+
+        // Derive _currentDrive from _driveOut
+        this._currentDrive = null;
+        const selectBits = this._driveOut & DriveOut.selectFlags;
+        if (selectBits === DriveOut.select_0) this._currentDrive = this._drives[0];
+        else if (selectBits === DriveOut.select_1) this._currentDrive = this._drives[1];
+
+        // Restore timer
+        this._timerTask.cancel();
+        if (state.timerTaskOffset !== null) this._timerTask.schedule(state.timerTaskOffset);
+
+        // NMI level is saved/restored by the CPU snapshot directly,
+        // so we don't reassert it here.
+    }
+
     /// jsbeeb compatibility stuff
     /**
      *

package/src/jsbeeb.css

@@ -352,6 +352,72 @@ small {
   pointer-events: auto;
 }
 
+/* Rewind scrubber panel */
+#rewind-panel {
+  position: fixed;
+  bottom: 40px;
+  left: 0;
+  right: 0;
+  background: rgba(0, 0, 0, 0.85);
+  border-top: 1px solid #555;
+  z-index: 10;
+  padding: 8px 12px;
+}
+
+.rewind-header {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 6px;
+}
+
+.rewind-title {
+  color: #ccc;
+  font-size: 12px;
+  font-weight: bold;
+}
+
+.rewind-filmstrip {
+  display: flex;
+  gap: 6px;
+  overflow-x: auto;
+  padding: 4px 0;
+}
+
+.rewind-thumb {
+  flex: 0 0 auto;
+  cursor: pointer;
+  border: 2px solid transparent;
+  border-radius: 3px;
+  position: relative;
+  transition: border-color 0.15s;
+}
+
+.rewind-thumb:hover {
+  border-color: #aaa;
+}
+
+.rewind-thumb.selected {
+  border-color: #4af;
+}
+
+.rewind-thumb canvas {
+  display: block;
+  border-radius: 2px;
+}
+
+.rewind-thumb-label {
+  position: absolute;
+  bottom: 2px;
+  right: 4px;
+  font-size: 10px;
+  color: #fff;
+  text-shadow:
+    0 0 3px #000,
+    0 0 6px #000;
+  pointer-events: none;
+}
+
 div.smoothie-chart-tooltip {
   background: #444;
   padding: 1em;