@crvy/rprtr 0.0.3

package/dist/is-direct-execution.d.ts

@@ -0,0 +1,2 @@
+export declare function isDirectExecution(moduleUrl: string): boolean;
+//# sourceMappingURL=is-direct-execution.d.ts.map

package/dist/is-direct-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-direct-execution.d.ts","sourceRoot":"","sources":["../src/is-direct-execution.ts"],"names":[],"mappings":"AAYA,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAU5D"}

package/dist/offline-reports.d.ts

@@ -0,0 +1,9 @@
+import { type OfflineReport as ParsedOfflineReport } from './schemas.ts';
+import type { TestData } from './types.ts';
+export declare function findOfflineReportPaths(searchDir: string): Promise<string[]>;
+export declare function parseOfflineReport(value: unknown): ParsedOfflineReport | null;
+export declare function mergeOfflineReportsIntoTests(existingTests: Record<string, TestData>, offlineReports: ParsedOfflineReport[], options?: {
+    screenshotDir?: string;
+    screenshotsBaseUrl?: string;
+}): Record<string, TestData>;
+//# sourceMappingURL=offline-reports.d.ts.map

package/dist/offline-reports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-reports.d.ts","sourceRoot":"","sources":["../src/offline-reports.ts"],"names":[],"mappings":"AAIA,OAAO,EAKL,KAAK,aAAa,IAAI,mBAAmB,EAC1C,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAI1C,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAcjF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CAO7E;AAED,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACvC,cAAc,EAAE,mBAAmB,EAAE,EACrC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAO,GACpE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAoC1B"}

package/dist/report-artifact.d.ts

@@ -0,0 +1,12 @@
+import type { OfflineEvent } from './types.ts';
+export declare const STATIC_ARTIFACT_APPROVAL_MESSAGE = "This artifact is read-only. Open it with the Crvy Rprtr server to approve screenshots.";
+export interface WriteReportArtifactOptions {
+    events: Array<{
+        type: OfflineEvent['type'];
+        data: unknown;
+    }>;
+    screenshotDir: string;
+    reportHtmlPath?: string;
+}
+export declare function writeReportArtifact(options: WriteReportArtifactOptions): Promise<void>;
+//# sourceMappingURL=report-artifact.d.ts.map

package/dist/report-artifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-artifact.d.ts","sourceRoot":"","sources":["../src/report-artifact.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAuB,YAAY,EAAE,MAAM,YAAY,CAAA;AAInE,eAAO,MAAM,gCAAgC,2FAC6C,CAAA;AA+H1F,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;IAC5D,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB5F"}

package/dist/report-state.d.ts

@@ -0,0 +1,28 @@
+import type { TestBeginData, TestEndData } from './schemas.ts';
+import type { TestData } from './types.ts';
+export interface MutableReportData {
+    isRunning: boolean;
+    tests: Record<string, TestData>;
+    browsers: string[];
+    isUpdateMode: boolean;
+    screenshotDir: string;
+}
+export interface MutableReportState {
+    reportData: MutableReportData;
+    currentRunIds: Set<string>;
+}
+export interface ApplyTestEndResult {
+    test: TestData;
+    diffCount: number;
+}
+export declare function createMutableReportState(screenshotDir?: string): MutableReportState;
+export declare function applyTestBeginEvent(state: MutableReportState, data: TestBeginData): TestData;
+export declare function applyTestEndEvent(state: MutableReportState, data: TestEndData, options?: {
+    screenshotsBaseUrl?: string;
+}): ApplyTestEndResult | null;
+export declare function finalizeRunEvent(state: MutableReportState): {
+    passed: number;
+    failed: number;
+    pending: number;
+};
+//# sourceMappingURL=report-state.d.ts.map

package/dist/report-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-state.d.ts","sourceRoot":"","sources":["../src/report-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC9D,OAAO,KAAK,EAAU,QAAQ,EAAE,MAAM,YAAY,CAAA;AAElD,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,YAAY,EAAE,OAAO,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,iBAAiB,CAAA;IAC7B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB;AA0BD,wBAAgB,wBAAwB,CAAC,aAAa,SAAkB,GAAG,kBAAkB,CAW5F;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,aAAa,GAAG,QAAQ,CAa5F;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,kBAAkB,EACzB,IAAI,EAAE,WAAW,EACjB,OAAO,GAAE;IAAE,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5C,kBAAkB,GAAG,IAAI,CAkC3B;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAa/G"}

package/dist/report-utils.d.ts

@@ -0,0 +1,5 @@
+import type { Attachment } from './schemas.ts';
+import type { Images, TestData } from './types.ts';
+export declare function attachmentsToImages(attachments: Attachment[], screenshotsBaseUrl?: string): Partial<Record<string, Images>>;
+export declare function mapStatus(status: 'passed' | 'failed' | 'skipped'): TestData['status'];
+//# sourceMappingURL=report-utils.d.ts.map

package/dist/report-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-utils.d.ts","sourceRoot":"","sources":["../src/report-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAMlD,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,UAAU,EAAE,EACzB,kBAAkB,SAAkB,GACnC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqCjC;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAWrF"}

package/dist/reporter-utils.d.ts

@@ -0,0 +1,3 @@
+import type { TestStep } from '@playwright/test/reporter';
+export declare function extractScreenshotNames(steps: TestStep[]): string[];
+//# sourceMappingURL=reporter-utils.d.ts.map

