@crvy/rprtr 0.0.4 → 0.0.7

package/dist/reporter.cjs

@@ -34,8 +34,9 @@ __export(reporter_exports, {
   default: () => reporter_default
 });
 module.exports = __toCommonJS(reporter_exports);
+var import_fs = require("fs");
 var import_promises2 = require("fs/promises");
-var import_path2 = require("path");
+var import_path3 = require("path");
 var import_p_limit = __toESM(require("p-limit"), 1);
 
 // src/report-artifact.ts
@@ -47,6 +48,36 @@ var import_url = require("url");
 function normalizeScreenshotsBaseUrl(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 }
+function classifyImage(image) {
+  if (image.actual !== void 0 || image.diff !== void 0) {
+    return "comparison";
+  }
+  if (image.expect !== void 0) {
+    return "baseline-only";
+  }
+  return "declared-only";
+}
+function withImageSource(image) {
+  return {
+    ...image,
+    source: classifyImage(image)
+  };
+}
+function getDeclaredVisualNames(visualNames, visualDeclarations) {
+  return visualDeclarations?.map(({ visualName }) => visualName) ?? visualNames;
+}
+function copyVisualDeclarations(visualDeclarations) {
+  return visualDeclarations?.map((visualDeclaration) => ({ ...visualDeclaration }));
+}
+function mergeDeclaredImages(images, visualNames) {
+  const names = /* @__PURE__ */ new Set([...Object.keys(images), ...visualNames]);
+  return Object.fromEntries(
+    Array.from(names, (name) => {
+      const current = images[name] ?? {};
+      return [name, withImageSource(current)];
+    })
+  );
+}
 function attachmentsToImages(attachments, screenshotsBaseUrl = "/screenshots/") {
   const images = {};
   const baseUrl = normalizeScreenshotsBaseUrl(screenshotsBaseUrl);
@@ -57,7 +88,7 @@ function attachmentsToImages(attachments, screenshotsBaseUrl = "/screenshots/")
     const baseName = match[1];
     const role = match[2];
     if (baseName === null || baseName === void 0 || role === null || role === void 0) continue;
-    images[baseName] ??= { actual: "" };
+    images[baseName] ??= {};
     const url = `${baseUrl}${attachment.path}`;
     const img = images[baseName];
     if (img !== null && img !== void 0) {
@@ -68,10 +99,11 @@ function attachmentsToImages(attachments, screenshotsBaseUrl = "/screenshots/")
   }
   for (const key of Object.keys(images)) {
     const img = images[key];
-    if (img?.actual !== null && img?.actual !== void 0 && img?.expect !== null && img?.expect !== void 0 && img?.diff === void 0)
+    if (img?.actual !== void 0 && img?.expect !== void 0 && img?.diff === void 0) {
       delete img.expect;
+    }
   }
-  return images;
+  return mergeDeclaredImages(images, []);
 }
 function mapStatus(status) {
   switch (status) {
@@ -87,17 +119,39 @@ function mapStatus(status) {
 }
 
 // src/report-state.ts
-function hasReviewablePassingImages(images) {
-  return Object.values(images).some(
-    (img) => img !== null && img !== void 0 && img.actual !== null && img.actual !== void 0 && img.diff === void 0
-  );
+function isCurrentArtifact(image) {
+  return image?.actual !== void 0 || image?.expect !== void 0 || image?.diff !== void 0;
+}
+function isReusablePassingImage(image) {
+  const source = image.source ?? classifyImage(image);
+  if (source === "comparison") {
+    return image.actual !== void 0 && image.diff === void 0;
+  }
+  return source === "baseline-only";
+}
+function hasReusablePassingImages(images) {
+  return Object.values(images).some((img) => img !== null && img !== void 0 && isReusablePassingImage(img));
 }
 function preservePreviousPassingImages(test, status, images) {
-  if (status !== "passed" || Object.keys(images).length > 0) {
+  if (status !== "passed") {
     return images;
   }
   const previousImages = test.results?.[0]?.images ?? {};
-  return hasReviewablePassingImages(previousImages) ? previousImages : images;
+  if (!hasReusablePassingImages(previousImages)) {
+    return images;
+  }
+  return Object.entries(previousImages).reduce((currentImages, [name, previousImage]) => {
+    if (!Object.hasOwn(currentImages, name) || previousImage === void 0 || !isReusablePassingImage(previousImage) || isCurrentArtifact(currentImages[name])) {
+      return currentImages;
+    }
+    return {
+      ...currentImages,
+      [name]: {
+        ...previousImage,
+        source: previousImage.source ?? classifyImage(previousImage)
+      }
+    };
+  }, images);
 }
 function countDiffImages(images) {
   return Object.values(images).filter((img) => img?.diff !== null && img?.diff !== void 0).length;
@@ -133,10 +187,15 @@ function applyTestEndEvent(state, data, options = {}) {
     return null;
   }
   test.status = mapStatus(data.status);
+  const resultStatus = data.status === "passed" ? "success" : data.status === "failed" ? "failed" : "pending";
+  const visualDeclarations = copyVisualDeclarations(data.visualDeclarations);
   const images = preservePreviousPassingImages(
     test,
     data.status,
-    attachmentsToImages(data.attachments, options.screenshotsBaseUrl)
+    mergeDeclaredImages(
+      attachmentsToImages(data.attachments, options.screenshotsBaseUrl),
+      getDeclaredVisualNames(data.visualNames, visualDeclarations)
+    )
   );
   const diffCount = countDiffImages(images);
   const hasDiffs = diffCount > 0;
@@ -145,9 +204,10 @@ function applyTestEndEvent(state, data, options = {}) {
   }
   test.results = [
     {
-      status: data.status === "passed" ? "success" : "failed",
+      status: resultStatus,
       retries: 0,
       images,
+      visualDeclarations,
       error: data.error,
       duration: data.duration
     }
@@ -177,23 +237,40 @@ var LocationSchema = import_zod.z.object({
   file: import_zod.z.string(),
   line: import_zod.z.number()
 });
+var VisualSourceSchema = import_zod.z.enum(["comparison", "baseline-only", "declared-only"]);
 var ImagesSchema = import_zod.z.object({
-  actual: import_zod.z.string(),
+  actual: import_zod.z.string().optional(),
   expect: import_zod.z.string().optional(),
   diff: import_zod.z.string().optional(),
-  error: import_zod.z.string().optional()
+  error: import_zod.z.string().optional(),
+  source: VisualSourceSchema.optional()
 });
+var ScreenshotDeclarationSchema = import_zod.z.discriminatedUnion("kind", [
+  import_zod.z.object({
+    visualName: import_zod.z.string(),
+    kind: import_zod.z.literal("named"),
+    declaredName: import_zod.z.string(),
+    snapshotBaseName: import_zod.z.string(),
+    occurrenceIndex: import_zod.z.number()
+  }),
+  import_zod.z.object({
+    visualName: import_zod.z.string(),
+    kind: import_zod.z.literal("unnamed"),
+    occurrenceIndex: import_zod.z.number()
+  })
+]);
 var AttachmentSchema = import_zod.z.object({
   name: import_zod.z.string(),
   path: import_zod.z.string(),
   contentType: import_zod.z.string()
 });
 var TestStatusSchema = import_zod.z.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
+var TestResultStatusSchema = import_zod.z.enum(["failed", "success", "pending"]);
 var TestResultSchema = import_zod.z.object({
-  status: import_zod.z.enum(["failed", "success"]),
+  status: TestResultStatusSchema,
   retries: import_zod.z.number(),
-  // eslint-disable-next-line typescript/no-unsafe-type-assertion
   images: import_zod.z.record(import_zod.z.string(), ImagesSchema).optional(),
+  visualDeclarations: import_zod.z.array(ScreenshotDeclarationSchema).optional(),
   error: import_zod.z.string().optional(),
   duration: import_zod.z.number().optional()
 });
@@ -221,7 +298,6 @@ var CrvyRprtrSuiteSchema = import_zod.z.lazy(
     opened: import_zod.z.boolean(),
     checked: import_zod.z.boolean(),
     indeterminate: import_zod.z.boolean(),
-    // eslint-disable-next-line typescript/no-unsafe-type-assertion
     children: import_zod.z.record(import_zod.z.string(), import_zod.z.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
   })
 );
@@ -240,6 +316,11 @@ var TestEndDataSchema = import_zod.z.object({
   id: import_zod.z.string(),
   status: import_zod.z.enum(["passed", "failed", "skipped"]),
   attachments: import_zod.z.array(AttachmentSchema),
+  visualNames: import_zod.z.array(import_zod.z.string()).default([]),
+  visualDeclarations: import_zod.z.preprocess(
+    (value) => value === null ? void 0 : value,
+    import_zod.z.array(ScreenshotDeclarationSchema).optional()
+  ),
   error: import_zod.z.string().optional(),
   duration: import_zod.z.number().optional()
 });
@@ -412,18 +493,244 @@ async function writeReportArtifact(options) {
 }
 
 // src/reporter-utils.ts
-function extractScreenshotNames(steps) {
-  const names = [];
+var NAMED_SCREENSHOT_STEP_TITLE = /toHaveScreenshot\((.+?)\)/;
+var UNNAMED_SCREENSHOT_STEP_TITLE = /^Expect "toHaveScreenshot"(?:\s|$)/;
+var SYNTHETIC_SCREENSHOT_PREFIX = "__unnamed-screenshot-";
+function addVisualSuffix(visualName, occurrenceIndex) {
+  if (occurrenceIndex === 1) {
+    return visualName;
+  }
+  const slashIndex = visualName.lastIndexOf("/");
+  return slashIndex === -1 ? `${visualName}-${occurrenceIndex - 1}` : `${visualName.slice(0, slashIndex + 1)}${visualName.slice(slashIndex + 1)}-${occurrenceIndex - 1}`;
+}
+function normalizeNamedScreenshot(titleMatch, state) {
+  const unquotedName = titleMatch.trim().replace(/^['"`]|['"`]$/g, "");
+  if (unquotedName === "") {
+    return null;
+  }
+  const normalizedPath = unquotedName.replace(/\\/g, "/");
+  const declaredName = normalizedPath.replace(/\.png$/, "");
+  if (declaredName === "") {
+    return null;
+  }
+  const occurrenceIndex = (state.namedOccurrences.get(declaredName) ?? 0) + 1;
+  state.namedOccurrences.set(declaredName, occurrenceIndex);
+  return {
+    visualName: addVisualSuffix(declaredName, occurrenceIndex),
+    kind: "named",
+    declaredName,
+    snapshotBaseName: declaredName,
+    occurrenceIndex
+  };
+}
+function visitStep(step, state) {
+  const declarationsBeforeChildren = state.declarations.length;
+  for (const nestedStep of step.steps) {
+    visitStep(nestedStep, state);
+  }
+  const namedMatch = step.title.match(NAMED_SCREENSHOT_STEP_TITLE);
+  if (namedMatch?.[1] !== void 0) {
+    const declaration = normalizeNamedScreenshot(namedMatch[1], state);
+    if (declaration !== null) {
+      state.declarations.push(declaration);
+      return true;
+    }
+  }
+  const hasNestedScreenshotDeclaration = state.declarations.length > declarationsBeforeChildren;
+  if (UNNAMED_SCREENSHOT_STEP_TITLE.test(step.title) && !hasNestedScreenshotDeclaration) {
+    const occurrenceIndex = state.nextUnnamedIndex;
+    state.declarations.push({
+      visualName: `${SYNTHETIC_SCREENSHOT_PREFIX}${occurrenceIndex}`,
+      kind: "unnamed",
+      occurrenceIndex
+    });
+    state.nextUnnamedIndex += 1;
+    return true;
+  }
+  return hasNestedScreenshotDeclaration;
+}
+function extractScreenshotDeclarations(steps) {
+  const state = {
+    declarations: [],
+    namedOccurrences: /* @__PURE__ */ new Map(),
+    nextUnnamedIndex: 1
+  };
   for (const step of steps) {
-    const match = step.title.match(/toHaveScreenshot\((.+?)\)/);
-    if (match?.[1] !== void 0 && match[1] !== "") names.push(match[1]);
-    if (step.steps.length) names.push(...extractScreenshotNames(step.steps));
+    visitStep(step, state);
   }
-  return names;
+  return state.declarations;
+}
+
+// src/snapshot-path-resolver.ts
+var import_crypto = require("crypto");
+var import_path2 = require("path");
+var DEFAULT_SCREENSHOT_TEMPLATE = "{snapshotDir}/{testFileDir}/{testFileName}-snapshots/{arg}{-projectName}{-snapshotSuffix}{ext}";
+var WINDOWS_FILESYSTEM_FRIENDLY_LENGTH = 60;
+function isUnsafeFilePathCharacter(character) {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && (codePoint <= 44 || codePoint >= 46 && codePoint <= 47 || codePoint >= 58 && codePoint <= 64 || codePoint >= 91 && codePoint <= 96 || codePoint >= 123 && codePoint <= 127);
+}
+function sanitizeForFilePath(value) {
+  return Array.from(value).reduce(
+    (state, character) => {
+      const unsafeCharacter = isUnsafeFilePathCharacter(character);
+      return unsafeCharacter ? state.previousCharacterWasUnsafe ? state : {
+        value: `${state.value}-`,
+        previousCharacterWasUnsafe: true
+      } : {
+        value: `${state.value}${character}`,
+        previousCharacterWasUnsafe: false
+      };
+    },
+    {
+      value: "",
+      previousCharacterWasUnsafe: false
+    }
+  ).value;
+}
+function trimLongString(value, length = WINDOWS_FILESYSTEM_FRIENDLY_LENGTH) {
+  if (value.length <= length) {
+    return value;
+  }
+  const hash = (0, import_crypto.createHash)("sha1").update(value).digest("hex");
+  const middle = `-${hash.slice(0, 5)}-`;
+  const start = Math.floor((length - middle.length) / 2);
+  const end = length - middle.length - start;
+  return value.slice(0, start) + middle + value.slice(-end);
+}
+function sanitizeFilePathBeforeExtension(filePath, extension = (0, import_path2.extname)(filePath)) {
+  const base = filePath.slice(0, filePath.length - extension.length);
+  return sanitizeForFilePath(base) + extension;
+}
+function addSuffixToFilePath(filePath, suffix) {
+  const extension = (0, import_path2.extname)(filePath);
+  return filePath.slice(0, filePath.length - extension.length) + suffix + extension;
+}
+function normalizedSnapshotDir(config) {
+  return (0, import_path2.resolve)(config.configDir, config.snapshotDir);
+}
+function templateValue(template, token, value) {
+  return template.replace(
+    new RegExp(`\\{(.)?${token}\\}`, "g"),
+    (_, prefix) => value === "" ? "" : `${prefix ?? ""}${value}`
+  );
+}
+function applyTemplate(input, nameArgument, extension) {
+  const template = input.config.toHaveScreenshotPathTemplate ?? input.config.snapshotPathTemplate ?? DEFAULT_SCREENSHOT_TEMPLATE;
+  const relativeTestFilePath = (0, import_path2.relative)(input.config.testDir, input.testFile);
+  const parsed = (0, import_path2.parse)(relativeTestFilePath);
+  const tokens = [
+    ["testDir", input.config.testDir],
+    ["snapshotDir", normalizedSnapshotDir(input.config)],
+    ["snapshotSuffix", input.config.snapshotSuffix],
+    ["testFileDir", parsed.dir],
+    ["platform", process.platform],
+    ["projectName", sanitizeForFilePath(input.config.projectName)],
+    ["testName", ""],
+    ["testFileName", parsed.base],
+    ["testFilePath", relativeTestFilePath],
+    ["arg", nameArgument],
+    ["ext", extension]
+  ];
+  const snapshotPath = tokens.reduce(
+    (currentTemplate, [token, value]) => templateValue(currentTemplate, token, value),
+    template
+  );
+  return (0, import_path2.resolve)(input.config.configDir, snapshotPath);
+}
+function removeExtension(filePath, extension = (0, import_path2.extname)(filePath)) {
+  return filePath.slice(0, filePath.length - extension.length);
+}
+function snapshotNameParts(declaredName) {
+  const extension = (0, import_path2.extname)(declaredName) || ".png";
+  return {
+    extension,
+    filePath: (0, import_path2.extname)(declaredName) === "" ? `${declaredName}${extension}` : declaredName
+  };
+}
+function filePathForOccurrence(filePath, occurrenceIndex) {
+  return occurrenceIndex === 1 ? filePath : addSuffixToFilePath(filePath, `-${occurrenceIndex - 1}`);
+}
+function createResolvedBaselineTarget(input, declaration, nameArgument, extension) {
+  return {
+    visualName: declaration.visualName,
+    attachmentBaseName: declaration.visualName,
+    artifactBaseName: sanitizeForFilePath(declaration.visualName),
+    snapshotPath: applyTemplate(input, nameArgument, extension)
+  };
+}
+function resolveStringCallTarget(input, declaration) {
+  const { extension, filePath } = snapshotNameParts(declaration.declaredName);
+  const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
+  const sanitizedNameWithExtension = sanitizeFilePathBeforeExtension(occurrenceFilePath, extension);
+  const nameArgument = removeExtension(sanitizedNameWithExtension, extension);
+  return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+}
+function resolveArrayCallTarget(input, declaration) {
+  const { extension, filePath } = snapshotNameParts(declaration.declaredName);
+  const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
+  const nameArgument = (0, import_path2.join)((0, import_path2.dirname)(occurrenceFilePath), (0, import_path2.basename)(occurrenceFilePath, extension));
+  return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+}
+function resolveNamedTarget(input, declaration) {
+  if (!declaration.declaredName.includes("/")) {
+    return resolveStringCallTarget(input, declaration);
+  }
+  const stringCallTarget = resolveStringCallTarget(input, declaration);
+  const arrayCallTarget = resolveArrayCallTarget(input, declaration);
+  if (stringCallTarget.snapshotPath === arrayCallTarget.snapshotPath) {
+    return stringCallTarget;
+  }
+  if (input.snapshotPathExists === void 0) {
+    return void 0;
+  }
+  const stringCallTargetExists = input.snapshotPathExists(stringCallTarget.snapshotPath);
+  const arrayCallTargetExists = input.snapshotPathExists(arrayCallTarget.snapshotPath);
+  if (stringCallTargetExists === arrayCallTargetExists) {
+    return void 0;
+  }
+  return stringCallTargetExists ? stringCallTarget : arrayCallTarget;
+}
+function reporterTitlesWithoutProjectAndFile(reporterTitlePath) {
+  return reporterTitlePath.slice(3).filter((part) => part !== "");
+}
+function anonymousName(reporterTitlePath, occurrenceIndex) {
+  const rawAnonymousName = `${reporterTitlesWithoutProjectAndFile(reporterTitlePath).join(" ")} ${occurrenceIndex}.png`;
+  return sanitizeFilePathBeforeExtension(trimLongString(rawAnonymousName), ".png");
+}
+function resolveTarget(input, declaration) {
+  switch (declaration.kind) {
+    case "named":
+      return typeof declaration.declaredName === "string" && declaration.declaredName !== "" ? resolveNamedTarget(input, declaration) : void 0;
+    case "unnamed": {
+      const anonymousFileName = anonymousName(input.reporterTitlePath, declaration.occurrenceIndex);
+      const extension = ".png";
+      const nameArgument = (0, import_path2.join)((0, import_path2.dirname)(anonymousFileName), (0, import_path2.basename)(anonymousFileName, extension));
+      return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+    }
+  }
+}
+function resolveBaselineTargets(input) {
+  return input.declarations.flatMap((declaration) => {
+    const resolvedTarget = resolveTarget(input, declaration);
+    return resolvedTarget === void 0 ? [] : [resolvedTarget];
+  });
 }
 
 // src/reporter.ts
+var CURRENT_DIRECTORY_ARTIFACT_SEGMENT = "+dot+";
+var PARENT_DIRECTORY_ARTIFACT_SEGMENT = "+dotdot+";
 var MAX_CONCURRENT_FILE_OPS = 5;
+var SAFE_ARTIFACT_CHARACTER = /^[A-Za-z0-9._-]$/;
+var encodeArtifactPathSegment = (segment) => {
+  if (segment === ".") return CURRENT_DIRECTORY_ARTIFACT_SEGMENT;
+  if (segment === "..") return PARENT_DIRECTORY_ARTIFACT_SEGMENT;
+  return Array.from(
+    segment,
+    (character) => SAFE_ARTIFACT_CHARACTER.test(character) ? character : encodeURIComponent(character)
+  ).join("");
+};
+var safeArtifactPath = (name) => name.split("/").map(encodeArtifactPathSegment).join("/");
 var CrvyRprtr = class {
   ws = null;
   serverUrl;
@@ -432,6 +739,11 @@ var CrvyRprtr = class {
   workerIndex;
   offlineReportPath;
   reportHtmlPath;
+  configDir = process.cwd();
+  testMetadata = /* @__PURE__ */ new Map();
+  playwrightSnapshotDir;
+  playwrightSnapshotPathTemplate;
+  playwrightToHaveScreenshotPathTemplate;
   isOfflineMode = false;
   hadOfflineMode = false;
   runEvents = [];
@@ -441,8 +753,12 @@ var CrvyRprtr = class {
     this.workerIndex = parseInt(process.env.TEST_WORKER_INDEX ?? "0", 10) || 0;
     this.offlineReportPath = options.offlineReportPath ?? `./crvy-rprtr-${this.workerIndex}.json`;
     this.reportHtmlPath = options.reportHtmlPath ?? "./crvy-rprtr.html";
+    this.playwrightSnapshotDir = options.playwrightSnapshotDir;
+    this.playwrightSnapshotPathTemplate = options.playwrightSnapshotPathTemplate;
+    this.playwrightToHaveScreenshotPathTemplate = options.playwrightToHaveScreenshotPathTemplate;
   }
   async onBegin(config, suite) {
+    this.configDir = config.configFile === void 0 ? config.rootDir : (0, import_path3.dirname)(config.configFile);
     console.log(`[CrvyRprtr] Starting run with ${suite.allTests().length} tests`);
     await (0, import_promises2.mkdir)(this.screenshotDir, { recursive: true });
     this.connect();
@@ -459,7 +775,7 @@ var CrvyRprtr = class {
       this.ws.onopen = () => {
         console.log("[CrvyRprtr] Connected to Crvy Rprtr server");
         this.isOfflineMode = false;
-        for (const msg of this.queue) this.ws.send(msg);
+        for (const message of this.queue) this.ws.send(message);
         this.queue = [];
       };
       this.ws.onerror = (error) => {
@@ -470,140 +786,158 @@ var CrvyRprtr = class {
         console.log("[CrvyRprtr] Disconnected from Crvy Rprtr server");
         this.enableOfflineMode();
       };
-    } catch (e) {
-      console.error("[CrvyRprtr] Failed to connect:", e);
+    } catch (error) {
+      console.error("[CrvyRprtr] Failed to connect:", error);
       this.enableOfflineMode();
     }
   }
   enableOfflineMode() {
-    if (!this.isOfflineMode) {
-      this.isOfflineMode = true;
-      this.hadOfflineMode = true;
-      console.log("[CrvyRprtr] Offline mode enabled - events will be queued to file");
-    }
+    if (this.isOfflineMode) return;
+    this.isOfflineMode = this.hadOfflineMode = true;
+    console.log("[CrvyRprtr] Offline mode enabled - events will be queued to file");
   }
-  onTestBegin(test) {
+  describeTitlePath(test) {
     const titlePath = [];
-    let suite = test.parent;
-    while (suite && suite.type === "describe") {
+    for (let suite = test.parent; suite?.type === "describe"; suite = suite.parent)
       titlePath.unshift(suite.title);
-      suite = suite.parent;
-    }
+    return titlePath;
+  }
+  reporterTitlePath(test) {
+    return typeof test.titlePath === "function" ? test.titlePath() : ["", test.parent.project()?.name ?? "chromium", test.location.file, ...this.describeTitlePath(test), test.title];
+  }
+  onTestBegin(test) {
+    this.testMetadata.set(test.id, { reporterTitlePath: this.reporterTitlePath(test) });
     this.send({
       type: "test-begin",
       data: {
         id: test.id,
         title: test.title,
-        titlePath,
+        titlePath: this.describeTitlePath(test),
         browser: test.parent.project()?.name ?? "chromium",
-        location: {
-          file: test.location.file,
-          line: test.location.line
-        }
+        location: { file: test.location.file, line: test.location.line }
       }
     });
   }
   async onTestEnd(test, result) {
+    const screenshotDeclarations = extractScreenshotDeclarations(result.steps);
     const savedAttachments = await this.saveAttachments(test.id, result);
-    await this.copySnapshotBaselines(test, result, savedAttachments);
-    this.send({
-      type: "test-end",
-      data: {
-        id: test.id,
-        title: test.title,
-        status: result.status,
-        attachments: savedAttachments,
-        error: result.errors.length > 0 ? result.errors[0]?.message : void 0,
-        duration: result.duration
-      }
-    });
+    try {
+      await this.copySnapshotBaselines(test, result.status, screenshotDeclarations, savedAttachments);
+      this.send({
+        type: "test-end",
+        data: {
+          id: test.id,
+          title: test.title,
+          status: result.status,
+          attachments: savedAttachments,
+          visualNames: screenshotDeclarations.map(({ visualName }) => visualName),
+          visualDeclarations: screenshotDeclarations,
+          error: result.errors.length > 0 ? result.errors[0]?.message : void 0,
+          duration: result.duration
+        }
+      });
+    } finally {
+      this.testMetadata.delete(test.id);
+    }
   }
-  async copySnapshotBaselines(test, result, savedAttachments) {
-    if (result.status !== "passed") return;
-    const snapshotNames = extractScreenshotNames(result.steps);
-    if (snapshotNames.length === 0) return;
-    const projectName = test.parent.project()?.name ?? "chromium";
-    const snapshotDir = `${test.location.file}-snapshots`;
-    const testScreenshotDir = (0, import_path2.join)(this.screenshotDir, this.sanitizeId(test.id));
+  baselineInput(test, shots) {
+    const project = test.parent.project();
+    const snapshotDir = this.playwrightSnapshotDir ?? project?.snapshotDir;
+    if (project === void 0 || typeof project.testDir !== "string" || typeof snapshotDir !== "string") return null;
+    return {
+      testFile: test.location.file,
+      reporterTitlePath: this.testMetadata.get(test.id)?.reporterTitlePath ?? this.reporterTitlePath(test),
+      declarations: shots,
+      config: {
+        configDir: this.configDir,
+        testDir: project.testDir,
+        snapshotDir,
+        projectName: project.name,
+        snapshotSuffix: process.platform,
+        snapshotPathTemplate: this.playwrightSnapshotPathTemplate,
+        toHaveScreenshotPathTemplate: this.playwrightToHaveScreenshotPathTemplate
+      },
+      snapshotPathExists: import_fs.existsSync
+    };
+  }
+  async copyResolvedBaseline(safeTestId, testScreenshotDir, target, savedAttachments) {
+    const attachmentName = `${target.attachmentBaseName}-expected.png`;
+    const artifactPath = safeArtifactPath(attachmentName);
+    const destPath = (0, import_path3.join)(testScreenshotDir, artifactPath);
+    try {
+      await (0, import_promises2.mkdir)((0, import_path3.dirname)(destPath), { recursive: true });
+      await (0, import_promises2.copyFile)(target.snapshotPath, destPath);
+      savedAttachments.push({ name: attachmentName, path: `${safeTestId}/${artifactPath}`, contentType: "image/png" });
+      console.log(`[CrvyRprtr] Attached baseline: ${target.snapshotPath}`);
+    } catch {
+    }
+  }
+  async copySnapshotBaselines(test, status, screenshotDeclarations, savedAttachments) {
+    if (status !== "passed" || screenshotDeclarations.length === 0) return;
+    const input = this.baselineInput(test, screenshotDeclarations);
+    if (input === null) return;
+    const targets = resolveBaselineTargets(input);
+    if (targets.length === 0) return;
+    const safeTestId = this.sanitizeId(test.id);
+    const testScreenshotDir = (0, import_path3.join)(this.screenshotDir, safeTestId);
     const limit = (0, import_p_limit.default)(MAX_CONCURRENT_FILE_OPS);
-    const copyPromises = snapshotNames.map(
-      (name) => limit(async () => {
-        const baseName = name.replace(/\.png$/, "");
-        const snapshotPath = (0, import_path2.join)(snapshotDir, `${baseName}-${projectName}-${process.platform}.png`);
-        const destName = `${baseName}-expected`;
-        const destPath = (0, import_path2.join)(testScreenshotDir, destName);
-        try {
-          await (0, import_promises2.mkdir)(testScreenshotDir, { recursive: true });
-          await (0, import_promises2.copyFile)(snapshotPath, destPath);
-          savedAttachments.push({
-            name: destName,
-            path: `${this.sanitizeId(test.id)}/${destName}`,
-            contentType: "image/png"
-          });
-          console.log(`[CrvyRprtr] Attached baseline: ${snapshotPath}`);
-        } catch {
-        }
-      })
+    await Promise.all(
+      targets.map(
+        (target) => limit(() => this.copyResolvedBaseline(safeTestId, testScreenshotDir, target, savedAttachments))
+      )
     );
-    await Promise.all(copyPromises);
   }
   async saveAttachments(testId, result) {
     const savedAttachments = [];
-    const testScreenshotDir = (0, import_path2.join)(this.screenshotDir, this.sanitizeId(testId));
+    const safeTestId = this.sanitizeId(testId);
+    const testScreenshotDir = (0, import_path3.join)(this.screenshotDir, safeTestId);
     const limit = (0, import_p_limit.default)(MAX_CONCURRENT_FILE_OPS);
-    const attachmentPromises = result.attachments.filter(
-      (attachment) => attachment.contentType === "image/png" && attachment.path !== void 0
-    ).map(
-      (attachment) => limit(async () => {
-        try {
-          await (0, import_promises2.mkdir)(testScreenshotDir, { recursive: true });
-          const fileName = attachment.name;
-          const destPath = (0, import_path2.join)(testScreenshotDir, fileName);
-          await (0, import_promises2.copyFile)(attachment.path, destPath);
-          const attachmentData = {
-            name: attachment.name,
-            path: `${this.sanitizeId(testId)}/${fileName}`,
-            contentType: attachment.contentType
-          };
-          savedAttachments.push(attachmentData);
-          console.log(`[CrvyRprtr] Saved screenshot: ${destPath}`);
-        } catch (e) {
-          console.error(`[CrvyRprtr] Failed to save screenshot: ${attachment.path}`, e);
-          const fallbackData = {
-            name: attachment.name,
-            path: attachment.path,
-            contentType: attachment.contentType
-          };
-          savedAttachments.push(fallbackData);
-        }
-      })
+    await Promise.all(
+      result.attachments.filter(
+        (attachment) => attachment.contentType === "image/png" && attachment.path !== void 0
+      ).map(
+        (attachment) => limit(async () => {
+          try {
+            const artifactPath = safeArtifactPath(attachment.name);
+            const destPath = (0, import_path3.join)(testScreenshotDir, artifactPath);
+            await (0, import_promises2.mkdir)((0, import_path3.dirname)(destPath), { recursive: true });
+            await (0, import_promises2.copyFile)(attachment.path, destPath);
+            savedAttachments.push({
+              name: attachment.name,
+              path: `${safeTestId}/${artifactPath}`,
+              contentType: attachment.contentType
+            });
+            console.log(`[CrvyRprtr] Saved screenshot: ${destPath}`);
+          } catch (error) {
+            console.error(`[CrvyRprtr] Failed to save screenshot: ${attachment.path}`, error);
+            savedAttachments.push({
+              name: attachment.name,
+              path: attachment.path,
+              contentType: attachment.contentType
+            });
+          }
+        })
+      )
     );
-    await Promise.all(attachmentPromises);
     return savedAttachments;
   }
   sanitizeId(id) {
     return id.replace(/[^a-zA-Z0-9-_]/g, "_");
   }
   async writeOfflineReport() {
-    if (this.runEvents.length === 0) {
-      console.log("[CrvyRprtr] No offline events to write");
-      return;
-    }
+    if (this.runEvents.length === 0) console.log("[CrvyRprtr] No offline events to write");
+    if (this.runEvents.length === 0) return;
     try {
       const report = {
         version: 1,
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         workers: this.workerIndex + 1,
-        events: this.runEvents.map((e) => ({
-          ...e,
-          timestamp: Date.now(),
-          workerIndex: this.workerIndex
-        }))
+        events: this.runEvents.map((event) => ({ ...event, timestamp: Date.now(), workerIndex: this.workerIndex }))
       };
       await (0, import_promises2.writeFile)(this.offlineReportPath, JSON.stringify(report, null, 2));
       console.log(`[CrvyRprtr] Wrote offline report: ${this.offlineReportPath}`);
-    } catch (e) {
-      console.error("[CrvyRprtr] Failed to write offline report:", e);
+    } catch (error) {
+      console.error("[CrvyRprtr] Failed to write offline report:", error);
     }
   }
   async writeStaticArtifact() {
@@ -614,51 +948,35 @@ var CrvyRprtr = class {
         reportHtmlPath: this.reportHtmlPath
       });
       console.log(`[CrvyRprtr] Wrote report artifact: ${this.reportHtmlPath}`);
-    } catch (e) {
-      console.error("[CrvyRprtr] Failed to write report artifact:", e);
+    } catch (error) {
+      console.error("[CrvyRprtr] Failed to write report artifact:", error);
     }
   }
   async onEnd(result) {
-    this.send({
-      type: "run-end",
-      data: {
-        status: result.status
-      }
-    });
+    this.send({ type: "run-end", data: { status: result.status } });
     await this.writeStaticArtifact();
-    if (this.hadOfflineMode) {
-      await this.writeOfflineReport();
-    }
-    await new Promise((resolve2) => {
-      if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
-        resolve2();
-        return;
-      }
-      this.ws.onclose = () => {
-        resolve2();
-      };
-      setTimeout(() => {
-        this.ws?.close();
-        resolve2();
-      }, 1e3);
-      this.ws.close();
+    if (this.hadOfflineMode) await this.writeOfflineReport();
+    await new Promise((resolve3) => {
+      if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
+        this.ws.onclose = () => {
+          resolve3();
+        };
+        setTimeout(() => {
+          this.ws?.close();
+          resolve3();
+        }, 1e3);
+        this.ws.close();
+      } else resolve3();
     });
   }
-  send(msg) {
-    const msgObj = msg;
-    if (msgObj.type === "test-begin" || msgObj.type === "test-end" || msgObj.type === "run-end") {
-      this.runEvents.push({
-        type: msgObj.type,
-        data: msgObj.data
-      });
-    }
-    const payload = JSON.stringify(msg);
+  send(message) {
+    const event = message;
+    if (event.type === "test-begin" || event.type === "test-end" || event.type === "run-end")
+      this.runEvents.push({ type: event.type, data: event.data });
+    const payload = JSON.stringify(message);
     if (!this.isOfflineMode) {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        this.ws.send(payload);
-      } else {
-        this.queue.push(payload);
-      }
+      if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(payload);
+      else this.queue.push(payload);
     }
   }
 };