visual-regression-compare 0.0.0-stage → 1.0.0-beta.0

package/dist/job.d.ts

@@ -0,0 +1,36 @@
+import type { DiffEngine, EngineOptions, EngineResult, SizeMismatch } from './types';
+/** The CPU-bound part of one comparison: plain data in, plain data out, so it can run in a worker. */
+export type CompareJob = {
+    baseline: Uint8Array;
+    actual: Uint8Array;
+    onSizeMismatch: SizeMismatch;
+    /** An engine id (see `loadEngine`), so a worker can load it itself. */
+    engine: {
+        id: string;
+        options?: EngineOptions;
+        cwd?: string;
+    };
+};
+type Size = {
+    width: number;
+    height: number;
+};
+export type JobResult = {
+    kind: 'compared';
+    baselineSize: Size;
+    actualSize: Size;
+    resized?: 'pad' | 'crop';
+    diffPixels: number;
+    diffRatio: number;
+    /** The diff image, already encoded. */
+    diffPng?: Uint8Array;
+    score?: EngineResult['score'];
+} | {
+    kind: 'size-mismatch';
+    baselineSize: Size;
+    actualSize: Size;
+};
+export declare const runCompare: (job: Pick<CompareJob, "baseline" | "actual" | "onSizeMismatch">, engine: DiffEngine) => Promise<JobResult>;
+/** Runs a job in this thread (what a worker does for each message). */
+export declare const runJob: (job: CompareJob) => Promise<JobResult>;
+export {};

package/dist/layout.d.ts

@@ -0,0 +1,16 @@
+import type { Layout, Matcher } from './types';
+/** Replaces characters no file system accepts and drops `.`/`..` segments, so a screenshot name is always a safe relative path. */
+export declare const sanitizeName: (name: string) => string;
+/**
+ * The manifest convention: `<name>.png` is the baseline, `<name>.actual.png`
+ * and `<name>.diff.png` sit beside it (or in the diff directory).
+ */
+export declare const manifestLayout: () => Layout;
+/** The baseline is the same relative path under the baseline directory. */
+export declare const samePathMatcher: () => Matcher;
+/**
+ * The baseline path from a template over the incoming path: `{dir}` (with its
+ * trailing slash, empty at the top level), `{name}` (file stem) and `{path}`
+ * (directory and stem), e.g. `{dir}{name}-baseline.png`.
+ */
+export declare const templateMatcher: (template: string) => Matcher;

package/dist/options.d.ts

