@crvy/rprtr 0.0.5 → 0.0.8

package/dist/reporter.cjs

@@ -34,8 +34,23 @@ __export(reporter_exports, {
   default: () => reporter_default
 });
 module.exports = __toCommonJS(reporter_exports);
+var import_fs = require("fs");
+var import_promises3 = require("fs/promises");
+var import_path4 = require("path");
+var import_p_limit2 = __toESM(require("p-limit"), 1);
+
+// src/debug-log.ts
+var isDebug = () => process.env.DEBUG !== void 0 && process.env.DEBUG !== "";
+var log = (...args) => {
+  if (isDebug()) console.log(...args);
+};
+var logError = (...args) => {
+  if (isDebug()) console.error(...args);
+};
+
+// src/reporter-artifact-ops.ts
 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
@@ -62,6 +77,12 @@ function withImageSource(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(
@@ -181,10 +202,14 @@ function applyTestEndEvent(state, data, options = {}) {
   }
   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,
-    mergeDeclaredImages(attachmentsToImages(data.attachments, options.screenshotsBaseUrl), data.visualNames)
+    mergeDeclaredImages(
+      attachmentsToImages(data.attachments, options.screenshotsBaseUrl),
+      getDeclaredVisualNames(data.visualNames, visualDeclarations)
+    )
   );
   const diffCount = countDiffImages(images);
   const hasDiffs = diffCount > 0;
@@ -196,6 +221,7 @@ function applyTestEndEvent(state, data, options = {}) {
       status: resultStatus,
       retries: 0,
       images,
+      visualDeclarations,
       error: data.error,
       duration: data.duration
     }
@@ -233,6 +259,20 @@ var ImagesSchema = import_zod.z.object({
   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(),
@@ -244,6 +284,7 @@ var TestResultSchema = import_zod.z.object({
   status: TestResultStatusSchema,
   retries: import_zod.z.number(),
   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()
 });
@@ -290,6 +331,10 @@ var TestEndDataSchema = import_zod.z.object({
   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()
 });
@@ -461,32 +506,285 @@ async function writeReportArtifact(options) {
   await (0, import_promises.writeFile)(reportHtmlPath, html);
 }
 
+// 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-artifact-ops.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._-]$/;
+function 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("");
+}
+function safeArtifactPath(name) {
+  return name.split("/").map(encodeArtifactPathSegment).join("/");
+}
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+async function 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" });
+    log(`[CrvyRprtr] Attached baseline: ${target.snapshotPath}`);
+  } catch {
+  }
+}
+async function saveAttachments(screenshotDir, testId, result) {
+  const savedAttachments = [];
+  const safeTestId = sanitizeId(testId);
+  const testScreenshotDir = (0, import_path3.join)(screenshotDir, safeTestId);
+  const limit = (0, import_p_limit.default)(MAX_CONCURRENT_FILE_OPS);
+  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 ?? "image/png"
+          });
+          log(`[CrvyRprtr] Saved screenshot: ${destPath}`);
+        } catch (error) {
+          logError(`[CrvyRprtr] Failed to save screenshot: ${attachment.path}`, error);
+          savedAttachments.push({
+            name: attachment.name,
+            path: attachment.path,
+            contentType: attachment.contentType ?? "image/png"
+          });
+        }
+      })
+    )
+  );
+  return savedAttachments;
+}
+async function writeOfflineReport(runEvents, offlineReportPath, workerIndex) {
+  if (runEvents.length === 0) {
+    log("[CrvyRprtr] No offline events to write");
+    return;
+  }
+  try {
+    const report = {
+      version: 1,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workers: workerIndex + 1,
+      events: runEvents.map((event) => ({ ...event, timestamp: Date.now(), workerIndex }))
+    };
+    await (0, import_promises2.writeFile)(offlineReportPath, JSON.stringify(report, null, 2));
+    log(`[CrvyRprtr] Wrote offline report: ${offlineReportPath}`);
+  } catch (error) {
+    logError("[CrvyRprtr] Failed to write offline report:", error);
+  }
+}
+async function writeStaticArtifact(runEvents, screenshotDir, reportHtmlPath) {
+  try {
+    await writeReportArtifact({ events: runEvents, screenshotDir, reportHtmlPath });
+    log(`[CrvyRprtr] Wrote report artifact: ${reportHtmlPath}`);
+  } catch (error) {
+    logError("[CrvyRprtr] Failed to write report artifact:", error);
+  }
+}
+
 // src/reporter-utils.ts
 var NAMED_SCREENSHOT_STEP_TITLE = /toHaveScreenshot\((.+?)\)/;
 var UNNAMED_SCREENSHOT_STEP_TITLE = /^Expect "toHaveScreenshot"(?:\s|$)/;
 var SYNTHETIC_SCREENSHOT_PREFIX = "__unnamed-screenshot-";
