@henols/c64-re-tools 2.0.0-rc.2 → 2.0.0-rc.21

package/src/host/tools/status.ts

@@ -1,9 +1,15 @@
 // host.status: VICE and the tools that come with it, each found the way its
 // operations find it and run once with a version option. A tool from a
 // VICE older than MIN_VICE is reported as not working, as its operations refuse it.
+// VICE itself is reported with the version that the host read from the
+// running emulator at start: the Homebrew x64sc of VICE 3.10 on macOS stops
+// on -version ("argv[0] is NULL") although the emulator runs.
 
-import type { ToolStatus } from "../../protocol/tools.ts";
-import { C1541, findTool, isOlderThanMinimum, MIN_VICE, PETCAT, VICE, viceVersionOf, type ToolSpec } from "../../native/discover.ts";
+import { arch, platform, release } from "node:os";
+
+import { PACKAGE } from "../../package.ts";
+import type { HostInfo, ToolStatus } from "../../protocol/tools.ts";
+import { C1541, findTool, isOlderThanMinimum, MIN_VICE, PETCAT, VICE, viceFlaws, viceVersionOf, type ToolSpec, type ViceVersion } from "../../native/discover.ts";
 import type { ToolContext } from "../../native/run.ts";
 import { probeTools } from "../../native/status.ts";
 import { findVice } from "../vice/process.ts";
@@ -16,15 +22,26 @@ function requireMinimum(status: ToolStatus, tool: ToolSpec): ToolStatus {
   return { ...status, runs: false, problem: `${found}, and c64-re-tools needs VICE ${MIN_VICE.major}.${MIN_VICE.minor} or later. ${tool.remedy}` };
 }
 