@@ -0,0 +1,53 @@
+import { type ManifestStatus } from 'visual-regression-manifest';
+import type { OnMissingBaseline, SizeMismatch, UpdatePolicy } from './types';
+export declare class UsageError extends Error {
+}
+export type CompareCliOptions = {
+    actualDir: string;
+    baselineDir: string;
+    diffDir?: string;
+    engine: string;
+    engineOptions: Record<string, unknown>;
+    maxDiffRatio?: number;
+    maxDiffPixels?: number;
+    onMissingBaseline: OnMissingBaseline;
+    onSizeMismatch: SizeMismatch;
+    update: UpdatePolicy;
+    match?: string;
+    layout: string;
+    manifest?: string;
+    runner?: string;
+    variant?: string;
+    platform?: string;
+    report: string;
+    concurrency?: number;
+    failOn: ManifestStatus[];
+    /** `record` copies every screenshot over its baseline. */
+    record: boolean;
+};
+export type ApproveCliOptions = {
+    manifests: string[];
+    names: string[];
+    all: boolean;
+    test?: string;
+    repoRoot?: string;
+    force: boolean;
+    dryRun: boolean;
+};
+export type Command = {
+    kind: 'help';
+} | {
+    kind: 'version';
+} | {
+    kind: 'compare';
+    options: CompareCliOptions;
+} | {
+    kind: 'approve';
+    options: ApproveCliOptions;
+};
+/** The keys a config file may set; the flags override them. */
+export type ConfigFile = Partial<Omit<CompareCliOptions, 'actualDir' | 'record'> & {
+    actualDir: string;
+}>;
+export declare const helpText = "Compare folders of screenshots against their baselines and write a visual-regression-manifest.\n\nUsage:\n  visual-regression-compare [compare] <actual-dir> --baseline <dir> [options]\n  visual-regression-compare record <actual-dir> --baseline <dir> [options]\n  visual-regression-compare approve --manifest <path>... [<name>...|--all] [options]\n\ncompare options:\n  --baseline <dir>          directory of baseline images (required)\n  --diff <dir>              where .actual and .diff files go (default: next to the baselines)\n  --engine <id>             pixelmatch, or a module path or package name (default: pixelmatch)\n  --max-diff-ratio <n>      largest accepted share of differing pixels, 0..1 (default: 0)\n  --max-diff-pixels <n>     largest accepted number of differing pixels\n  --color-threshold <n>     per-pixel color tolerance of the engine, 0..1 (default: 0.1)\n  --include-aa              count anti-aliased pixels as differences\n  --on-missing fail|create  a screenshot without baseline (default: fail)\n  --on-size-mismatch fail|pad|crop\n                            fail records the size change and compares nothing; pad grows both\n                            images to the larger size, crop cuts both to the smaller (default: fail)\n  --update none|failures-only|all\n                            overwrite baselines (default: none)\n  --match <template>        baseline path from the screenshot path: {dir}, {name}, {path}\n  --layout manifest         file naming (default: manifest)\n  --manifest <path>         default: <actual-dir>/visual-regression-manifest.compare.json\n  --runner <name> --variant <id> --platform <os>[/<browser>]\n                            metadata recorded on every entry\n  --report <list>           console, ctrf[:<file>], github-summary[:<file>] (default: console)\n  --concurrency <n>         worker threads for decoding and comparing (default: CPU count)\n  --config <file>           visual-regression.config.{json,mjs,js}, found in the working directory\n  --fail-on <list>          statuses that make the exit code 1 (default: failed,missing-baseline)\n\napprove options:\n  --manifest <path>         a manifest to apply (repeatable; required)\n  --all                     every entry that needs a human (the default without names)\n  --test <file>             only entries of this test file\n  --repo-root <dir>         the repository the manifest's paths are applied to (default: the working directory)\n  --force                   approve although the baseline changed since the run\n  --dry-run                 report what would be approved\n\n  -h, --help, -v, --version\n";
+export declare const parseCommand: (argv: string[], config?: ConfigFile) => Command;

package/dist/plugins.d.ts

@@ -0,0 +1,25 @@
+import type { CompareContext, Decision, DiffEngine, EngineModule, Layout, Matcher, Measurement, Plugin, Reporter, Store, WritePlan } from './types';
+import type { Manifest } from 'visual-regression-manifest';
+export type Hooks = {
+    beforeCompare: ((ctx: CompareContext) => void | Promise<void>)[];
+    afterCompare: ((ctx: CompareContext, measurement: Measurement) => void | Promise<void>)[];
+    decide: ((ctx: CompareContext, decision: Decision) => Decision | Promise<Decision>)[];
+    beforeWrite: ((ctx: CompareContext, plan: WritePlan) => WritePlan | Promise<WritePlan>)[];
+    end: ((manifest: Manifest) => void | Promise<void>)[];
+};
+/** What the plugins configured: replaceable parts and the hooks, owned by one comparer. */
+export type Registry = {
+    store: Store;
+    layout: Layout;
+    matcher: Matcher;
+    reporters: Reporter[];
+    engines: Map<string, DiffEngine | EngineModule>;
+    hooks: Hooks;
+    setup(plugins: Plugin[]): Promise<void>;
+};
+export declare const createRegistry: (initial: {
+    store: Store;
+    layout: Layout;
+    matcher: Matcher;
+    reporters: Reporter[];
+}) => Registry;

package/dist/pool.d.ts

@@ -0,0 +1,22 @@
+import { type CompareJob, type JobResult } from './job';
+/**
+ * Runs jobs in worker threads, one at a time per worker. With `size` 1 or no
+ * worker file it runs them in this thread, so the same code path serves tests
+ * and tiny runs.
+ */
+export declare class WorkerPool {
+    private readonly size;
+    private readonly workerFile;
+    private readonly idle;
+    private readonly workers;
+    private readonly queue;
+    private readonly running;
+    private nextId;
+    private readonly current;
+    constructor(size: number, workerFile: URL | string | undefined);
+    get threaded(): boolean;
+    run(job: CompareJob): Promise<JobResult>;
+    private pump;
+    private spawn;
+    close(): Promise<void>;
+}