-function normalizeNamedScreenshot(titleMatch) {
+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 normalizedName = normalizedPath.replace(/\.png$/, "");
-  if (normalizedName === "") {
+  const declaredName = normalizedPath.replace(/\.png$/, "");
+  if (declaredName === "") {
     return null;
   }
+  const occurrenceIndex = (state.namedOccurrences.get(declaredName) ?? 0) + 1;
+  state.namedOccurrences.set(declaredName, occurrenceIndex);
   return {
-    visualName: normalizedName,
-    snapshotBaseName: normalizedName
+    visualName: addVisualSuffix(declaredName, occurrenceIndex),
+    kind: "named",
+    declaredName,
+    snapshotBaseName: declaredName,
+    occurrenceIndex
   };
 }
-function appendDeclaration(state, declaration) {
-  if (state.seenVisualNames.has(declaration.visualName)) {
-    return;
-  }
-  state.seenVisualNames.add(declaration.visualName);
-  state.declarations.push(declaration);
-}
 function visitStep(step, state) {
   const declarationsBeforeChildren = state.declarations.length;
   for (const nestedStep of step.steps) {
@@ -494,16 +792,19 @@ function visitStep(step, state) {
   }
   const namedMatch = step.title.match(NAMED_SCREENSHOT_STEP_TITLE);
   if (namedMatch?.[1] !== void 0) {
-    const declaration = normalizeNamedScreenshot(namedMatch[1]);
+    const declaration = normalizeNamedScreenshot(namedMatch[1], state);
     if (declaration !== null) {
-      appendDeclaration(state, declaration);
+      state.declarations.push(declaration);
       return true;
     }
   }
   const hasNestedScreenshotDeclaration = state.declarations.length > declarationsBeforeChildren;
   if (UNNAMED_SCREENSHOT_STEP_TITLE.test(step.title) && !hasNestedScreenshotDeclaration) {
-    appendDeclaration(state, {
-      visualName: `${SYNTHETIC_SCREENSHOT_PREFIX}${state.nextUnnamedIndex}`
+    const occurrenceIndex = state.nextUnnamedIndex;
+    state.declarations.push({
+      visualName: `${SYNTHETIC_SCREENSHOT_PREFIX}${occurrenceIndex}`,
+      kind: "unnamed",
+      occurrenceIndex
     });
     state.nextUnnamedIndex += 1;
     return true;
@@ -513,7 +814,7 @@ function visitStep(step, state) {
 function extractScreenshotDeclarations(steps) {
   const state = {
     declarations: [],
-    seenVisualNames: /* @__PURE__ */ new Set(),
+    namedOccurrences: /* @__PURE__ */ new Map(),
     nextUnnamedIndex: 1
   };
   for (const step of steps) {
@@ -523,7 +824,6 @@ function extractScreenshotDeclarations(steps) {
 }
 
 // src/reporter.ts
-var MAX_CONCURRENT_FILE_OPS = 5;
 var CrvyRprtr = class {
   ws = null;
   serverUrl;
@@ -532,6 +832,11 @@ var CrvyRprtr = class {
   workerIndex;
   offlineReportPath;
   reportHtmlPath;
+  configDir = process.cwd();
+  testMetadata = /* @__PURE__ */ new Map();
+  playwrightSnapshotDir;
+  playwrightSnapshotPathTemplate;
+  playwrightToHaveScreenshotPathTemplate;
   isOfflineMode = false;
   hadOfflineMode = false;
   runEvents = [];
@@ -541,228 +846,155 @@ 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) {
-    console.log(`[CrvyRprtr] Starting run with ${suite.allTests().length} tests`);
-    await (0, import_promises2.mkdir)(this.screenshotDir, { recursive: true });
+    this.configDir = config.configFile === void 0 ? config.rootDir : (0, import_path4.dirname)(config.configFile);
+    log(`[CrvyRprtr] Starting run with ${suite.allTests().length} tests`);
+    await (0, import_promises3.mkdir)(this.screenshotDir, { recursive: true });
     this.connect();
   }
   connect() {
     const WebSocketConstructor = globalThis.WebSocket;
     if (typeof WebSocketConstructor !== "function") {
-      console.log("[CrvyRprtr] WebSocket unavailable in current runtime; offline mode enabled");
+      log("[CrvyRprtr] WebSocket unavailable in current runtime; offline mode enabled");
       this.enableOfflineMode();
       return;
     }
     try {
       this.ws = new WebSocketConstructor(this.serverUrl);
       this.ws.onopen = () => {
-        console.log("[CrvyRprtr] Connected to Crvy Rprtr server");
+        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) => {
-        console.error("[CrvyRprtr] WebSocket error:", error);
+        logError("[CrvyRprtr] WebSocket error:", error);
         this.enableOfflineMode();
       };
       this.ws.onclose = () => {
-        console.log("[CrvyRprtr] Disconnected from Crvy Rprtr server");
+        log("[CrvyRprtr] Disconnected from Crvy Rprtr server");
         this.enableOfflineMode();
       };
-    } catch (e) {
-      console.error("[CrvyRprtr] Failed to connect:", e);
+    } catch (error) {
+      logError("[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;
+    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 visualNames = screenshotDeclarations.map(({ visualName }) => visualName);
-    const savedAttachments = await this.saveAttachments(test.id, result);
-    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,
-        error: result.errors.length > 0 ? result.errors[0]?.message : void 0,
-        duration: result.duration
-      }
-    });
-  }
-  async copySnapshotBaselines(test, status, screenshotDeclarations, savedAttachments) {
-    if (status !== "passed") return;
-    const namedDeclarations = screenshotDeclarations.filter(
-      (declaration) => declaration.snapshotBaseName !== void 0
-    );
-    if (namedDeclarations.length === 0) return;
-    const projectName = test.parent.project()?.name;
-    const snapshotDir = `${test.location.file}-snapshots`;
-    const testScreenshotDir = (0, import_path2.join)(this.screenshotDir, this.sanitizeId(test.id));
-    const limit = (0, import_p_limit.default)(MAX_CONCURRENT_FILE_OPS);
-    const copyPromises = namedDeclarations.map(
-      ({ visualName, snapshotBaseName }) => limit(async () => {
-        const destName = `${visualName}-expected.png`;
-        const destPath = (0, import_path2.join)(testScreenshotDir, destName);
-        const snapshotPath = projectName === "" ? (0, import_path2.join)(snapshotDir, `${snapshotBaseName}-${process.platform}.png`) : (0, import_path2.join)(snapshotDir, `${snapshotBaseName}-${projectName ?? "chromium"}-${process.platform}.png`);
-        try {
-          await (0, import_promises2.mkdir)((0, import_path2.dirname)(destPath), { 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(copyPromises);
-  }
-  async saveAttachments(testId, result) {
-    const savedAttachments = [];
-    const testScreenshotDir = (0, import_path2.join)(this.screenshotDir, this.sanitizeId(testId));
-    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(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;
-    }
+    const savedAttachments = await saveAttachments(this.screenshotDir, test.id, result);
     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
-        }))
-      };
-      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);
-    }
-  }
-  async writeStaticArtifact() {
-    try {
-      await writeReportArtifact({
-        events: this.runEvents,
-        screenshotDir: this.screenshotDir,
-        reportHtmlPath: this.reportHtmlPath
+      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
+        }
       });
-      console.log(`[CrvyRprtr] Wrote report artifact: ${this.reportHtmlPath}`);
-    } catch (e) {
-      console.error("[CrvyRprtr] Failed to write report artifact:", e);
+    } finally {
+      this.testMetadata.delete(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 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 = sanitizeId(test.id);
+    const testScreenshotDir = (0, import_path4.join)(this.screenshotDir, safeTestId);
+    const limit = (0, import_p_limit2.default)(5);
+    await Promise.all(
+      targets.map(
+        (target) => limit(() => copyResolvedBaseline(safeTestId, testScreenshotDir, target, savedAttachments))
+      )
+    );
+  }
   async onEnd(result) {
-    this.send({
-      type: "run-end",
-      data: {
-        status: result.status
-      }
-    });
-    await this.writeStaticArtifact();
-    if (this.hadOfflineMode) {
-      await this.writeOfflineReport();
-    }
-    await new Promise((resolve2) => {
+    this.send({ type: "run-end", data: { status: result.status } });
+    await writeStaticArtifact(this.runEvents, this.screenshotDir, this.reportHtmlPath);
+    if (this.hadOfflineMode) await writeOfflineReport(this.runEvents, this.offlineReportPath, this.workerIndex);
+    await new Promise((resolve3) => {
       if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
-        resolve2();
+        resolve3();
         return;
       }
       this.ws.onclose = () => {
-        resolve2();
+        resolve3();
       };
       setTimeout(() => {
         this.ws?.close();
-        resolve2();
+        resolve3();
       }, 1e3);
       this.ws.close();
     });
   }
-  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);
     }
   }
 };