@checkly/playwright-reporter 0.1.5 → 0.1.7

package/dist/index.js

@@ -1 +1,1036 @@
-function a6_0x9da0(_0x181701,_0x24254e){_0x181701=_0x181701-0x1c0;var _0x1016ec=a6_0x1016();var _0x9da0d7=_0x1016ec[_0x181701];return _0x9da0d7;}(function(_0x5bc3a0,_0x6585ad){var _0x427d94=a6_0x9da0,_0x196632=_0x5bc3a0();while(!![]){try{var _0x1863df=parseInt(_0x427d94(0x1c7))/0x1*(parseInt(_0x427d94(0x1c9))/0x2)+-parseInt(_0x427d94(0x1c0))/0x3*(parseInt(_0x427d94(0x1c4))/0x4)+parseInt(_0x427d94(0x1c1))/0x5*(-parseInt(_0x427d94(0x1c5))/0x6)+-parseInt(_0x427d94(0x1c8))/0x7+-parseInt(_0x427d94(0x1c3))/0x8+parseInt(_0x427d94(0x1c6))/0x9+parseInt(_0x427d94(0x1c2))/0xa;if(_0x1863df===_0x6585ad)break;else _0x196632['push'](_0x196632['shift']());}catch(_0x6a0cb4){_0x196632['push'](_0x196632['shift']());}}}(a6_0x1016,0x2c5fc));function a6_0x1016(){var _0x3baf3f=['27114qglyOx','814041updBIT','19542XDbSZA','1359253GFKSKw','16UXhciG','293790bpXJMH','270htEmFX','5993960opQwGf','242880kIhRkx','8jGckKj'];a6_0x1016=function(){return _0x3baf3f;};return a6_0x1016();}export{ChecklyReporter}from'./reporter.js';export{AssetCollector}from'./asset-collector.js';export{Zipper}from'./zipper.js';export{ChecklyReporter as default}from'./reporter.js';
+// ../utils/src/asset-collector.ts
+import * as fs from "fs";
+import * as path from "path";
+var AssetCollector = class {
+  constructor(testResultsDir) {
+    this.testResultsDir = testResultsDir;
+  }
+  /**
+   * Collects assets from test results directory
+   * Uses a two-phase approach to support both normal test runs and blob merge scenarios:
+   * 1. First, extract attachment paths from the JSON report (works for merge scenarios)
+   * 2. Fall back to directory scanning for any additional assets not in the report
+   *
+   * @param report Optional Playwright JSONReport with attachment paths
+   * @returns Array of Asset objects with source and archive paths
+   */
+  async collectAssets(report) {
+    const assets = [];
+    const addedPaths = /* @__PURE__ */ new Set();
+    if (report) {
+      this.collectAssetsFromReport(report, assets, addedPaths);
+    }
+    if (fs.existsSync(this.testResultsDir)) {
+      await this.collectAssetsRecursive(this.testResultsDir, assets, addedPaths);
+    }
+    return assets;
+  }
+  /**
+   * Extracts assets from JSON report attachment paths
+   * Essential for blob merge scenarios where attachments are extracted to temporary locations
+   */
+  collectAssetsFromReport(report, assets, addedPaths) {
+    const processResults = (results) => {
+      for (const result of results) {
+        if (result.attachments && Array.isArray(result.attachments)) {
+          for (const attachment of result.attachments) {
+            if (attachment.path && typeof attachment.path === "string") {
+              const sourcePath = attachment.path;
+              if (addedPaths.has(sourcePath)) continue;
+              if (!fs.existsSync(sourcePath)) {
+                continue;
+              }
+              const archivePath = this.determineArchivePath(sourcePath);
+              const asset = this.createAsset(sourcePath, archivePath);
+              assets.push(asset);
+              addedPaths.add(sourcePath);
+            }
+          }
+        }
+      }
+    };
+    const processSuite = (suite) => {
+      if (suite.specs) {
+        for (const spec of suite.specs) {
+          if (spec.tests) {
+            for (const test of spec.tests) {
+              if (test.results) {
+                processResults(test.results);
+              }
+            }
+          }
+        }
+      }
+      if (suite.suites) {
+        for (const nestedSuite of suite.suites) {
+          processSuite(nestedSuite);
+        }
+      }
+    };
+    if (report.suites) {
+      for (const suite of report.suites) {
+        processSuite(suite);
+      }
+    }
+  }
+  /**
+   * Determines the archive path for an asset based on its source path
+   * Handles both test-results paths and blob merge extraction paths
+   */
+  determineArchivePath(sourcePath) {
+    const normalizedPath = sourcePath.replace(/\\/g, "/");
+    const testResultsIndex = normalizedPath.indexOf("test-results/");
+    if (testResultsIndex !== -1) {
+      return normalizedPath.substring(testResultsIndex);
+    }
+    const parts = normalizedPath.split("/");
+    if (parts.length >= 2) {
+      return `test-results/${parts.slice(-2).join("/")}`;
+    }
+    return `test-results/${path.basename(sourcePath)}`;
+  }
+  /**
+   * Recursively traverses directories to collect assets
+   */
+  async collectAssetsRecursive(currentDir, assets, addedPaths) {
+    let entries;
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const baseDirName = path.basename(path.resolve(this.testResultsDir));
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      const relativeFromBase = path.relative(this.testResultsDir, fullPath);
+      const archivePath = path.join(baseDirName, relativeFromBase);
+      if (this.shouldSkipFile(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await this.collectAssetsRecursive(fullPath, assets, addedPaths);
+      } else if (entry.isFile()) {
+        if (!addedPaths.has(fullPath)) {
+          const asset = this.createAsset(fullPath, archivePath);
+          assets.push(asset);
+          addedPaths.add(fullPath);
+        }
+      }
+    }
+  }
+  /**
+   * Determines if a file should be skipped
+   */
+  shouldSkipFile(filename) {
+    const skipPatterns = [
+      /^\./,
+      // Hidden files (.DS_Store, .gitkeep, etc.)
+      /\.tmp$/i,
+      // Temporary files
+      /~$/,
+      // Backup files
+      /\.swp$/i,
+      // Vim swap files
+      /\.lock$/i,
+      // Lock files
+      /^playwright-test-report\.json$/i
+      // Skip the JSON report itself
+    ];
+    return skipPatterns.some((pattern) => pattern.test(filename));
+  }
+  /**
+   * Creates an Asset object from file path
+   */
+  createAsset(sourcePath, archivePath) {
+    const ext = path.extname(sourcePath).toLowerCase();
+    const { type, contentType } = this.determineAssetType(ext);
+    const normalizedArchivePath = archivePath.split(path.sep).join("/");
+    return {
+      sourcePath,
+      archivePath: normalizedArchivePath,
+      type,
+      contentType
+    };
+  }
+  /**
+   * Determines asset type and content type from file extension
+   */
+  determineAssetType(ext) {
+    if ([".png", ".jpg", ".jpeg", ".gif", ".bmp", ".svg"].includes(ext)) {
+      return {
+        type: "screenshot",
+        contentType: this.getImageContentType(ext)
+      };
+    }
+    if ([".webm", ".mp4", ".avi", ".mov"].includes(ext)) {
+      return {
+        type: "video",
+        contentType: this.getVideoContentType(ext)
+      };
+    }
+    if (ext === ".zip") {
+      return {
+        type: "trace",
+        contentType: "application/zip"
+      };
+    }
+    if (ext === ".html" || ext === ".htm") {
+      return {
+        type: "attachment",
+        contentType: "text/html"
+      };
+    }
+    if (ext === ".json") {
+      return {
+        type: "attachment",
+        contentType: "application/json"
+      };
+    }
+    if (ext === ".txt" || ext === ".log") {
+      return {
+        type: "attachment",
+        contentType: "text/plain"
+      };
+    }
+    return {
+      type: "other",
+      contentType: "application/octet-stream"
+    };
+  }
+  /**
+   * Gets content type for image files
+   */
+  getImageContentType(ext) {
+    const contentTypes = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".bmp": "image/bmp",
+      ".svg": "image/svg+xml"
+    };
+    return contentTypes[ext] || "image/png";
+  }
+  /**
+   * Gets content type for video files
+   */
+  getVideoContentType(ext) {
+    const contentTypes = {
+      ".webm": "video/webm",
+      ".mp4": "video/mp4",
+      ".avi": "video/x-msvideo",
+      ".mov": "video/quicktime"
+    };
+    return contentTypes[ext] || "video/webm";
+  }
+};
+
+// ../utils/src/zipper.ts
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+import { ZipArchive } from "archiver";
+var Zipper = class {
+  outputPath;
+  constructor(options) {
+    this.outputPath = options.outputPath;
+  }
+  /**
+   * Creates a ZIP archive containing the JSON report and assets
+   * @param reportPath - Path to the JSON report file
+   * @param assets - Array of assets to include in the ZIP
+   * @returns ZIP creation result with metadata
+   */
+  async createZip(reportPath, assets) {
+    const entries = [];
+    return new Promise((resolve2, reject) => {
+      try {
+        const output = fs2.createWriteStream(this.outputPath);
+        const archive = new ZipArchive({
+          zlib: { level: 0 }
+        });
+        archive.on("entry", (entryData) => {
+          const entryName = entryData.name.replace(/\\/g, "/");
+          const start = entryData._offsets?.contents ?? 0;
+          const end = entryData._offsets?.contents + (entryData.csize ?? 0) - 1;
+          entries.push({
+            name: entryName,
+            start,
+            end
+          });
+        });
+        output.on("close", () => {
+          const zipSize = archive.pointer();
+          resolve2({
+            zipPath: this.outputPath,
+            size: zipSize,
+            entryCount: entries.length,
+            entries
+          });
+        });
+        archive.on("error", (err) => {
+          reject(err);
+        });
+        output.on("error", (err) => {
+          reject(err);
+        });
+        archive.pipe(output);
+        if (!fs2.existsSync(reportPath)) {
+          reject(new Error(`Report file not found: ${reportPath}`));
+          return;
+        }
+        const transformedReportPath = this.transformJsonReport(reportPath);
+        archive.file(transformedReportPath, { name: "output/playwright-test-report.json" });
+        for (const asset of assets) {
+          if (!fs2.existsSync(asset.sourcePath)) {
+            console.warn(`[Checkly Reporter] Skipping missing asset: ${asset.sourcePath}`);
+            continue;
+          }
+          archive.file(asset.sourcePath, { name: asset.archivePath });
+        }
+        archive.finalize();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Transforms the JSON report to use relative paths for attachments
+   * This ensures the UI can map attachment paths to ZIP entries
+   * @param reportPath - Path to the original JSON report
+   * @returns Path to the transformed JSON report (in temp directory)
+   */
+  transformJsonReport(reportPath) {
+    const reportContent = fs2.readFileSync(reportPath, "utf-8");
+    const report = JSON.parse(reportContent);
+    this.transformAttachmentPaths(report);
+    const tempReportPath = path2.join(os.tmpdir(), `playwright-test-report-${Date.now()}.json`);
+    fs2.writeFileSync(tempReportPath, JSON.stringify(report, null, 2));
+    return tempReportPath;
+  }
+  /**
+   * Recursively transforms attachment paths in the report structure
+   * Converts absolute paths to relative paths matching ZIP structure
+   * @param obj - Object to transform (mutated in place)
+   */
+  transformAttachmentPaths(obj) {
+    if (typeof obj !== "object" || obj === null) {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach((item) => this.transformAttachmentPaths(item));
+      return;
+    }
+    if (obj.attachments && Array.isArray(obj.attachments)) {
+      obj.attachments.forEach((attachment) => {
+        if (attachment.path && typeof attachment.path === "string") {
+          attachment.path = this.normalizeAttachmentPath(attachment.path);
+        }
+      });
+    }
+    Object.values(obj).forEach((value) => this.transformAttachmentPaths(value));
+  }
+  /**
+   * Normalizes attachment paths by extracting the relevant snapshot directory portion.
+   * Supports Playwright's default and common custom snapshot directory patterns.
+   *
+   * Priority order (first match wins):
+   * 1. test-results/ (highest priority, existing behavior)
+   * 2. *-snapshots/ (Playwright default pattern)
+   * 3. __screenshots__/ (common custom pattern)
+   * 4. __snapshots__/ (common custom pattern)
+   * 5. screenshots/ (simple custom pattern)
+   * 6. snapshots/ (simple custom pattern)
+   *
+   * @param attachmentPath - Absolute or relative path to attachment
+   * @returns Normalized path starting from the matched directory, or original path if no match
+   */
+  normalizeAttachmentPath(attachmentPath) {
+    const normalizedPath = attachmentPath.replace(/\\/g, "/");
+    const testResultsIndex = normalizedPath.indexOf("test-results/");
+    if (testResultsIndex !== -1) {
+      return normalizedPath.substring(testResultsIndex);
+    }
+    const snapshotsIndex = normalizedPath.indexOf("-snapshots/");
+    if (snapshotsIndex !== -1) {
+      const pathBeforeSnapshots = normalizedPath.substring(0, snapshotsIndex);
+      const lastSlashIndex = pathBeforeSnapshots.lastIndexOf("/");
+      const startIndex = lastSlashIndex !== -1 ? lastSlashIndex + 1 : 0;
+      return normalizedPath.substring(startIndex);
+    }
+    const patterns = ["__screenshots__/", "__snapshots__/", "screenshots/", "snapshots/"];
+    for (const pattern of patterns) {
+      const matchIndex = normalizedPath.indexOf(pattern);
+      if (matchIndex !== -1) {
+        return normalizedPath.substring(matchIndex);
+      }
+    }
+    console.warn(`[Checkly Reporter] Could not normalize attachment path: ${attachmentPath}`);
+    return attachmentPath;
+  }
+};
+
+// src/reporter.ts
+import * as fs3 from "fs";
+import { readFileSync as readFileSync3 } from "fs";
+import * as path3 from "path";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+
+// ../clients/src/checkly-client.ts
+import axios from "axios";
+
+// ../clients/src/errors.ts
+var ApiError = class extends Error {
+  data;
+  constructor(data, options) {
+    super(data.message, options);
+    this.name = this.constructor.name;
+    this.data = data;
+  }
+};
+var ValidationError = class extends ApiError {
+  constructor(data, options) {
+    super(data, options);
+  }
+};
+var UnauthorizedError = class extends ApiError {
+  constructor(data, options) {
+    super(data, options);
+  }
+};
+var ForbiddenError = class extends ApiError {
+  constructor(data, options) {
+    super(data, options);
+  }
+};
+var NotFoundError = class extends ApiError {
+  constructor(data, options) {
+    super(data, options);
+  }
+};
+var RequestTimeoutError = class extends ApiError {
+  constructor(data, options) {
+    super(data, options);
+  }
+};
+var ConflictError = class extends ApiError {
+  constructor(data, options) {
+    super(data, options);
+  }
+};
+var ServerError = class extends ApiError {
+  constructor(data, options) {
+    super(data, options);
+  }
+};
+var MiscellaneousError = class extends ApiError {
+  constructor(data, options) {
+    super(data, options);
+  }
+};
+var MissingResponseError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MissingResponseError";
+  }
+};
+function parseErrorData(data, options) {
+  if (!data) {
+    return void 0;
+  }
+  if (typeof data === "object" && data.statusCode && data.error && data.message) {
+    return {
+      statusCode: data.statusCode,
+      error: data.error,
+      message: data.message,
+      errorCode: data.errorCode
+    };
+  }
+  if (typeof data === "object" && data.error && !data.message) {
+    return {
+      statusCode: options.statusCode,
+      error: data.error,
+      message: data.error
+    };
+  }
+  if (typeof data === "object" && data.error && data.message) {
+    return {
+      statusCode: options.statusCode,
+      error: data.error,
+      message: data.message,
+      errorCode: data.errorCode
+    };
+  }
+  if (typeof data === "object" && data.message) {
+    return {
+      statusCode: options.statusCode,
+      error: data.message,
+      message: data.message,
+      errorCode: data.errorCode
+    };
+  }
+  if (typeof data === "string") {
+    return {
+      statusCode: options.statusCode,
+      error: data,
+      message: data
+    };
+  }
+  return void 0;
+}
+function handleErrorResponse(err) {
+  if (!err.response) {
+    throw new MissingResponseError(err.message || "Network error");
+  }
+  const { status, data } = err.response;
+  const errorData = parseErrorData(data, { statusCode: status });
+  if (!errorData) {
+    throw new MiscellaneousError({
+      statusCode: status,
+      error: "Unknown error",
+      message: err.message || "An error occurred"
+    });
+  }
+  switch (status) {
+    case 400:
+      throw new ValidationError(errorData);
+    case 401:
+      throw new UnauthorizedError(errorData);
+    case 403:
+      throw new ForbiddenError(errorData);
+    case 404:
+      throw new NotFoundError(errorData);
+    case 408:
+      throw new RequestTimeoutError(errorData);
+    case 409:
+      throw new ConflictError(errorData);
+    default:
+      if (status >= 500) {
+        throw new ServerError(errorData);
+      }
+      throw new MiscellaneousError(errorData);
+  }
+}
+
+// ../clients/src/checkly-client.ts
+function getVersion() {
+  return "0.1.0";
+}
+function createRequestInterceptor(apiKey, accountId) {
+  return (config) => {
+    if (config.headers) {
+      config.headers.Authorization = `Bearer ${apiKey}`;
+      config.headers["x-checkly-account"] = accountId;
+      config.headers["User-Agent"] = `@checkly/playwright-reporter/${getVersion()}`;
+    }
+    return config;
+  };
+}
+function createResponseErrorInterceptor() {
+  return (error) => {
+    handleErrorResponse(error);
+  };
+}
+var ChecklyClient = class {
+  apiKey;
+  baseUrl;
+  accountId;
+  api;
+  constructor(options) {
+    this.accountId = options.accountId;
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl;
+    this.api = axios.create({
+      baseURL: this.baseUrl,
+      timeout: 12e4,
+      // 120 second timeout for large uploads
+      maxContentLength: Number.POSITIVE_INFINITY,
+      // Allow large payloads
+      maxBodyLength: Number.POSITIVE_INFINITY
+      // Allow large request bodies
+    });
+    this.api.interceptors.request.use(createRequestInterceptor(this.apiKey, this.accountId));
+    this.api.interceptors.response.use((response) => response, createResponseErrorInterceptor());
+  }
+  /**
+   * Gets the underlying axios instance
+   * Useful for creating resource-specific clients (e.g., TestResults)
+   */
+  getAxiosInstance() {
+    return this.api;
+  }
+};
+
+// ../clients/src/test-results.ts
+import FormData from "form-data";
+var TestResults = class {
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Creates a new test session in Checkly
+   *
+   * @param request Test session creation request
+   * @returns Test session response with session ID and test result IDs
+   * @throws {ValidationError} If request data is invalid
+   * @throws {UnauthorizedError} If authentication fails
+   * @throws {ServerError} If server error occurs
+   */
+  async createTestSession(request) {
+    const response = await this.api.post("/next/test-sessions/create", request);
+    return response.data;
+  }
+  /**
+   * Step 1: Upload test result assets to S3
+   * Streams a ZIP file containing test assets (traces, videos, screenshots)
+   *
+   * @param testSessionId ID of the test session
+   * @param testResultId ID of the test result
+   * @param assets Buffer or ReadableStream of the ZIP file
+   * @returns Upload response with assetId, region, key, and url
+   * @throws {ValidationError} If assets are invalid
+   * @throws {UnauthorizedError} If authentication fails
+   * @throws {NotFoundError} If test session or result not found
+   * @throws {PayloadTooLargeError} If assets exceed 500MB
+   * @throws {ServerError} If S3 upload fails
+   */
+  async uploadTestResultAsset(testSessionId, testResultId, assets) {
+    const form = new FormData();
+    form.append("assets", assets, {
+      filename: "assets.zip",
+      contentType: "application/zip"
+    });
+    const response = await this.api.post(
+      `/next/test-sessions/${testSessionId}/results/${testResultId}/assets`,
+      form,
+      {
+        headers: {
+          ...form.getHeaders()
+        }
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Step 2: Update test result with status and optional asset reference
+   * Uses JSON payload for clean, easy-to-validate updates
+   *
+   * @param testSessionId ID of the test session
+   * @param testResultId ID of the test result to update
+   * @param request Test result update request (JSON)
+   * @returns Test result update response
+   * @throws {ValidationError} If request data is invalid
+   * @throws {UnauthorizedError} If authentication fails
+   * @throws {NotFoundError} If test session or result not found
+   * @throws {ServerError} If server error occurs
+   */
+  async updateTestResult(testSessionId, testResultId, request) {
+    const response = await this.api.post(
+      `/next/test-sessions/${testSessionId}/results/${testResultId}`,
+      request
+    );
+    return response.data;
+  }
+};
+
+// src/reporter.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var packageJson = JSON.parse(readFileSync3(join3(__dirname, "..", "package.json"), "utf-8"));
+var pkgVersion = packageJson.version;
+var pluralRules = new Intl.PluralRules("en-US");
+var projectForms = {
+  zero: "Project",
+  one: "Project",
+  two: "Projects",
+  few: "Projects",
+  many: "Projects",
+  other: "Projects"
+};
+function getApiUrl(environment) {
+  const environments = {
+    local: "http://127.0.0.1:3000",
+    development: "https://api-dev.checklyhq.com",
+    staging: "https://api-test.checklyhq.com",
+    production: "https://api.checklyhq.com"
+  };
+  return environments[environment];
+}
+function getEnvironment(options) {
+  const envFromOptions = options?.environment;
+  const envFromEnvVar = process.env.CHECKLY_ENV;
+  const env = envFromOptions || envFromEnvVar || "production";
+  const validEnvironments = ["local", "development", "staging", "production"];
+  if (!validEnvironments.includes(env)) {
+    console.warn(`[Checkly Reporter] Invalid environment "${env}", using "production"`);
+    return "production";
+  }
+  return env;
+}
+function convertStepToJSON(step) {
+  return {
+    title: step.title,
+    duration: step.duration,
+    error: step.error,
+    steps: step.steps.length > 0 ? step.steps.map(convertStepToJSON) : void 0
+  };
+}
+function getDirectoryName() {
+  const cwd = process.cwd();
+  let dirName = path3.basename(cwd);
+  if (!dirName || dirName === "/" || dirName === ".") {
+    dirName = "playwright-tests";
+  }
+  dirName = dirName.replace(/[<>:"|?*]/g, "-");
+  if (dirName.length > 255) {
+    dirName = dirName.substring(0, 255);
+  }
+  return dirName;
+}
+var ChecklyReporter = class {
+  options;
+  assetCollector;
+  zipper;
+  testResults;
+  testSession;
+  startTime;
+  testCounts = {
+    passed: 0,
+    failed: 0,
+    flaky: 0
+  };
+  // Store steps per test result, keyed by "testId:retry"
+  stepsMap = /* @__PURE__ */ new Map();
+  // Store warnings per test result, keyed by "testId:retry"
+  warningsMap = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const environment = getEnvironment(options);
+    const baseUrl = getApiUrl(environment);
+    const apiKey = process.env.CHECKLY_API_KEY || options.apiKey;
+    const accountId = process.env.CHECKLY_ACCOUNT_ID || options.accountId;
+    this.options = {
+      accountId,
+      apiKey,
+      outputPath: options.outputPath ?? "checkly-report.zip",
+      jsonReportPath: options.jsonReportPath ?? "test-results/playwright-test-report.json",
+      testResultsDir: options.testResultsDir ?? "test-results",
+      dryRun: options.dryRun ?? false,
+      sessionName: options.sessionName
+    };
+    this.assetCollector = new AssetCollector(this.options.testResultsDir);
+    this.zipper = new Zipper({
+      outputPath: this.options.outputPath
+    });
+    if (!this.options.dryRun && this.options.apiKey && this.options.accountId) {
+      const client = new ChecklyClient({
+        apiKey: this.options.apiKey,
+        accountId: this.options.accountId,
+        baseUrl
+      });
+      this.testResults = new TestResults(client.getAxiosInstance());
+    }
+  }
+  /**
+   * Resolves the session name from options
+   * Supports string, callback function, or falls back to default
+   */
+  resolveSessionName(context) {
+    const { sessionName } = this.options;
+    if (typeof sessionName === "function") {
+      return sessionName(context);
+    }
+    if (typeof sessionName === "string") {
+      return sessionName;
+    }
+    return `Playwright Test Session: ${context.directoryName}`;
+  }
+  /**
+   * Checks if test result has a trace attachment and adds context-aware warning if missing
+   * The warning type depends on the trace configuration and test result state
+   */
+  checkTraceAttachment(test, result) {
+    const warningsKey = `${test.id}:${result.retry}`;
+    const hasTrace = result.attachments?.some(
+      (attachment) => attachment.name === "trace" || attachment.contentType === "application/zip"
+    );
+    if (hasTrace) {
+      return;
+    }
+    const traceConfig = test.parent?.project()?.use?.trace;
+    const traceMode = typeof traceConfig === "object" ? traceConfig.mode : traceConfig;
+    const isRetry = result.retry > 0;
+    const testPassed = result.status === "passed";
+    let warningType;
+    let message;
+    switch (traceMode) {
+      case void 0:
+        return;
+      case "off":
+        warningType = "trace-off";
+        message = 'Traces are disabled. Set trace: "on" in playwright.config.ts to capture traces.';
+        break;
+      case "retain-on-failure":
+        if (testPassed) {
+          warningType = "trace-retained-on-failure";
+          message = 'No trace retained because test passed. Trace mode is "retain-on-failure" which discards traces for passing tests.';
+        } else {
+          warningType = "trace-missing";
+          message = 'Trace should exist but was not found. The test failed with trace: "retain-on-failure".';
+        }
+        break;
+      case "on-first-retry":
+        if (!isRetry) {
+          warningType = "trace-first-retry-only";
+          message = 'No trace for initial attempt. Trace mode is "on-first-retry" which only records traces on the first retry.';
+        } else if (result.retry === 1) {
+          warningType = "trace-missing";
+          message = 'Trace should exist but was not found. This is the first retry with trace: "on-first-retry".';
+        } else {
+          warningType = "trace-first-retry-only";
+          message = `No trace for retry #${result.retry}. Trace mode is "on-first-retry" which only records the first retry.`;
+        }
+        break;
+      case "on-all-retries":
+        if (!isRetry) {
+          warningType = "trace-retries-only";
+          message = 'No trace for initial attempt. Trace mode is "on-all-retries" which only records traces on retries.';
+        } else {
+          warningType = "trace-missing";
+          message = `Trace should exist but was not found. This is retry #${result.retry} with trace: "on-all-retries".`;
+        }
+        break;
+      case "retain-on-first-failure":
+        if (testPassed) {
+          warningType = "trace-retained-on-first-failure";
+          message = 'No trace retained because test passed. Trace mode is "retain-on-first-failure" which discards traces for passing tests.';
+        } else if (isRetry) {
+          warningType = "trace-retained-on-first-failure";
+          message = 'No trace for retries. Trace mode is "retain-on-first-failure" which only records the first run.';
+        } else {
+          warningType = "trace-missing";
+          message = 'Trace should exist but was not found. The test failed on first run with trace: "retain-on-first-failure".';
+        }
+        break;
+      case "on":
+        warningType = "trace-missing";
+        message = 'Trace should exist but was not found. Trace mode is "on" which should always record traces.';
+        break;
+      default:
+        warningType = "trace-missing";
+        message = `No trace found. Trace mode "${traceMode}" may not be generating traces for this result.`;
+    }
+    const warnings = this.warningsMap.get(warningsKey) || [];
+    warnings.push({ type: warningType, message });
+    this.warningsMap.set(warningsKey, warnings);
+  }
+  /**
+   * Called once before running tests
+   * Creates test session in Checkly if credentials provided
+   */
+  onBegin(config, suite) {
+    this.startTime = /* @__PURE__ */ new Date();
+    if (!this.testResults) {
+      return;
+    }
+    try {
+      const directoryName = getDirectoryName();
+      const sessionName = this.resolveSessionName({ directoryName, config, suite });
+      const testResults = [{ name: directoryName }];
+      const repoUrl = process.env.GITHUB_REPOSITORY ? `https://github.com/${process.env.GITHUB_REPOSITORY}` : void 0;
+      const repoInfo = repoUrl ? {
+        repoUrl,
+        commitId: process.env.GITHUB_SHA,
+        branchName: process.env.GITHUB_REF_NAME,
+        commitOwner: process.env.GITHUB_ACTOR,
+        commitMessage: process.env.GITHUB_EVENT_NAME
+      } : void 0;
+      this.testResults.createTestSession({
+        name: sessionName,
+        environment: process.env.NODE_ENV || "test",
+        repoInfo,
+        startedAt: this.startTime.getTime(),
+        // Required timestamp in milliseconds
+        testResults,
+        provider: "PW_REPORTER"
+      }).then((response) => {
+        this.testSession = response;
+      }).catch((error) => {
+        console.error("[Checkly Reporter] Failed to create test session:", error.message);
+      });
+    } catch (error) {
+      console.error("[Checkly Reporter] Error in onBegin:", error);
+    }
+  }
+  /**
+   * Called for each test when it completes
+   * Captures steps and warnings, tracks test results for final status calculation
+   */
+  onTestEnd(test, result) {
+    try {
+      this.checkTraceAttachment(test, result);
+      const stepsKey = `${test.id}:${result.retry}`;
+      if (result.steps && result.steps.length > 0) {
+        this.stepsMap.set(stepsKey, result.steps.map(convertStepToJSON));
+      }
+      const outcome = test.outcome();
+      const testIsComplete = result.retry === test.retries || outcome !== "unexpected";
+      if (!testIsComplete) {
+        return;
+      }
+      const isFlaky = outcome === "flaky";
+      if (isFlaky) {
+        this.testCounts.flaky++;
+        this.testCounts.passed++;
+      } else {
+        if (result.status === "passed") {
+          this.testCounts.passed++;
+        } else if (result.status === "failed" || result.status === "timedOut") {
+          this.testCounts.failed++;
+        }
+      }
+    } catch (error) {
+      console.error("[Checkly Reporter] Error in onTestEnd:", error);
+    }
+  }
+  /**
+   * Called after all tests have completed
+   * This is where we create the ZIP archive and upload results
+   */
+  async onEnd() {
+    try {
+      const jsonReportPath = this.options.jsonReportPath;
+      if (!fs3.existsSync(jsonReportPath)) {
+        console.error(`[Checkly Reporter] ERROR: JSON report not found at: ${jsonReportPath}`);
+        console.error("[Checkly Reporter] Make sure to configure the json reporter before the checkly reporter:");
+        console.error(
+          "  reporter: [\n    ['json', { outputFile: 'test-results/playwright-test-report.json' }],\n    ['@checkly/playwright-reporter']\n  ]"
+        );
+        return;
+      }
+      const reportContent = fs3.readFileSync(jsonReportPath, "utf-8");
+      const report = JSON.parse(reportContent);
+      this.injectDataIntoReport(report);
+      fs3.writeFileSync(jsonReportPath, JSON.stringify(report, null, 2), "utf-8");
+      const assets = await this.assetCollector.collectAssets(report);
+      const result = await this.zipper.createZip(jsonReportPath, assets);
+      if (this.testResults && this.testSession) {
+        await this.uploadResults(report, result.zipPath, result.entries);
+        if (!this.options.dryRun) {
+          try {
+            fs3.unlinkSync(result.zipPath);
+          } catch (cleanupError) {
+            console.warn(`[Checkly Reporter] Warning: Could not delete ZIP file: ${cleanupError}`);
+          }
+        }
+      }
+      if (this.testResults && this.testSession?.link) {
+        this.printSummary(report, this.testSession);
+      }
+    } catch (error) {
+      console.error("[Checkly Reporter] ERROR creating report:", error);
+    }
+  }
+  printSummary(report, testSession) {
+    const rule = pluralRules.select(report.config.projects.length);
+    console.log("\n======================================================\n");
+    console.log(`\u{1F99D} Checkly reporter: ${pkgVersion}`);
+    console.log(`\u{1F3AD} Playwright: ${report.config.version}`);
+    console.log(`\u{1F4D4} ${projectForms[rule]}: ${report.config.projects.map(({ name }) => name).join(",")}`);
+    console.log(`\u{1F517} Test session URL: ${testSession.link}`);
+    console.log("\n======================================================");
+  }
+  /**
+   * Injects captured steps and warnings into the JSON report
+   * Traverses the report structure and matches by test ID + retry
+   */
+  injectDataIntoReport(report) {
+    const processSuite = (suite) => {
+      for (const spec of suite.specs) {
+        for (const test of spec.tests) {
+          for (const result of test.results) {
+            const key = `${spec.id}:${result.retry}`;
+            const steps = this.stepsMap.get(key);
+            if (steps) {
+              result.steps = steps;
+            }
+            const warnings = this.warningsMap.get(key);
+            if (warnings && warnings.length > 0) {
+              result._checkly = { warnings };
+            }
+          }
+        }
+      }
+      if (suite.suites) {
+        for (const nestedSuite of suite.suites) {
+          processSuite(nestedSuite);
+        }
+      }
+    };
+    for (const suite of report.suites) {
+      processSuite(suite);
+    }
+  }
+  /**
+   * Uploads test results to Checkly API
+   */
+  async uploadResults(report, zipPath, entries) {
+    if (!this.testResults || !this.testSession) {
+      return;
+    }
+    try {
+      const { failed: failedCount, flaky: flakyCount } = this.testCounts;
+      const overallStatus = failedCount > 0 ? "FAILED" : "PASSED";
+      const isDegraded = failedCount === 0 && flakyCount > 0;
+      const endTime = /* @__PURE__ */ new Date();
+      const responseTime = this.startTime ? Math.max(0, endTime.getTime() - this.startTime.getTime()) : 0;
+      const zipSizeBytes = (await fs3.promises.stat(zipPath)).size;
+      if (this.testSession.testResults.length > 0) {
+        const firstResult = this.testSession.testResults[0];
+        let assetId;
+        if (zipSizeBytes > 0) {
+          try {
+            const assets = fs3.createReadStream(zipPath);
+            const uploadResponse = await this.testResults.uploadTestResultAsset(
+              this.testSession.testSessionId,
+              firstResult.testResultId,
+              assets
+            );
+            assetId = uploadResponse.assetId;
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error("[Checkly Reporter] Asset upload failed:", errorMessage);
+          }
+        }
+        await this.testResults.updateTestResult(this.testSession.testSessionId, firstResult.testResultId, {
+          status: overallStatus,
+          assetEntries: assetId ? entries : void 0,
+          isDegraded,
+          startedAt: this.startTime?.toISOString(),
+          stoppedAt: endTime.toISOString(),
+          responseTime,
+          metadata: {
+            usageData: {
+              s3PostTotalBytes: zipSizeBytes
+            }
+          }
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("[Checkly Reporter] Failed to upload results:", errorMessage);
+    }
+  }
+  /**
+   * Called when a global error occurs
+   */
+  onError(error) {
+    console.error("[Checkly Reporter] Global error:", error);
+  }
+};
+export {
+  AssetCollector,
+  ChecklyReporter,
+  Zipper,
+  ChecklyReporter as default
+};