package/dist/reporters.d.ts

@@ -0,0 +1,15 @@
+import { type Manifest } from 'visual-regression-manifest';
+import type { Reporter } from './types';
+type Log = (line: string) => void;
+/** One line per screenshot as it is decided, then the counts. */
+export declare const consoleReporter: (log?: Log) => Reporter;
+/** The finished run as a CTRF report. */
+export declare const ctrfReporter: (file: string) => Reporter;
+/** Markdown for a GitHub job summary: the counts and a table of what needs a human. */
+export declare const summaryMarkdown: ({ summary, entries }: Manifest) => string;
+/** Appends the summary to `file`, by default the job summary GitHub points `GITHUB_STEP_SUMMARY` at. */
+export declare const githubSummaryReporter: (file?: string | undefined) => Reporter;
+export declare const REPORTER_NAMES: readonly ["console", "ctrf", "github-summary"];
+/** `console,ctrf:report.json,github-summary[:<path>]` as reporters. */
+export declare const parseReporters: (spec: string) => Reporter[];
+export {};

package/dist/run.d.ts

@@ -0,0 +1,7 @@
+type Out = {
+    log(line: string): void;
+    error(line: string): void;
+};
+/** Runs the CLI and returns its exit code. */
+export declare const runCli: (argv: string[], out: Out) => Promise<number>;
+export {};

package/dist/store.d.ts

@@ -0,0 +1,9 @@
+import type { Store } from './types';
+export type FsStoreOptions = {
+    baselineDir: string;
+    /** Where the screenshots to compare are; only the directory call needs it. */
+    actualDir?: string;
+    /** Where `.actual` and `.diff` files are written; defaults to `baselineDir`, next to the baselines. */
+    diffDir?: string;
+};
+export declare const fsStore: ({ baselineDir, actualDir, diffDir, }: FsStoreOptions) => Store;

package/dist/test-utils.d.ts

@@ -0,0 +1,2 @@
+/** A solid-color PNG, with `dots` red pixels in its first row. */
+export declare const makePng: (width: number, height: number, color?: [number, number, number, number], dots?: number) => Uint8Array;

package/dist/types.d.ts

