@moku-labs/game 0.14.12 → 0.14.13

package/dist/visual.d.mts

@@ -1,333 +1,2 @@
-import { A as Api$1, Jt as Api$2, h as Api, un as Api$3 } from "./types-BjTtGSFb.mjs";
-import { r as UiApi, x as AnimApi } from "./types-Y_rCuXtj.mjs";
-import { A as InputApi } from "./types-DOlpeuGx.mjs";
-import { r as Repro } from "./headless-CMHNsKjW.mjs";
-import { a as InputOf, r as ControlApp } from "./types-CAPv9l29.mjs";
-import { t as commands } from "./commands-BaCx2B9j.mjs";
-
-//#region src/visual/types.d.ts
-/** The base commands of the `/control` door, keyed by their short names. */
-type Catalogue = typeof commands;
-/**
- * The commands a step may name: the catalogue of `/control` minus `bookmark` (it only reads),
- * `capture` (the runner captures by itself) and `debug` (debug drawing would enter a baseline). A
- * command the catalogue gains is a step with no change to the runner.
- *
- * @example
- * ```ts
- * const name: StepCommand = "tap"; // also "answer", "walk", "step", "reducedMotion", ...
- * ```
- */
-type StepCommand = Exclude<keyof Catalogue, "bookmark" | "capture" | "debug">;
-/**
- * Where a visual test starts: what `game.restore` loads, a repro without its route. The player
- * is required; the session, the rng and the checkpoint are optional, as in a repro.
- *
- * @example
- * ```ts
- * // A save with a plank ready for the first order, entered at Home.
- * const start: VisualStart = { player: { coins: 40, orders: [] }, checkpoint: "home" };
- * ```
- */
-type VisualStart = Omit<Repro, "route">;
-/**
- * One step of a visual test: a `/control` command by its short name with that command's input,
- * typed from the catalogue, or a checkpoint by its name.
- *
- * @example
- * ```ts
- * // Tap Play, answer the order on the board, then compare the screen with its baseline.
- * const steps: VisualStep[] = [
- *   { tap: { key: "play" } },
- *   { answer: { intent: "deliver", payload: { orderId: "o1" } } },
- *   { checkpoint: "open" }
- * ];
- * ```
- */
-type VisualStep = {
-  checkpoint: string;
-} | { [K in StepCommand]: { [P in K]: InputOf<Catalogue[K]["input"]> } }[StepCommand];
-/**
- * A visual test as `defineVisualTest` answers it: its name, where it starts, its steps, and
- * `webgl`, true when it also runs in the WebGL leg. Frozen data; nothing runs at definition.
- *
- * @example
- * ```ts
- * const test: VisualTest = defineVisualTest("reward-popup", {
- *   start: { player: { coins: 40 }, checkpoint: "home" },
- *   steps: [{ tap: { key: "play" } }, { checkpoint: "board" }]
- * });
- * test.name; // "reward-popup"
- * test.webgl; // false
- * Object.isFrozen(test.steps); // true
- * ```
- */
-type VisualTest = {
-  readonly name: string;
-  readonly start: Readonly<VisualStart>;
-  readonly steps: readonly VisualStep[];
-  readonly webgl: boolean;
-};
-/**
- * What the runner needs of an app: the control app, the plugins the base commands act on and
- * the plugins the readers read. Every app composed with the screen set fits.
- *
- * @example
- * ```ts
- * const app: VisualApp = createApp({ plugins: [...screen, boardFeature], pluginConfigs });
- * ```
- */
-type VisualApp = ControlApp & {
-  readonly anim: AnimApi;
-  readonly ui: UiApi;
-  readonly renderer: Api;
-  readonly world: Api$1;
-  readonly model: Api$2;
-  readonly input: InputApi;
-  readonly lifecycle: Api$3;
-};
-/**
- * The dev page the browser leg opens: its URL, the viewport width in CSS px (390 by default), the
- * device scale (2 by default) and which Chrome to launch. The page height follows the inert frame
- * of the renderer: 520 for a 390 wide portrait game at the default 4:3. Without `browser` the leg
- * launches Playwright's own Chromium, and the system Chrome when that one is not installed.
- *
- * @example
- * ```ts
- * // The fixture's dev server, a 390 px wide phone at 2x, the system Chrome.
- * const page: VisualPage = { url: "http://localhost:3000/", browser: { channel: "chrome" } };
- * ```
- */
-type VisualPage = {
-  url: string;
-  width?: number;
-  deviceScaleFactor?: number;
-  browser?: {
-    channel?: string;
-    executablePath?: string;
-  };
-};
-/**
- * How the runner builds a game: a fresh app per test, not started, with the screen set
- * composed; the renderer stays inert in Bun. `page` is the dev page of the pixel leg.
- *
- * @example
- * ```ts
- * // tests/visual/run.ts of a game.
- * const setup: VisualSetup = { app: () => createScreenGame().app, page: { url: "http://localhost:3000/" } };
- * ```
- */
-type VisualSetup = {
-  app: () => VisualApp;
-  page?: VisualPage;
-};
-/**
- * How far a pixel may differ: `threshold` is the largest channel delta that still counts as the
- * same pixel, `ratio` the share of differing pixels a checkpoint tolerates.
- *
- * @example
- * ```ts
- * const tolerance: VisualTolerance = { ratio: 0.001, threshold: 24 }; // the defaults
- * ```
- */
-type VisualTolerance = {
-  ratio: number;
-  threshold: number;
-};
-/**
- * The backend the browser leg draws with: `"webgpu"`, or `"webgl"` for the WebGL leg.
- *
- * @example
- * ```ts
- * const renderer: VisualRenderer = "webgl"; // what --webgl asks for
- * ```
- */
-type VisualRenderer = "webgpu" | "webgl";
-/**
- * The options of a run. Each one left out comes from the command line (`argv`), then from its
- * default: `dir` `"tests/visual"`, `update` false, `pixels` true with a `page` on a Mac,
- * `renderer` `"webgpu"`, `settleFrames` 600, `tolerance` `{ ratio: 0.001, threshold: 24 }`,
- * `argv` `process.argv.slice(2)`. An option given here wins over a flag. `renderer: "webgl"`
- * runs only the tests with `webgl: true`, on the page with `?renderer=webgl`, and compares their
- * pictures with `screen.webgl.webp`.
- *
- * @example
- * ```ts
- * // The same as `bun tests/visual/run.ts --only reward-popup --no-pixels`.
- * const options: VisualOptions = { only: ["reward-popup"], pixels: false };
- * // The same as `bun tests/visual/run.ts --webgl`.
- * const webgl: VisualOptions = { renderer: "webgl" };
- * ```
- */
-type VisualOptions = {
-  dir?: string;
-  update?: boolean;
-  pixels?: boolean;
-  renderer?: VisualRenderer;
-  only?: readonly string[];
-  settleFrames?: number;
-  tolerance?: VisualTolerance;
-  argv?: readonly string[];
-};
-/**
- * What a comparison with a baseline file found: the same content, a different one, or no
- * baseline (or `--update`), so the file was written.
- *
- * @example
- * ```ts
- * const outcome: Outcome = "written"; // the first run of a new checkpoint
- * ```
- */
-type Outcome = "same" | "different" | "written";
-/**
- * The outcome of one checkpoint. `first` is the JSON path of the first difference, the state's
- * before the describe's. `pixels` is `"skipped"` when the pixel leg did not run; `pixelRatio`
- * and `verdict` come with a pixel difference.
- *
- * @example
- * ```ts
- * // The player's coins differ from the baseline; the layout is the same.
- * const result: CheckpointResult = {
- *   name: "claimed", state: "different", describe: "same", pixels: "skipped", first: "player.coins"
- * };
- * ```
- */
-type CheckpointResult = {
-  name: string;
-  state: Outcome;
-  describe: Outcome;
-  pixels: Outcome | "skipped";
-  pixelRatio?: number;
-  first?: string;
-  verdict?: "rendering" | "behaviour";
-};
-/**
- * The outcome of one visual test: every checkpoint it reached, and the error that ended it early.
- *
- * @example
- * ```ts
- * const result: VisualTestResult = {
- *   name: "reward-popup",
- *   checkpoints: [{ name: "open", state: "same", describe: "same", pixels: "skipped" }]
- * };
- * ```
- */
-type VisualTestResult = {
-  name: string;
-  checkpoints: readonly CheckpointResult[];
-  error?: string;
-};
-/**
- * What `runVisualTests` answers: `ok` is true when no test failed and no outcome is
- * `"different"`.
- *
- * @example
- * ```ts
- * const report: VisualReport = await runVisualTests(setup, [rewardPopup], { argv: [] });
- * process.exitCode = report.ok ? 0 : 1;
- * ```
- */
-type VisualReport = {
-  ok: boolean;
-  tests: readonly VisualTestResult[];
-};
-/** What the command line asked for: the flags it carried, nothing else. */
-type VisualFlags = {
-  dir?: string;
-  update?: boolean;
-  pixels?: boolean;
-  renderer?: VisualRenderer;
-  only?: readonly string[];
-};
-//#endregion
-//#region src/visual/define.d.ts
-/**
- * Defines a visual test: where it starts, what `game.restore` loads, and its steps. A step is a
- * `/control` command by its short name with that command's input, or `{ checkpoint: name }`,
- * where the runner saves `state.json` and `describe.json` next to the test. `walk` runs fast: a
- * popup its last node opens never mounts, so the step before a checkpoint that shows a node's
- * result is `answer` or `tap`. With `webgl: true` the test also runs in the WebGL leg
- * (`--webgl`), whose pictures go to `screen.webgl.webp`: set it on a screen with a custom filter.
- * The answer is a frozen copy; nothing runs here.
- *
- * @param name - The test name, also its folder: lowercase letters, digits and dashes.
- * @param test - Where it starts, its steps and its WebGL leg.
- * @param test.start - The player, and optionally the session, the rng and the checkpoint.
- * @param test.steps - The commands and the checkpoints, in order.
- * @param test.webgl - True to run the test in the WebGL leg too; false by default.
- * @returns The test, frozen.
- * @throws {Error} When the name or a checkpoint name is not a file name, a checkpoint name is
- *   used twice, or a step is not one step command.
- * @example
- * ```ts
- * // tests/visual/home.visual.ts: Home with the glowing Play plank, in both legs.
- * const home = defineVisualTest("home", { start: atHome, steps: [{ checkpoint: "rest" }], webgl: true });
- * home.webgl; // true
- * ```
- */
-declare function defineVisualTest(name: string, test: {
-  start: VisualStart;
-  steps: readonly VisualStep[];
-  webgl?: boolean;
-}): VisualTest;
-//#endregion
-//#region src/visual/run.d.ts
-/**
- * Reads the flags of the visual tests from a command line: `--update`, `--no-pixels`, `--pixels`,
- * `--webgl`, `--only <name>` (repeatable) and `--dir <path>`. `--pixels` forces the pixel leg on
- * off a Mac; the last of `--pixels` and `--no-pixels` wins. An argument it does not know is left
- * to the script that got it, so a test runner's own arguments pass through. `moku-game visual`
- * reads its flags with it.
- *
- * @param argv - The arguments after the script name.
- * @returns The flags that were given, and nothing else.
- * @throws {Error} When `--only` or `--dir` has no value.
- * @example
- * ```ts
- * // `bun tests/visual/run.ts --update --only reward-popup`
- * parseVisualArgv(["--update", "--only", "reward-popup"]); // { update: true, only: ["reward-popup"] }
- * parseVisualArgv(["--no-pixels", "--dir", "shots"]); // { pixels: false, dir: "shots" }
- * parseVisualArgv(["--webgl"]); // { renderer: "webgl" }
- * parseVisualArgv(["--pixels"]); // { pixels: true }
- * ```
- */
-declare function parseVisualArgv(argv: readonly string[]): VisualFlags;
-/**
- * Runs visual tests: the headless leg over every selected test, then the browser leg over the
- * same tests when `pixels` is on (by default only with a `page` on a Mac). With `renderer:
- * "webgl"` (`--webgl`) only the tests with `webgl: true` run, the page opens with
- * `?renderer=webgl` and its pictures go to `screen.webgl.webp`; `state.json` and `describe.json`
- * are shared with the WebGPU leg and compared as always. A checkpoint saves
- * `state.json` and `describe.json` in `<dir>/<test>/<checkpoint>/`, and the browser leg
- * `screen.webp`, lossless: a missing file is written, `--update` rewrites every file of the tests
- * run, a JSON file is compared exactly. The browser leg opens the dev page in Chrome with WebGPU
- * through `playwright-core`, pauses its game, plays each test there on stepped frames of 1000/60
- * ms, so two runs see the same game time, checks the page's state against `state.json` and
- * compares the picture in the page: a pixel differs above `tolerance.threshold`, and the screen
- * differs when more than `tolerance.ratio` of its pixels do; `screen.actual.webp` and
- * `screen.diff.webp` are written beside the baseline then. A pixel difference over the same state
- * and describe is a rendering regression (`verdict: "rendering"`). One line per checkpoint goes
- * to the branded console; the script sets the exit code from `ok`.
- *
- * @param setup - How to build a game: a fresh, unstarted app per test, and the dev page.
- * @param tests - Every visual test of the game.
- * @param options - Overrides of the flags of `argv` and of the defaults.
- * @returns The report: `ok` when no test failed and nothing is `"different"`.
- * @throws {Error} When a test is not well formed, two tests share a name, `only` names no test,
- *   a flag misses its value, or the browser leg fails as a whole: no `page`, no
- *   `playwright-core`, no Chrome, or a page that does not open, expose `game` and `doors`, start,
- *   draw with the requested backend or stop loading. In the WebGL leg, also when `only` names a
- *   test without `webgl: true`.
- * @example
- * ```ts
- * // tests/visual/run.ts of a game, `bun tests/visual/run.ts --update` on a Mac
- * const report = await runVisualTests(
- *   { app: () => createScreenGame().app, page: { url: "http://localhost:3000/" } },
- *   [rewardPopup]
- * );
- * report.tests[0]?.checkpoints[0]; // { name: "open", state: "written", describe: "written", pixels: "written" }
- * ```
- */
-declare function runVisualTests(setup: VisualSetup, tests: readonly VisualTest[], options?: VisualOptions): Promise<VisualReport>;
-//#endregion
+import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-_XhoGeIC.mjs";
 export { type CheckpointResult, type VisualApp, type VisualOptions, type VisualPage, type VisualRenderer, type VisualReport, type VisualSetup, type VisualStart, type VisualStep, type VisualTest, type VisualTestResult, type VisualTolerance, defineVisualTest, parseVisualArgv, runVisualTests };

