@henols/c64-re-tools 2.1.1 → 2.1.3

package/skills/c64-unpacker/scripts/lib/machine.ts

@@ -2,8 +2,14 @@
 // 0-3, the chip registers read without side effects, and the vectors. The
 // capture and loads commands of the unpacker share it.
 
+import { readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
 import { formatC64Address } from "#src/c64.ts";
+import { resetToReady } from "#src/host-client/entry-state.ts";
+import { writeRefusal } from "#src/host-client/transfer.ts";
 import type { ViceSessionClient } from "#src/host-client/vice-session.ts";
+import { projectRoot, resolveProjectPath } from "#src/project.ts";
 
 type Registers = Awaited<ReturnType<ViceSessionClient["registersGet"]>>;
 
@@ -61,8 +67,34 @@ export function vectorsOf(state: MachineState, memory: Buffer) {
   };
 }
 
-/** The content of entry_state.json; `differsFromReset` only when the caller compared with a clean reset. */
-export function entryState(registers: Registers, state: MachineState, vectors: ReturnType<typeof vectorsOf>, differsFromReset?: Array<{ address: string; entry: number; reset: number }>) {
+/** The state of a clean machine at the READY prompt after a hard reset: what differsFromReset compares with. It resets the machine. */
+export async function readyState(client: ViceSessionClient): Promise<MachineState> {
+  await resetToReady(client);
+  return machineState(client);
+}
+
+/** The bytes that differ from a clean machine: the CPU port, pages 0-3 from $0002, and the I/O areas. */
+export function differsFrom(state: MachineState, clean: MachineState): Array<{ address: string; entry: number; reset: number }> {
+  const differs: Array<{ address: string; entry: number; reset: number }> = [];
+  const compare = (base: number, entry: Buffer, reset: Buffer) => entry.forEach((value, offset) => value !== reset[offset] && differs.push({ address: formatC64Address(base + offset), entry: value, reset: reset[offset]! }));
+  compare(0x0000, state.port, clean.port);
+  compare(0x0002, state.pages.subarray(2), clean.pages.subarray(2));
+  for (const [name, [address]] of Object.entries(IO_AREAS)) compare(address, state.io[name as keyof typeof IO_AREAS], clean.io[name as keyof typeof IO_AREAS]);
+  return differs;
+}
+
+/**
+ * entry_state.json, the one writer of capture and loads: the state at the
+ * entry, and what differs from `clean` (readyState). Gives the file and the
+ * count of differing bytes.
+ */
+export function entryStateFile(registers: Registers, state: MachineState, vectors: ReturnType<typeof vectorsOf>, clean: MachineState): { bytes: Buffer; differsFromReset: number } {
+  const differs = differsFrom(state, clean);
+  return { bytes: json(entryState(registers, state, vectors, differs)), differsFromReset: differs.length };
+}
+
+/** The content of entry_state.json. */
+function entryState(registers: Registers, state: MachineState, vectors: ReturnType<typeof vectorsOf>, differsFromReset: Array<{ address: string; entry: number; reset: number }>) {
   return {
     registers: { pc: formatC64Address(registers.pc), a: registers.a, x: registers.x, y: registers.y, sp: registers.sp, flags: registers.flags },
     cpuPort: { $00: state.port[0], $01: state.port[1] },
@@ -71,8 +103,34 @@ export function entryState(registers: Registers, state: MachineState, vectors: R
     // The CIA latches and interrupt masks: write-only on the chip, so the I/O bytes do not hold them.
     cia: state.cia,
     vectors,
-    ...(differsFromReset === undefined ? {} : { differsFromReset }),
+    differsFromReset,
   };
 }
 
+/** The names of the files that a capture writes for its content: a PRG for each segment, and the drive RAM. */
+const CAPTURE_FILE = /^(?:segment-[0-9a-f]{4}-[0-9a-f]{4}\.prg|drive8\.prg)$/;
+
+/**
+ * Removes from the capture folder `folder` (a project path) each file that an
+ * earlier capture wrote and this capture did not: a segment PRG of another
+ * range, or the drive RAM. image.json lists only the files of this capture.
+ * Every other file stays. Gives the removed files as project paths.
+ */
+export function removeStaleFiles(folder: string, written: readonly string[]): string[] {
+  const path = resolveProjectPath(folder, projectRoot());
+  const removed: string[] = [];
+  for (const entry of readdirSync(path, { withFileTypes: true })) {
+    // A symbolic link is not a file of a capture: it stays.
+    if (!entry.isFile() || !CAPTURE_FILE.test(entry.name) || written.includes(entry.name)) continue;
+    const file = `${folder}/${entry.name}`;
+    try {
+      rmSync(join(path, entry.name));
+    } catch (error) {
+      throw writeRefusal(error, file, "--out") ?? error;
+    }
+    removed.push(file);
+  }
+  return removed.sort();
+}
+
 export const json = (value: unknown) => Buffer.from(`${JSON.stringify(value, null, 2)}\n`);

package/skills/c64-unpacker/scripts/lib/stages.ts

@@ -93,25 +93,33 @@ export function executedIn(map: Uint8Array, block: AddressRange): AddressRange[]
   return ranges;
 }
 
+/** Pages 0-3 ($0000-$03ff) are in entry_state.json: a written block that is all in them is no segment. */
+export const FIRST_SEGMENT_ADDRESS = 0x0400;
+
 /**
  * The segments of a capture: the blocks that the stages wrote, without loader
- * leftovers, joined into ranges that do not overlap or touch. A block
+ * leftovers and without blocks that are all in pages 0-3 (the entry state
+ * holds them), joined into ranges that do not overlap or touch. A block
  * is a leftover when it holds the entry of an intermediate stage that started
  * after the block's writer, and no write from that stage on replaced the code
  * at that entry. Code that a stage ran before a later stage wrote over
  * it never drops a block, and the block that holds the capture entry is always
- * a segment. The filter comes before the join: a join first would drop the
- * program with a leftover. `writtenBy` is the last stage that wrote into the
- * range.
+ * a segment. A block that an intermediate stage wrote inside a leftover, for
+ * example a variable of the loader, is a leftover too. The filter comes before
+ * the join: a join first would drop the program with a leftover. `writtenBy` is
+ * the last stage that wrote into the range.
  */
 export function captureSegments(stages: ReadonlyArray<{ entry: number; wrote: readonly AddressRange[] }>, entry: number): Array<AddressRange & { writtenBy: number }> {
   const last = stages.length - 1;
   const replaced = (from: number, address: number) => stages.slice(from).some((stage) => inRanges(stage.wrote, address));
   const leftover = (block: AddressRange, writer: number) =>
     !contains(block, entry) && stages.some((stage, index) => index > writer && index < last && contains(block, stage.entry) && !replaced(index, stage.entry));
-  const blocks = stages
-    .flatMap((stage, index) => stage.wrote.map((range) => ({ start: range.start, end: range.end, writtenBy: index })))
-    .filter((block) => !leftover(block, block.writtenBy))
+  const written = stages.flatMap((stage, index) => stage.wrote.map((range) => ({ start: range.start, end: range.end, writtenBy: index })));
+  const leftovers = written.filter((block) => leftover(block, block.writtenBy));
+  const inLeftover = (block: AddressRange & { writtenBy: number }) =>
+    block.writtenBy < last && !contains(block, entry) && leftovers.some((left) => block.start >= left.start && block.end <= left.end);
+  const blocks = written
+    .filter((block) => !leftover(block, block.writtenBy) && !inLeftover(block) && (block.end >= FIRST_SEGMENT_ADDRESS || contains(block, entry)))
     .sort((a, b) => a.start - b.start);
   const segments: Array<AddressRange & { writtenBy: number }> = [];
   for (const block of blocks) {

package/skills/c64-unpacker/scripts/unpacker.ts

@@ -9,7 +9,6 @@
 import { type AddressRange, COVERAGE, EXECUTE, formatC64Address, READ, WRITE } from "#src/c64.ts";
 import { autostartLoaded, LOAD_LIMIT_FRAMES, RUN_LIMIT_FRAMES, typeRun } from "#src/host-client/autostart.ts";
 import { readCoverage, writtenBlocks } from "#src/host-client/coverage.ts";
-import { resetToReady } from "#src/host-client/entry-state.ts";
 import { readActionSteps, runActionStep, type ActionStep } from "#src/host-client/steps.ts";
 import { WireFailure } from "#src/host-client/tools.ts";
 import { readPrg } from "#src/host-client/image.ts";
@@ -20,7 +19,7 @@ import { listed, OPTIONS, runScript, UsageError, type Call, type CommandSpec, ty
 import { basicStart, inspect, readMemoryMap, underRom, writtenThenExecuted } from "./lib/evidence.ts";
 import { loads, readLoadSteps } from "./lib/loads.ts";
 import { callReturn, captureSegments, executedIn, inRanges, mergeMaps, stageCandidates, stagePoints, withoutRanges } from "./lib/stages.ts";
-import { entryState, IO_AREAS, json, machineState, readRam, vectorsOf } from "./lib/machine.ts";
+import { entryStateFile, machineState, readRam, readyState, removeStaleFiles, vectorsOf } from "./lib/machine.ts";
 
 /** Written-then-executed bytes from this many on are unpacking, decrypting or relocating, not self-changing code. */
 const UNPACKED_BYTES = 256;
@@ -165,6 +164,13 @@ async function firstPcAfterBasic(client: ViceSessionClient, from: number, to: nu
   return from > to ? undefined : firstPcIn(client, [{ start: from, end: to }]);
 }
 
+/**
+ * What a stage wrote: every written block, also a small one. --min-stage
+ * decides only where a stage starts; the wrote list and the capture segments
+ * keep each byte that a stage wrote.
+ */
+const stageWrote = (map: Uint8Array) => writtenBlocks(map, 1);
+
 /** Frames between two looks at the memory map while stages are followed. */
 const STAGE_CHUNK_FRAMES = 25;
 const MAX_STAGES = 16;
@@ -238,7 +244,7 @@ async function follow(
   let stage = { map: new Uint8Array(0x10000), own: new Set<number>(), called: [] as AddressRange[] };
   const startStage = async (next: number, last: Uint8Array) => {
     mergeMaps(stage.map, last);
-    found.push({ entry, firstFrame, frames: total - firstFrame, wrote: writtenBlocks(stage.map, options.minStage), next });
+    found.push({ entry, firstFrame, frames: total - firstFrame, wrote: stageWrote(stage.map), next });
     entry = next;
     firstFrame = total;
     stage = { map: new Uint8Array(0x10000), own: new Set<number>(), called: [] };
@@ -428,7 +434,7 @@ async function follow(
   else reached = await trackTo(options.until, left);
   await client.snapshot({ action: "remove", name: STAGE_SNAPSHOT }).catch(() => undefined);
   mergeMaps(stage.map, await readCoverage(client));
-  found.push({ entry, firstFrame, frames: total - firstFrame, wrote: writtenBlocks(stage.map, options.minStage) });
+  found.push({ entry, firstFrame, frames: total - firstFrame, wrote: stageWrote(stage.map) });
   return { stages: found, frames: total, reached, ...(halted === undefined ? {} : { halted }) };
 }
 
@@ -529,24 +535,21 @@ async function capture(
       ),
     );
     // A clean machine at the READY prompt shows what the loader and the stages changed.
-    await resetToReady(client);
-    const clean = await machineState(client);
-    const differs: Array<{ address: string; entry: number; reset: number }> = [];
-    const compare = (base: number, entry: Buffer, reset: Buffer) => entry.forEach((value, offset) => value !== reset[offset] && differs.push({ address: formatC64Address(base + offset), entry: value, reset: reset[offset]! }));
-    compare(0x0000, state.port, clean.port);
-    compare(0x0002, state.pages.subarray(2), clean.pages.subarray(2));
-    for (const [name, [address]] of Object.entries(IO_AREAS)) compare(address, state.io[name as keyof typeof IO_AREAS], clean.io[name as keyof typeof IO_AREAS]);
-    write("entry_state.json", json(entryState(registers, state, vectors, differs)));
+    const entry = entryStateFile(registers, state, vectors, await readyState(client));
+    write("entry_state.json", entry.bytes);
+    // A capture again into the folder: the segment PRGs of the earlier capture that image.json no longer lists go.
+    const removed = removeStaleFiles(options.out, files);
     return {
       output: {
         captured: true,
         pc: formatC64Address(registers.pc),
         out: options.out,
         files: written,
+        ...(removed.length === 0 ? {} : { removed }),
         segments: segments.map(showRange),
         ...(options.exclude.length === 0 ? {} : { excluded: options.exclude.map(showRange) }),
         stages: followed.stages.length,
-        differsFromReset: differs.length,
+        differsFromReset: entry.differsFromReset,
       },
       failed: false,
     };
@@ -569,7 +572,7 @@ const entryOf = (call: Call) => {
 };
 const stepsOf = (call: Call) => {
   const path = call.string("steps");
-  return path === undefined ? [] : readActionSteps(path, "--steps");
+  return path === undefined ? [] : readActionSteps(path, "--steps", knowledgeAt());
 };
 
 const COMMANDS: CommandSpec[] = [
@@ -595,7 +598,8 @@ const COMMANDS: CommandSpec[] = [
     run: async (call) => {
       const steps = stepsOf(call);
       // A runUntil step to a raster line or a memory value cannot be tracked in chunks of frames; capture takes it.
-      if (steps.some((step) => "runUntil" in step && !trackedRunUntil(step))) throw new UsageError("stages takes a runUntil step only with an address target without a condition. Use frames steps, or capture");
+      const untracked = steps.findIndex((step) => "runUntil" in step && !trackedRunUntil(step));
+      if (untracked >= 0) throw new UsageError(`--steps ${call.string("steps")!}: step ${untracked + 1}: stages takes a runUntil step only with an address target without a condition. Use frames steps, or capture`);
       return outcome(await stages(call.subject(0), { frames: call.count("frames")!, steps, minStage: call.count("min-stage")!, ...entryOf(call) }));
     },
   },
@@ -605,7 +609,7 @@ const COMMANDS: CommandSpec[] = [
     subjects: [PROGRAM],
     options: {
       until: { kind: "address", value: "<address>", required: true, help: "the unpacked entry point" },
-      out: { ...OPTIONS.out, value: "<dir>", required: true, help: "the folder for the capture, relative to the project folder" },
+      out: { ...OPTIONS.out, output: "folder", value: "<dir>", required: true, help: "the folder for the capture, relative to the project folder" },
       range: { ...OPTIONS.range, help: "one segment in place of the found ones" },
       exclude: { kind: "range", value: "<start>-<end>", multiple: true, help: "a range to leave out of the segments, for example bytes that a crack left and the program never reads" },
       "timeout-frames": { ...OPTIONS["timeout-frames"], max: 30_000, default: 3000, help: "stop the wait for --until after n frames (default 3000)" },
@@ -632,7 +636,7 @@ const COMMANDS: CommandSpec[] = [
     subjects: [{ name: "<program>", help: "a PRG, or a disk, tape or cartridge image, relative to the project folder" }],
     options: {
       steps: { ...STEPS, required: true, help: "action steps and capture steps (JSON)" },
-      out: { ...OPTIONS.out, value: "<dir>", required: true, help: "the folder for the captures, relative to the project folder" },
+      out: { ...OPTIONS.out, output: "folder", value: "<dir>", required: true, help: "the folder for the captures, relative to the project folder" },
       drive: { kind: "flag", help: "also write the 2 KiB drive RAM as drive8.prg, for knowledge space drive8" },
       "min-block": { kind: "count", value: "<bytes>", min: 1, max: 0x10000, default: 64, help: "write a changed block of at least this many bytes (default 64)" },
     },

package/src/host/vice/adapter.ts

@@ -59,7 +59,10 @@ export function conditionExpression(condition: Condition, space: Space): string
     }
     case "memory": {
       if (condition.space !== "c64") {
-        throw new WireFailure("unsupported-in-space", "A memory condition can test only space c64 memory.");
+        throw new WireFailure(
+          "unsupported-in-space",
+          "A memory target or a memory condition tests only space c64 memory. For the drive, use a watchpoint in space drive8, or a c64_run_until address target in space drive8.",
+        );
       }
       return `(@${condition.view}:${formatC64Address(condition.address)} ${operator(condition.operator)} ${formatC64Byte(condition.value)})`;
     }

package/src/host/vice/session.ts

@@ -13,7 +13,7 @@ import { setTimeout as sleep } from "node:timers/promises";
 
 import { formatC64Address, instructionLength } from "../../c64.ts";
 import { encodePng, type IndexedFrame } from "../../graphics.ts";
-import { instructionText, operandAddress } from "../../opcodes.ts";
+import { accessedValue, instructionText, operandAddress } from "../../opcodes.ts";
 import type { ProcessSupervisor } from "../../native/processes.ts";
 import { trace } from "../../trace.ts";
 import type { ViceSessionFactory, ViceSessionHandle } from "../server.ts";
@@ -30,6 +30,8 @@ import {
 import { decodeProgramCounter, MonitorConnectionError, MonitorError, MonitorTimeoutError, ResponseType, type MonitorResponse } from "./binary-monitor.ts";
 import { decodeCia, decodeSid, decodeSprite, decodeVicii } from "./chips.ts";
 import { compareFrames, differenceImage } from "./screen.ts";
+import { isRefusal } from "../../errors.ts";
+import { checkMedia, hasSignature } from "../../media.ts";
 import { launchVice, startErrorLines, type ViceMode, type ViceProcess } from "./process.ts";
 import { TextMonitorError, TextMonitorTimeoutError } from "./text-monitor.ts";
 
@@ -78,7 +80,6 @@ const WINDOW_CLOSED =
 
 /** Emulator state that a move to another VICE cannot carry. */
 /** The first bytes of every VICE snapshot file. */
-const VSF_MAGIC = Buffer.from("VICE Snapshot File\x1a", "latin1");
 const NOT_CARRIED = ["cpu history", "memory map", "profile", "keyboard input not yet typed"];
 
 /** Starts another VICE for this session; `log` also gets that launch's lines. */
@@ -193,6 +194,28 @@ export class ViceSession implements ViceSessionHandle {
    * pc write, and reports the JAM only once.
    */
   #jammed: number | undefined;
+  /**
+   * An autostart can still be loading: VICE goes on with it after a snapshot
+   * restore and writes the program over the restored memory. Only a reset stops it.
+   */
+  #autostarting = false;
+  /** The C64 clock just after the last snapshot restore: VICE keeps the history of before it. */
+  #historySince: bigint | undefined;
+  /**
+   * A breakpoint or watchpoint stopped a step, next or until-return early. VICE
+   * keeps the rest of that step and stops the machine once more when it ends.
+   * No monitor command ends it without running the CPU, so the session takes
+   * that one stop as the end of the step and lets the machine run on.
+   */
+  #pendingStep = false;
+  /**
+   * The CPU stands at the stop of a reset without run, and nothing ran since. VICE
+   * (3.9, 3.10) stops answering at the restore of a snapshot saved here while the
+   * disk drive was busy, so a save here is refused.
+   */
+  #atResetStop = false;
+  /** The CPU that the last run stopped in, when it was the drive: status then gives the drive's pc. */
+  #stopSpace: "c64" | "drive8" = "c64";
   /** VICE records no CPU history after a JAM until the next reset. */
   #historyStopped = false;
   /** The CPU ran again after a JAM without a reset: the CPU history that VICE gives is old. */
@@ -396,6 +419,7 @@ export class ViceSession implements ViceSessionHandle {
       case "autostart": {
         const { type, index, run } = params as ViceOperations["autostart"]["params"];
         const bytes = onlyAttachment(attachments);
+        checkMedia(type, bytes);
         if (index > 0 && this.#directory !== undefined && isOneOf(DISK_IMAGE_TYPES, type)) checkDirectoryEntry(await this.#directory(type, bytes), index);
         const file = this.#stage(bytes, type);
         // VICE keeps a cartridge through every reset and autostart, as a real C64 does.
@@ -415,6 +439,7 @@ export class ViceSession implements ViceSessionHandle {
         }
         await this.#runningCommand(() => this.#machine.autostart(file, index, run));
         this.#clearJam();
+        this.#autostarting = true;
         if (type === "crt") this.#cartridge = true;
         this.#replaceStaged(stagedKind(type), file);
         // A reset sets the CPU clock back, so the stopwatch starts again.
@@ -423,7 +448,9 @@ export class ViceSession implements ViceSessionHandle {
       }
       case "diskAttach": {
         const { type } = params as ViceOperations["diskAttach"]["params"];
-        const file = this.#stage(onlyAttachment(attachments), type);
+        const bytes = onlyAttachment(attachments);
+        checkMedia(type, bytes);
+        const file = this.#stage(bytes, type);
         await this.#observe(() => this.#machine.attachDisk(file));
         this.#replaceStaged("disk", file);
         return { attached: true };
@@ -543,15 +570,23 @@ export class ViceSession implements ViceSessionHandle {
       // VICE 3.9 sends no JAM event: the opcode at the pc tells.
       const stop = this.#lastStop ?? ((await this.#jamAt(status.pc)) ? { stopReason: "jam" as const } : undefined);
       if (stop !== undefined) Object.assign(status, stop);
+      // A point in the drive stopped it: the pc is the drive's, as advance-frames and run-until give it.
+      const point = status.pointId === undefined ? undefined : (status.stopReason === "watchpoint" ? this.#watchpoints : this.#breakpoints).get(status.pointId);
+      status.space = point?.space === "drive8" || this.#stopSpace === "drive8" ? "drive8" : "c64";
+      if (status.space === "drive8") status.pc = (await this.#machine.readRegisters("drive8")).pc;
     }
     return status;
   }
 
   async #execution(params: ExecutionParams): Promise<ExecutionResult> {
+    if (params.space === "drive8" && (params.action === "pause" || params.action === "resume")) {
+      throw new WireFailure("unsupported-in-space", `${params.action} stops or runs the whole machine, the computer and the disk drive together: use space c64.`);
+    }
     if (params.action === "resume") {
       if (this.#state === "stopped") {
         await this.#refuseJammed("resume");
         await this.#resume();
+        if (this.#pendingStep) await this.#endPendingStep();
       }
       return { state: "running" };
     }
@@ -580,6 +615,7 @@ export class ViceSession implements ViceSessionHandle {
         throw new WireFailure("invalid-input", `The anchor is outside the frame: a ${this.#videoStandard} frame has lines 0-${raster.lines - 1} and cycles 0-${raster.cycles - 1}.`);
       }
       const outcome = await this.#runFrames(params.count, undefined, params.anchor);
+      this.#stopSpace = outcome.space;
       return {
         state: "stopped",
         // A stop event carries the computer's PC; a stop in the drive reports the drive's.
@@ -592,6 +628,8 @@ export class ViceSession implements ViceSessionHandle {
     }
     await this.#stop();
     await this.#refuseJammed(params.action);
+    // A new step replaces the rest of an earlier one in VICE.
+    this.#pendingStep = false;
     if (params.action === "until-return") {
       const stopped = this.#nextStop(this.#untilReturnLimitMs);
       await this.#resumingCommand(() => this.#machine.untilReturn());
@@ -603,18 +641,39 @@ export class ViceSession implements ViceSessionHandle {
           `The routine did not return within ${this.#untilReturnLimitMs / 1000} seconds. The machine is stopped at ${formatC64Address(await this.#pc())}.`,
         );
       }
-      return { state: "stopped", pc: stop.pc };
+      return { state: "stopped", pc: stop.pc, ...this.#stepStoppedByPoint() };
     }
     const count = params.count ?? 1;
+    this.#atResetStop = false;
     try {
       await this.#machine.step(count, params.action === "next", this.#stepLimitMs);
     } catch (error) {
       if (error instanceof MonitorTimeoutError) throw new StepTimeout(stepNotEnded(params.action, count, this.#stepLimitMs), error);
       throw error;
     }
-    // VICE answers a step only after the machine stopped again.
+    // VICE answers a step only after the machine stopped again; a ping reads the events of that stop (a hit point).
+    await this.#machine.stop();
     this.#state = "stopped";
-    return { state: "stopped", pc: await this.#pc(), executed: count };
+    const point = this.#stepStoppedByPoint();
+    // A point stops the step early: VICE does not tell how many instructions ran.
+    return { state: "stopped", pc: await this.#pc(), ...(point.pointId === undefined ? { executed: count } : point) };
+  }
+
+  /** The breakpoint or watchpoint that stopped a step, next or until-return early; VICE then keeps the rest of the step. */
+  #stepStoppedByPoint(): { stopReason?: PointStopReason; pointId?: number } {
+    const stop = this.#lastStop;
+    if (stop?.pointId === undefined) return {};
+    this.#pendingStep = true;
+    return { stopReason: stop.stopReason, pointId: stop.pointId };
+  }
+
+  /** After a resume: waits for the stop that ends the rest of an earlier step, and runs on. */
+  async #endPendingStep(): Promise<void> {
+    const stop = await this.#nextStop(HALF_FRAME_LIMIT_MS);
+    if (stop === undefined) return;
+    this.#pendingStep = false;
+    // A user point or a JAM stopped the machine: it stays stopped and status tells why.
+    if (stop.hits.length === 0 && this.#lastStop === undefined) await this.#resume();
   }
 
   async #reset(params: { mode: "soft" | "hard"; run: boolean }): Promise<{ state: RunState; pc?: number }> {
@@ -639,6 +698,7 @@ export class ViceSession implements ViceSessionHandle {
     if (!reached) await this.#stop();
     await this.#machine.deleteCheckpoint(checkpoint);
     if (!reached) throw new WireFailure("operation-failed", "The C64 did not reach its reset vector after the reset.");
+    this.#atResetStop = true;
     return { state: "stopped", pc: vector };
   }
 
@@ -695,6 +755,11 @@ export class ViceSession implements ViceSessionHandle {
         }
         if (end === "unknown") {
           if (await this.#jamAt(stop.pc)) return { end: "jam", frames, pc: stop.pc, space: "c64" };
+          if (this.#pendingStep) {
+            // The rest of an earlier step ended: run on.
+            this.#pendingStep = false;
+            continue;
+          }
           throw new WireFailure("operation-failed", "The emulator stopped the machine for a reason outside this run.");
         }
         // A drive stop is completed before the result names the computer's pc; `space` says which CPU stopped.
@@ -763,6 +828,10 @@ export class ViceSession implements ViceSessionHandle {
         const point = this.#userPoint(stop.hits);
         if (point !== undefined) return { hits, frames, end: point.stopReason, pc: stop.pc };
         if (await this.#jamAt(stop.pc)) return { hits, frames, end: "jam", pc: stop.pc };
+        if (this.#pendingStep) {
+          this.#pendingStep = false;
+          continue;
+        }
         throw new WireFailure("operation-failed", "The emulator stopped the machine for a reason outside this trace.");
       }
     } finally {
@@ -821,10 +890,22 @@ export class ViceSession implements ViceSessionHandle {
       frame,
       rasterLine: Math.floor(at / cycles),
       rasterCycle: at % cycles,
-      ...(address === undefined ? {} : { address, value: await byteAt(address) }),
+      ...(address === undefined ? {} : { address, ...(await this.#accessed(bytes[0]!, entry, address, byteAt)) }),
     };
   }
 
+  /**
+   * The byte of a read or write hit. A read of an I/O register after the
+   * access can give another byte than the access did (raster bits, cleared
+   * flags), so for $D000-$DFFF only a load or a store gives a value.
+   */
+  async #accessed(opcode: number, before: { a: number; x: number; y: number }, address: number, byteAt: (address: number) => Promise<number>): Promise<{ value?: number }> {
+    const after = await this.#machine.readRegisters("c64");
+    const io = address >= 0xd000 && address <= 0xdfff;
+    const value = accessedValue(opcode, before, after, io ? undefined : await byteAt(address));
+    return value === undefined ? {} : { value };
+  }
+
   /**
    * Completes a stop that a drive 8 checkpoint caused: the computer runs to
    * its next instruction boundary, where a computer checkpoint stops it, so
@@ -896,6 +977,9 @@ export class ViceSession implements ViceSessionHandle {
 
   /** A reset or an autostart starts a jammed CPU and the CPU history again. */
   #clearJam(): void {
+    this.#autostarting = false;
+    // A reset sets the clock back to 0: the history from before it is of this run again.
+    this.#historySince = undefined;
     this.#jammed = undefined;
     this.#historyStopped = false;
     this.#historyOld = false;
@@ -952,6 +1036,7 @@ export class ViceSession implements ViceSessionHandle {
       const stopReason = outcome.end === "frames" ? "timeout" : outcome.end;
       // A stop event carries the computer's PC; a stop in the drive reports the drive's.
       const pc = outcome.space === "drive8" ? (await this.#machine.readRegisters("drive8")).pc : outcome.pc;
+      this.#stopSpace = outcome.space;
       return { reached: stopReason === "target", stopReason, state: "stopped", pc, space: outcome.space, ...(outcome.pointId === undefined ? {} : { pointId: outcome.pointId }) };
     } finally {
       await this.#machine.deleteCheckpoint(checkpoint);
@@ -1007,7 +1092,10 @@ export class ViceSession implements ViceSessionHandle {
 
   #point<T>(registry: Map<number, T>, kind: string, id: number): T {
     const point = registry.get(id);
-    if (point === undefined) throw new WireFailure("not-found", `There is no ${kind} with id ${id}.`);
+    if (point === undefined) {
+      const other = kind === "breakpoint" ? (this.#watchpoints.has(id) ? "watchpoint" : undefined) : this.#breakpoints.has(id) ? "breakpoint" : undefined;
+      throw new WireFailure("not-found", `There is no ${kind} with id ${id}.${other === undefined ? "" : ` Id ${id} is a ${other}: use c64_${other}.`}`);
+    }
     return point;
   }
 
@@ -1121,9 +1209,14 @@ export class ViceSession implements ViceSessionHandle {
       );
     }
     return this.#observe(async () => {
-      const raw = await this.#machine.history(params.limit, params.space);
-      if (params.space === "drive8") return { entries: raw.map(({ clock: _clock, ...entry }) => entry) };
+      const all = await this.#machine.history(params.limit, params.space);
+      if (params.space === "drive8") {
+        // VICE records a wrong third byte for a 3-byte drive instruction ("JSR $00a6" for 20 a6 d5): the drive memory gives the bytes.
+        const memory = await this.#machine.readAll("drive8");
+        return { entries: all.map(({ clock: _clock, ...entry }) => driveEntry(entry, memory)) };
+      }
       const now = await this.#machine.clock();
+      const raw = entriesSince(all, this.#historySince, now);
       const position = await this.#machine.rasterPosition();
       const { lines, cycles } = RASTER[this.#videoStandard];
       const frame = BigInt(lines * cycles);
@@ -1197,6 +1290,13 @@ export class ViceSession implements ViceSessionHandle {
     if (params.action === "list") return { snapshots: [...this.#snapshots.keys()] };
     const existing = this.#snapshots.get(params.name);
     if (params.action === "save") {
+      if (this.#atResetStop) {
+        throw new WireFailure(
+          "operation-failed",
+          "The CPU stands at the reset stop of c64_reset with run false. The emulator stops answering at the restore of a snapshot saved here when the disk drive was busy. " +
+            "Step one instruction with c64_execution, then save the snapshot.",
+        );
+      }
       if (existing === undefined && this.#snapshots.size >= MAX_SNAPSHOTS) {
         throw new WireFailure("limit-exceeded", `A session keeps at most ${MAX_SNAPSHOTS} snapshots. Remove one first with action remove.`);
       }
@@ -1218,7 +1318,10 @@ export class ViceSession implements ViceSessionHandle {
   async #restoreFrom(file: string): Promise<{ restored: true; state: "stopped" }> {
     await this.#stop();
     const elapsed = (await this.#machine.clock()) - this.#timingStart;
+    // The restore replaces the whole machine state, so the reset that stops the autostart leaves no trace.
+    if (this.#autostarting) await this.#reset({ mode: "soft", run: false });
     await this.#machine.restoreSnapshot(file);
+    this.#historySince = await this.#machine.clock();
     // A restore starts a jammed CPU again, but VICE still records no CPU history.
     this.#jammed = undefined;
     if (this.#historyStopped) this.#historyOld = true;
@@ -1239,7 +1342,7 @@ export class ViceSession implements ViceSessionHandle {
     }
     const bytes = onlyAttachment(attachments);
     // Checked before the machine stops: VICE gives no reason for a file that is no snapshot.
-    if (!bytes.subarray(0, VSF_MAGIC.length).equals(VSF_MAGIC)) throw new WireFailure("invalid-input", "The file is not a VICE snapshot file (.vsf). Give a file that c64_snapshot save wrote.");
+    if (!hasSignature("vsf", bytes)) throw new WireFailure("invalid-input", "The file is not a VICE snapshot file (.vsf). Give a file that c64_snapshot save wrote.");
     const file = this.#stage(bytes, "vsf");
     // VICE resets the machine after a snapshot file that it cannot read: a backup keeps the state before the restore.
     const backup = join(this.#workDir, "before-restore.vsf");
@@ -1425,6 +1528,8 @@ export class ViceSession implements ViceSessionHandle {
    * arrive together, and those events must have the last word.
    */
   async #resumingCommand(send: () => Promise<void>): Promise<void> {
+    this.#atResetStop = false;
+    this.#stopSpace = "c64";
     this.#state = "running";
     this.#lastStop = undefined;
     try {
@@ -1534,6 +1639,8 @@ export class ViceSession implements ViceSessionHandle {
 
   async #translate(error: unknown, runningBefore: boolean, halts: number): Promise<unknown> {
     if (error instanceof WireFailure) return error;
+    // A refusal of a shared module (for example the media check) goes on the wire as the host's own.
+    if (isRefusal(error)) return new WireFailure(error.code, error.message);
     if (this.#closed) return new WireFailure("machine-unavailable", "The emulator session is closed.");
     if (error instanceof MonitorConnectionError || error instanceof TextMonitorError || error instanceof StepTimeout) {
       this.#log(error.message);
@@ -1614,6 +1721,32 @@ export class ViceSession implements ViceSessionHandle {
   }
 }
 
+/** A drive history entry with its bytes and text from drive memory, when the opcode there is still the one that ran. */
+export function driveEntry<T extends { address: number; bytes: string; text: string }>(entry: T, memory: Uint8Array): T {
+  const opcode = Number.parseInt(entry.bytes.slice(0, 2), 16);
+  if (memory[entry.address] !== opcode) return entry;
+  const length = instructionLength(opcode);
+  const bytes = Array.from({ length }, (_, offset) => memory[(entry.address + offset) & 0xffff]!);
+  return { ...entry, bytes: Buffer.from(bytes).toString("hex"), text: instructionText(bytes, entry.address) };
+}
+
+/**
+ * The history entries (oldest first) that the CPU executed after a restore at
+ * clock `since`, with the clock at `now`: the last entries, back to the first
+ * one outside since to now or the first one whose clock does not go up to the
+ * next. The others are of before the restore.
+ */
+export function entriesSince<T extends { clock: bigint }>(entries: readonly T[], since: bigint | undefined, now: bigint): T[] {
+  if (since === undefined) return [...entries];
+  let first = entries.length;
+  while (first > 0) {
+    const entry = entries[first - 1]!;
+    if (entry.clock < since || entry.clock > now || (first < entries.length && entry.clock >= entries[first]!.clock)) break;
+    first--;
+  }
+  return entries.slice(first);
+}
+
 /** The one attachment of an operation that takes a file (see attachmentCount); refuses any other count. */
 function onlyAttachment(attachments: Buffer[]): Buffer {
   const [bytes] = attachments;