@@ -0,0 +1,165 @@
+import type { Manifest, ManifestColorMetric, ManifestEntry, ManifestEntryPlatform, ManifestExtra, ManifestStatus, ManifestViewport } from 'visual-regression-manifest';
+/** Decoded image: 8-bit RGBA, row by row. */
+export type RgbaImage = {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+};
+/** What the engine is given besides the images; must be structured-cloneable (it crosses the worker boundary). */
+export type EngineOptions = Record<string, unknown>;
+export type EngineResult = {
+    diffPixels: number;
+    /** `diffPixels / (width * height)` after size handling. */
+    diffRatio: number;
+    /** Omitted by engines that produce none. */
+    diff?: RgbaImage;
+    /** Engine-specific score, e.g. an SSIM mean or Resemble's mismatch percentage. */
+    score?: {
+        name: string;
+        value: number;
+    };
+};
+/** Both images have the same size by the time an engine sees them (see `SizeMismatch`). */
+export type DiffEngine = {
+    /** Recorded as `extra.visualRegressionCompare.engine`. */
+    name: string;
+    /** The manifest's `comparison.colorMetric`. */
+    colorMetric: ManifestColorMetric;
+    /** The per-pixel color tolerance used, recorded as `comparison.colorThreshold`. */
+    colorThreshold?: number;
+    compare(baseline: RgbaImage, actual: RgbaImage): EngineResult | Promise<EngineResult>;
+};
+/**
+ * A DiffEngine as a module id loads it: the default export is an engine, or a
+ * function that makes one from `EngineOptions`.
+ */
+export type EngineModule = DiffEngine | ((options: EngineOptions) => DiffEngine);
+/**
+ * What to do when baseline and actual differ in size:
+ * - `fail`: no pixel comparison; the entry fails and records both sizes, so a
+ *   resolution change shows up as what it is.
+ * - `pad`: grow both to the larger size with transparent pixels and compare.
+ * - `crop`: cut both to the smaller size and compare.
+ */
+export type SizeMismatch = 'fail' | 'pad' | 'crop';
+export type OnMissingBaseline = 'fail' | 'create';
+export type UpdatePolicy = 'none' | 'failures-only' | 'all';
+export type Limits = {
+    /** Largest accepted share of differing pixels, 0..1. Default `0`. */
+    maxDiffRatio?: number;
+    /** Largest accepted number of differing pixels; the stricter of the two limits wins. */
+    maxDiffPixels?: number;
+};
+export type ImageKind = 'baseline' | 'incoming' | 'actual' | 'diff';
+/** A file in a store: its kind and the path relative to that kind's root, with `/` separators. */
+export type ImageRef = {
+    kind: ImageKind;
+    path: string;
+};
+export type Store = {
+    /** `null` when there is no such file. */
+    read(ref: ImageRef): Promise<Uint8Array | null>;
+    write(ref: ImageRef, bytes: Uint8Array): Promise<void>;
+    /** Removing a file that is not there is not an error. */
+    remove(ref: ImageRef): Promise<void>;
+    /** Every PNG of that kind, sorted. `actual` and `diff` files are never listed as `incoming`. */
+    list(kind: 'baseline' | 'incoming'): AsyncIterable<ImageRef>;
+    /** Absolute path of the file in the project, for the manifest; `null` for stores that keep files elsewhere. */
+    locate(ref: ImageRef): string | null;
+};
+export type Layout = {
+    /** Where the files of the screenshot `name` (a relative path without extension) live, relative to each root. */
+    paths(name: string): Record<ImageKind, string>;
+    /** The reverse: the name an image of that kind belongs to, `null` for a file the layout does not own. */
+    nameOf(kind: ImageKind, path: string): string | null;
+};
+export type Matcher = {
+    /** Where the baseline of an incoming image is (or should be); `null` skips the image. */
+    baselineFor(incoming: ImageRef): ImageRef | null;
+};
+/** Identity of one compared screenshot, as an adapter or the CLI states it. */
+export type CompareInput = {
+    /** Screenshot name; becomes the file name through the layout (unsafe characters are replaced). */
+    name: string;
+    actual: Uint8Array;
+    test?: {
+        filePath?: string;
+        titlePath?: string[];
+        retry?: number;
+    };
+    platform?: ManifestEntryPlatform;
+    viewport?: ManifestViewport;
+    variant?: string;
+    extra?: ManifestExtra;
+    /** Capture plus preceding time in milliseconds, recorded as the entry's `duration`. */
+    duration?: number;
+};
+/**
+ * What hooks see of one comparison. `attachments` is reserved for extra inputs
+ * an engine may want next to the pixels (a DOM snapshot for layout-aware
+ * comparison); nothing fills it yet.
+ */
+export type CompareContext = {
+    name: string;
+    input: CompareInput;
+    attachments?: Record<string, unknown>;
+};
+export type Measurement = {
+    kind: 'compared';
+    baselineSize: {
+        width: number;
+        height: number;
+    };
+    actualSize: {
+        width: number;
+        height: number;
+    };
+    result: EngineResult;
+    /** `pad` or `crop` when the sizes differed. */
+    resized?: 'pad' | 'crop';
+} | {
+    kind: 'size-mismatch';
+    baselineSize: {
+        width: number;
+        height: number;
+    };
+    actualSize: {
+        width: number;
+        height: number;
+    };
+} | {
+    kind: 'missing-baseline';
+};
+export type Decision = {
+    status: ManifestStatus;
+    message: string;
+    /** Becomes the `visualRegressionCompare` namespace of the entry's `extra`, merged with the compare's own keys. */
+    extra?: Record<string, unknown>;
+};
+export type WritePlan = {
+    /** Files to write; a hook may drop or replace entries (a store that keeps baselines elsewhere). */
+    write: {
+        ref: ImageRef;
+        bytes: Uint8Array;
+    }[];
+};
+export type Reporter = {
+    onEntry?(entry: ManifestEntry): void | Promise<void>;
+    onEnd?(manifest: Manifest): void | Promise<void>;
+};
+export type PluginApi = {
+    addEngine(name: string, engine: DiffEngine | EngineModule): void;
+    addReporter(reporter: Reporter): void;
+    setStore(store: Store): void;
+    setLayout(layout: Layout): void;
+    setMatcher(matcher: Matcher): void;
+    on(event: 'beforeCompare', fn: (ctx: CompareContext) => void | Promise<void>): void;
+    on(event: 'afterCompare', fn: (ctx: CompareContext, measurement: Measurement) => void | Promise<void>): void;
+    on(event: 'decide', fn: (ctx: CompareContext, decision: Decision) => Decision | Promise<Decision>): void;
+    on(event: 'beforeWrite', fn: (ctx: CompareContext, plan: WritePlan) => WritePlan | Promise<WritePlan>): void;
+    on(event: 'end', fn: (manifest: Manifest) => void | Promise<void>): void;
+};
+export type Plugin = {
+    name: string;
+    setup(api: PluginApi): void | Promise<void>;
+};

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker.js

