visual-regression-compare 1.0.0-beta.0 → 1.0.0-beta.1

package/README.md

@@ -141,7 +141,74 @@ await comparer.compareAll(); // every image under actualDir
 await comparer.close(); // flushes the manifest, ends the reporters
 ```
 
-Decoding and comparing run in worker threads when the engine is named by id (`engine: 'pixelmatch'`, `engine: './my-engine.mjs'`). An engine passed as an object runs in the main thread, and `concurrency` then only affects `compareAll`'s parallel reads. Engine options must be structured-cloneable.
+Decoding and comparing run in worker threads when the engine is named by id (`engine: 'pixelmatch'`, `engine: './my-engine.mjs'`) and `concurrency` is above 1. The library's default is `1`, which runs everything in the calling thread, because a test runner's own workers already use the CPUs; the command line defaults to the CPU count. An engine passed as an object runs in the main thread, and `concurrency` then only affects `compareAll`'s parallel reads. Engine options must be structured-cloneable.
+
+### Per-call settings
+
+A test runner changes its options from one assertion to the next. `compareImage` and `compare` take them on the input, for that screenshot only:
+
+```ts
+await comparer.compareImage({
+  name: 'checkout',
+  actual: pngBuffer,
+  options: {
+    limits: { maxDiffRatio: 0.02 }, // replaces the comparer's limits
+    engineOptions: { threshold: 0.2, includeAA: true }, // merged over its engine options
+    update: 'failures-only',
+    onMissingBaseline: 'create',
+    onSizeMismatch: 'pad',
+  },
+});
+```
+
+The entry records the limit and color threshold the call used.
+
+### Files at known paths
+
+A runner that already knows where the baseline, the `.actual` and the `.diff` file live (or that compares against a baseline kept under another name) passes them as absolute paths. They replace the store, layout and matcher for that call; `actual` and `diff` default to `<baseline>.actual.png` and `<baseline>.diff.png`.
+
+```ts
+await comparer.compareImage({
+  name: 'checkout',
+  actual: pngBuffer,
+  files: {
+    baseline: '/repo/e2e/__image_snapshots__/checkout.png',
+    actual: '/repo/e2e/__image_snapshots__/checkout.actual.png',
+  },
+});
+```
+
+### Getting the images back
+
+`compare` returns the entry and, when asked, the PNG bytes of the baseline, the actual and the diff as they were compared (padded or cropped to the same size when the sizes differed). That is what a review UI needs, including for a screenshot that passed.
+
+```ts
+const { entry, images } = await comparer.compare(
+  { name: 'checkout', actual: pngBuffer },
+  { include: ['baseline', 'actual', 'diff'] },
+);
+// images.diff, images.actual, images.baseline: Uint8Array
+```
+
+### Your own manifest writer
+
+By default the comparer writes its own manifest. A runner that builds the header itself (CI and run metadata, one file per worker) passes its `ManifestWriter`, and states per-entry fields the comparer cannot know (`options`, `renderer`, `attachments`, `baselineExtra`, `target`, `subject`) as `entry` on the input. They are recorded as given.
+
+```ts
+const writer = new ManifestWriter(
+  'out/visual-regression-manifest.worker-0.json',
+  {
+    projectRoot: process.cwd(),
+    runner: { name: 'my-runner' },
+  },
+);
+const comparer = createComparer({ store, manifest: { writer } });
+await comparer.compareImage({
+  name: 'checkout',
+  actual: pngBuffer,
+  entry: { renderer: { backend: 'docker', name: 'chromium' } },
+});
+```
 
 ## Extending
 

package/dist/cli.js

@@ -2,6 +2,7 @@
 
 // src/run.ts
 import fs6 from "fs";
+import os from "os";
 import path7 from "path";
 
 // src/approve.ts
@@ -138,11 +139,11 @@ var approve = ({
 };
 
 // src/comparer.ts
-import fs2 from "fs";
-import os from "os";
-import path3 from "path";
+import fs3 from "fs";
+import path4 from "path";
 import {
   ManifestWriter,
+  IMAGE_SUFFIX as IMAGE_SUFFIX2,
   getManifestFileName,
   maxRatioFrom
 } from "visual-regression-manifest";
@@ -283,13 +284,18 @@ var runCompare = async (job, engine) => {
     );
   }
   const { diff, ...result } = await engine.compare(baseline, actual);
+  const compared = (part, image) => job.include?.includes(part) ? {
+    [`${part}Png`]: resized ? encodePng(image) : job[part]
+  } : {};
   return {
     kind: "compared",
     baselineSize,
     actualSize,
     ...resized && { resized },
     ...result,
-    ...diff && { diffPng: encodePng(diff) }
+    ...diff && { diffPng: encodePng(diff) },
+    ...compared("baseline", baseline),
+    ...compared("actual", actual)
   };
 };
 var runJob = async (job) => runCompare(
@@ -411,6 +417,103 @@ var templateMatcher = (template) => ({
   }
 });
 
+// src/store.ts
+import fs2 from "fs";
+import path3 from "path";
+import { isSafeRelativePath as isSafeRelativePath2 } from "visual-regression-manifest";
+var GENERATED = /\.(actual|diff)\.png$/;
+var fsStore = ({
+  baselineDir,
+  actualDir,
+  diffDir
+}) => {
+  const roots = {
+    baseline: baselineDir,
+    incoming: actualDir,
+    actual: diffDir ?? baselineDir,
+    diff: diffDir ?? baselineDir
+  };
+  const rootOf = (kind) => {
+    const root = roots[kind];
+    if (!root) throw new Error(`The store has no directory for ${kind} images`);
+    return path3.resolve(root);
+  };
+  const locate = ({ kind, path: relative }) => {
+    if (relative !== "" && !isSafeRelativePath2(relative)) {
+      throw new Error(`Unsafe image path ${JSON.stringify(relative)}`);
+    }
+    return path3.join(rootOf(kind), relative);
+  };
+  return {
+    locate,
+    async read(ref) {
+      try {
+        return await fs2.promises.readFile(locate(ref));
+      } catch (error) {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      }
+    },
+    async write(ref, bytes) {
+      const file = locate(ref);
+      await fs2.promises.mkdir(path3.dirname(file), { recursive: true });
+      await fs2.promises.writeFile(file, bytes);
+    },
+    async remove(ref) {
+      await fs2.promises.rm(locate(ref), { force: true });
+    },
+    async *list(kind) {
+      const root = rootOf(kind);
+      const found = [];
+      const walk = async (dir, prefix) => {
+        for (const dirent of await fs2.promises.readdir(dir, {
+          withFileTypes: true
+        })) {
+          const relative = prefix ? `${prefix}/${dirent.name}` : dirent.name;
+          if (dirent.isDirectory()) {
+            if (dirent.name !== "node_modules" && dirent.name !== ".git") {
+              await walk(path3.join(dir, dirent.name), relative);
+            }
+          } else if (dirent.isFile() && dirent.name.endsWith(".png") && !GENERATED.test(dirent.name)) {
+            found.push(relative);
+          }
+        }
+      };
+      await walk(root, "");
+      for (const relative of found.sort()) yield { kind, path: relative };
+    }
+  };
+};
+var fileStore = (files) => {
+  const locate = ({ kind }) => {
+    if (kind === "incoming") {
+      throw new Error("A file store has no incoming images");
+    }
+    return files[kind];
+  };
+  return {
+    locate,
+    async read(ref) {
+      try {
+        return await fs2.promises.readFile(locate(ref));
+      } catch (error) {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      }
+    },
+    async write(ref, bytes) {
+      const file = locate(ref);
+      await fs2.promises.mkdir(path3.dirname(file), { recursive: true });
+      await fs2.promises.writeFile(file, bytes);
+    },
+    async remove(ref) {
+      await fs2.promises.rm(locate(ref), { force: true });
+    },
+    async *list() {
+    }
+  };
+};
+
 // src/plugins.ts
 var createRegistry = (initial) => {
   const registry = {
@@ -445,7 +548,7 @@ var createRegistry = (initial) => {
 var TOOL_NAME = "visual-regression-compare";
 var packageVersion = () => {
   try {
-    const text = fs2.readFileSync(
+    const text = fs3.readFileSync(
       new URL("../package.json", import.meta.url),
       "utf8"
     );
@@ -454,15 +557,21 @@ var packageVersion = () => {
     return void 0;
   }
 };
+var withDefaults = ({ baseline, actual, diff }) => {
+  const stem = baseline.replace(/\.png$/, "");
+  return {
+    baseline,
+    actual: actual ?? `${stem}${IMAGE_SUFFIX2.actual}.png`,
+    diff: diff ?? `${stem}${IMAGE_SUFFIX2.diff}.png`
+  };
+};
 var DEFAULT_WORKER = new URL("./worker.js", import.meta.url);
 var percent = (ratio2) => `${Number((ratio2 * 100).toPrecision(3))}%`;
 var sizeText = ({ width, height }) => `${width}x${height}`;
 var Comparer = class {
   constructor(options) {
     this.options = options;
-    this.projectRoot = path3.resolve(
-      options.manifest.projectRoot ?? process.cwd()
-    );
+    this.projectRoot = options.manifest.writer ? options.manifest.writer.projectRoot : path4.resolve(options.manifest.projectRoot ?? process.cwd());
     this.registry = createRegistry({
       store: options.store,
       layout: options.layout ?? manifestLayout(),
@@ -473,9 +582,27 @@ var Comparer = class {
     this.layout = () => this.registry.layout;
     this.matcher = () => this.registry.matcher;
     this.ready = this.registry.setup(options.plugins ?? []);
-    const manifestPath = options.manifest.path ?? path3.join(this.projectRoot, getManifestFileName("compare"));
-    this.writer = new ManifestWriter(
-      path3.resolve(this.projectRoot, manifestPath),
+    this.writer = options.manifest.writer ?? this.createWriter(options);
+    this.pool = new WorkerPool(
+      options.concurrency ?? 1,
+      options.workerFile ?? DEFAULT_WORKER
+    );
+  }
+  options;
+  writer;
+  projectRoot;
+  store;
+  layout;
+  matcher;
+  pool;
+  registry;
+  ready;
+  engines = /* @__PURE__ */ new Map();
+  closed = false;
+  createWriter(options) {
+    const manifestPath = options.manifest.path ?? path4.join(this.projectRoot, getManifestFileName("compare"));
+    return new ManifestWriter(
+      path4.resolve(this.projectRoot, manifestPath),
       {
         projectRoot: this.projectRoot,
         tool: options.manifest.tool ?? {
@@ -494,73 +621,106 @@ var Comparer = class {
       },
       { writeDelayMs: 200 }
     );
-    this.pool = new WorkerPool(
-      options.concurrency ?? os.cpus().length,
-      options.workerFile ?? DEFAULT_WORKER
-    );
   }
-  options;
-  writer;
-  projectRoot;
-  store;
-  layout;
-  matcher;
-  pool;
-  registry;
-  ready;
-  engine;
-  closed = false;
+  /** The comparer's settings with the overrides of one call applied. */
+  settings(call = {}) {
+    const o = this.options;
+    return {
+      limits: call.limits ?? o.limits ?? {},
+      engineOptions: { ...o.engineOptions, ...call.engineOptions },
+      update: call.update ?? o.update ?? "none",
+      onMissingBaseline: call.onMissingBaseline ?? o.onMissingBaseline ?? "fail",
+      onSizeMismatch: call.onSizeMismatch ?? o.onSizeMismatch ?? "fail"
+    };
+  }
   /** The engine as the main thread knows it: for its name and metric, and to run it when it is an object or came from a plugin. */
-  resolveEngine() {
-    this.engine ??= (async () => {
-      await this.ready;
-      const { engine = "pixelmatch", engineOptions = {} } = this.options;
-      if (typeof engine === "object") return engine;
-      const registered = this.registry.engines.get(engine);
-      if (typeof registered === "object") return registered;
-      if (typeof registered === "function") return registered(engineOptions);
-      return loadEngine(engine, engineOptions);
-    })();
-    return this.engine;
+  resolveEngine(engineOptions) {
+    const key = JSON.stringify(engineOptions);
+    let engine = this.engines.get(key);
+    if (!engine) {
+      engine = (async () => {
+        await this.ready;
+        const { engine: spec = "pixelmatch" } = this.options;
+        if (typeof spec === "object") return spec;
+        const registered = this.registry.engines.get(spec);
+        if (typeof registered === "object") return registered;
+        if (typeof registered === "function") return registered(engineOptions);
+        return loadEngine(spec, engineOptions);
+      })();
+      this.engines.set(key, engine);
+    }
+    return engine;
   }
-  async measure(baseline, actual, engine) {
-    const { engine: spec = "pixelmatch", engineOptions } = this.options;
+  async measure(baseline, actual, engine, cfg, include) {
+    const { engine: spec = "pixelmatch" } = this.options;
     const inMainThread = typeof spec === "object" || this.registry.engines.has(spec);
-    const onSizeMismatch = this.options.onSizeMismatch ?? "fail";
-    if (inMainThread) {
-      return runCompare({ baseline, actual, onSizeMismatch }, engine);
-    }
-    return this.pool.run({
+    const job = {
       baseline,
       actual,
-      onSizeMismatch,
-      engine: { id: spec, options: engineOptions, cwd: process.cwd() }
+      onSizeMismatch: cfg.onSizeMismatch,
+      include
+    };
+    if (inMainThread) return runCompare(job, engine);
+    return this.pool.run({
+      ...job,
+      engine: { id: spec, options: cfg.engineOptions, cwd: process.cwd() }
     });
   }
   /** Compares one screenshot, decides, writes the files and records the manifest entry. */
   async compareImage(input) {
+    return (await this.compare(input)).entry;
+  }
+  /**
+   * `compareImage` that can also hand back the compared images as PNG bytes,
+   * for a runner that shows them (a review UI). `include` names the parts;
+   * the diff is encoded anyway, the other two cost nothing when the sizes
+   * match.
+   */
+  async compare(input, { include = [] } = {}) {
     await this.ready;
     const name = sanitizeName(input.name);
+    if (input.files) {
+      return this.compareAt(
+        input,
+        name,
+        { kind: "baseline", path: "baseline" },
+        include
+      );
+    }
     const baseline = {
       kind: "baseline",
       path: this.layout().paths(name).baseline
     };
-    return this.compareAt(input, name, baseline);
+    return this.compareAt(input, name, baseline, include);
+  }
+  compareAt(input, name, baselineRef, include) {
+    const store = input.files ? fileStore(withDefaults(input.files)) : this.store();
+    const names = input.files ? { actual: "actual", diff: "diff" } : this.layout().paths(name);
+    return this.compareWith(input, name, baselineRef, include, store, names);
   }
-  async compareAt(input, name, baselineRef) {
+  async compareWith(input, name, baselineRef, include, store, names) {
+    const cfg = this.settings(input.options);
     const started = Date.now();
     const ctx = { name, input };
     for (const fn of this.registry.hooks.beforeCompare) await fn(ctx);
-    const engine = await this.resolveEngine();
-    const baselineBytes = await this.store().read(baselineRef);
+    const engine = await this.resolveEngine(cfg.engineOptions);
+    const baselineBytes = await store.read(baselineRef);
     let measurement;
     let diffPng;
+    const images = {};
     if (baselineBytes === null) {
       measurement = { kind: "missing-baseline" };
+      if (include.includes("actual")) images.actual = input.actual;
     } else {
       let job;
       try {
-        job = await this.measure(baselineBytes, input.actual, engine);
+        job = await this.measure(
+          baselineBytes,
+          input.actual,
+          engine,
+          cfg,
+          include
+        );
       } catch (error) {
         throw new Error(`${name}: ${error.message}`, {
           cause: error
@@ -578,21 +738,25 @@ var Comparer = class {
         }
       };
       diffPng = job.kind === "compared" ? job.diffPng : void 0;
+      if (job.kind === "compared") {
+        if (include.includes("diff") && diffPng) images.diff = diffPng;
+        if (job.baselinePng) images.baseline = job.baselinePng;
+        if (job.actualPng) images.actual = job.actualPng;
+      }
     }
     for (const fn of this.registry.hooks.afterCompare)
       await fn(ctx, measurement);
-    const limit = this.limitFor(measurement);
-    let decision = this.decide(measurement, limit);
+    const limit = this.limitFor(measurement, cfg);
+    let decision = this.decide(measurement, limit, cfg);
     for (const fn of this.registry.hooks.decide) {
       decision = await fn(ctx, decision);
     }
-    const names = this.layout().paths(name);
     const refs = {
       actual: { kind: "actual", path: names.actual },
       diff: { kind: "diff", path: names.diff }
     };
-    await this.store().remove(refs.actual);
-    await this.store().remove(refs.diff);
+    await store.remove(refs.actual);
+    await store.remove(refs.diff);
     let plan = { write: [] };
     const status = decision.status;
     if (status === "failed" || status === "missing-baseline") {
@@ -603,9 +767,10 @@ var Comparer = class {
     }
     for (const fn of this.registry.hooks.beforeWrite)
       plan = await fn(ctx, plan);
-    for (const { ref, bytes } of plan.write)
-      await this.store().write(ref, bytes);
+    for (const { ref, bytes } of plan.write) await store.write(ref, bytes);
     const entry = this.record(
+      store,
+      cfg,
       input,
       name,
       baselineRef,
@@ -618,10 +783,10 @@ var Comparer = class {
     );
     for (const reporter of this.registry.reporters)
       await reporter.onEntry?.(entry);
-    return entry;
+    return { entry, images };
   }
   /** `maxDiffRatio` of the entry: the stricter of the ratio and the pixel count, for the size actually compared. */
-  limitFor(measurement) {
+  limitFor(measurement, cfg) {
     if (measurement.kind !== "compared") return void 0;
     const { baselineSize: b, actualSize: a, resized } = measurement;
     const size = resized === "pad" ? {
@@ -631,11 +796,10 @@ var Comparer = class {
       width: Math.min(a.width, b.width),
       height: Math.min(a.height, b.height)
     } : a;
-    const { maxDiffRatio, maxDiffPixels } = this.options.limits ?? {};
+    const { maxDiffRatio, maxDiffPixels } = cfg.limits;
     return maxRatioFrom({ ratio: maxDiffRatio, pixels: maxDiffPixels }, size) ?? 0;
   }
-  decide(measurement, limit) {
-    const { update = "none", onMissingBaseline = "fail" } = this.options;
+  decide(measurement, limit, { update, onMissingBaseline }) {
     if (measurement.kind === "missing-baseline") {
       return onMissingBaseline === "create" ? {
         status: "created",
@@ -673,16 +837,15 @@ var Comparer = class {
       message: `${counts}; the limit is ${percent(limit ?? 0)}.${resized}`
     };
   }
-  record(input, name, baselineRef, refs, measurement, decision, limit, engine, duration) {
-    const store = this.store();
-    const where = (ref) => store.locate(ref) ?? path3.join(this.projectRoot, ref.path);
+  record(store, cfg, input, name, baselineRef, refs, measurement, decision, limit, engine, duration) {
+    const where = (ref) => store.locate(ref) ?? path4.join(this.projectRoot, ref.path);
     const status = decision.status;
     const compared = measurement.kind === "compared" ? measurement : void 0;
     const sized = measurement.kind !== "missing-baseline" ? measurement : void 0;
-    const { maxDiffRatio = 0 } = this.options.limits ?? {};
-    const baselineRoot = path3.relative(
+    const { maxDiffRatio = 0 } = cfg.limits;
+    const baselineRoot = path4.relative(
       this.projectRoot,
-      where({ kind: "baseline", path: "" })
+      input.files ? path4.dirname(input.files.baseline) : where({ kind: "baseline", path: "" })
     );
     const meta = {
       engine: engine.name,
@@ -717,12 +880,13 @@ var Comparer = class {
       viewport: input.viewport,
       variant: input.variant ?? this.options.manifest.variant,
       extra: { ...input.extra, visualRegressionCompare: meta },
-      options: {
+      ...input.entry,
+      options: input.entry?.options ?? {
         imagesPath: `${baselineRoot || "."}/{name}.png`,
         maxDiffRatio,
-        diffConfig: { engine: engine.name, ...this.options.engineOptions },
-        createMissingImages: this.options.onMissingBaseline === "create",
-        updateImages: this.options.update === "failures-only" ? "failures-only" : this.options.update === "all"
+        diffConfig: { engine: engine.name, ...cfg.engineOptions },
+        createMissingImages: cfg.onMissingBaseline === "create",
+        updateImages: cfg.update === "failures-only" ? "failures-only" : cfg.update === "all"
       },
       duration: input.duration ?? duration
     });
@@ -733,7 +897,7 @@ var Comparer = class {
     const refs = [];
     for await (const ref of this.store().list("incoming")) refs.push(ref);
     const queue = [...refs];
-    const workers = Math.max(1, this.options.concurrency ?? os.cpus().length);
+    const workers = Math.max(1, this.options.concurrency ?? 1);
     const failures = [];
     await Promise.all(
       Array.from({ length: Math.min(workers, queue.length) }, async () => {
@@ -761,7 +925,7 @@ ${failures.map((f) => `  ${f.message}`).join("\n")}`
     const name = this.layout().nameOf("baseline", baselineRef.path) ?? baselineRef.path.replace(/\.png$/, "");
     const actual = await this.store().read(incoming);
     if (actual === null) return;