package/dist/visual.mjs

@@ -1,5 +1,5 @@
-import { n as read, t as sources } from "./sources-Duzj6lhV.mjs";
-import { n as commands, t as run } from "./run-Bf2hKyjZ.mjs";
+import { n as read, t as sources } from "./sources-Cdvb0rOS.mjs";
+import { n as commands, t as run } from "./run-BbipFRc6.mjs";
 import path from "node:path";
 import { createBrandConsole } from "@moku-labs/common/cli";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
@@ -1120,9 +1120,88 @@ async function pagePause(argument) {
 	}
 }
 /**
+* Tells whether a log line fails a visual test wherever the page logged it, its load included: a
+* filter broken for good (`effects:broken`), a warm-up probe whose render threw inside Pixi
+* (`renderer:warm-failed`), a read of the frame oracles that failed (`renderer: pixel read failed`).
+* No frame oracle can see them: the oracles compare the engine with itself.
+*
+* @param event - The event of the line.
+* @returns True for one of the three.
+* @example
+* ```ts
+* pageBroke("effects:broken"); // true
+* ```
+*/
+function pageBroke(event) {
+	return event === "effects:broken" || event === "renderer:warm-failed" || event === "renderer: pixel read failed";
+}
+/**
+* Tells whether a log line is a finding of the frame oracles: a skipped frame that differed from
+* the frame drawn live, a view written without a mark, a kept picture that no longer matches its
+* live frame (spec 23).
+*
+* @param event - The event of the line.
+* @returns True for one of the three.
+* @example
+* ```ts
+* pageOracle("renderer:stale-picture"); // true
+* ```
+*/
+function pageOracle(event) {
+	return event === "renderer:missed-frame" || event === "renderer:missed-mark" || event === "renderer:stale-picture";
+}
+/**
+* Turns on the pixel check of the frames the renderer skips, through the door `game.debug`, and
+* starts reading the log of the page from its end: from here on, `pageMissed` fails a step on the
+* first line of the frame oracles or of `pageBroke`. A `pageBroke` line the page logged while it
+* loaded, before the check, fails the start.
+*
+* @param _argument - The test and the step, for the leg's message.
+* @returns Nothing, or why the page refused the switch or broke while it loaded.
+*/
+async function pageVerify(_argument) {
+	try {
+		const { game, doors } = pageHandles();
+		await doors.run(game, doors.commands.debug, { verifyFrames: true });
+		const entries = game.log.trace();
+		Reflect.set(globalThis, "__mokuVisualTrace", entries.length);
+		for (const entry of entries) if (pageBroke(entry.event)) return {
+			ok: false,
+			reason: `${entry.event} ${JSON.stringify(entry.data)}`
+		};
+		return {
+			ok: true,
+			value: void 0
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			reason: pageMessage(error)
+		};
+	}
+}
+/**
+* Reads the log of the page since the last read, once `pageVerify` turned the check on, for the
+* first line of the frame oracles (`pageOracle`) or of an error no oracle can see (`pageBroke`).
+*
+* @param handles - The game and the doors.
+* @returns The line, as its event and its data, or `undefined` when none was logged.
+*/
+function pageMissed(handles) {
+	const from = Reflect.get(globalThis, "__mokuVisualTrace");
+	if (typeof from !== "number") return void 0;
+	const entries = handles.game.log.trace();
+	Reflect.set(globalThis, "__mokuVisualTrace", entries.length);
+	for (let at = from; at < entries.length; at += 1) {
+		const entry = entries[at];
+		if (entry !== void 0 && (pageOracle(entry.event) || pageBroke(entry.event))) return `${entry.event} ${JSON.stringify(entry.data)}`;
+	}
+}
+/**
 * Runs one `/control` command through the doors of the page, the way an editor does, with frames
 * stepped while it waits for them, then settles. The leg restores the start of a test with it
-* too, as the command `restore`.
+* too, as the command `restore`. With the frame check on, a missed frame or mark logged in the
+* meantime fails the step.
 *
 * @param argument - The test and the step, the command by its short name, its input, and the most
 *   frames to settle.
@@ -1135,12 +1214,17 @@ async function pageStep(argument) {
 	try {
 		const handles = pageHandles();
 		const unsettled = await pageRun(handles, argument, argument.settleFrames, argument) ?? await pageSettle(handles, argument.settleFrames, argument);
-		return unsettled === void 0 ? {
+		if (unsettled !== void 0) return {
+			ok: false,
+			error: unsettled
+		};
+		const missed = pageMissed(handles);
+		return missed === void 0 ? {
 			ok: true,
 			value: void 0
 		} : {
 			ok: false,
-			error: unsettled
+			reason: missed
 		};
 	} catch (error) {
 		return {
@@ -1152,7 +1236,8 @@ async function pageStep(argument) {
 /**
 * Plays a checkpoint in the page: settle, land every track and loop, two stepped frames, then the
 * picture of the whole canvas as lossless WebP and the state through the doors. The game is
-* paused, so the picture is the stage after the last stepped frame.
+* paused, so the picture is the stage after the last stepped frame. With the frame check on, a
+* missed frame or mark logged in the meantime fails the checkpoint.
 *
 * @param argument - The test and the step, and the most frames to settle.
 * @param argument.settleFrames - The most frames to settle.
@@ -1172,13 +1257,19 @@ async function pageCheckpoint(argument) {
 		await pageTick(handles);
 		const captured = await game.renderer.capture();
 		const screen = captured === void 0 ? void 0 : await pageWebp(captured.png);
+		const state = {
+			path: doors.read(game, doors.sources.position).path,
+			...doors.read(game, doors.sources.model)
+		};
+		const missed = pageMissed(handles);
+		if (missed !== void 0) return {
+			ok: false,
+			reason: missed
+		};
 		return {
 			ok: true,
 			value: {
-				state: {
-					path: doors.read(game, doors.sources.position).path,
-					...doors.read(game, doors.sources.model)
-				},
+				state,
 				screen
 			}
 		};
@@ -1380,6 +1471,10 @@ const pageFunctions = [
 	pageRun,
 	pageStart,
 	pagePause,
+	pageBroke,
+	pageOracle,
+	pageVerify,
+	pageMissed,
 	pageStep,
 	pageCheckpoint,
 	channelDelta,
@@ -1750,9 +1845,10 @@ async function checkpoint(play, name, where) {
 	};
 }
 /**
-* Plays the start and the steps of a test in the open page, the way the headless leg does: pause
-* the game and step it to the start time, restore the start, run each command and settle on
-* stepped frames, and check each checkpoint.
+* Plays the start and the steps of a test in the open page, the way the headless leg does: turn
+* on the check of skipped frames (unless `--no-verify-frames`), pause the game and step it to the
+* start time, restore the start, run each command and settle on stepped frames, and check each
+* checkpoint. A missed frame or mark the page logs fails the step it happened in.
 *
 * @param play - The test being played.
 * @param found - Where what each checkpoint found goes, as soon as it is known.
@@ -1767,6 +1863,10 @@ async function playSteps(play, found) {
 		test: test.name,
 		settleFrames: run.settleFrames
 	};
+	if (run.verifyFrames) await callPage(play.page, pageVerify, {
+		test: test.name,
+		where: "the start"
+	});
 	await callPage(play.page, pagePause, {
 		test: test.name,
 		where: "the start",
@@ -1891,6 +1991,14 @@ const DEFAULT_TOLERANCE = {
 	ratio: .001,
 	threshold: 24
 };
+/** The flags without a value, and what each one sets. */
+const SWITCHES = {
+	"--update": { update: true },
+	"--no-pixels": { pixels: false },
+	"--pixels": { pixels: true },
+	"--webgl": { renderer: "webgl" },
+	"--no-verify-frames": { verifyFrames: false }
+};
 /**
 * Reads the value after a flag that takes one.
 *
@@ -1908,8 +2016,9 @@ function valueAfter(argv, index, placeholder) {
 }
 /**
 * Reads the flags of the visual tests from a command line: `--update`, `--no-pixels`, `--pixels`,
-* `--webgl`, `--only <name>` (repeatable) and `--dir <path>`. `--pixels` forces the pixel leg on
-* off a Mac; the last of `--pixels` and `--no-pixels` wins. An argument it does not know is left
+* `--webgl`, `--no-verify-frames`, `--only <name>` (repeatable) and `--dir <path>`. `--pixels`
+* forces the pixel leg on off a Mac; the last of `--pixels` and `--no-pixels` wins.
+* `--no-verify-frames` keeps the browser leg from checking the frames the renderer skips. An argument it does not know is left
 * to the script that got it, so a test runner's own arguments pass through. `moku-game visual`
 * reads its flags with it.
 *
@@ -1923,16 +2032,15 @@ function valueAfter(argv, index, placeholder) {
 * parseVisualArgv(["--no-pixels", "--dir", "shots"]); // { pixels: false, dir: "shots" }
 * parseVisualArgv(["--webgl"]); // { renderer: "webgl" }
 * parseVisualArgv(["--pixels"]); // { pixels: true }
+* parseVisualArgv(["--no-verify-frames"]); // { verifyFrames: false }
 * ```
 */
 function parseVisualArgv(argv) {
 	const flags = {};
 	const only = [];
 	for (const [index, argument] of argv.entries()) {
-		if (argument === "--update") flags.update = true;
-		if (argument === "--no-pixels") flags.pixels = false;
-		if (argument === "--pixels") flags.pixels = true;
-		if (argument === "--webgl") flags.renderer = "webgl";
+		const switched = SWITCHES[argument];
+		if (switched !== void 0) Object.assign(flags, switched);
 		if (argument === "--only") only.push(valueAfter(argv, index, "<name>"));
 		if (argument === "--dir") flags.dir = valueAfter(argv, index, "<path>");
 	}
@@ -1943,7 +2051,8 @@ function parseVisualArgv(argv) {
 }
 /**
 * Fills in the options of a run: an explicit option wins over a flag of `argv`, a flag over the
-* default. `pixels` is on by default only with a `page` on a Mac; `renderer` is `"webgpu"`.
+* default. `pixels` is on by default only with a `page` on a Mac; `renderer` is `"webgpu"`;
+* `verifyFrames` is on.
 *
 * @param setup - The setup, for its `page`.
 * @param options - The options the script passed.
@@ -1957,6 +2066,7 @@ function resolveVisualOptions(setup, options = {}) {
 		dir: options.dir ?? flags.dir ?? DEFAULT_DIR,
 		update: options.update ?? flags.update ?? false,
 		pixels: options.pixels ?? flags.pixels ?? (setup.page !== void 0 && process.platform === "darwin"),
+		verifyFrames: options.verifyFrames ?? flags.verifyFrames ?? true,
 		renderer: options.renderer ?? flags.renderer ?? "webgpu",
 		settleFrames: options.settleFrames ?? DEFAULT_SETTLE_FRAMES,
 		tolerance: options.tolerance ?? { ...DEFAULT_TOLERANCE }