package/dist/reporter-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter-utils.d.ts","sourceRoot":"","sources":["../src/reporter-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AAEzD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,EAAE,CAQlE"}

package/dist/reporter.d.ts

@@ -0,0 +1,34 @@
+import type { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+export interface CrvyRprtrOptions {
+    serverUrl?: string;
+    screenshotDir?: string;
+    offlineReportPath?: string;
+    reportHtmlPath?: string;
+}
+export declare class CrvyRprtr implements Reporter {
+    private ws;
+    private serverUrl;
+    private screenshotDir;
+    private queue;
+    private workerIndex;
+    private offlineReportPath;
+    private reportHtmlPath;
+    private isOfflineMode;
+    private hadOfflineMode;
+    private runEvents;
+    constructor(options?: CrvyRprtrOptions);
+    onBegin(config: FullConfig, suite: Suite): Promise<void>;
+    private connect;
+    private enableOfflineMode;
+    onTestBegin(test: TestCase): void;
+    onTestEnd(test: TestCase, result: TestResult): Promise<void>;
+    private copySnapshotBaselines;
+    private saveAttachments;
+    private sanitizeId;
+    private writeOfflineReport;
+    private writeStaticArtifact;
+    onEnd(result: FullResult): Promise<void>;
+    private send;
+}
+export default CrvyRprtr;
+//# sourceMappingURL=reporter.d.ts.map

package/dist/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAQ9G,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAQD,qBAAa,SAAU,YAAW,QAAQ;IACxC,OAAO,CAAC,EAAE,CAAyB;IACnC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,iBAAiB,CAAQ;IACjC,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,SAAS,CAA4E;gBAEjF,OAAO,GAAE,gBAAqB;IAQpC,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAM9D,OAAO,CAAC,OAAO;IA8Bf,OAAO,CAAC,iBAAiB;IAQzB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAsB3B,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;YAiBpD,qBAAqB;YAsCrB,eAAe;IAyC7B,OAAO,CAAC,UAAU;YAIJ,kBAAkB;YAyBlB,mBAAmB;IAa3B,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B9C,OAAO,CAAC,IAAI;CAkBb;AAED,eAAe,SAAS,CAAA"}

package/dist/reporter.js

@@ -0,0 +1,393 @@
+import {
+  ClientBootstrapDataSchema,
+  TestBeginDataSchema,
+  TestEndDataSchema,
+  applyTestBeginEvent,
+  applyTestEndEvent,
+  createMutableReportState,
+  finalizeRunEvent,
+  safeParse
+} from "./chunk-IEYNAB6M.js";
+
+// src/reporter.ts
+import { mkdir as mkdir2, copyFile, writeFile as writeFile2 } from "fs/promises";
+import { join } from "path";
+import pLimit from "p-limit";
+
+// src/report-artifact.ts
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, relative, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+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(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 = dirname(fileURLToPath(import.meta.url));
+  const candidates = [currentDir, resolve(currentDir, "../dist")];
+  const resolvedCandidates = await Promise.all(
+    candidates.map(async (candidate) => {
+      const assetPath = resolve(candidate, fileName);
+      try {
+        await 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(relative(dirname(htmlPath), 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 = resolve(options.reportHtmlPath ?? DEFAULT_REPORT_HTML_PATH);
+  const [indexHtmlPath, indexJsPath, indexCssPath] = await Promise.all([
+    getPackagedAssetPath("index.html"),
+    getPackagedAssetPath("index.js"),
+    getPackagedAssetPath("index.css")
+  ]);
+  await mkdir(dirname(reportHtmlPath), { recursive: true });
+  const [template, script, stylesheet] = await Promise.all([
+    readFile(indexHtmlPath, "utf8"),
+    readFile(indexJsPath, "utf8"),
+    readFile(indexCssPath, "utf8")
+  ]);
+  const bootstrapData = buildStaticBootstrapData(options.events, options.screenshotDir, reportHtmlPath);
+  const html = renderArtifactHtml(template, bootstrapData, stylesheet, script);
+  await writeFile(reportHtmlPath, html);
+}
+
+// src/reporter-utils.ts
+function extractScreenshotNames(steps) {
+  const names = [];
+  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));
+  }
+  return names;
+}
+
+// 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 mkdir2(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 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
+      }
+    });
+  }
+  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 = join(this.screenshotDir, this.sanitizeId(test.id));
+    const limit = pLimit(MAX_CONCURRENT_FILE_OPS);
+    const copyPromises = snapshotNames.map(
+      (name) => limit(async () => {
+        const baseName = name.replace(/\.png$/, "");
+        const snapshotPath = join(snapshotDir, `${baseName}-${projectName}-${process.platform}.png`);
+        const destName = `${baseName}-expected`;
+        const destPath = join(testScreenshotDir, destName);
+        try {
+          await mkdir2(testScreenshotDir, { recursive: true });
+          await 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 = join(this.screenshotDir, this.sanitizeId(testId));
+    const limit = pLimit(MAX_CONCURRENT_FILE_OPS);
+    const attachmentPromises = result.attachments.filter(
+      (attachment) => attachment.contentType === "image/png" && attachment.path !== void 0
+    ).map(
+      (attachment) => limit(async () => {
+        try {
+          await mkdir2(testScreenshotDir, { recursive: true });
+          const fileName = attachment.name;
+          const destPath = join(testScreenshotDir, fileName);
+          await 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 writeFile2(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;
+export {
+  CrvyRprtr,
+  reporter_default as default
+};