-    await this.compareAt({ name, actual }, name, baselineRef);
+    await this.compareAt({ name, actual }, name, baselineRef, []);
   }
   /** Flushes the manifest and ends the reporters. Call once, after the last comparison. */
   async close() {
@@ -782,8 +946,8 @@ ${failures.map((f) => `  ${f.message}`).join("\n")}`
 var createComparer = (options) => new Comparer(options);
 
 // src/config.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var CANDIDATES = [
   "visual-regression.config.json",
@@ -791,13 +955,13 @@ var CANDIDATES = [
   "visual-regression.config.js"
 ];
 var loadConfig = async (explicit, cwd = process.cwd()) => {
-  const file = explicit ? path4.resolve(cwd, explicit) : CANDIDATES.map((name) => path4.join(cwd, name)).find(
-    (f) => fs3.existsSync(f)
+  const file = explicit ? path5.resolve(cwd, explicit) : CANDIDATES.map((name) => path5.join(cwd, name)).find(
+    (f) => fs4.existsSync(f)
   );
   if (!file) return {};
-  if (!fs3.existsSync(file))
+  if (!fs4.existsSync(file))
     throw new Error(`Config file ${file} does not exist`);
-  if (file.endsWith(".json")) return JSON.parse(fs3.readFileSync(file, "utf8"));
+  if (file.endsWith(".json")) return JSON.parse(fs4.readFileSync(file, "utf8"));
   const loaded = await import(pathToFileURL2(file).href);
   return loaded.default ?? {};
 };
@@ -810,74 +974,6 @@ var configArg = (argv) => {
   return arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : argv[at + 1];
 };
 
-// src/store.ts
-import fs4 from "fs";
-import path5 from "path";
-import { isSafeRelativePath as isSafeRelativePath2 } from "visual-regression-manifest";
-var GENERATED = /\.(actual|diff)\.png$/;
-var fsStore = ({
-  baselineDir,
-  actualDir,
-  diffDir
-}) => {
-  const roots = {
-    baseline: baselineDir,
-    incoming: actualDir,
-    actual: diffDir ?? baselineDir,
-    diff: diffDir ?? baselineDir
-  };
-  const rootOf = (kind) => {
-    const root = roots[kind];
-    if (!root) throw new Error(`The store has no directory for ${kind} images`);
-    return path5.resolve(root);
-  };
-  const locate = ({ kind, path: relative }) => {
-    if (relative !== "" && !isSafeRelativePath2(relative)) {
-      throw new Error(`Unsafe image path ${JSON.stringify(relative)}`);
-    }
-    return path5.join(rootOf(kind), relative);
-  };
-  return {
-    locate,
-    async read(ref) {
-      try {
-        return await fs4.promises.readFile(locate(ref));
-      } catch (error) {
-        if (error.code === "ENOENT") return null;
-        throw error;
-      }
-    },
-    async write(ref, bytes) {
-      const file = locate(ref);
-      await fs4.promises.mkdir(path5.dirname(file), { recursive: true });
-      await fs4.promises.writeFile(file, bytes);
-    },
-    async remove(ref) {
-      await fs4.promises.rm(locate(ref), { force: true });
-    },
-    async *list(kind) {
-      const root = rootOf(kind);
-      const found = [];
-      const walk = async (dir, prefix) => {
-        for (const dirent of await fs4.promises.readdir(dir, {
-          withFileTypes: true
-        })) {
-          const relative = prefix ? `${prefix}/${dirent.name}` : dirent.name;
-          if (dirent.isDirectory()) {
-            if (dirent.name !== "node_modules" && dirent.name !== ".git") {
-              await walk(path5.join(dir, dirent.name), relative);
-            }
-          } else if (dirent.isFile() && dirent.name.endsWith(".png") && !GENERATED.test(dirent.name)) {
-            found.push(relative);
-          }
-        }
-      };
-      await walk(root, "");
-      for (const relative of found.sort()) yield { kind, path: relative };
-    }
-  };
-};
-
 // src/options.ts
 import { parseArgs } from "util";
 import {
@@ -1217,7 +1313,7 @@ var compare = async (options, version, out) => {
       variant: options.variant
     },
     reporters: parseReporters(options.report),
-    concurrency: options.concurrency
+    concurrency: options.concurrency ?? os.cpus().length
   });
   try {
     await comparer.compareAll();