@crvy/rprtr 0.0.3 → 0.0.5

package/dist/reporter.cjs

@@ -0,0 +1,773 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/reporter.ts
+var reporter_exports = {};
+__export(reporter_exports, {
+  CrvyRprtr: () => CrvyRprtr,
+  default: () => reporter_default
+});
+module.exports = __toCommonJS(reporter_exports);
+var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
+var import_p_limit = __toESM(require("p-limit"), 1);
+
+// src/report-artifact.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_url = require("url");
+
+// src/report-utils.ts
+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 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);
+  for (const attachment of attachments) {
+    if (attachment.contentType !== "image/png") continue;
+    const match = attachment.name.match(/^(.+?)-(actual|expected|diff)(?:\.png)?$/);
+    if (match === null) continue;
+    const baseName = match[1];
+    const role = match[2];
+    if (baseName === null || baseName === void 0 || role === null || role === void 0) continue;
+    images[baseName] ??= {};
+    const url = `${baseUrl}${attachment.path}`;
+    const img = images[baseName];
+    if (img !== null && img !== void 0) {
+      if (role === "actual") img.actual = url;
+      else if (role === "expected") img.expect = url;
+      else if (role === "diff") img.diff = url;
+    }
+  }
+  for (const key of Object.keys(images)) {
+    const img = images[key];
+    if (img?.actual !== void 0 && img?.expect !== void 0 && img?.diff === void 0) {
+      delete img.expect;
+    }
+  }
+  return mergeDeclaredImages(images, []);
+}
+function mapStatus(status) {
+  switch (status) {
+    case "passed":
+      return "success";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "pending";
+    default:
+      return "unknown";
+  }
+}
+
+// src/report-state.ts
+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") {
+    return images;
+  }
+  const previousImages = test.results?.[0]?.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;
+}
+function createMutableReportState(screenshotDir = "./screenshots") {
+  return {
+    reportData: {
+      isRunning: false,
+      tests: {},
+      browsers: ["chromium"],
+      isUpdateMode: false,
+      screenshotDir
+    },
+    currentRunIds: /* @__PURE__ */ new Set()
+  };
+}
+function applyTestBeginEvent(state, data) {
+  const { id, title, titlePath, browser, location } = data;
+  state.currentRunIds.add(id);
+  state.reportData.tests[id] ??= {
+    id,
+    titlePath: titlePath ?? [],
+    browser: browser ?? "",
+    title: title ?? "",
+    location,
+    status: "running"
+  };
+  return state.reportData.tests[id];
+}
+function applyTestEndEvent(state, data, options = {}) {
+  const test = state.reportData.tests[data.id];
+  if (test === void 0) {
+    return null;
+  }
+  test.status = mapStatus(data.status);
+  const resultStatus = data.status === "passed" ? "success" : data.status === "failed" ? "failed" : "pending";
+  const images = preservePreviousPassingImages(
+    test,
+    data.status,
+    mergeDeclaredImages(attachmentsToImages(data.attachments, options.screenshotsBaseUrl), data.visualNames)
+  );
+  const diffCount = countDiffImages(images);
+  const hasDiffs = diffCount > 0;
+  if (hasDiffs) {
+    test.approved = null;
+  }
+  test.results = [
+    {
+      status: resultStatus,
+      retries: 0,
+      images,
+      error: data.error,
+      duration: data.duration
+    }
+  ];
+  return {
+    test,
+    diffCount
+  };
+}
+function finalizeRunEvent(state) {
+  state.reportData.isRunning = false;
+  state.reportData.tests = Object.fromEntries(
+    Object.entries(state.reportData.tests).filter(([id]) => state.currentRunIds.has(id))
+  );
+  state.currentRunIds.clear();
+  const runTests = Object.values(state.reportData.tests).filter((test) => test !== void 0);
+  return {
+    passed: runTests.filter((test) => test.status === "success").length,
+    failed: runTests.filter((test) => test.status === "failed").length,
+    pending: runTests.filter((test) => test.status === "pending").length
+  };
+}
+
+// src/schemas.ts
+var import_zod = require("zod");
+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().optional(),
+  expect: import_zod.z.string().optional(),
+  diff: import_zod.z.string().optional(),
+  error: import_zod.z.string().optional(),
+  source: VisualSourceSchema.optional()
+});
+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: TestResultStatusSchema,
+  retries: import_zod.z.number(),
+  images: import_zod.z.record(import_zod.z.string(), ImagesSchema).optional(),
+  error: import_zod.z.string().optional(),
+  duration: import_zod.z.number().optional()
+});
+var TestDataSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  titlePath: import_zod.z.array(import_zod.z.string()),
+  browser: import_zod.z.string(),
+  title: import_zod.z.string(),
+  skip: import_zod.z.union([import_zod.z.boolean(), import_zod.z.string()]).optional(),
+  retries: import_zod.z.number().optional(),
+  status: TestStatusSchema.optional(),
+  results: import_zod.z.array(TestResultSchema).optional(),
+  approved: import_zod.z.record(import_zod.z.string(), import_zod.z.number()).nullable().optional(),
+  attachments: import_zod.z.array(AttachmentSchema).optional(),
+  location: LocationSchema.optional()
+});
+var CrvyRprtrTestSchema = TestDataSchema.extend({
+  checked: import_zod.z.boolean()
+});
+var CrvyRprtrSuiteSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    path: import_zod.z.array(import_zod.z.string()),
+    skip: import_zod.z.boolean(),
+    status: TestStatusSchema.optional(),
+    opened: import_zod.z.boolean(),
+    checked: import_zod.z.boolean(),
+    indeterminate: import_zod.z.boolean(),
+    children: import_zod.z.record(import_zod.z.string(), import_zod.z.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
+  })
+);
+var WebSocketMessageSchema = import_zod.z.object({
+  type: import_zod.z.enum(["test-begin", "test-end", "run-end", "approve", "sync"]),
+  data: import_zod.z.unknown()
+});
+var TestBeginDataSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  title: import_zod.z.string(),
+  titlePath: import_zod.z.array(import_zod.z.string()),
+  browser: import_zod.z.string(),
+  location: LocationSchema
+});
+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([]),
+  error: import_zod.z.string().optional(),
+  duration: import_zod.z.number().optional()
+});
+var ReportDataSchema = import_zod.z.object({
+  isRunning: import_zod.z.boolean(),
+  tests: import_zod.z.record(import_zod.z.string(), TestDataSchema),
+  browsers: import_zod.z.array(import_zod.z.string()),
+  isUpdateMode: import_zod.z.boolean(),
+  screenshotDir: import_zod.z.string()
+});
+var LoadedReportDataSchema = import_zod.z.object({
+  tests: import_zod.z.record(import_zod.z.string(), TestDataSchema).optional(),
+  isUpdateMode: import_zod.z.boolean().optional()
+});
+var OfflineEventSchema = import_zod.z.object({
+  type: import_zod.z.enum(["test-begin", "test-end", "run-end"]),
+  data: import_zod.z.unknown(),
+  timestamp: import_zod.z.number(),
+  workerIndex: import_zod.z.number()
+});
+var OfflineReportSchema = import_zod.z.object({
+  version: import_zod.z.number(),
+  generatedAt: import_zod.z.string(),
+  workers: import_zod.z.number(),
+  events: import_zod.z.array(OfflineEventSchema)
+});
+var ApproveRequestBodySchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  retry: import_zod.z.number(),
+  image: import_zod.z.string()
+});
+var ReportApiResponseSchema = import_zod.z.object({
+  tests: import_zod.z.record(import_zod.z.string(), TestDataSchema),
+  isUpdateMode: import_zod.z.boolean().optional()
+});
+var ClientBootstrapDataSchema = import_zod.z.object({
+  report: ReportApiResponseSchema.extend({
+    isUpdateMode: import_zod.z.boolean()
+  }),
+  liveUpdates: import_zod.z.boolean(),
+  approvalEnabled: import_zod.z.boolean(),
+  approvalMessage: import_zod.z.string().optional()
+});
+var ImagesViewModeSchema = import_zod.z.enum(["side-by-side", "swap", "slide", "blend"]);
+function safeParse(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return result.data;
+  }
+  return null;
+}
+
+// src/report-artifact.ts
+var import_meta = { url: require("url").pathToFileURL(__filename).href };
+var DEFAULT_REPORT_HTML_PATH = "./crvy-rprtr.html";
+var STATIC_ARTIFACT_APPROVAL_MESSAGE = "This artifact is read-only. Open it with the Crvy Rprtr server to approve screenshots.";
+function toBrowserPath(pathValue) {
+  const normalized = pathValue.split(import_path.sep).join("/");
+  if (normalized === "") return ".";
+  if (normalized.startsWith(".")) return normalized;
+  return `./${normalized}`;
+}
+function toBrowserDirPath(pathValue) {
+  const path = toBrowserPath(pathValue);
+  return path === "." ? "./" : `${path}/`;
+}
+function serializeBootstrapData(data) {
+  return JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+function escapeInlineStyle(style) {
+  return style.replace(/<\/style>/gi, "<\\/style>");
+}
+function escapeInlineScript(script) {
+  return script.replace(/<\/script>/gi, "<\\/script>");
+}
+function renderArtifactHtml(template, bootstrapData, stylesheet, script) {
+  const stylesheetPlaceholder = '<link rel="stylesheet" href="/dist/index.css" />';
+  const scriptPlaceholder = '<script type="module" src="/dist/index.js"></script>';
+  if (!template.includes(stylesheetPlaceholder) || !template.includes(scriptPlaceholder)) {
+    throw new Error("Failed to find static asset placeholders in the HTML template");
+  }
+  const withStylesheet = template.replace(
+    stylesheetPlaceholder,
+    () => `<style>${escapeInlineStyle(stylesheet)}</style>`
+  );
+  const bootstrapScript = `<script id="crvy-rprtr-bootstrap" type="application/json">${serializeBootstrapData(bootstrapData)}</script>`;
+  return withStylesheet.replace(
+    scriptPlaceholder,
+    () => `${bootstrapScript}
+    <script type="module">${escapeInlineScript(script)}</script>`
+  );
+}
+async function getPackagedAssetPath(fileName) {
+  const currentDir = (0, import_path.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+  const candidates = [currentDir, (0, import_path.resolve)(currentDir, "../dist")];
+  const resolvedCandidates = await Promise.all(
+    candidates.map(async (candidate) => {
+      const assetPath = (0, import_path.resolve)(candidate, fileName);
+      try {
+        await (0, import_promises.access)(assetPath);
+        return assetPath;
+      } catch {
+        return null;
+      }
+    })
+  );
+  const resolvedAssetPath = resolvedCandidates.find((assetPath) => assetPath !== null);
+  if (resolvedAssetPath !== void 0) {
+    return resolvedAssetPath;
+  }
+  throw new Error(
+    `Could not find packaged asset "${fileName}". Run "bun run build" before generating report artifacts.`
+  );
+}
+function buildStaticBootstrapData(events, screenshotDir, htmlPath) {
+  const screenshotBaseUrl = toBrowserDirPath((0, import_path.relative)((0, import_path.dirname)(htmlPath), (0, import_path.resolve)(screenshotDir)));
+  const state = createMutableReportState(screenshotDir);
+  for (const event of events) {
+    switch (event.type) {
+      case "test-begin": {
+        const parsed = safeParse(TestBeginDataSchema, event.data);
+        if (parsed !== null) {
+          applyTestBeginEvent(state, parsed);
+        }
+        break;
+      }
+      case "test-end": {
+        const parsed = safeParse(TestEndDataSchema, event.data);
+        if (parsed !== null) {
+          applyTestEndEvent(state, parsed, { screenshotsBaseUrl: screenshotBaseUrl });
+        }
+        break;
+      }
+      case "run-end":
+        finalizeRunEvent(state);
+        break;
+    }
+  }
+  const bootstrapData = {
+    report: {
+      tests: state.reportData.tests,
+      isUpdateMode: state.reportData.isUpdateMode
+    },
+    liveUpdates: false,
+    approvalEnabled: false,
+    approvalMessage: STATIC_ARTIFACT_APPROVAL_MESSAGE
+  };
+  const parsedBootstrapData = safeParse(ClientBootstrapDataSchema, bootstrapData);
+  if (parsedBootstrapData === null) {
+    throw new Error("Failed to build static report bootstrap data");
+  }
+  return parsedBootstrapData;
+}
+async function writeReportArtifact(options) {
+  const reportHtmlPath = (0, import_path.resolve)(options.reportHtmlPath ?? DEFAULT_REPORT_HTML_PATH);
+  const [indexHtmlPath, indexJsPath, indexCssPath] = await Promise.all([
+    getPackagedAssetPath("index.html"),
+    getPackagedAssetPath("index.js"),
+    getPackagedAssetPath("index.css")
+  ]);
+  await (0, import_promises.mkdir)((0, import_path.dirname)(reportHtmlPath), { recursive: true });
+  const [template, script, stylesheet] = await Promise.all([
+    (0, import_promises.readFile)(indexHtmlPath, "utf8"),
+    (0, import_promises.readFile)(indexJsPath, "utf8"),
+    (0, import_promises.readFile)(indexCssPath, "utf8")
+  ]);
+  const bootstrapData = buildStaticBootstrapData(options.events, options.screenshotDir, reportHtmlPath);
+  const html = renderArtifactHtml(template, bootstrapData, stylesheet, script);
+  await (0, import_promises.writeFile)(reportHtmlPath, html);
+}
+
+// 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) {
+  const unquotedName = titleMatch.trim().replace(/^['"`]|['"`]$/g, "");
+  if (unquotedName === "") {
+    return null;
+  }
+  const normalizedPath = unquotedName.replace(/\\/g, "/");
+  const normalizedName = normalizedPath.replace(/\.png$/, "");
+  if (normalizedName === "") {
+    return null;
+  }
+  return {
+    visualName: normalizedName,
+    snapshotBaseName: normalizedName
+  };
+}
+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) {
+    visitStep(nestedStep, state);
+  }
+  const namedMatch = step.title.match(NAMED_SCREENSHOT_STEP_TITLE);
+  if (namedMatch?.[1] !== void 0) {
+    const declaration = normalizeNamedScreenshot(namedMatch[1]);
+    if (declaration !== null) {
+      appendDeclaration(state, 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}`
+    });
+    state.nextUnnamedIndex += 1;
+    return true;
+  }
+  return hasNestedScreenshotDeclaration;
+}
+function extractScreenshotDeclarations(steps) {
+  const state = {
+    declarations: [],
+    seenVisualNames: /* @__PURE__ */ new Set(),
+    nextUnnamedIndex: 1
+  };
+  for (const step of steps) {
+    visitStep(step, state);
+  }
+  return state.declarations;
+}
+
+// src/reporter.ts
+var MAX_CONCURRENT_FILE_OPS = 5;
+var CrvyRprtr = class {
+  ws = null;
+  serverUrl;
+  screenshotDir;
+  queue = [];
+  workerIndex;
+  offlineReportPath;
+  reportHtmlPath;
+  isOfflineMode = false;
+  hadOfflineMode = false;
+  runEvents = [];
+  constructor(options = {}) {
+    this.serverUrl = options.serverUrl ?? "ws://localhost:3000";
+    this.screenshotDir = options.screenshotDir ?? "./screenshots";
+    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";
+  }
+  async onBegin(config, suite) {
+    console.log(`[CrvyRprtr] Starting run with ${suite.allTests().length} tests`);
+    await (0, import_promises2.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");
+      this.enableOfflineMode();
+      return;
+    }
+    try {
+      this.ws = new WebSocketConstructor(this.serverUrl);
+      this.ws.onopen = () => {
+        console.log("[CrvyRprtr] Connected to Crvy Rprtr server");
+        this.isOfflineMode = false;
+        for (const msg of this.queue) this.ws.send(msg);
+        this.queue = [];
+      };
+      this.ws.onerror = (error) => {
+        console.error("[CrvyRprtr] WebSocket error:", error);
+        this.enableOfflineMode();
+      };
+      this.ws.onclose = () => {
+        console.log("[CrvyRprtr] Disconnected from Crvy Rprtr server");
+        this.enableOfflineMode();
+      };
+    } catch (e) {
+      console.error("[CrvyRprtr] Failed to connect:", e);
+      this.enableOfflineMode();
+    }
+  }
+  enableOfflineMode() {
+    if (!this.isOfflineMode) {
+      this.isOfflineMode = true;
+      this.hadOfflineMode = true;
+      console.log("[CrvyRprtr] Offline mode enabled - events will be queued to file");
+    }
+  }
+  onTestBegin(test) {
+    const titlePath = [];
+    let suite = test.parent;
+    while (suite && suite.type === "describe") {
+      titlePath.unshift(suite.title);
+      suite = suite.parent;
+    }
+    this.send({
+      type: "test-begin",
+      data: {
+        id: test.id,
+        title: test.title,
+        titlePath,
+        browser: test.parent.project()?.name ?? "chromium",
+        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;
+    }
+    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
+      });
+      console.log(`[CrvyRprtr] Wrote report artifact: ${this.reportHtmlPath}`);
+    } catch (e) {
+      console.error("[CrvyRprtr] Failed to write report artifact:", e);
+    }
+  }
+  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) => {
+      if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+        resolve2();
+        return;
+      }
+      this.ws.onclose = () => {
+        resolve2();
+      };
+      setTimeout(() => {
+        this.ws?.close();
+        resolve2();
+      }, 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);
+    if (!this.isOfflineMode) {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(payload);
+      } else {
+        this.queue.push(payload);
+      }
+    }
+  }
+};
+var reporter_default = CrvyRprtr;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CrvyRprtr
+});