-export async function hostStatus(context: ToolContext): Promise<{ result: { tools: ToolStatus[] } }> {
+/** The version text of a VICE version, as x64sc -version prints it. */
+const versionText = (version: ViceVersion) => `x64sc (VICE ${version.major}.${version.minor}${version.revision === undefined ? "" : ` SVN r${version.revision}`})`;
+
+/** `started`: the version that the host read from the emulator at start; without it, VICE is probed with -version too. */
+export async function hostStatus(context: ToolContext, started?: ViceVersion): Promise<{ result: { host: HostInfo; tools: ToolStatus[] } }> {
   const specs = [VICE, C1541, PETCAT];
-  const tools = await probeTools(
+  const probed = await probeTools(
     [
-      { name: VICE.name, find: findVice, args: ["-version"], pattern: /^x64sc \(VICE \d/ },
+      ...(started === undefined ? [{ name: VICE.name, find: findVice, args: ["-version"], pattern: /^x64sc \(VICE \d/ }] : []),
       { name: C1541.name, find: (env) => findTool(C1541, env), args: ["-version"], pattern: /^c1541 \(VICE \d/ },
       { name: PETCAT.name, find: (env) => findTool(PETCAT, env), args: ["-version"], pattern: /^petcat \(VICE \d/ },
     ],
     context,
   );
-  return { result: { tools: tools.map((status, index) => requireMinimum(status, specs[index]!)) } };
+  const tools = started === undefined ? probed : [{ name: VICE.name, found: true, path: findVice(context.env ?? process.env), version: versionText(started), runs: true }, ...probed];
+  const checked = tools.map((status, index) => requireMinimum(status, specs[index]!));
+  // VICE runs with its known flaws; status names them (D56).
+  const vice = checked[0]!;
+  const version = vice.runs ? viceVersionOf(vice.version ?? "") : undefined;
+  const flaws = version === undefined ? [] : viceFlaws(version);
+  if (flaws.length > 0) checked[0] = { ...vice, flaws };
+  return { result: { host: { version: PACKAGE.version, platform: platform(), release: release(), arch: arch() }, tools: checked } };
 }

package/src/host/vice/adapter.ts

@@ -3,9 +3,11 @@
 
 import { WireFailure, type VideoStandard } from "../../protocol/messages.ts";
 import { type Comparison, type Condition, type BacktraceFrame, type HistoryEntry, type Instruction, type MemmapRange, type ProfileEntry, type JoystickState, type MemoryView, type RegisterValues, type Registers, type Space } from "../../protocol/vice.ts";
-import { formatC64Address, formatC64Byte } from "../../c64.ts";
-import { decodeDisplay, decodePalette, visibleFrame, type IndexedFrame } from "./screen.ts";
+import { COVERAGE, formatC64Address, formatC64Byte } from "../../c64.ts";
+import type { IndexedFrame } from "../../graphics.ts";
+import { decodeDisplay, decodePalette, visibleFrame } from "./screen.ts";
 import type { TextMonitor } from "./text-monitor.ts";
+import type { CiaHidden } from "./chips.ts";
 import {
   BinaryMonitor,
   Command,
@@ -135,7 +137,7 @@ export function parseDisassembly(answer: string, start: number): Instruction[] {
   for (const line of answer.split("\n")) {
     const match = /^\.(?:C|\d+):([0-9a-f]{4})\s+((?:[0-9a-f]{2} )*[0-9a-f]{2})\s+(.*?)\s*$/i.exec(line);
     if (match === null) {
-      if (line.trim() !== "") unknown.push(line.trim());
+      if (line.trim() !== "" && !CONDITION_LINE.test(line.trim())) unknown.push(line.trim());
       continue;
     }
     const address = Number.parseInt(match[1]!, 16);
@@ -164,7 +166,7 @@ export function parseHistory(answer: string): Array<Omit<HistoryEntry, "rasterLi
         line,
       );
     if (match === null) {
-      if (line.trim() !== "") unknown.push(line.trim());
+      if (line.trim() !== "" && !CONDITION_LINE.test(line.trim())) unknown.push(line.trim());
       continue;
     }
     entries.push({
@@ -193,7 +195,7 @@ export function parseHunt(answer: string, limit: number): number[] {
   for (const line of answer.split("\n")) {
     const match = /^([0-9a-f]{4})$/i.exec(line.trim());
     if (match === null) {
-      if (line.trim() !== "") unknown.push(line.trim());
+      if (line.trim() !== "" && !CONDITION_LINE.test(line.trim())) unknown.push(line.trim());
       continue;
     }
     if (matches.length < limit) matches.push(Number.parseInt(match[1]!, 16));
@@ -236,14 +238,15 @@ export function parseProfile(answer: string): ProfileEntry[] {
   const unknown: string[] = [];
   for (const line of answer.split("\n")) {
     // Counts can carry the host locale's digit grouping ("1,123,200") and the percent a decimal comma.
-    const row = new RegExp(`^\\s*(${COUNT})\\s+[\\d.,]+%\\s+(${COUNT})\\s+([\\d.,]+)%\\s+(\\S+)\\s*$`).exec(line);
+    // A profile of zero cycles, as after a window move restarts it, prints its percents as "-nan".
+    const row = new RegExp(`^\\s*(${COUNT})\\s+(?:[\\d.,]+|-?nan)%\\s+(${COUNT})\\s+([\\d.,]+|-?nan)%\\s+(\\S+)\\s*$`, "i").exec(line);
     if (row === null) {
-      if (line.trim() !== "" && !/^Total\s+%\s+Self\s+%$/.test(line.trim()) && !/^[-\s]+$/.test(line)) unknown.push(line.trim());
+      if (line.trim() !== "" && !CONDITION_LINE.test(line.trim()) && !/^Total\s+%\s+Self\s+%$/.test(line.trim()) && !/^[-\s]+$/.test(line)) unknown.push(line.trim());
       continue;
     }
     // A row named ROOT or by a label has no routine address.
     if (!/^[0-9a-f]{4}$/i.test(row[4]!)) continue;
-    entries.push({ address: Number.parseInt(row[4]!, 16), totalCycles: digits(row[1]!), selfCycles: digits(row[2]!), percent: Number(row[3]!.replace(",", ".")) });
+    entries.push({ address: Number.parseInt(row[4]!, 16), totalCycles: digits(row[1]!), selfCycles: digits(row[2]!), percent: /nan/i.test(row[3]!) ? 0 : Number(row[3]!.replace(",", ".")) });
   }
   // An answer in another form must not read as "nothing ran".
   if (entries.length === 0 && unknown.length > 0) throw unknownForm("profile", unknown);
@@ -258,33 +261,48 @@ function unknownForm(what: string, lines: string[]): WireFailure {
   return new WireFailure("operation-failed", `VICE printed the ${what} in a form that c64-re-tools does not read: ${JSON.stringify(lines.slice(0, 3))}`);
 }
 
+/** The coverage byte (D40) of one memmap row's I/O, ROM and RAM columns, each "rwx" with "-" for no access. */
+export function memmapFlags(io: string, rom: string, ram: string): number {
+  let flags = 0;
+  if (ram[0] === "r") flags |= COVERAGE.ramRead;
+  if (ram[1] === "w") flags |= COVERAGE.ramWrite;
+  if (ram[2] === "x") flags |= COVERAGE.ramExecute;
+  if (rom[0] === "r") flags |= COVERAGE.romRead;
+  if (rom[2] === "x") flags |= COVERAGE.romExecute;
+  if (io[0] === "r") flags |= COVERAGE.ioRead;
+  if (io[1] === "w") flags |= COVERAGE.ioWrite;
+  if (io[2] === "x") flags |= COVERAGE.ioExecute;
+  return flags;
+}
+
 /**
  * Parses memmap rows such as "00c2: --- --- rw- (uninitialized read)": the I/O,
  * ROM and RAM access flags of one address. Adjacent addresses with the same
- * combined flags merge into one range; at most `maxRanges` come back.
+ * flags merge into one range; at most `maxRanges` come back. When more ranges
+ * follow, `next` is the first touched address that is not reported.
  */
-export function parseMemmap(answer: string, maxRanges: number): MemmapRange[] {
+export function parseMemmap(answer: string, maxRanges: number): { ranges: MemmapRange[]; next?: number } {
   const ranges: MemmapRange[] = [];
   const unknown: string[] = [];
   for (const line of answer.split("\n")) {
     const match = /^([0-9a-f]{4}): (\S{3}) (\S{3}) (\S{3})/i.exec(line);
     if (match === null) {
-      if (line.trim() !== "" && !/^addr:\s+IO\s+ROM\s+RAM$/.test(line.trim())) unknown.push(line.trim());
+      if (line.trim() !== "" && !CONDITION_LINE.test(line.trim()) && !/^addr:\s+IO\s+ROM\s+RAM$/.test(line.trim())) unknown.push(line.trim());
       continue;
     }
     const address = Number.parseInt(match[1]!, 16);
-    const flags = match[2]! + match[3]! + match[4]!;
-    const access = { execute: flags.includes("x"), read: flags.includes("r"), write: flags.includes("w") };
+    const flags = memmapFlags(match[2]!, match[3]!, match[4]!);
+    if (flags === 0) continue;
     const last = ranges.at(-1);
-    if (last !== undefined && last.end === address - 1 && last.execute === access.execute && last.read === access.read && last.write === access.write) {
+    if (last !== undefined && last.end === address - 1 && last.flags === flags) {
       last.end = address;
       continue;
     }
-    if (ranges.length >= maxRanges) break;
-    ranges.push({ start: address, end: address, ...access });
+    if (ranges.length >= maxRanges) return { ranges, next: address };
+    ranges.push({ start: address, end: address, flags });
   }
   if (ranges.length === 0 && unknown.length > 0) throw unknownForm("memory map", unknown);
-  return ranges;
+  return { ranges };
 }
 
 /**
@@ -293,12 +311,19 @@ export function parseMemmap(answer: string, maxRanges: number): MemmapRange[] {
  */
 const STOP_LINE = /^(?:#\d+ \((?:Stop on|Trace)\s|\.(?:C|\d+):[0-9a-f]{4}\s)/i;
 
-/** The lines of a text command's answer that are not blank, not a stop line and not `known`. */
+/**
+ * The line VICE prints on the text monitor when the binary monitor sets a
+ * checkpoint condition. It can come late, in the answer of the next text
+ * command (seen on Windows).
+ */
+const CONDITION_LINE = /^Setting checkpoint \d+ condition to: /;
+
+/** The lines of a text command's answer that are not blank, not a stop line, not a condition line and not `known`. */
 function otherLines(answer: string, known?: RegExp): string[] {
   return answer
     .split("\n")
     .map((line) => line.trim())
-    .filter((line) => line !== "" && !STOP_LINE.test(line) && known?.test(line) !== true);
+    .filter((line) => line !== "" && !STOP_LINE.test(line) && !CONDITION_LINE.test(line) && known?.test(line) !== true);
 }
 
 /** Refuses the answer of a text command that prints nothing, or only `known` lines, when it works. */
@@ -408,6 +433,19 @@ export class ViceAdapter {
     return bytes.toString("hex");
   }
 
+  /**
+   * The timer latches and the interrupt mask of the CIA at `base`, from VICE's
+   * text-monitor dump: no register read gives them (D63).
+   */
+  async ciaHidden(base: 0xdc00 | 0xdd00): Promise<CiaHidden> {
+    const answer = await this.#computerText(`io ${hex4(base)}`);
+    const mask = /\(mask: ([0-9a-f]{2})\)/i.exec(answer);
+    const latchA = /Timer A: [0-9a-f]{4} \(latched ([0-9a-f]{4})\)/i.exec(answer);
+    const latchB = /Timer B: [0-9a-f]{4} \(latched ([0-9a-f]{4})\)/i.exec(answer);
+    if (mask === null || latchA === null || latchB === null) throw unknownForm("CIA dump", answer.split("\n"));
+    return { latchA: Number.parseInt(latchA[1]!, 16), latchB: Number.parseInt(latchB[1]!, 16), interruptMask: Number.parseInt(mask[1]!, 16) & 0x1f };
+  }
+
   /** Reads C64 I/O registers through the I/O bank, whatever the CPU has banked in, without side effects. */
   async readIo(start: number, size: number): Promise<Uint8Array> {
     const response = await this.#monitor.request(
@@ -616,6 +654,12 @@ export class ViceAdapter {
     await this.#monitor.request(Command.autostart, Buffer.concat([head, name]));
   }
 
+  /** Detaches every cartridge. VICE powers the cartridge off; the C64 keeps running. */
+  async detachCartridge(): Promise<void> {
+    // Device 32 is the cartridge port; the monitor reads numbers as hex. VICE prints nothing when it detaches.
+    expectQuiet("cartridge detach answer", await this.#text.command("detach 20"));
+  }
+
   /** Attaches a disk image file from the host file system to drive 8. */
   async attachDisk(file: string): Promise<void> {
     const answer = await this.#text.command(`attach ${quoted(file)} 8`);
@@ -739,7 +783,7 @@ export class ViceAdapter {
   }
 
   /** How the C64 CPU accessed [start, end] since the memmap was last cleared, as merged ranges. */
-  async memmap(start: number, end: number, maxRanges: number): Promise<MemmapRange[]> {
+  async memmap(start: number, end: number, maxRanges: number): Promise<{ ranges: MemmapRange[]; next?: number }> {
     // The first argument is the access mask ("ioRWXrwx"); ff shows every kind of access.
     return parseMemmap(await this.#computerText(`mmsh ff ${hex4(start)} ${hex4(end)}`, 60_000), maxRanges);
   }

package/src/host/vice/chips.ts

@@ -57,8 +57,15 @@ function bcd(value: number): number {
   return (value >> 4) * 10 + (value & 0x0f);
 }
 
+/** The parts of a CIA that no register read gives: the timer latches and the interrupt mask. */
+export interface CiaHidden {
+  latchA: number;
+  latchB: number;
+  interruptMask: number;
+}
+
 /** `registers` holds $dc00-$dc0f or $dd00-$dd0f. TOD hours become 0-23. */
-export function decodeCia(id: 1 | 2, registers: Uint8Array): CiaState {
+export function decodeCia(id: 1 | 2, registers: Uint8Array, hidden: CiaHidden): CiaState {
   const word = (low: number) => registers[low]! | (registers[low + 1]! << 8);
   const hourRegister = registers[0x0b]!;
   const pm = (hourRegister & 0x80) !== 0;
@@ -70,9 +77,12 @@ export function decodeCia(id: 1 | 2, registers: Uint8Array): CiaState {
     ddrB: registers[0x03]!,
     timerA: word(0x04),
     timerB: word(0x06),
+    latchA: hidden.latchA,
+    latchB: hidden.latchB,
     controlA: registers[0x0e]!,
     controlB: registers[0x0f]!,
     interruptStatus: registers[0x0d]!,
+    interruptMask: hidden.interruptMask,
     tod: {
       hours: (bcd(hourRegister & 0x1f) % 12) + (pm ? 12 : 0),
       minutes: bcd(registers[0x0a]! & 0x7f),

package/src/host/vice/process.ts

@@ -1,5 +1,7 @@
 // VICE launch, readiness and termination. The launch contract of x64sc:
 // - `-default` must come before `-binarymonitor`, or the monitor never binds;
+// - `-config` must come first: VICE's trunk (after 3.10) drops every argument
+//   before it, so the monitors would never start;
 // - the monitor may accept a connection during startup and then drop it, so
 //   readiness is a connect plus a successful ping, retried until a deadline;
 // - any monitor command stops the machine, so readiness ends with `exit`;
@@ -9,7 +11,8 @@
 //   operations only it offers; both act on the same machine;
 // - autostart of a PRG needs `-autostartprgmode 1` (inject into RAM);
 // - the joyport command reaches the C64 only through the "Joyport I/O
-//   simulation" device (37), whose lines start all pressed until set;
+//   simulation" device (37). In VICE 3.10 and older it holds bits 5-7 of
+//   both CIA 1 ports low (VICE bug #2202, a known flaw named by D56);
 // - with the default JAM action a jammed CPU hangs silently; -jamaction 2
 //   enters the monitor instead;
 // - the monitor's profiler prints numbers in the host locale, so VICE runs
@@ -29,7 +32,7 @@ import { setTimeout as sleep } from "node:timers/promises";
 
 import { WireFailure, type VideoStandard } from "../../protocol/messages.ts";
 import { elapsedMs, trace } from "../../trace.ts";
-import { findTool, isOlderThanMinimum, MIN_VICE, VICE } from "../../native/discover.ts";
+import { findTool, isOlderThanMinimum, MIN_VICE, VICE, type ViceVersion } from "../../native/discover.ts";
 import type { ExitStatus, ProcessSupervisor, SupervisedProcess } from "../../native/processes.ts";
 import { BinaryMonitor, Command, decodeMemory, memoryGetBody } from "./binary-monitor.ts";
 import { TextMonitor } from "./text-monitor.ts";
@@ -75,6 +78,9 @@ export function viceArguments(options: {
   const headless = options.mode === "headless" ? ["-console", "-sounddev", "dummy"] : [];
   return [
     options.binary,
+    // VICE's trunk (after 3.10) drops every argument before -config, so it comes first.
+    "-config",
+    options.configFile,
     "-default",
     "-logfile",
     options.logFile,
@@ -84,8 +90,6 @@ export function viceArguments(options: {
     "-remotemonitor",
     "-remotemonitoraddress",
     `ip4://127.0.0.1:${options.textPort}`,
-    "-config",
-    options.configFile,
     "-model",
     options.videoStandard === "ntsc" ? "ntsc" : "c64",
     "-drive8type",
@@ -93,6 +97,8 @@ export function viceArguments(options: {
     // Autostart injects a PRG into RAM; the default mode copies it to a disk image first.
     "-autostartprgmode",
     "1",
+    // VICE's default waits a random time before an autostart types its LOAD, so two runs of one file differ (R2-12).
+    "+autostart-delay-random",
     // The same RAM after every power-up: a hard reset is a power cycle, and VICE's default can flip
     // random bits, so two runs from one start state could differ.
     "-raminitstartvalue",
@@ -200,9 +206,10 @@ export function startErrorLines(output: string[]): string[] {
 /**
  * Starts VICE once, as a session does, and stops it again. Finding
  * x64sc is not enough: without its ROM files VICE exits at once. Throws
- * WireFailure installation-incomplete with VICE's own error lines.
+ * WireFailure installation-incomplete with VICE's own error lines. Returns
+ * the VICE version.
  */
-export async function checkViceStarts(options: Omit<LaunchOptions, "videoStandard" | "log">): Promise<void> {
+export async function checkViceStarts(options: Omit<LaunchOptions, "videoStandard" | "log">): Promise<ViceVersion> {
   const binary = findVice(options.env ?? process.env);
   const output: string[] = [];
   let vice: ViceProcess;
@@ -231,13 +238,16 @@ export async function checkViceStarts(options: Omit<LaunchOptions, "videoStandar
   } finally {
     await vice.stop();
   }
-  const version = { major: info[1] ?? 0, minor: info[2] ?? 0 };
+  // The SVN revision is 0 in a release build.
+  const revision = info.length >= 10 ? info.readUInt32LE(6) : 0;
+  const version = { major: info[1] ?? 0, minor: info[2] ?? 0, ...(revision === 0 ? {} : { revision }) };
   if (isOlderThanMinimum(version)) {
     throw new WireFailure(
       "installation-incomplete",
       `VICE (${binary}) is version ${version.major}.${version.minor}, and c64-re-tools needs VICE ${MIN_VICE.major}.${MIN_VICE.minor} or later. ${VICE.remedy}`,
     );
   }
+  return version;
 }
 
 async function launchOnce(options: LaunchOptions): Promise<ViceProcess> {
@@ -302,6 +312,7 @@ async function launchOnce(options: LaunchOptions): Promise<ViceProcess> {
         clearInterval(slow);
       }
       if (failure !== undefined) throw failure;
+      log(`VICE stopped (pid ${child.pid}, in ${Date.now() - started} ms)`);
     })();
     return stopping;
   };
@@ -320,7 +331,7 @@ async function launchOnce(options: LaunchOptions): Promise<ViceProcess> {
     if (error instanceof WireFailure) throw error;
     throw new WireFailure("machine-unavailable", "The emulator could not be started on the host.");
   }
-  log(`VICE started (pid ${child.pid}, monitor ports ${port} and ${textPort})`);
+  log(`VICE started (${mode}, pid ${child.pid}, monitor ports ${port} and ${textPort})`);
   trace().event("vice.ready", { pid: child.pid, ms: elapsedMs(launched) });
   return { pid: child.pid, monitor, text, exited: child.exited, outputTail, stop };
 }

package/src/host/vice/screen.ts

@@ -1,16 +1,9 @@
 // Canonical emulator-frame capture: VICE's own rendered VIC-II frame, never a
 // desktop screenshot; the frame comparison and difference image for baselines.
 
-import { crc32, deflateSync } from "node:zlib";
-
+import type { IndexedFrame } from "../../graphics.ts";
 import type { VideoStandard } from "../../protocol/messages.ts";
-
-export interface IndexedFrame {
-  width: number;
-  height: number;
-  /** One palette index per pixel, row by row. */
-  pixels: Uint8Array;
-}
+import { FRAME_SIZE } from "../../protocol/vice.ts";
 
 export interface RawDisplay {
   /** Full buffer size, blanking included. */
@@ -44,8 +37,8 @@ export function decodeDisplay(body: Buffer): RawDisplay {
  * offsets: PAL 384×272, NTSC 384×247.
  */
 const VISIBLE: Record<VideoStandard, { dx: number; dy: number; width: number; height: number }> = {
-  pal: { dx: -32, dy: -36, width: 384, height: 272 },
-  ntsc: { dx: -32, dy: -23, width: 384, height: 247 },
+  pal: { dx: -32, dy: -36, ...FRAME_SIZE.pal },
+  ntsc: { dx: -32, dy: -23, ...FRAME_SIZE.ntsc },
 };
 
 /** Crops the visible bordered frame out of VICE's full raster buffer. */
@@ -82,39 +75,6 @@ export function decodePalette(body: Buffer): Array<[number, number, number]> {
   return colours;
 }
 
-function chunk(type: string, data: Uint8Array): Buffer {
-  const length = Buffer.alloc(4);
-  length.writeUInt32BE(data.length, 0);
-  const body = Buffer.concat([Buffer.from(type, "latin1"), data]);
-  const crc = Buffer.alloc(4);
-  crc.writeUInt32BE(crc32(body), 0);
-  return Buffer.concat([length, body, crc]);
-}
-
-/** Encodes an indexed frame as an 8-bit palette PNG. */
-export function encodePng(frame: IndexedFrame, palette: ReadonlyArray<readonly [number, number, number]>): Buffer {
-  for (const index of frame.pixels) {
-    if (index >= palette.length) throw new Error(`pixel colour ${index} is not in the ${palette.length}-colour palette`);
-  }
-  const header = Buffer.alloc(13);
-  header.writeUInt32BE(frame.width, 0);
-  header.writeUInt32BE(frame.height, 4);
-  header[8] = 8; // bit depth
-  header[9] = 3; // indexed colour
-  const rows = Buffer.alloc((frame.width + 1) * frame.height);
-  for (let row = 0; row < frame.height; row++) {
-    // Filter byte 0 (none), then the row.
-    rows.set(frame.pixels.subarray(row * frame.width, (row + 1) * frame.width), row * (frame.width + 1) + 1);
-  }
-  return Buffer.concat([
-    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
-    chunk("IHDR", header),
-    chunk("PLTE", Buffer.from(palette.flat())),
-    chunk("IDAT", deflateSync(rows)),
-    chunk("IEND", new Uint8Array(0)),
-  ]);
-}
-
 export interface FrameDifference {
   mismatchingPixels: number;
   /** Pixels compared: the frame minus the masked ones. */