@cappa/core 0.13.2 → 0.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.cjs CHANGED
@@ -482,6 +482,48 @@ function defineConfig(options) {
482
482
  return options;
483
483
  }
484
484
  //#endregion
485
+ //#region src/consoleEvents.ts
486
+ const CONSOLE_LOG_LEVELS = [
487
+ "error",
488
+ "warn",
489
+ "info",
490
+ "log",
491
+ "debug"
492
+ ];
493
+ /** Maps a Playwright `ConsoleMessage.type()` onto a {@link ConsoleLogLevel}. */
494
+ const toConsoleLogLevel = (type) => {
495
+ switch (type) {
496
+ case "error":
497
+ case "assert": return "error";
498
+ case "warning": return "warn";
499
+ case "info": return "info";
500
+ case "debug":
501
+ case "trace": return "debug";
502
+ default: return "log";
503
+ }
504
+ };
505
+ const severity = (level) => CONSOLE_LOG_LEVELS.indexOf(level);
506
+ /**
507
+ * Wires a page's `console` and `pageerror` events to `logger` according to
508
+ * `setting`. Uncaught page errors are always forwarded — at error level when
509
+ * a severity threshold is set, at debug level otherwise.
510
+ */
511
+ const attachConsoleLogging = (page, setting, logger) => {
512
+ const threshold = setting ?? true;
513
+ if (threshold === true) page.on("console", (message) => {
514
+ logger.debug("console", message.text());
515
+ });
516
+ else if (threshold !== false) page.on("console", (message) => {
517
+ const level = toConsoleLogLevel(message.type());
518
+ if (severity(level) > severity(threshold)) return;
519
+ logger[level](`[browser ${level}]`, message.text());
520
+ });
521
+ page.on("pageerror", (error) => {
522
+ if (typeof threshold === "string") logger.error("[browser pageerror]", error);
523
+ else logger.debug("pageerror", error);
524
+ });
525
+ };
526
+ //#endregion
485
527
  //#region src/mapWithConcurrency.ts
486
528
  /**
487
529
  * Run async work over `items` with at most `concurrency` tasks in flight.
@@ -802,6 +844,17 @@ var ScreenshotFileSystem = class {
802
844
  await node_fs_promises.default.writeFile(filepath, data);
803
845
  }
804
846
  /**
847
+ * Remove a screenshot's diff image and metadata sidecar, if any.
848
+ *
849
+ * A run that does not clear `diff/` — a filtered or single-screenshot
850
+ * re-capture — would otherwise leave the previous run's diff behind for a
851
+ * screenshot that now passes, and a screenshot with a diff is `changed`.
852
+ */
853
+ async removeDiffFiles(filename) {
854
+ const filepath = this.getDiffFilePath(filename);
855
+ await Promise.all([node_fs_promises.default.rm(filepath, { force: true }), node_fs_promises.default.rm(toDiffMetaPath(filepath), { force: true })]);
856
+ }
857
+ /**
805
858
  * Get the path to a diff metadata sidecar file (`<name>.json`)
806
859
  */