@@ -0,0 +1,167 @@
+// src/worker.ts
+import { parentPort } from "worker_threads";
+
+// src/engines/index.ts
+import path from "path";
+import { pathToFileURL } from "url";
+
+// src/engines/pixelmatch.ts
+import pixelmatch from "pixelmatch";
+var pixelmatchEngine = ({
+  threshold = 0.1,
+  includeAA = false
+} = {}) => ({
+  name: "pixelmatch",
+  colorMetric: "yiq",
+  colorThreshold: threshold,
+  compare(baseline, actual) {
+    const { width, height } = baseline;
+    const diff = new Uint8ClampedArray(width * height * 4);
+    const diffPixels = pixelmatch(
+      baseline.data,
+      actual.data,
+      diff,
+      width,
+      height,
+      {
+        threshold,
+        includeAA
+      }
+    );
+    const area = width * height;
+    return {
+      diffPixels,
+      diffRatio: area === 0 ? 0 : diffPixels / area,
+      diff: { width, height, data: diff }
+    };
+  }
+});
+var pixelmatchFrom = (options) => pixelmatchEngine(options);
+
+// src/engines/index.ts
+var BUILT_IN = {
+  pixelmatch: pixelmatchFrom
+};
+var BUILT_IN_ENGINES = Object.keys(BUILT_IN);
+var isDiffEngine = (value) => typeof value === "object" && value !== null && typeof value.compare === "function" && typeof value.name === "string";
+var loadEngine = async (id, options = {}, cwd = process.cwd()) => {
+  const builtIn = BUILT_IN[id];
+  if (builtIn) return builtIn(options);
+  const isPath = /^\.{0,2}[\\/]/.test(id) || path.isAbsolute(id);
+  const specifier = isPath ? pathToFileURL(path.resolve(cwd, id)).href : id;
+  let loaded;
+  try {
+    loaded = await import(specifier);
+  } catch (error) {
+    throw new Error(
+      `Cannot load engine "${id}" (built in: ${BUILT_IN_ENGINES.join(", ")}): ${error.message}`,
+      { cause: error }
+    );
+  }
+  const exported = loaded.default;
+  const engine = typeof exported === "function" ? exported(options) : exported;
+  if (!isDiffEngine(engine)) {
+    throw new Error(
+      `Engine "${id}" must default-export a { name, colorMetric, compare } object or a function returning one`
+    );
+  }
+  return engine;
+};
+
+// src/image.ts
+import { PNG } from "pngjs";
+var LFS_POINTER = "version https://git-lfs.github.com/spec/";
+var decodePng = (bytes) => {
+  const head = Buffer.from(bytes.subarray(0, LFS_POINTER.length)).toString(
+    "latin1"
+  );
+  if (head === LFS_POINTER) {
+    throw new Error(
+      "the file is a Git LFS pointer, not an image; run `git lfs pull`"
+    );
+  }
+  const { width, height, data } = PNG.sync.read(Buffer.from(bytes));
+  return { width, height, data: new Uint8ClampedArray(data) };
+};
+var encodePng = ({ width, height, data }) => {
+  const png = new PNG({ width, height });
+  png.data = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  return PNG.sync.write(png);
+};
+var resize = (image, width, height) => {
+  const data = new Uint8ClampedArray(width * height * 4);
+  const rows = Math.min(height, image.height);
+  const rowBytes = Math.min(width, image.width) * 4;
+  for (let y = 0; y < rows; y++) {
+    const from = y * image.width * 4;
+    data.set(image.data.subarray(from, from + rowBytes), y * width * 4);
+  }
+  return { width, height, data };
+};
+var padToSame = (a, b) => {
+  const width = Math.max(a.width, b.width);
+  const height = Math.max(a.height, b.height);
+  return [resize(a, width, height), resize(b, width, height)];
+};
+var cropToSame = (a, b) => {
+  const width = Math.min(a.width, b.width);
+  const height = Math.min(a.height, b.height);
+  return [resize(a, width, height), resize(b, width, height)];
+};
+
+// src/job.ts
+var decodeNamed = (which, bytes) => {
+  try {
+    return decodePng(bytes);
+  } catch (error) {
+    throw new Error(`the ${which} image: ${error.message}`, {
+      cause: error
+    });
+  }
+};
+var sizeOf = ({ width, height }) => ({ width, height });
+var runCompare = async (job, engine) => {
+  let baseline = decodeNamed("baseline", job.baseline);
+  let actual = decodeNamed("actual", job.actual);
+  const baselineSize = sizeOf(baseline);
+  const actualSize = sizeOf(actual);
+  let resized;
+  if (baseline.width !== actual.width || baseline.height !== actual.height) {
+    if (job.onSizeMismatch === "fail") {
+      return { kind: "size-mismatch", baselineSize, actualSize };
+    }
+    resized = job.onSizeMismatch;
+    [baseline, actual] = (resized === "pad" ? padToSame : cropToSame)(
+      baseline,
+      actual
+    );
+  }
+  const { diff, ...result } = await engine.compare(baseline, actual);
+  return {
+    kind: "compared",
+    baselineSize,
+    actualSize,
+    ...resized && { resized },
+    ...result,
+    ...diff && { diffPng: encodePng(diff) }
+  };
+};
+var runJob = async (job) => runCompare(
+  job,
+  await loadEngine(job.engine.id, job.engine.options, job.engine.cwd)
+);
+
+// src/worker.ts
+parentPort?.on(
+  "message",
+  async ({ id, job }) => {
+    try {
+      parentPort?.postMessage({ id, result: await runJob(job) });
+    } catch (error) {
+      parentPort?.postMessage({
+        id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+);

package/package.json

@@ -1,6 +1,72 @@
 {
   "name": "visual-regression-compare",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Tool-agnostic image comparison for visual regression testing: pairs baseline and actual screenshots, runs a pluggable diff engine, applies limits, writes .actual and .diff files and a visual-regression-manifest run manifest. A CLI for folders of images and a library for test-runner adapters.",
+  "version": "1.0.0-beta.0",
+  "author": "Jakub Freisler <jakub.freisler@frsource.org>",
+  "homepage": "https://visual-regression.dev/compare-cli",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/visual-regression/visual-regression.git",
+    "directory": "packages/visual-regression-compare"
+  },
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "visual-regression-compare": "dist/cli.js",
+    "vrc": "dist/cli.js"
+  },
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "dependencies": {
+    "pixelmatch": "^7.2.0",
+    "pngjs": "^7.0.0",
+    "visual-regression-manifest": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.43",
+    "@types/pngjs": "^6.0.5",
+    "@types/tmp": "0.2.6",
+    "@vitest/coverage-v8": "4.1.11",
+    "del-cli": "7.0.0",
+    "esbuild": "0.28.2",
+    "tmp-promise": "3.0.3",
+    "typescript": "6.0.3",
+    "vitest": "4.1.11"
+  },
+  "keywords": [
+    "visual regression testing",
+    "visual diff",
+    "image diff",
+    "screenshot testing",
+    "pixelmatch",
+    "run manifest",
+    "CLI"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "del-cli dist && tsc -p tsconfig.build.json --emitDeclarationOnly --declaration --outDir dist && esbuild src/index.ts src/worker.ts --bundle --platform=node --target=node20 --format=esm --packages=external --outdir=dist && esbuild src/cli.ts --bundle --platform=node --target=node20 --format=esm --packages=external --banner:js='#!/usr/bin/env node' --outfile=dist/cli.js && node scripts/executable.mjs",
+    "test:integration": "vitest run",
+    "test:integration:watch": "vitest",
+    "test:integration:coverage": "vitest run --coverage",
+    "test:integration:ci": "CI=true vitest run --coverage"
+  }
 }