807
860
  getDiffMetaFilePath(filename) {
@@ -1815,6 +1868,7 @@ var ScreenshotTool = class {
1815
1868
  const saveDiff = extras.saveDiffImage ?? false;
1816
1869
  const diffFilename = extras.diffImageFilename ?? filename;
1817
1870
  const diffOverride = extras.diff;
1871
+ await this.filesystem.removeDiffFiles(diffFilename);
1818
1872
  if (!await this.filesystem.hasExpectedFile(filename)) {
1819
1873
  this.logger.debug(`Expected image not found for ${filename}, taking screenshot`);
1820
1874
  result.filepath = await this.takeScreenshot(page, filename, options);
@@ -2014,6 +2068,204 @@ var ScreenshotTool = class {
2014
2068
  }
2015
2069
  };
2016
2070
  //#endregion
2071
+ //#region src/agent/paths.ts
2072
+ /**
2073
+ * Where agent review keeps its state, inside `outputDir`.
2074
+ *
2075
+ * Its own module so screenshot collection can read the report without
2076
+ * importing the review pipeline, which itself collects screenshots.
2077
+ */
2078
+ const AGENT_DIRNAME = ".cappa-agent";
2079
+ /** Bumped only if `request.json` or `report.json` change incompatibly. */
2080
+ const AGENT_REPORT_VERSION = 1;
2081
+ const agentDir = (outputDir) => node_path.default.resolve(outputDir, AGENT_DIRNAME);
2082
+ const judgmentsRoot = (outputDir) => node_path.default.join(agentDir(outputDir), "judgments");
2083
+ const agentReportPath = (outputDir) => node_path.default.join(agentDir(outputDir), "report.json");
2084
+ //#endregion
2085
+ //#region src/agent/verdict.ts
2086
+ /**
2087
+ * What a reviewer — heuristic or agent — believes a changed screenshot is.
2088
+ *
2089
+ * `ambiguous` is only ever produced by the heuristic: it is the signal that
2090
+ * the change has to be looked at, and an agent's verdict must resolve it into
2091
+ * one of the other three.
2092
+ */
2093
+ const VERDICT_LABELS = [
2094
+ "regression-likely",
2095
+ "intentional-likely",
2096
+ "noise-likely",
2097
+ "ambiguous"
2098
+ ];
2099
+ /** The labels a judge may hand back — everything but `ambiguous`. */
2100
+ const JUDGED_LABELS = [
2101
+ "regression-likely",
2102
+ "intentional-likely",
2103
+ "noise-likely"
2104
+ ];
2105
+ const ACTION_BY_LABEL = {
2106
+ "regression-likely": "investigate",
2107
+ "intentional-likely": "approve-if-intended",
2108
+ "noise-likely": "mask-or-approve",
2109
+ ambiguous: "investigate"
2110
+ };
2111
+ const isVerdictLabel = (value) => typeof value === "string" && VERDICT_LABELS.includes(value);
2112
+ const isJudgedLabel = (value) => typeof value === "string" && JUDGED_LABELS.includes(value);
2113
+ /**
2114
+ * Change types are normalised to kebab-case before they are compared.
2115
+ *
2116
+ * `@blazediff/interpret-native` reports `color-change` today but earlier
2117
+ * releases reported `ColorChange`; normalising keeps the heuristic working
2118
+ * across a diff-engine upgrade instead of silently degrading every screenshot
2119
+ * to `ambiguous`.
2120
+ */
2121
+ const normalizeChangeType = (changeType) => changeType.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
2122
+ const normalizeSeverity = (severity) => (severity ?? "").toLowerCase();
2123
+ /** Structural: something appeared, vanished or was replaced. */
2124
+ const REGRESSIVE_TYPES = /* @__PURE__ */ new Set([
2125
+ "content-change",
2126
+ "addition",
2127
+ "deletion"
2128
+ ]);
2129
+ /** Restyled or moved, with structure intact. */
2130
+ const RESTYLE_TYPES = /* @__PURE__ */ new Set(["color-change", "shift"]);
2131
+ const NOISE_TYPES = /* @__PURE__ */ new Set(["rendering-noise"]);
2132
+ const ELEVATED_SEVERITY = /* @__PURE__ */ new Set(["medium", "high"]);
2133
+ /** Below this share of the image, a low-severity change is not perceptible. */
2134
+ const SUB_PERCEPTUAL_PERCENT = .01;
2135
+ /** Mean region confidence above which a pure recolour is trusted. */
2136
+ const RECOLOR_CONFIDENCE = .7;
2137
+ const formatPercent = (percent) => {
2138
+ if (percent === void 0) return "?%";
2139
+ return percent >= .01 ? `${percent.toFixed(2)}%` : `${percent.toFixed(3)}%`;
2140
+ };
2141
+ const countByType = (regions) => {
2142
+ const counts = /* @__PURE__ */ new Map();
2143
+ for (const region of regions) {
2144
+ const type = normalizeChangeType(region.changeType);
2145
+ counts.set(type, (counts.get(type) ?? 0) + 1);
2146
+ }
2147
+ return counts;
2148
+ };
2149
+ const formatBreakdown = (counts) => [...counts].sort((a, b) => b[1] - a[1]).map(([type, count]) => `${count} ${type}`).join(", ");
2150
+ const largestRegion = (regions) => regions.reduce((best, region) => !best || region.pixelCount > best.pixelCount ? region : best, void 0);
2151
+ const meanConfidence = (regions) => regions.length === 0 ? 0 : regions.reduce((sum, region) => sum + (region.confidence ?? 0), 0) / regions.length;
2152
+ /**
2153
+ * A one-line description of a change, shaped so that the same kind of change
2154
+ * on different screenshots produces the same headline — which is what lets an
2155
+ * agent spot one shared cause (a footer timestamp, a theme toggle) across
2156
+ * dozens of screenshots without opening any of them.
2157
+ */
2158
+ const buildHeadline = (input) => {
2159
+ if (input.differentSizes) return "image dimensions changed";
2160
+ const interpretation = input.interpretation;
2161
+ const percent = input.percentDifference ?? interpretation?.diffPercentage;
2162
+ if (!interpretation || interpretation.regions.length === 0) return `${(input.numDiffPixels ?? interpretation?.diffCount)?.toLocaleString("en-US") ?? "?"} px (${formatPercent(percent)}) - no region analysis`;
2163
+ const regions = interpretation.regions;
2164
+ const counts = countByType(regions);
2165
+ const position = largestRegion(regions)?.position;
2166
+ const at = position ? ` @ ${position}` : "";
2167
+ const severity = normalizeSeverity(interpretation.severity) || "?";
2168
+ if (regions.length === 1) return `1 ${[...counts.keys()][0]}${at} (${formatPercent(percent)}, ${severity})`;
2169
+ return `${regions.length} regions: ${formatBreakdown(counts)}${at} (${formatPercent(percent)}, ${severity})`;
2170
+ };
2171
+ const verdict = (label, headline, rationale) => ({
2172
+ label,
2173
+ headline,
2174
+ rationale,
2175
+ action: ACTION_BY_LABEL[label]
2176
+ });
2177
+ /**
2178
+ * Classify a changed screenshot from its diff interpretation alone.
2179
+ *
2180
+ * Deliberately conservative: only the cases the signals settle are labelled,
2181
+ * and everything else is `ambiguous` so that it reaches a judge who can look
2182
+ * at the pixels. A wrong `noise-likely` hides a regression; a wrong
2183
+ * `ambiguous` costs one look.
2184
+ */
2185
+ const deriveVerdict = (input) => {
2186
+ const headline = buildHeadline(input);
2187
+ if (input.differentSizes) return verdict("ambiguous", headline, ["expected and actual have different dimensions — content likely grew or shrank", "could be an intended content change or a broken layout"]);
2188
+ const interpretation = input.interpretation;
2189
+ if (!interpretation || interpretation.regions.length === 0) return verdict("ambiguous", headline, ["pixels differ but no change regions were found"]);
2190
+ const regions = interpretation.regions;
2191
+ const types = regions.map((region) => normalizeChangeType(region.changeType));
2192
+ const severity = normalizeSeverity(interpretation.severity);
2193
+ const percent = input.percentDifference ?? interpretation.diffPercentage;
2194
+ const counts = countByType(regions);
2195
+ if (types.every((type) => NOISE_TYPES.has(type))) return verdict("noise-likely", headline, ["every region is classified as rendering noise"]);
2196
+ if (percent < .01 && severity === "low") return verdict("noise-likely", headline, [`less than ${SUB_PERCEPTUAL_PERCENT}% of the image differs (${formatPercent(percent)}) at low severity`, "sub-perceptual change"]);
2197
+ if (types.some((type) => REGRESSIVE_TYPES.has(type)) && ELEVATED_SEVERITY.has(severity)) {
2198
+ const structural = [...counts].filter(([type]) => REGRESSIVE_TYPES.has(type)).map(([type, count]) => `${count} ${type}`).join(", ");
2199
+ return verdict("regression-likely", headline, [`${severity} severity with structural changes (${structural})`, "content or layout changed, not just styling"]);
2200
+ }
2201
+ const allRecolor = types.every((type) => type === "color-change");
2202
+ if (allRecolor && meanConfidence(regions) > RECOLOR_CONFIDENCE) return verdict("intentional-likely", headline, [`${regions.length} confident color-change ${regions.length === 1 ? "region" : "regions"}`, "edge structure preserved — looks like a theming or palette change"]);
2203
+ if (!allRecolor && types.every((type) => RESTYLE_TYPES.has(type))) return verdict("intentional-likely", headline, ["every region is a shift or color change — content moved or was restyled, structure preserved"]);
2204
+ return verdict("ambiguous", headline, [`mix of change types (${formatBreakdown(counts)}) at ${severity || "unknown"} severity`, `${formatPercent(percent)} of the image differs`]);
2205
+ };
2206
+ //#endregion
2207
+ //#region src/agent/reviewIndex.ts
2208
+ /**
2209
+ * Read the review index, or nothing.
2210
+ *
2211
+ * Never throws: like the capture manifest, the report is an extra, and a
2212
+ * missing or hand-edited file must not break the screenshot listing.
2213
+ */
2214
+ const readAgentReviewIndex = async (outputDir) => {
2215
+ let raw;
2216
+ try {
2217
+ raw = JSON.parse(await node_fs_promises.default.readFile(agentReportPath(outputDir), "utf8"));
2218
+ } catch {
2219
+ return;
2220
+ }
2221
+ const createdAt = typeof raw?.createdAt === "string" ? Date.parse(raw.createdAt) : NaN;
2222
+ if (raw?.version !== 1 || Number.isNaN(createdAt) || !Array.isArray(raw.entries)) return;
2223
+ const reviews = /* @__PURE__ */ new Map();
2224
+ for (const entry of raw.entries) {
2225
+ if (typeof entry !== "object" || entry === null) continue;
2226
+ const { name, category, verdict, pending } = entry;
2227
+ if (typeof name !== "string" || category !== "changed") continue;
2228
+ if (typeof verdict !== "object" || verdict === null) continue;
2229
+ const v = verdict;
2230
+ if (!isVerdictLabel(v.label) || typeof v.headline !== "string") continue;
2231
+ reviews.set(name, {
2232
+ label: v.label,
2233
+ headline: v.headline,
2234
+ rationale: Array.isArray(v.rationale) ? v.rationale.filter((line) => typeof line === "string") : [],
2235
+ action: v.action,
2236
+ source: v.source === "agent" ? "agent" : "heuristic",
2237
+ ...typeof v.confidence === "number" ? { confidence: v.confidence } : {},
2238
+ pending: pending === true,
2239
+ reviewedAt: new Date(createdAt).toISOString()
2240
+ });
2241
+ }
2242
+ return {
2243
+ createdAt,
2244
+ reviews
2245
+ };
2246
+ };
2247
+ const modifiedAt = async (file) => {
2248
+ try {
2249
+ return (await node_fs_promises.default.stat(file)).mtimeMs;
2250
+ } catch {
2251
+ return Number.POSITIVE_INFINITY;
2252
+ }
2253
+ };
2254
+ /**
2255
+ * The review for a changed screenshot, if it is still about these images.
2256
+ *
2257
+ * A capture after the check rewrites `actual/`, an approval rewrites
2258
+ * `expected/`; either makes the verdict describe pixels that are gone. File
2259
+ * times are compared rather than content hashed because this runs on every
2260
+ * listing the review UI makes.
2261
+ */
2262
+ const freshAgentReview = async (index, outputDir, screenshot) => {
2263
+ const review = index?.reviews.get(screenshot.name);
2264
+ if (!index || !review) return void 0;
2265
+ const [actual, expected] = await Promise.all([modifiedAt(node_path.default.resolve(outputDir, screenshot.actualPath)), modifiedAt(node_path.default.resolve(outputDir, screenshot.expectedPath))]);
2266
+ return actual <= index.createdAt && expected <= index.createdAt ? review : void 0;
2267
+ };
2268
+ //#endregion
2017
2269
  //#region src/screenshots/groupScreenshots.ts
2018
2270
  const groupScreenshots = async (actualScreenshots, expectedScreenshots, diffScreenshots, outputDir) => {
2019
2271
  const screenshotRepresentations = [];
@@ -2083,23 +2335,33 @@ const listPngs = async (dir) => Array.fromAsync(await (0, node_fs_promises.glob)
2083
2335
  *
2084
2336
  * The capture manifest is folded in here so every consumer — the CLI, the
2085
2337
  * server, the review UI — sees the same `taskId`, and so a screenshot captured
2086
- * before manifests existed simply has none rather than a wrong one.
2338
+ * before manifests existed simply has none rather than a wrong one. The last
2339
+ * `cappa agent check` verdict is folded in the same way, as `review`, while it
2340
+ * still describes the images on disk.
2087
2341
  */
2088
2342
  const collectScreenshots = async (outputDir) => {
2089
- const [actualScreenshots, expectedScreenshots, diffScreenshots, manifest] = await Promise.all([
2343
+ const [actualScreenshots, expectedScreenshots, diffScreenshots, manifest, reviewIndex] = await Promise.all([
2090
2344
  listPngs(node_path.default.resolve(outputDir, "actual")),
2091
2345
  listPngs(node_path.default.resolve(outputDir, "expected")),
2092
2346
  listPngs(node_path.default.resolve(outputDir, "diff")),
2093
- readCaptureManifest(outputDir)
2347
+ readCaptureManifest(outputDir),
2348
+ readAgentReviewIndex(outputDir)
2094
2349
  ]);
2095
- return (await groupScreenshots(actualScreenshots, expectedScreenshots, diffScreenshots, outputDir)).map((screenshot) => {
2350
+ const screenshots = await groupScreenshots(actualScreenshots, expectedScreenshots, diffScreenshots, outputDir);
2351
+ return Promise.all(screenshots.map(async (screenshot) => {
2096
2352
  const origin = manifest.screenshots[screenshot.name];
2097
- return origin ? {
2353
+ const withOrigin = origin ? {
2098
2354
  ...screenshot,
2099
2355
  taskId: origin.taskId,
2100
2356
  plugin: origin.plugin
2101
2357
  } : screenshot;
2102
- });
2358
+ if (withOrigin.category !== "changed" || !reviewIndex) return withOrigin;
2359
+ const review = await freshAgentReview(reviewIndex, outputDir, withOrigin);
2360
+ return review ? {
2361
+ ...withOrigin,
2362
+ review
2363
+ } : withOrigin;
2364
+ }));
2103
2365
  };
2104
2366
  //#endregion
2105
2367
  //#region src/engine/RunStore.ts
@@ -3140,46 +3402,708 @@ var FsScreenshotStore = class {
3140
3402
  }
3141
3403
  };
3142
3404
  //#endregion
3405
+ //#region src/agent/tiles.ts
3406
+ const LOCATOR_MAX_WIDTH = 400;
3407
+ const LOCATOR_MAX_HEIGHT = 1200;
3408
+ const GUTTER = 12;
3409
+ const ROW_GUTTER = 16;
3410
+ const LABEL_HEIGHT = 18;
3411
+ const BACKGROUND = {
3412
+ r: 128,
3413
+ g: 128,
3414
+ b: 128
3415
+ };
3416
+ const escapeXml = (text) => text.replace(/[<>&"]/g, (c) => `&#${c.charCodeAt(0)};`);
3417
+ /** A caption strip, so a row reads as "#2 expected | #2 actual" at a glance. */
3418
+ const label = (text, width) => Buffer.from(`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${LABEL_HEIGHT}"><rect width="100%" height="100%" fill="#222"/><text x="4" y="13" font-family="sans-serif" font-size="12" fill="#fff">${escapeXml(text)}</text></svg>`);
3419
+ const padAndClamp = (bbox, padding, width, height) => {
3420
+ const padX = typeof padding === "number" ? padding : padding.x;
3421
+ const padY = typeof padding === "number" ? padding : padding.y;
3422
+ const x = Math.max(0, Math.floor(bbox.x - padX));
3423
+ const y = Math.max(0, Math.floor(bbox.y - padY));
3424
+ const right = Math.min(width, Math.ceil(bbox.x + bbox.width + padX));
3425
+ const bottom = Math.min(height, Math.ceil(bbox.y + bbox.height + padY));
3426
+ return {
3427
+ x,
3428
+ y,
3429
+ width: Math.max(1, right - x),
3430
+ height: Math.max(1, bottom - y)
3431
+ };
3432
+ };
3433
+ const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
3434
+ /**
3435
+ * Context kept around a region: proportional to its size, within bounds.
3436
+ *
3437
+ * A fixed margin is too tight for small regions — a changed letter cropped
3438
+ * with 24px around it says nothing about whether a button label got
3439
+ * truncated — and wasteful for large ones.
3440
+ */
3441
+ const contextPadding = (bbox, minimum) => ({
3442
+ x: clamp(bbox.width, minimum * 2, 160),
3443
+ y: clamp(bbox.height, minimum, 96)
3444
+ });
3445
+ /** Scale that fits `width`x`height` into the bounds without upscaling. */
3446
+ const fitScale = (width, height, maxWidth, maxHeight) => Math.min(1, maxWidth / width, maxHeight / height);
3447
+ const readSize$1 = async (file) => {
3448
+ const { width, height } = await (0, sharp.default)(file).metadata();
3449
+ if (!width || !height) throw new Error(`Unable to read image dimensions: ${file}`);
3450
+ return {
3451
+ width,
3452
+ height
3453
+ };
3454
+ };
3455
+ const renderCrop = async (file, box, scale) => {
3456
+ const crop = (0, sharp.default)(file).extract({
3457
+ left: box.x,
3458
+ top: box.y,
3459
+ width: box.width,
3460
+ height: box.height
3461
+ });
3462
+ if (scale < 1) crop.resize(Math.max(1, Math.round(box.width * scale)), Math.max(1, Math.round(box.height * scale)));
3463
+ return crop.png().toBuffer();
3464
+ };
3465
+ const renderRegions = async (options, width, height) => {
3466
+ const padding = options.padding ?? 24;
3467
+ const maxCropWidth = options.maxCropWidth ?? 640;
3468
+ const regions = options.regions.slice(0, options.maxRegions ?? 8);
3469
+ if (regions.length === 0) return void 0;
3470
+ const rows = await Promise.all(regions.map(async (region) => {
3471
+ const box = padAndClamp(region, contextPadding(region, padding), width, height);
3472
+ const scale = Math.min(1, maxCropWidth / box.width);
3473
+ const [expected, actual] = await Promise.all([renderCrop(options.expectedPath, box, scale), renderCrop(options.actualPath, box, scale)]);
3474
+ return {
3475
+ expected,
3476
+ actual,
3477
+ width: Math.max(1, Math.round(box.width * scale)),
3478
+ height: Math.max(1, Math.round(box.height * scale))
3479
+ };
3480
+ }));
3481
+ const columnWidth = (row) => Math.max(row.width, 96);
3482
+ const canvasWidth = Math.max(...rows.map((row) => columnWidth(row) * 2 + GUTTER));
3483
+ const canvasHeight = rows.reduce((sum, row) => sum + LABEL_HEIGHT + row.height, 0) + ROW_GUTTER * (rows.length - 1);
3484
+ const composites = [];
3485
+ let top = 0;
3486
+ rows.forEach((row, index) => {
3487
+ const column = columnWidth(row);
3488
+ const right = column + GUTTER;
3489
+ composites.push({
3490
+ input: label(`#${index + 1} expected`, column),
3491
+ left: 0,
3492
+ top
3493
+ }, {
3494
+ input: label(`#${index + 1} actual`, column),
3495
+ left: right,
3496
+ top
3497
+ }, {
3498
+ input: row.expected,
3499
+ left: 0,
3500
+ top: top + LABEL_HEIGHT
3501
+ }, {
3502
+ input: row.actual,
3503
+ left: right,
3504
+ top: top + LABEL_HEIGHT
3505
+ });
3506
+ top += LABEL_HEIGHT + row.height + ROW_GUTTER;
3507
+ });
3508
+ const file = node_path.default.join(options.outDir, "regions.png");
3509
+ await (0, sharp.default)({ create: {
3510
+ width: canvasWidth,
3511
+ height: canvasHeight,
3512
+ channels: 3,
3513
+ background: BACKGROUND
3514
+ } }).composite(composites).png().toFile(file);
3515
+ return {
3516
+ file,
3517
+ count: rows.length
3518
+ };
3519
+ };
3520
+ const renderLocator = async (options, width, height) => {
3521
+ const scale = fitScale(width, height, LOCATOR_MAX_WIDTH, LOCATOR_MAX_HEIGHT);
3522
+ const locatorWidth = Math.max(1, Math.round(width * scale));
3523
+ const locatorHeight = Math.max(1, Math.round(height * scale));
3524
+ const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${locatorWidth}" height="${locatorHeight}">${options.regions.map((region, index) => {
3525
+ const x = Math.round(region.x * scale);
3526
+ const y = Math.round(region.y * scale);
3527
+ return `<rect x="${x}" y="${y}" width="${Math.max(2, Math.round(region.width * scale))}" height="${Math.max(2, Math.round(region.height * scale))}" fill="none" stroke="red" stroke-width="2"/><text x="${x + 2}" y="${Math.max(12, y - 3)}" font-family="sans-serif" font-size="12" font-weight="bold" fill="red" stroke="#fff" stroke-width="3" paint-order="stroke">${index + 1}</text>`;
3528
+ }).join("")}</svg>`;
3529
+ const file = node_path.default.join(options.outDir, "locator.png");
3530
+ await (0, sharp.default)(options.diffPath ?? options.actualPath).resize(locatorWidth, locatorHeight, { fit: "fill" }).composite([{
3531
+ input: Buffer.from(svg),
3532
+ left: 0,
3533
+ top: 0
3534
+ }]).png().toFile(file);
3535
+ return file;
3536
+ };
3537
+ /**
3538
+ * Write `locator.png` and `regions.png` into `outDir`.
3539
+ *
3540
+ * Expected and actual must have the same dimensions — region boxes are only
3541
+ * meaningful when both images share a coordinate space. Use
3542
+ * {@link renderOverview} when they do not.
3543
+ */
3544
+ const renderJudgmentTiles = async (options) => {
3545
+ const { width, height } = await readSize$1(options.actualPath);
3546
+ const [regions, locator] = await Promise.all([renderRegions(options, width, height), renderLocator(options, width, height)]);
3547
+ return {
3548
+ locator,
3549
+ regions: regions?.file,
3550
+ renderedRegions: regions?.count ?? 0
3551
+ };
3552
+ };
3553
+ /**
3554
+ * Write `overview.png`: expected and actual, scaled down side by side.
3555
+ *
3556
+ * For screenshots whose dimensions changed, where no region can be located,
3557
+ * this is what the judge looks at instead of two full-size images.
3558
+ */
3559
+ const renderOverview = async (options) => {
3560
+ const [expectedSize, actualSize] = await Promise.all([readSize$1(options.expectedPath), readSize$1(options.actualPath)]);
3561
+ const scale = Math.min(fitScale(expectedSize.width, expectedSize.height, LOCATOR_MAX_WIDTH, LOCATOR_MAX_HEIGHT), fitScale(actualSize.width, actualSize.height, LOCATOR_MAX_WIDTH, LOCATOR_MAX_HEIGHT));
3562
+ const scaled = (size) => ({
3563
+ width: Math.max(1, Math.round(size.width * scale)),
3564
+ height: Math.max(1, Math.round(size.height * scale))
3565
+ });
3566
+ const expected = scaled(expectedSize);
3567
+ const actual = scaled(actualSize);
3568
+ const [expectedBuffer, actualBuffer] = await Promise.all([(0, sharp.default)(options.expectedPath).resize(expected.width, expected.height, { fit: "fill" }).png().toBuffer(), (0, sharp.default)(options.actualPath).resize(actual.width, actual.height, { fit: "fill" }).png().toBuffer()]);
3569
+ const file = node_path.default.join(options.outDir, "overview.png");
3570
+ await (0, sharp.default)({ create: {
3571
+ width: expected.width + GUTTER + actual.width,
3572
+ height: LABEL_HEIGHT + Math.max(expected.height, actual.height),
3573
+ channels: 3,
3574
+ background: BACKGROUND
3575
+ } }).composite([
3576
+ {
3577
+ input: label(`expected ${expectedSize.width}x${expectedSize.height}`, expected.width),
3578
+ left: 0,
3579
+ top: 0
3580
+ },
3581
+ {
3582
+ input: label(`actual ${actualSize.width}x${actualSize.height}`, actual.width),
3583
+ left: expected.width + GUTTER,
3584
+ top: 0
3585
+ },
3586
+ {
3587
+ input: expectedBuffer,
3588
+ left: 0,
3589
+ top: LABEL_HEIGHT
3590
+ },
3591
+ {
3592
+ input: actualBuffer,
3593
+ left: expected.width + GUTTER,
3594
+ top: LABEL_HEIGHT
3595
+ }
3596
+ ]).png().toFile(file);
3597
+ return file;
3598
+ };
3599
+ //#endregion
3600
+ //#region src/agent/review.ts
3601
+ /**
3602
+ * Agent review: turn the screenshots on disk into something a coding agent
3603
+ * can judge cheaply, and fold its judgments back in.
3604
+ *
3605
+ * Nothing here captures. It reads `actual/`, `expected/` and `diff/` as the
3606
+ * last `cappa capture` left them, so it is safe to run repeatedly — a re-run
3607
+ * is how an agent's verdicts are applied, and a re-capture invalidates them
3608
+ * automatically because every judgment is tied to a fingerprint of the two
3609
+ * images it was made about.
3610
+ *
3611
+ * Layout, all inside `<outputDir>/.cappa-agent/` (dot-prefixed, so neither
3612
+ * screenshot collection nor the review server's static handler touch it):
3613
+ *
3614
+ * ```
3615
+ * report.json full report of the last check
3616
+ * judgments/<name>/request.json what to judge and where the evidence is
3617
+ * judgments/<name>/locator.png thumbnail with every region outlined
3618
+ * judgments/<name>/regions.png [expected | actual] crop per region
3619
+ * judgments/<name>/overview.png instead of the two above when sizes differ
3620
+ * judgments/<name>/verdict.json written by the judge
3621
+ * ```
3622
+ */
3623
+ const REQUEST_FILE = "request.json";
3624
+ const VERDICT_FILE = "verdict.json";
3625
+ const JUDGMENT_FILES = [
3626
+ REQUEST_FILE,
3627
+ VERDICT_FILE,
3628
+ "locator.png",
3629
+ "regions.png",
3630
+ "overview.png"
3631
+ ];
3632
+ const JUDGE_MODES = [
3633
+ "ambiguous",
3634
+ "all",
3635
+ "none"
3636
+ ];
3637
+ /**
3638
+ * The directory holding a screenshot's judgment.
3639
+ *
3640
+ * Screenshot names are relative paths (`example/button/primary`), so they map
3641
+ * onto nested directories directly; anything that would resolve outside the
3642
+ * judgments root is refused rather than written.
3643
+ */
3644
+ const judgmentDir = (outputDir, name) => {
3645
+ const root = judgmentsRoot(outputDir);
3646
+ const dir = node_path.default.resolve(root, name);
3647
+ const relative = node_path.default.relative(root, dir);
3648
+ if (!relative || relative.startsWith("..") || node_path.default.isAbsolute(relative)) throw new Error(`Invalid screenshot name for a judgment: ${name}`);
3649
+ return dir;
3650
+ };
3651
+ const exists = async (file) => {
3652
+ try {
3653
+ await node_fs_promises.default.access(file);
3654
+ return true;
3655
+ } catch {
3656
+ return false;
3657
+ }
3658
+ };
3659
+ const readJson = async (file) => {
3660
+ try {
3661
+ return JSON.parse(await node_fs_promises.default.readFile(file, "utf8"));
3662
+ } catch {
3663
+ return;
3664
+ }
3665
+ };
3666
+ const writeJson = async (file, value) => {
3667
+ await node_fs_promises.default.mkdir(node_path.default.dirname(file), { recursive: true });
3668
+ await node_fs_promises.default.writeFile(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
3669
+ };
3670
+ /** Ties a judgment to the exact pair of images it was made about. */
3671
+ const fingerprintImages = async (expectedPath, actualPath) => {
3672
+ const [expected, actual] = await Promise.all([node_fs_promises.default.readFile(expectedPath), node_fs_promises.default.readFile(actualPath)]);
3673
+ return (0, node_crypto.createHash)("sha256").update(expected).update("\0").update(actual).digest("hex");
3674
+ };
3675
+ /**
3676
+ * Read a judge's verdict, accepting both the nested shape blazediff uses
3677
+ * (`{ verdict: { label, headline, rationale }, confidence }`) and a flat one
3678
+ * (`{ label, headline, rationale, confidence }`) — a judge that writes either
3679
+ * should not have its work thrown away over nesting.
3680
+ */
3681
+ const parseAgentVerdict = (raw) => {
3682
+ if (typeof raw !== "object" || raw === null) return {
3683
+ ok: false,
3684
+ error: "verdict.json is not a JSON object"
3685
+ };
3686
+ const outer = raw;
3687
+ const inner = typeof outer.verdict === "object" && outer.verdict !== null ? outer.verdict : outer;
3688
+ const label = inner.label;
3689
+ if (!isJudgedLabel(label)) return {
3690
+ ok: false,
3691
+ error: `label must be one of regression-likely, intentional-likely, noise-likely (got ${JSON.stringify(label)})`
3692
+ };
3693
+ const headline = typeof inner.headline === "string" && inner.headline.trim() ? inner.headline.trim() : void 0;
3694
+ if (!headline) return {
3695
+ ok: false,
3696
+ error: "headline must be a non-empty string"
3697
+ };
3698
+ const toLines = (value) => Array.isArray(value) ? value.filter((line) => typeof line === "string") : typeof value === "string" && value.trim() ? [value.trim()] : [];
3699
+ const rationale = [...toLines(inner.rationale)];
3700
+ if (inner !== outer) rationale.push(...toLines(outer.rationale));
3701
+ const rawConfidence = outer.confidence ?? inner.confidence;
3702
+ const confidence = typeof rawConfidence === "number" && Number.isFinite(rawConfidence) ? Math.min(1, Math.max(0, rawConfidence)) : void 0;
3703
+ return {
3704
+ ok: true,
3705
+ label,
3706
+ headline,
3707
+ rationale,
3708
+ ...confidence !== void 0 ? { confidence } : {}
3709
+ };
3710
+ };
3711
+ const readSize = async (file) => {
3712
+ const { width = 0, height = 0 } = await (0, sharp.default)(file).metadata();
3713
+ return {
3714
+ width,
3715
+ height
3716
+ };
3717
+ };
3718
+ const toAgentRegions = (regions) => [...regions].sort((a, b) => b.pixelCount - a.pixelCount).map((region, index) => ({
3719
+ index: index + 1,
3720
+ bbox: {
3721
+ x: region.bbox.x,
3722
+ y: region.bbox.y,
3723
+ width: region.bbox.width,
3724
+ height: region.bbox.height
3725
+ },
3726
+ pixelCount: region.pixelCount,
3727
+ percentage: region.percentage,
3728
+ position: region.position,
3729
+ shape: region.shape,
3730
+ changeType: normalizeChangeType(region.changeType),
3731
+ confidence: region.confidence
3732
+ }));
3733
+ /**
3734
+ * The interpretation a capture already persisted, or a fresh one.
3735
+ *
3736
+ * `diff.interpret` is off by default, so most changed screenshots arrive
3737
+ * without one; computing it here means agent review works on any project
3738
+ * rather than only on those that opted into interpretation at capture time.
3739
+ */
3740
+ const interpretationFor = async (screenshot, expectedPath, actualPath, diff) => {
3741
+ if (screenshot.diffMeta?.interpretation) return screenshot.diffMeta.interpretation;
3742
+ const pixel = diff && diff.type !== "gmsd" ? diff : void 0;
3743
+ try {
3744
+ return await (0, _blazediff_interpret_native.interpret)(expectedPath, actualPath, void 0, {
3745
+ source: "pixel",
3746
+ threshold: pixel?.threshold,
3747
+ antialiasing: pixel?.includeAA ?? false
3748
+ });
3749
+ } catch {
3750
+ return;
3751
+ }
3752
+ };
3753
+ const JUDGE_INSTRUCTIONS = [
3754
+ "Read locator.png and regions.png together. locator.png outlines every region (numbered) on a thumbnail; regions.png stacks one [expected | actual] row per region, in `regions` order.",
3755
+ "Open overview.png when it exists instead — the image dimensions changed, so no regions could be located.",
3756
+ "Only open paths.expected / paths.actual / paths.diff (full size) when a change clearly continues outside its crop.",
3757
+ "Write verdict.json next to this file, or run `cappa agent judge <name> --label <label> --headline <text>`."
3758
+ ];
3759
+ const VERDICT_SCHEMA = {
3760
+ label: "regression-likely | intentional-likely | noise-likely",
3761
+ headline: "one line describing what changed",
3762
+ rationale: ["short reasons"],
3763
+ confidence: "0..1"
3764
+ };
3765
+ const analyseChanged = async (screenshot, options, createdAt) => {
3766
+ const { outputDir } = options;
3767
+ const expectedPath = node_path.default.resolve(outputDir, screenshot.expectedPath);
3768
+ const actualPath = node_path.default.resolve(outputDir, screenshot.actualPath);
3769
+ const diffPath = node_path.default.resolve(outputDir, screenshot.diffPath);
3770
+ const [expectedSize, actualSize, diffExists] = await Promise.all([
3771
+ readSize(expectedPath),
3772
+ readSize(actualPath),
3773
+ exists(diffPath)
3774
+ ]);
3775
+ const differentSizes = expectedSize.width !== actualSize.width || expectedSize.height !== actualSize.height;
3776
+ const interpretation = differentSizes ? void 0 : await interpretationFor(screenshot, expectedPath, actualPath, options.diff);
3777
+ const percentDifference = screenshot.diffMeta?.percentDifference ?? interpretation?.diffPercentage;
3778
+ const numDiffPixels = screenshot.diffMeta?.numDiffPixels ?? interpretation?.diffCount;
3779
+ const regions = toAgentRegions(interpretation?.regions ?? []);
3780
+ const heuristic = deriveVerdict({
3781
+ percentDifference,
3782
+ numDiffPixels,
3783
+ interpretation,
3784
+ differentSizes
3785
+ });
3786
+ const entry = {
3787
+ name: screenshot.name,
3788
+ category: "changed",
3789
+ ...screenshot.taskId ? {
3790
+ taskId: screenshot.taskId,
3791
+ plugin: screenshot.plugin
3792
+ } : {},
3793
+ paths: {
3794
+ expected: expectedPath,
3795
+ actual: actualPath,
3796
+ ...diffExists ? { diff: diffPath } : {}
3797
+ },
3798
+ percentDifference,
3799
+ numDiffPixels,
3800
+ dimensions: {
3801
+ expected: expectedSize,
3802
+ actual: actualSize
3803
+ },
3804
+ severity: interpretation?.severity?.toLowerCase(),
3805
+ summary: interpretation?.summary,
3806
+ regions,
3807
+ heuristic,
3808
+ verdict: {
3809
+ ...heuristic,
3810
+ source: "heuristic"
3811
+ },
3812
+ pending: false
3813
+ };
3814
+ const dir = judgmentDir(outputDir, screenshot.name);
3815
+ const requestPath = node_path.default.join(dir, REQUEST_FILE);
3816
+ const verdictPath = node_path.default.join(dir, VERDICT_FILE);
3817
+ if (!(options.judge === "all" || options.judge === "ambiguous" && heuristic.label === "ambiguous" || await exists(requestPath))) return entry;
3818
+ const fingerprint = await fingerprintImages(expectedPath, actualPath);
3819
+ const previous = await readJson(requestPath);
3820
+ if (previous && previous.fingerprint !== fingerprint) await clearJudgmentFiles(dir);
3821
+ await node_fs_promises.default.mkdir(dir, { recursive: true });
3822
+ const judgment = {
3823
+ dir,
3824
+ request: requestPath,
3825
+ verdict: verdictPath
3826
+ };
3827
+ if (differentSizes) judgment.overview = await renderOverview({
3828
+ expectedPath,
3829
+ actualPath,
3830
+ outDir: dir
3831
+ });
3832
+ else {
3833
+ const tiles = await renderJudgmentTiles({
3834
+ expectedPath,
3835
+ actualPath,
3836
+ diffPath: diffExists ? diffPath : void 0,
3837
+ regions: regions.map((region) => region.bbox),
3838
+ outDir: dir,
3839
+ maxRegions: options.maxTileRegions
3840
+ });
3841
+ if (tiles.locator) judgment.locator = tiles.locator;
3842
+ if (tiles.regions) judgment.regions = tiles.regions;
3843
+ }
3844
+ entry.judgment = judgment;
3845
+ await writeJson(requestPath, {
3846
+ version: 1,
3847
+ name: entry.name,
3848
+ taskId: entry.taskId,
3849
+ plugin: entry.plugin,
3850
+ fingerprint,
3851
+ createdAt,
3852
+ instructions: JUDGE_INSTRUCTIONS,
3853
+ verdictSchema: VERDICT_SCHEMA,
3854
+ heuristic,
3855
+ percentDifference,
3856
+ numDiffPixels,
3857
+ dimensions: entry.dimensions,
3858
+ severity: entry.severity,
3859
+ summary: entry.summary,
3860
+ regions,
3861
+ paths: {
3862
+ locator: judgment.locator,
3863
+ regions: judgment.regions,
3864
+ overview: judgment.overview,
3865
+ expected: expectedPath,
3866
+ actual: actualPath,
3867
+ diff: entry.paths.diff,
3868
+ verdict: verdictPath
3869
+ }
3870
+ });
3871
+ if (!await exists(verdictPath)) {
3872
+ entry.pending = true;
3873
+ return entry;
3874
+ }
3875
+ const parsed = parseAgentVerdict(await readJson(verdictPath));
3876
+ if (!parsed.ok) {
3877
+ entry.pending = true;
3878
+ entry.verdictError = parsed.error;
3879
+ return entry;
3880
+ }
3881
+ entry.verdict = {
3882
+ label: parsed.label,
3883
+ headline: parsed.headline,
3884
+ rationale: parsed.rationale,
3885
+ action: ACTION_BY_LABEL[parsed.label],
3886
+ source: "agent",
3887
+ ...parsed.confidence !== void 0 ? { confidence: parsed.confidence } : {}
3888
+ };
3889
+ return entry;
3890
+ };
3891
+ const clearJudgmentFiles = async (dir) => {
3892
+ await Promise.all(JUDGMENT_FILES.map((file) => node_fs_promises.default.rm(node_path.default.join(dir, file), { force: true })));
3893
+ };
3894
+ /**
3895
+ * Remove a screenshot's judgment — after it was approved, or because it is no
3896
+ * longer changed. Only the judgment's own files go: a directory can also be
3897
+ * the parent of another screenshot's judgment (`button` and `button/primary`).
3898
+ */
3899
+ const clearJudgment = async (outputDir, name) => {
3900
+ const dir = judgmentDir(outputDir, name);
3901
+ await clearJudgmentFiles(dir);
3902
+ await removeEmptyDirs(dir, judgmentsRoot(outputDir));
3903
+ };
3904
+ /** Remove `dir` and its parents up to (excluding) `root` while empty. */
3905
+ const removeEmptyDirs = async (dir, root) => {
3906
+ let current = dir;
3907
+ while (current !== root && current.startsWith(root)) {
3908
+ try {
3909
+ await node_fs_promises.default.rmdir(current);
3910
+ } catch {
3911
+ return;
3912
+ }
3913
+ current = node_path.default.dirname(current);
3914
+ }
3915
+ };
3916
+ const listRequestDirs = async (root) => {
3917
+ if (!await exists(root)) return [];
3918
+ return (await Array.fromAsync(node_fs_promises.default.glob(`**/${REQUEST_FILE}`, { cwd: root }))).map((file) => node_path.default.resolve(root, node_path.default.dirname(file)));
3919
+ };
3920
+ /** Drop judgments for screenshots that no longer need one. */
3921
+ const pruneJudgments = async (outputDir, keep) => {
3922
+ const root = judgmentsRoot(outputDir);
3923
+ for (const dir of await listRequestDirs(root)) {
3924
+ if (keep.has(dir)) continue;
3925
+ await clearJudgmentFiles(dir);
3926
+ await removeEmptyDirs(dir, root);
3927
+ }
3928
+ };
3929
+ /**
3930
+ * Analyse every non-passing screenshot, write judgment requests for the ones
3931
+ * that need a judge, apply any verdicts already written, and persist the
3932
+ * full report to `<outputDir>/.cappa-agent/report.json`.
3933
+ */
3934
+ const runAgentCheck = async (options) => {
3935
+ const outputDir = node_path.default.resolve(options.outputDir);
3936
+ const judge = options.judge ?? "ambiguous";
3937
+ const createdAt = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
3938
+ const screenshots = await collectScreenshots(outputDir);
3939
+ await node_fs_promises.default.mkdir(agentDir(outputDir), { recursive: true });
3940
+ await node_fs_promises.default.writeFile(node_path.default.join(agentDir(outputDir), ".gitignore"), "*\n");
3941
+ const changed = screenshots.filter((s) => s.category === "changed");
3942
+ const changedEntries = await mapWithConcurrency(options.concurrency ?? 4, changed, (screenshot) => analyseChanged(screenshot, {
3943
+ ...options,
3944
+ outputDir,
3945
+ judge
3946
+ }, createdAt));
3947
+ await pruneJudgments(outputDir, new Set(changedEntries.flatMap((entry) => entry.judgment ? [entry.judgment.dir] : [])));
3948
+ const otherEntries = screenshots.flatMap((s) => {
3949
+ if (s.category === "new") return [{
3950
+ name: s.name,
3951
+ category: "new",
3952
+ ...s.taskId ? {
3953
+ taskId: s.taskId,
3954
+ plugin: s.plugin
3955
+ } : {},
3956
+ paths: { actual: node_path.default.resolve(outputDir, s.actualPath) },
3957
+ pending: false
3958
+ }];
3959
+ if (s.category === "deleted") return [{
3960
+ name: s.name,
3961
+ category: "deleted",
3962
+ paths: { expected: node_path.default.resolve(outputDir, s.expectedPath) },
3963
+ pending: false
3964
+ }];
3965
+ return [];
3966
+ });
3967
+ const entries = [...changedEntries, ...otherEntries];
3968
+ const count = (category) => screenshots.filter((s) => s.category === category).length;
3969
+ const report = {
3970
+ version: 1,
3971
+ createdAt,
3972
+ outputDir,
3973
+ reportPath: agentReportPath(outputDir),
3974
+ judge,
3975
+ totals: {
3976
+ total: screenshots.length,
3977
+ passed: count("passed"),
3978
+ changed: count("changed"),
3979
+ new: count("new"),
3980
+ deleted: count("deleted"),
3981
+ pendingJudgments: entries.filter((entry) => entry.pending).length
3982
+ },
3983
+ entries
3984
+ };
3985
+ await writeJson(report.reportPath, report);
3986
+ return report;
3987
+ };
3988
+ /** Read the report the last {@link runAgentCheck} wrote, if any. */
3989
+ const readAgentReport = async (outputDir) => {
3990
+ const raw = await readJson(agentReportPath(outputDir));
3991
+ return raw?.version === 1 ? raw : void 0;
3992
+ };
3993
+ /**
3994
+ * The report as an agent should first see it: one line of state per
3995
+ * screenshot, with the detail left in `report.json` and the judgment
3996
+ * requests for when it is actually needed.
3997
+ */
3998
+ const toSlimAgentReport = (report) => ({
3999
+ reportPath: report.reportPath,
4000
+ ...report.totals,
4001
+ results: report.entries.map((entry) => ({
4002
+ name: entry.name,
4003
+ category: entry.category,
4004
+ ...entry.verdict ? { verdict: {
4005
+ label: entry.verdict.label,
4006
+ headline: entry.verdict.headline,
4007
+ action: entry.verdict.action,
4008
+ source: entry.verdict.source
4009
+ } } : {},
4010
+ ...entry.pending ? { pending: true } : {},
4011
+ ...entry.pending && entry.judgment ? { judgment: entry.judgment.dir } : {},
4012
+ ...entry.verdictError ? { verdictError: entry.verdictError } : {}
4013
+ }))
4014
+ });
4015
+ /**
4016
+ * Record a judge's verdict for a screenshot with a pending request — the
4017
+ * validated alternative to hand-writing `verdict.json`.
4018
+ */
4019
+ const writeAgentVerdict = async (outputDir, name, input) => {
4020
+ const dir = judgmentDir(outputDir, name);
4021
+ if (!await exists(node_path.default.join(dir, REQUEST_FILE))) throw new Error(`No judgment request for "${name}" — run \`cappa agent check\` first (use --judge all to request one for any changed screenshot).`);
4022
+ const parsed = parseAgentVerdict(input);
4023
+ if (!parsed.ok) throw new Error(parsed.error);
4024
+ const verdictPath = node_path.default.join(dir, VERDICT_FILE);
4025
+ await writeJson(verdictPath, {
4026
+ name,
4027
+ verdict: {
4028
+ label: parsed.label,
4029
+ headline: parsed.headline,
4030
+ rationale: parsed.rationale,
4031
+ action: ACTION_BY_LABEL[parsed.label]
4032
+ },
4033
+ ...parsed.confidence !== void 0 ? { confidence: parsed.confidence } : {}
4034
+ });
4035
+ return verdictPath;
4036
+ };
4037
+ //#endregion
4038
+ exports.ACTION_BY_LABEL = ACTION_BY_LABEL;
4039
+ exports.AGENT_DIRNAME = AGENT_DIRNAME;
4040
+ exports.AGENT_REPORT_VERSION = AGENT_REPORT_VERSION;
4041
+ exports.CONSOLE_LOG_LEVELS = CONSOLE_LOG_LEVELS;
3143
4042
  exports.CaptureRunner = CaptureRunner;
3144
4043
  exports.DEFAULT_DEBOUNCE_MS = DEFAULT_DEBOUNCE_MS;
3145
4044
  exports.DEFAULT_IGNORED_DIRS = DEFAULT_IGNORED_DIRS;
3146
4045
  exports.DEFAULT_MAX_TASKS = DEFAULT_MAX_TASKS;
3147
4046
  exports.ENGINE_ERROR_CODES = ENGINE_ERROR_CODES;
3148
4047
  exports.FsScreenshotStore = FsScreenshotStore;
4048
+ exports.JUDGED_LABELS = JUDGED_LABELS;
4049
+ exports.JUDGE_MODES = JUDGE_MODES;
3149
4050
  exports.LocalEngine = LocalEngine;
3150
4051
  exports.MANIFEST_FILENAME = MANIFEST_FILENAME;
3151
4052
  exports.MANIFEST_VERSION = MANIFEST_VERSION;
3152
4053
  exports.RunInProgressError = RunInProgressError;
3153
4054
  exports.RunStore = RunStore;
4055
+ exports.SUB_PERCEPTUAL_PERCENT = SUB_PERCEPTUAL_PERCENT;
3154
4056
  exports.ScreenshotFileSystem = ScreenshotFileSystem;
3155
4057
  exports.ScreenshotTool = ScreenshotTool;
3156
4058
  exports.UnknownTargetsError = UnknownTargetsError;
4059
+ exports.VERDICT_LABELS = VERDICT_LABELS;
3157
4060
  exports.WarmBrowser = WarmBrowser;
3158
4061
  exports.WatchInProgressError = WatchInProgressError;
3159
4062
  exports.WatchSession = WatchSession;
4063
+ exports.agentDir = agentDir;
4064
+ exports.agentReportPath = agentReportPath;
4065
+ exports.attachConsoleLogging = attachConsoleLogging;
4066
+ exports.buildHeadline = buildHeadline;
4067
+ exports.clearJudgment = clearJudgment;
3160
4068
  exports.collectScreenshots = collectScreenshots;
3161
4069
  exports.compareImages = compareImages;
3162
4070
  exports.compareImagesGMSD = compareImagesGMSD;
4071
+ exports.contextPadding = contextPadding;
3163
4072
  exports.defineConfig = defineConfig;
4073
+ exports.deriveVerdict = deriveVerdict;
3164
4074
  exports.didScreenshotFail = didScreenshotFail;
3165
4075
  exports.filterTasks = filterTasks;
4076
+ exports.fingerprintImages = fingerprintImages;
3166
4077
  exports.getDeletedScreenshots = getDeletedScreenshots;
3167
4078
  exports.groupScreenshots = groupScreenshots;
3168
4079
  exports.imagesMatch = imagesMatch;
3169
4080
  exports.imagesMatchGMSD = imagesMatchGMSD;
4081
+ exports.isJudgedLabel = isJudgedLabel;
3170
4082
  exports.isRunInProgressError = isRunInProgressError;
3171
4083
  exports.isUnknownTargetsError = isUnknownTargetsError;
4084
+ exports.isVerdictLabel = isVerdictLabel;
3172
4085
  exports.isWatchInProgressError = isWatchInProgressError;
4086
+ exports.judgmentDir = judgmentDir;
3173
4087
  exports.mapWithConcurrency = mapWithConcurrency;
3174
4088
  exports.mergeCaptureManifest = mergeCaptureManifest;
4089
+ exports.normalizeChangeType = normalizeChangeType;
4090
+ exports.padAndClamp = padAndClamp;
4091
+ exports.parseAgentVerdict = parseAgentVerdict;
4092
+ exports.readAgentReport = readAgentReport;
3175
4093
  exports.readCaptureManifest = readCaptureManifest;
3176
4094
  exports.readDiffMeta = readDiffMeta;
3177
4095
  exports.recordCaptureOrigins = recordCaptureOrigins;
4096
+ exports.renderJudgmentTiles = renderJudgmentTiles;
4097
+ exports.renderOverview = renderOverview;
4098
+ exports.runAgentCheck = runAgentCheck;
3178
4099
  exports.sanitizeScreenshotFilename = sanitizeScreenshotFilename;
3179
4100
  exports.selectTasks = selectTasks;
4101
+ exports.toConsoleLogLevel = toConsoleLogLevel;
3180
4102
  exports.toDiffMetaPath = toDiffMetaPath;
3181
4103
  exports.toManifestKey = toManifestKey;
3182
4104
  exports.toSerializedError = toSerializedError;
4105
+ exports.toSlimAgentReport = toSlimAgentReport;
3183
4106
  exports.toTaskStatus = toTaskStatus;
4107
+ exports.writeAgentVerdict = writeAgentVerdict;
3184
4108
 
3185
4109
  //# sourceMappingURL=index.cjs.map