@checkly/playwright-reporter 0.1.9 → 1.1.0

package/dist/index.js

@@ -1,6 +1,56 @@
+"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.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createChecklyReporter: () => createChecklyReporter,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/extensions/checkly-upload.ts
+var fs5 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+
+// ../utils/src/ansi.ts
+var ansiRegex = new RegExp(
+  [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+  ].join("|"),
+  "g"
+);
+
 // ../utils/src/asset-collector.ts
-import * as fs from "fs";
-import * as path from "path";
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
 var AssetCollector = class {
   constructor(testResultsDir) {
     this.testResultsDir = testResultsDir;
@@ -234,15 +284,1034 @@ var AssetCollector = class {
   }
 };
 
+// ../utils/src/ci-detector.ts
+function detectCI() {
+  if (process.env.GITHUB_ACTIONS === "true") {
+    return { environment: "ci", ciProvider: "github-actions", repositoryId: process.env.GITHUB_REPOSITORY };
+  }
+  if (process.env.GITLAB_CI === "true") {
+    return { environment: "ci", ciProvider: "gitlab-ci", repositoryId: process.env.CI_PROJECT_PATH };
+  }
+  if (process.env.JENKINS_URL) {
+    return { environment: "ci", ciProvider: "jenkins", repositoryId: process.env.JOB_NAME };
+  }
+  if (process.env.CIRCLECI === "true") {
+    return { environment: "ci", ciProvider: "circleci", repositoryId: process.env.CIRCLE_PROJECT_REPONAME };
+  }
+  if (process.env.TRAVIS === "true") {
+    return { environment: "ci", ciProvider: "travis-ci", repositoryId: process.env.TRAVIS_REPO_SLUG };
+  }
+  if (process.env.TF_BUILD === "True") {
+    return { environment: "ci", ciProvider: "azure-devops", repositoryId: process.env.BUILD_REPOSITORY_NAME };
+  }
+  if (process.env.BITBUCKET_PIPELINE_UUID) {
+    return { environment: "ci", ciProvider: "bitbucket-pipelines", repositoryId: process.env.BITBUCKET_REPO_SLUG };
+  }
+  if (process.env.CI === "true" || process.env.CI === "1") {
+    return { environment: "ci", ciProvider: "unknown-ci" };
+  }
+  return { environment: "local", ciProvider: "local" };
+}
+
+// ../utils/src/console-adapter.ts
+var import_node_crypto = require("crypto");
+function normalizeType(messageType) {
+  switch (messageType.toLowerCase()) {
+    case "debug":
+      return "debug";
+    case "error":
+      return "error";
+    case "info":
+      return "info";
+    case "warning":
+    case "warn":
+      return "warning";
+    default:
+      return "log";
+  }
+}
+function generateId(time, messageType, text, url) {
+  return (0, import_node_crypto.createHash)("sha256").update(`${time}-${messageType}-${text}-${url}`).digest("hex").substring(0, 16);
+}
+function toConsoleMessage(event) {
+  const url = event.location?.url || "";
+  return {
+    id: generateId(event.time, event.messageType, event.text, url),
+    location: {
+      url,
+      columnNumber: event.location?.columnNumber || 0,
+      lineNumber: event.location?.lineNumber || 0
+    },
+    text: event.text || "",
+    timestamp: event.time,
+    type: normalizeType(event.messageType)
+  };
+}
+
+// ../utils/src/git-info.ts
+function getGitHubRepoInfo() {
+  const repository = process.env.GITHUB_REPOSITORY;
+  if (!repository) return void 0;
+  return {
+    repoUrl: `https://github.com/${repository}`,
+    commitId: process.env.GITHUB_SHA,
+    branchName: process.env.GITHUB_REF_NAME,
+    commitOwner: process.env.GITHUB_ACTOR,
+    commitMessage: process.env.GITHUB_EVENT_NAME
+  };
+}
+
+// ../utils/src/machine-id.ts
+var import_node_crypto2 = require("crypto");
+var fs2 = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// ../utils/src/network-adapter.ts
+var import_node_crypto3 = require("crypto");
+function generateId2(url, method, startedAt) {
+  return (0, import_node_crypto3.createHash)("sha256").update(`${url}-${method}-${startedAt}`).digest("hex").substring(0, 16);
+}
+function extractDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function headersArrayToRecord(headers) {
+  const record = {};
+  for (const { name, value } of headers) {
+    record[name.toLowerCase()] = value;
+  }
+  return record;
+}
+function isSuccessStatus(status) {
+  return status >= 200 && status < 400;
+}
+function determineResourceType(snapshot) {
+  if (snapshot._resourceType) {
+    return snapshot._resourceType;
+  }
+  if (snapshot._apiRequest) {
+    return "fetch";
+  }
+  return "other";
+}
+function toNetworkRequest(event) {
+  const { snapshot } = event;
+  const startedAt = new Date(snapshot.startedDateTime).getTime();
+  const time = Math.round(snapshot.time);
+  const finishedAt = startedAt + time;
+  const statusCode = snapshot.response.status;
+  const url = snapshot.request.url;
+  const method = snapshot.request.method;
+  return {
+    id: generateId2(url, method, startedAt),
+    url,
+    domain: extractDomain(url),
+    method,
+    resourceType: determineResourceType(snapshot),
+    statusCode,
+    statusText: snapshot.response.statusText || "",
+    start: startedAt,
+    startedAt,
+    finishedAt,
+    time,
+    hasFinished: true,
+    hasSucceeded: isSuccessStatus(statusCode),
+    requestHeaders: headersArrayToRecord(snapshot.request.headers || []),
+    responseHeaders: headersArrayToRecord(snapshot.response.headers || []),
+    transferBytes: snapshot.response._transferSize,
+    resourceBytes: snapshot.response.content?.size
+  };
+}
+
+// ../utils/src/trace-reader.ts
+var fs3 = __toESM(require("fs"), 1);
+
+// ../utils/src/zip-reader.ts
+var import_node_util = require("util");
+var zlib = __toESM(require("zlib"), 1);
+var gunzip2 = (0, import_node_util.promisify)(zlib.gunzip);
+var inflateRaw2 = (0, import_node_util.promisify)(zlib.inflateRaw);
+function parseZipEntries(zipBuffer) {
+  const EOCD_SIG = 101010256;
+  let eocdOffset = -1;
+  for (let i = zipBuffer.length - 22; i >= 0; i--) {
+    if (zipBuffer.readUInt32LE(i) === EOCD_SIG) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) {
+    return [];
+  }
+  const cdOffset = zipBuffer.readUInt32LE(eocdOffset + 16);
+  const cdEntries = zipBuffer.readUInt16LE(eocdOffset + 10);
+  const entries = [];
+  const CD_SIG = 33639248;
+  let offset = cdOffset;
+  for (let i = 0; i < cdEntries; i++) {
+    if (zipBuffer.readUInt32LE(offset) !== CD_SIG) {
+      break;
+    }
+    const compressionMethod = zipBuffer.readUInt16LE(offset + 10);
+    const compressedSize = zipBuffer.readUInt32LE(offset + 20);
+    const fileNameLength = zipBuffer.readUInt16LE(offset + 28);
+    const extraFieldLength = zipBuffer.readUInt16LE(offset + 30);
+    const commentLength = zipBuffer.readUInt16LE(offset + 32);
+    const localHeaderOffset = zipBuffer.readUInt32LE(offset + 42);
+    const fileName = zipBuffer.subarray(offset + 46, offset + 46 + fileNameLength).toString("utf-8");
+    entries.push({
+      fileName,
+      compressionMethod,
+      compressedSize,
+      localHeaderOffset
+    });
+    offset += 46 + fileNameLength + extraFieldLength + commentLength;
+  }
+  return entries;
+}
+async function readZipEntryContent(zipBuffer, entry) {
+  const LOCAL_SIG = 67324752;
+  if (zipBuffer.readUInt32LE(entry.localHeaderOffset) !== LOCAL_SIG) {
+    return null;
+  }
+  const localFileNameLength = zipBuffer.readUInt16LE(entry.localHeaderOffset + 26);
+  const localExtraLength = zipBuffer.readUInt16LE(entry.localHeaderOffset + 28);
+  const dataOffset = entry.localHeaderOffset + 30 + localFileNameLength + localExtraLength;
+  const compressedData = zipBuffer.subarray(dataOffset, dataOffset + entry.compressedSize);
+  let buffer;
+  if (entry.compressionMethod === 0) {
+    buffer = compressedData;
+  } else if (entry.compressionMethod === 8) {
+    buffer = await inflateRaw2(compressedData);
+  } else {
+    return null;
+  }
+  if (buffer.length >= 2 && buffer[0] === 31 && buffer[1] === 139) {
+    const decompressed = await gunzip2(buffer);
+    return decompressed.toString("utf-8");
+  }
+  return buffer.toString("utf-8");
+}
+
+// ../utils/src/trace-reader.ts
+var TraceReader = class {
+  constructor(tracePath) {
+    this.tracePath = tracePath;
+  }
+  zipBuffer = null;
+  traceEntries = [];
+  async open() {
+    if (!fs3.existsSync(this.tracePath)) {
+      return false;
+    }
+    try {
+      this.zipBuffer = fs3.readFileSync(this.tracePath);
+      const entries = parseZipEntries(this.zipBuffer);
+      this.traceEntries = entries.filter(
+        (e) => (/^\d+-trace\.trace$/.test(e.fileName) || /^\d+-trace\.network$/.test(e.fileName)) && !e.fileName.includes("/")
+      );
+      return this.traceEntries.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Extracts events matching a text filter.
+   *
+   * @param textFilter - Substring to match (e.g., '"type":"console"')
+   * @param adapter - Optional adapter to transform events
+   */
+  async extractEvents(textFilter, adapter) {
+    if (!this.zipBuffer) {
+      throw new Error("TraceReader not opened. Call open() first.");
+    }
+    const results = [];
+    for (const traceEntry of this.traceEntries) {
+      const content = await readZipEntryContent(this.zipBuffer, traceEntry);
+      if (!content) continue;
+      for (const line of content.split("\n")) {
+        if (line.indexOf(textFilter) !== -1) {
+          try {
+            const event = JSON.parse(line);
+            results.push(adapter ? adapter(event) : event);
+          } catch {
+          }
+        }
+      }
+    }
+    if (results.length > 0 && typeof results[0].time === "number") {
+      return results.sort((a, b) => a.time - b.time);
+    }
+    return results;
+  }
+  /**
+   * Extracts all events from the trace.
+   */
+  async extractAllEvents(adapter) {
+    if (!this.zipBuffer) {
+      throw new Error("TraceReader not opened. Call open() first.");
+    }
+    const results = [];
+    for (const traceEntry of this.traceEntries) {
+      const content = await readZipEntryContent(this.zipBuffer, traceEntry);
+      if (!content) continue;
+      for (const line of content.split("\n")) {
+        if (line.trim()) {
+          try {
+            const event = JSON.parse(line);
+            results.push(adapter ? adapter(event) : event);
+          } catch {
+          }
+        }
+      }
+    }
+    if (results.length > 0 && typeof results[0].time === "number") {
+      return results.sort((a, b) => a.time - b.time);
+    }
+    return results;
+  }
+  listFiles() {
+    if (!this.zipBuffer) {
+      return [];
+    }
+    return parseZipEntries(this.zipBuffer).map((e) => e.fileName);
+  }
+  isOpen() {
+    return this.zipBuffer !== null;
+  }
+};
+
+// ../utils/src/zipper.ts
+var fs4 = __toESM(require("fs"), 1);
+var os2 = __toESM(require("os"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// ../../node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/index.mjs
+var import_module = require("module");
+var require2 = (0, import_module.createRequire)("/");
+var Worker;
+try {
+  Worker = require2("worker_threads").Worker;
+} catch (e) {
+}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var wbits = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+};
+var wbits16 = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+  d[o + 2] |= v >> 16;
+};
+var hTree = function(d, mb) {
+  var t = [];
+  for (var i = 0; i < d.length; ++i) {
+    if (d[i])
+      t.push({ s: i, f: d[i] });
+  }
+  var s = t.length;
+  var t2 = t.slice();
+  if (!s)
+    return { t: et, l: 0 };
+  if (s == 1) {
+    var v = new u8(t[0].s + 1);
+    v[t[0].s] = 1;
+    return { t: v, l: 1 };
+  }
+  t.sort(function(a, b) {
+    return a.f - b.f;
+  });
+  t.push({ s: -1, f: 25001 });
+  var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
+  t[0] = { s: -1, f: l.f + r.f, l, r };
+  while (i1 != s - 1) {
+    l = t[t[i0].f < t[i2].f ? i0++ : i2++];
+    r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
+    t[i1++] = { s: -1, f: l.f + r.f, l, r };
+  }
+  var maxSym = t2[0].s;
+  for (var i = 1; i < s; ++i) {
+    if (t2[i].s > maxSym)
+      maxSym = t2[i].s;
+  }
+  var tr = new u16(maxSym + 1);
+  var mbt = ln(t[i1 - 1], tr, 0);
+  if (mbt > mb) {
+    var i = 0, dt = 0;
+    var lft = mbt - mb, cst = 1 << lft;
+    t2.sort(function(a, b) {
+      return tr[b.s] - tr[a.s] || a.f - b.f;
+    });
+    for (; i < s; ++i) {
+      var i2_1 = t2[i].s;
+      if (tr[i2_1] > mb) {
+        dt += cst - (1 << mbt - tr[i2_1]);
+        tr[i2_1] = mb;
+      } else
+        break;
+    }
+    dt >>= lft;
+    while (dt > 0) {
+      var i2_2 = t2[i].s;
+      if (tr[i2_2] < mb)
+        dt -= 1 << mb - tr[i2_2]++ - 1;
+      else
+        ++i;
+    }
+    for (; i >= 0 && dt; --i) {
+      var i2_3 = t2[i].s;
+      if (tr[i2_3] == mb) {
+        --tr[i2_3];
+        ++dt;
+      }
+    }
+    mbt = mb;
+  }
+  return { t: new u8(tr), l: mbt };
+};
+var ln = function(n, l, d) {
+  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+};
+var lc = function(c) {
+  var s = c.length;
+  while (s && !c[--s])
+    ;
+  var cl = new u16(++s);
+  var cli = 0, cln = c[0], cls = 1;
+  var w = function(v) {
+    cl[cli++] = v;
+  };
+  for (var i = 1; i <= s; ++i) {
+    if (c[i] == cln && i != s)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (; cls > 138; cls -= 138)
+          w(32754);
+        if (cls > 2) {
+          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w(cln), --cls;
+        for (; cls > 6; cls -= 6)
+          w(8304);
+        if (cls > 2)
+          w(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w(cln);
+      cls = 1;
+      cln = c[i];
+    }
+  }
+  return { c: cl.subarray(0, cli), n: s };
+};
+var clen = function(cf, cl) {
+  var l = 0;
+  for (var i = 0; i < cl.length; ++i)
+    l += cf[i] * cl[i];
+  return l;
+};
+var wfblk = function(out, pos, dat) {
+  var s = dat.length;
+  var o = shft(pos + 2);
+  out[o] = s & 255;
+  out[o + 1] = s >> 8;
+  out[o + 2] = out[o] ^ 255;
+  out[o + 3] = out[o + 1] ^ 255;
+  for (var i = 0; i < s; ++i)
+    out[o + i + 4] = dat[i];
+  return (o + 4 + s) * 8;
+};
+var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+  wbits(out, p++, final);
+  ++lf[256];
+  var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+  var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+  var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+  var lcfreq = new u16(19);
+  for (var i = 0; i < lclt.length; ++i)
+    ++lcfreq[lclt[i] & 31];
+  for (var i = 0; i < lcdt.length; ++i)
+    ++lcfreq[lcdt[i] & 31];
+  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+  var nlcc = 19;
+  for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl + 5 << 3;
+  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p, dat.subarray(bs, bs + bl));
+  var lm, ll, dm, dl;
+  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+  if (dtlen < ftlen) {
+    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p, nlc - 257);
+    wbits(out, p + 5, ndc - 1);
+    wbits(out, p + 10, nlcc - 4);
+    p += 14;
+    for (var i = 0; i < nlcc; ++i)
+      wbits(out, p + 3 * i, lct[clim[i]]);
+    p += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it = 0; it < 2; ++it) {
+      var clct = lcts[it];
+      for (var i = 0; i < clct.length; ++i) {
+        var len = clct[i] & 31;
+        wbits(out, p, llm[len]), p += lct[len];
+        if (len > 15)
+          wbits(out, p, clct[i] >> 5 & 127), p += clct[i] >> 12;
+      }
+    }
+  } else {
+    lm = flm, ll = flt, dm = fdm, dl = fdt;
+  }
+  for (var i = 0; i < li; ++i) {
+    var sym = syms[i];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+      if (len > 7)
+        wbits(out, p, sym >> 23 & 31), p += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p, dm[dst]), p += dl[dst];
+      if (dst > 3)
+        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+    } else {
+      wbits16(out, p, lm[sym]), p += ll[sym];
+    }
+  }
+  wbits16(out, p, lm[256]);
+  return p + ll[256];
+};
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et = /* @__PURE__ */ new u8(0);
+var dflt = function(dat, lvl, plvl, pre, post, st) {
+  var s = st.z || dat.length;
+  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
+  var w = o.subarray(pre, o.length - post);
+  var lst = st.l;
+  var pos = (st.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w[0] = st.r >> 3;
+    var opt = deo[lvl - 1];
+    var n = opt >> 13, c = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i2) {
+      return (dat[i2] ^ dat[i2 + 1] << bs1_1 ^ dat[i2 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25e3);
+    var lf = new u16(288), df = new u16(32);
+    var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+    for (; i + 2 < s; ++i) {
+      var hv = hsh(i);
+      var imod = i & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi <= i) {
+        var rem = s - i;
+        if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
+          li = lc_1 = eb = 0, bs = i;
+          for (var j = 0; j < 286; ++j)
+            lf[j] = 0;
+          for (var j = 0; j < 30; ++j)
+            df[j] = 0;
+        }
+        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i - dif)) {
+          var maxn = Math.min(n, rem) - 1;
+          var maxd = Math.min(32767, i);
+          var ml = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i + l] == dat[i + l - dif]) {
+              var nl = 0;
+              for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
+                ;
+              if (nl > l) {
+                l = nl, d = dif;
+                if (nl > maxn)
+                  break;
+                var mmd = Math.min(dif, nl - 2);
+                var md = 0;
+                for (var j = 0; j < mmd; ++j) {
+                  var ti = i - dif + j & 32767;
+                  var pti = prev[ti];
+                  var cd = ti - pti & 32767;
+                  if (cd > md)
+                    md = cd, pimod = ti;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d) {
+          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+          var lin = revfl[l] & 31, din = revfd[d] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf[257 + lin];
+          ++df[din];
+          wi = i + l;
+          ++lc_1;
+        } else {
+          syms[li++] = dat[i];
+          ++lf[dat[i]];
+        }
+      }
+    }
+    for (i = Math.max(i, wi); i < s; ++i) {
+      syms[li++] = dat[i];
+      ++lf[dat[i]];
+    }
+    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
+    if (!lst) {
+      st.r = pos & 7 | w[pos / 8 | 0] << 3;
+      pos -= 7;
+      st.h = head, st.p = prev, st.i = i, st.w = wi;
+    }
+  } else {
+    for (var i = st.w || 0; i < s + lst; i += 65535) {
+      var e = i + 65535;
+      if (e >= s) {
+        w[pos / 8 | 0] = lst;
+        e = s;
+      }
+      pos = wfblk(w, pos + 1, dat.subarray(i, e));
+    }
+    st.i = s;
+  }
+  return slc(o, 0, pre + shft(pos) + post);
+};
+var crct = /* @__PURE__ */ (function() {
+  var t = new Int32Array(256);
+  for (var i = 0; i < 256; ++i) {
+    var c = i, k = 9;
+    while (--k)
+      c = (c & 1 && -306674912) ^ c >>> 1;
+    t[i] = c;
+  }
+  return t;
+})();
+var crc = function() {
+  var c = -1;
+  return {
+    p: function(d) {
+      var cr = c;
+      for (var i = 0; i < d.length; ++i)
+        cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
+      c = cr;
+    },
+    d: function() {
+      return ~c;
+    }
+  };
+};
+var dopt = function(dat, opt, pre, post, st) {
+  if (!st) {
+    st = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+};
+var mrg = function(a, b) {
+  var o = {};
+  for (var k in a)
+    o[k] = a[k];
+  for (var k in b)
+    o[k] = b[k];
+  return o;
+};
+var wbytes = function(d, b, v) {
+  for (; v; ++b)
+    d[b] = v, v >>>= 8;
+};
+function deflateSync(data, opts) {
+  return dopt(data, opts || {}, 0, 0);
+}
+var fltn = function(d, p, t, o) {
+  for (var k in d) {
+    var val = d[k], n = p + k, op = o;
+    if (Array.isArray(val))
+      op = mrg(o, val[1]), val = val[0];
+    if (val instanceof u8)
+      t[n] = [val, op];
+    else {
+      t[n += "/"] = [new u8(0), op];
+      fltn(val, n, t, o);
+    }
+  }
+};
+var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+function strToU8(str, latin1) {
+  if (latin1) {
+    var ar_1 = new u8(str.length);
+    for (var i = 0; i < str.length; ++i)
+      ar_1[i] = str.charCodeAt(i);
+    return ar_1;
+  }
+  if (te)
+    return te.encode(str);
+  var l = str.length;
+  var ar = new u8(str.length + (str.length >> 1));
+  var ai = 0;
+  var w = function(v) {
+    ar[ai++] = v;
+  };
+  for (var i = 0; i < l; ++i) {
+    if (ai + 5 > ar.length) {
+      var n = new u8(ai + 8 + (l - i << 1));
+      n.set(ar);
+      ar = n;
+    }
+    var c = str.charCodeAt(i);
+    if (c < 128 || latin1)
+      w(c);
+    else if (c < 2048)
+      w(192 | c >> 6), w(128 | c & 63);
+    else if (c > 55295 && c < 57344)
+      c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
+    else
+      w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
+  }
+  return slc(ar, 0, ai);
+}
+var exfl = function(ex) {
+  var le = 0;
+  if (ex) {
+    for (var k in ex) {
+      var l = ex[k].length;
+      if (l > 65535)
+        err(9);
+      le += l + 4;
+    }
+  }
+  return le;
+};
+var wzh = function(d, b, f, fn, u, c, ce, co) {
+  var fl2 = fn.length, ex = f.extra, col = co && co.length;
+  var exl = exfl(ex);
+  wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
+  if (ce != null)
+    d[b++] = 20, d[b++] = f.os;
+  d[b] = 20, b += 2;
+  d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
+  d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
+  var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
+  if (y < 0 || y > 119)
+    err(10);
+  wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
+  if (c != -1) {
+    wbytes(d, b, f.crc);
+    wbytes(d, b + 4, c < 0 ? -c - 2 : c);
+    wbytes(d, b + 8, f.size);
+  }
+  wbytes(d, b + 12, fl2);
+  wbytes(d, b + 14, exl), b += 16;
+  if (ce != null) {
+    wbytes(d, b, col);
+    wbytes(d, b + 6, f.attrs);
+    wbytes(d, b + 10, ce), b += 14;
+  }
+  d.set(fn, b);
+  b += fl2;
+  if (exl) {
+    for (var k in ex) {
+      var exf = ex[k], l = exf.length;
+      wbytes(d, b, +k);
+      wbytes(d, b + 2, l);
+      d.set(exf, b + 4), b += 4 + l;
+    }
+  }
+  if (col)
+    d.set(co, b), b += col;
+  return b;
+};
+var wzf = function(o, b, c, d, e) {
+  wbytes(o, b, 101010256);
+  wbytes(o, b + 8, c);
+  wbytes(o, b + 10, c);
+  wbytes(o, b + 12, d);
+  wbytes(o, b + 16, e);
+};
+function zipSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var r = {};
+  var files = [];
+  fltn(data, "", r, opts);
+  var o = 0;
+  var tot = 0;
+  for (var fn in r) {
+    var _a2 = r[fn], file = _a2[0], p = _a2[1];
+    var compression = p.level == 0 ? 0 : 8;
+    var f = strToU8(fn), s = f.length;
+    var com = p.comment, m = com && strToU8(com), ms = m && m.length;
+    var exl = exfl(p.extra);
+    if (s > 65535)
+      err(11);
+    var d = compression ? deflateSync(file, p) : file, l = d.length;
+    var c = crc();
+    c.p(file);
+    files.push(mrg(p, {
+      size: file.length,
+      crc: c.d(),
+      c: d,
+      f,
+      m,
+      u: s != fn.length || m && com.length != ms,
+      o,
+      compression
+    }));
+    o += 30 + s + exl + l;
+    tot += 76 + 2 * (s + exl) + (ms || 0) + l;
+  }
+  var out = new u8(tot + 22), oe = o, cdl = tot - o;
+  for (var i = 0; i < files.length; ++i) {
+    var f = files[i];
+    wzh(out, f.o, f, f.f, f.u, f.c.length);
+    var badd = 30 + f.f.length + exfl(f.extra);
+    out.set(f.c, f.o + badd);
+    wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
+  }
+  wzf(out, o, files.length, cdl, oe);
+  return out;
+}
+
 // ../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;
+  compressionLevel;
+  onProgress;
   constructor(options) {
     this.outputPath = options.outputPath;
+    this.compressionLevel = options.compressionLevel ?? 0;
+    this.onProgress = options.onProgress;
   }
   /**
    * Creates a ZIP archive containing the JSON report and assets
@@ -251,76 +1320,105 @@ var Zipper = class {
    * @returns ZIP creation result with metadata
    */
   async createZip(reportPath, assets) {
+    if (!fs4.existsSync(reportPath)) {
+      throw new Error(`Report file not found: ${reportPath}`);
+    }
+    const transformedReportPath = this.transformJsonReport(reportPath);
+    const files = {};
+    const totalEntries = assets.length + 1;
+    let processedEntries = 0;
+    const reportContent = fs4.readFileSync(transformedReportPath);
+    files["output/playwright-test-report.json"] = new Uint8Array(reportContent);
+    processedEntries++;
+    this.onProgress?.({ processedEntries, totalEntries, currentFile: "output/playwright-test-report.json" });
+    for (const asset of assets) {
+      if (!fs4.existsSync(asset.sourcePath)) {
+        console.warn(`[Checkly Reporter] Skipping missing asset: ${asset.sourcePath}`);
+        continue;
+      }
+      const content = fs4.readFileSync(asset.sourcePath);
+      files[asset.archivePath] = new Uint8Array(content);
+      processedEntries++;
+      this.onProgress?.({ processedEntries, totalEntries, currentFile: asset.archivePath });
+    }
+    const zipData = zipSync(files, { level: this.compressionLevel });
+    fs4.writeFileSync(this.outputPath, zipData);
+    try {
+      fs4.unlinkSync(transformedReportPath);
+    } catch {
+    }
+    const entries = this.extractEntryOffsets(zipData);
+    return {
+      zipPath: this.outputPath,
+      size: zipData.length,
+      entryCount: entries.length,
+      entries
+    };
+  }
+  /**
+   * Extracts byte offsets for each entry from the ZIP data
+   * Parses the central directory to get accurate offset information
+   */
+  extractEntryOffsets(zipData) {
     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 });
+    const view = new DataView(zipData.buffer, zipData.byteOffset, zipData.byteLength);
+    let eocdOffset = -1;
+    for (let i = zipData.length - 22; i >= 0; i--) {
+      if (view.getUint32(i, true) === 101010256) {
+        eocdOffset = i;
+        break;
+      }
+    }
+    if (eocdOffset === -1) {
+      console.warn("[Checkly Reporter] Could not find ZIP end of central directory");
+      return entries;
+    }
+    let cdOffset = view.getUint32(eocdOffset + 16, true);
+    const cdSize = view.getUint32(eocdOffset + 12, true);
+    if (cdOffset === 4294967295 && eocdOffset >= 20) {
+      const zip64LocatorOffset = eocdOffset - 20;
+      if (view.getUint32(zip64LocatorOffset, true) === 117853008) {
+        const zip64EocdOffset = Number(view.getBigUint64(zip64LocatorOffset + 8, true));
+        if (view.getUint32(zip64EocdOffset, true) === 101075792) {
+          cdOffset = Number(view.getBigUint64(zip64EocdOffset + 48, true));
         }
-        archive.finalize();
-      } catch (error) {
-        reject(error);
       }
-    });
+    }
+    let offset = cdOffset;
+    const cdEnd = cdOffset + cdSize;
+    while (offset < cdEnd && view.getUint32(offset, true) === 33639248) {
+      const compressedSize = view.getUint32(offset + 20, true);
+      const filenameLength = view.getUint16(offset + 28, true);
+      const extraLength = view.getUint16(offset + 30, true);
+      const commentLength = view.getUint16(offset + 32, true);
+      const localHeaderOffset = view.getUint32(offset + 42, true);
+      const filenameBytes = zipData.slice(offset + 46, offset + 46 + filenameLength);
+      const filename = new TextDecoder().decode(filenameBytes);
+      const localExtraLength = view.getUint16(localHeaderOffset + 28, true);
+      const dataStart = localHeaderOffset + 30 + filenameLength + localExtraLength;
+      const dataEnd = dataStart + compressedSize - 1;
+      entries.push({
+        name: filename.replace(/\\/g, "/"),
+        start: dataStart,
+        end: dataEnd >= dataStart ? dataEnd : dataStart
+      });
+      offset += 46 + filenameLength + extraLength + commentLength;
+    }
+    return entries;
   }
   /**
    * 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 reportContent = fs4.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));
+    const tempReportPath = path3.join(os2.tmpdir(), `playwright-test-report-${Date.now()}.json`);
+    fs4.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) {
@@ -340,21 +1438,7 @@ var Zipper = class {
     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,
-   * as well as blob merge resource paths.
-   *
-   * Priority order (first match wins):
-   * 1. test-results/ (highest priority, existing behavior)
-   * 2. blob-reports/resources/ (blob merge extraction paths)
-   * 3. snapshots directories (Playwright default pattern)
-   * 4. __screenshots__/ (common custom pattern)
-   * 5. __snapshots__/ (common custom pattern)
-   * 6. screenshots/ (simple custom pattern)
-   * 7. 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
+   * Normalizes attachment paths by extracting the relevant snapshot directory portion
    */
   normalizeAttachmentPath(attachmentPath) {
     const normalizedPath = attachmentPath.replace(/\\/g, "/");
@@ -391,17 +1475,11 @@ var Zipper = class {
   }
 };
 
-// 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";
+// src/api/client.ts
+var import_axios = __toESM(require("axios"));
+var import_form_data = __toESM(require("form-data"));
 
-// ../clients/src/errors.ts
+// src/api/errors.ts
 var ApiError = class extends Error {
   data;
   constructor(data, options) {
@@ -411,44 +1489,20 @@ var ApiError = class extends Error {
   }
 };
 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) {
@@ -456,63 +1510,58 @@ var MissingResponseError = class extends Error {
     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
-    };
+function parseErrorData(data, statusCode) {
+  if (!data) return void 0;
+  if (typeof data === "object" && data !== null) {
+    const obj = data;
+    if (obj.statusCode && obj.error && obj.message) {
+      return {
+        statusCode: obj.statusCode,
+        error: obj.error,
+        message: obj.message,
+        errorCode: obj.errorCode
+      };
+    }
+    if (obj.error && obj.message) {
+      return {
+        statusCode,
+        error: obj.error,
+        message: obj.message,
+        errorCode: obj.errorCode
+      };
+    }
+    if (obj.error) {
+      return {
+        statusCode,
+        error: obj.error,
+        message: obj.error
+      };
+    }
+    if (obj.message) {
+      return {
+        statusCode,
+        error: obj.message,
+        message: obj.message,
+        errorCode: obj.errorCode
+      };
+    }
   }
   if (typeof data === "string") {
-    return {
-      statusCode: options.statusCode,
-      error: data,
-      message: data
-    };
+    return { 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"
-    });
+function handleErrorResponse(err2) {
+  const axiosError = err2;
+  if (!axiosError.response) {
+    throw new MissingResponseError(axiosError.message || "Network error");
   }
+  const { status, data } = axiosError.response;
+  const errorData = parseErrorData(data, status) ?? {
+    statusCode: status,
+    error: "Unknown error",
+    message: axiosError.message || "An error occurred"
+  };
   switch (status) {
     case 400:
       throw new ValidationError(errorData);
@@ -534,561 +1583,874 @@ function handleErrorResponse(err) {
   }
 }
 
-// ../clients/src/checkly-client.ts
-function getVersion() {
-  return "0.1.0";
-}
-function createRequestInterceptor(apiKey, accountId) {
-  return (config) => {
+// src/api/client.ts
+function createClient(options) {
+  const http = import_axios.default.create({
+    baseURL: options.baseUrl,
+    timeout: 12e4,
+    maxContentLength: Number.POSITIVE_INFINITY,
+    maxBodyLength: Number.POSITIVE_INFINITY
+  });
+  http.interceptors.request.use((config) => {
     if (config.headers) {
-      config.headers.Authorization = `Bearer ${apiKey}`;
-      config.headers["x-checkly-account"] = accountId;
-      config.headers["User-Agent"] = `@checkly/playwright-reporter/${getVersion()}`;
+      config.headers.Authorization = `Bearer ${options.apiKey}`;
+      config.headers["x-checkly-account"] = options.accountId;
+      config.headers["x-checkly-reporter-version"] = options.telemetry.reporterVersion;
+      config.headers["x-checkly-playwright-version"] = options.telemetry.playwrightVersion;
+      config.headers["x-checkly-ci-provider"] = options.telemetry.ciProvider;
+      config.headers["x-checkly-ci-environment"] = options.telemetry.ciEnvironment;
+      config.headers["x-checkly-node-version"] = options.telemetry.nodeVersion;
     }
     return config;
+  });
+  http.interceptors.response.use(
+    (response) => response,
+    (error) => handleErrorResponse(error)
+  );
+  return {
+    testSessions: {
+      async create(request) {
+        const response = await http.post("/next/test-sessions/create", request);
+        return response.data;
+      },
+      async uploadAsset(testSessionId, testResultId, assets) {
+        const form = new import_form_data.default();
+        form.append("assets", assets, { filename: "assets.zip", contentType: "application/zip" });
+        const response = await http.post(
+          `/next/test-sessions/${testSessionId}/results/${testResultId}/assets`,
+          form,
+          { headers: form.getHeaders() }
+        );
+        return response.data;
+      },
+      async updateResult(testSessionId, testResultId, request) {
+        const response = await http.post(
+          `/next/test-sessions/${testSessionId}/results/${testResultId}`,
+          request
+        );
+        return response.data;
+      }
+    }
   };
 }
-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;
+// src/extensions/checkly-upload.ts
+function getPackageVersion() {
+  try {
+    const packageJson = JSON.parse(fs5.readFileSync(path4.join(__dirname, "..", "package.json"), "utf-8"));
+    return packageJson.version;
+  } catch {
+    return "unknown";
   }
-  /**
-   * 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 = {
+  const urls = {
     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];
+  return urls[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"`);
+function getEnvironment() {
+  const env = process.env.CHECKLY_ENV || "production";
+  const valid = ["local", "development", "staging", "production"];
+  if (!valid.includes(env)) {
+    console.warn(`[Checkly] 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";
+  let name = path4.basename(cwd);
+  if (!name || name === "/" || name === ".") name = "playwright-tests";
+  name = name.replace(/[<>:"|?*]/g, "-");
+  if (name.length > 255) name = name.substring(0, 255);
+  return name;
+}
+function checklyUpload(options = {}) {
+  const apiKey = process.env.CHECKLY_API_KEY || options.apiKey;
+  const accountId = process.env.CHECKLY_ACCOUNT_ID || options.accountId;
+  const environment = getEnvironment();
+  const baseUrl = getApiUrl(environment);
+  const dryRun = options.dryRun ?? false;
+  const ciInfo = detectCI();
+  const reporterVersion = getPackageVersion();
+  const canUpload = !dryRun && apiKey && accountId;
+  let api;
+  let testSession;
+  let sessionCreationPromise;
+  let startTime;
+  let resolvedOutputDir;
+  let assetCollector;
+  let zipper;
+  const testCounts = { passed: 0, failed: 0, flaky: 0 };
+  const tracePathsMap = /* @__PURE__ */ new Map();
+  const warningsMap = /* @__PURE__ */ new Map();
+  const consoleMessagesMap = /* @__PURE__ */ new Map();
+  const networkRequestsMap = /* @__PURE__ */ new Map();
+  function resolveSessionName(ctx) {
+    const { sessionName } = options;
+    if (typeof sessionName === "function") return sessionName(ctx);
+    if (typeof sessionName === "string") return sessionName;
+    return `Playwright Test Session: ${ctx.directoryName}`;
   }
-  dirName = dirName.replace(/[<>:"|?*]/g, "-");
-  if (dirName.length > 255) {
-    dirName = dirName.substring(0, 255);
+  async function createSession(config, suite, log) {
+    if (!api) return;
+    try {
+      const directoryName = getDirectoryName();
+      const sessionName = resolveSessionName({ directoryName, config, suite });
+      const repoInfo = getGitHubRepoInfo();
+      log("\u{1F517} Creating test session", { name: sessionName, environment });
+      testSession = await api.testSessions.create({
+        name: sessionName,
+        environment: process.env.NODE_ENV || "test",
+        repoInfo,
+        startedAt: startTime.getTime(),
+        testResults: [{ name: directoryName }],
+        provider: "PW_REPORTER"
+      });
+      log("\u2705 Session created", { id: testSession.testSessionId });
+    } catch (err2) {
+      console.error("[Checkly] Failed to create test session:", err2);
+    }
   }
-  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
+  function checkTraceAttachment(test, result) {
+    const key = `${test.id}:${result.retry}`;
+    const traceAttachment = result.attachments?.find((a) => a.name === "trace" || a.contentType === "application/zip");
+    if (traceAttachment?.path) {
+      tracePathsMap.set(key, traceAttachment.path);
+      return;
+    }
+    const traceConfig = test.parent?.project()?.use?.trace;
+    const traceMode = typeof traceConfig === "object" ? traceConfig.mode : traceConfig;
+    if (!traceMode || traceMode === "off") return;
+    const warnings = warningsMap.get(key) || [];
+    warnings.push({ type: "trace-missing", message: `No trace found for trace mode "${traceMode}"` });
+    warningsMap.set(key, warnings);
+  }
+  async function extractTraceData(key, tracePath) {
+    const reader = new TraceReader(tracePath);
+    if (!await reader.open()) return;
+    const messages = await reader.extractEvents('"type":"console"', toConsoleMessage);
+    if (messages.length > 0) consoleMessagesMap.set(key, messages);
+    const requests = await reader.extractEvents('"type":"resource-snapshot"', toNetworkRequest);
+    if (requests.length > 0) networkRequestsMap.set(key, requests);
+  }
+  async function extractDataFromTraces(log) {
+    if (tracePathsMap.size === 0) return;
+    log("\u{1F4E6} Extracting trace data", { traces: tracePathsMap.size });
+    const extractions = Array.from(tracePathsMap.entries()).map(
+      ([key, tracePath]) => extractTraceData(key, tracePath).catch((err2) => {
+        console.error(`[Checkly] Failed to extract trace data: ${err2}`);
+      })
+    );
+    await Promise.all(extractions);
+  }
+  function buildChecklyExtensionData(key) {
+    const warnings = warningsMap.get(key);
+    const consoleMessages = consoleMessagesMap.get(key);
+    const network = networkRequestsMap.get(key);
+    if (!warnings?.length && !consoleMessages?.length && !network?.length) {
+      return null;
+    }
+    return {
+      ...warnings?.length ? { warnings } : {},
+      ...consoleMessages?.length ? { console: consoleMessages } : {},
+      ...network?.length ? { network } : {}
     };
-    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());
+  }
+  function injectDataIntoReport(report) {
+    function 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 checklyData = buildChecklyExtensionData(key);
+            if (checklyData) {
+              ;
+              result._checkly = checklyData;
+            }
+          }
+        }
+      }
+      suite.suites?.forEach(processSuite);
     }
+    report.suites.forEach(processSuite);
   }
-  /**
-   * 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);
+  function calculateTiming(report) {
+    const stats = report.stats;
+    if (stats?.startTime && stats?.duration !== void 0) {
+      const start = new Date(stats.startTime);
+      const responseTime = Math.round(stats.duration);
+      return {
+        startedAt: start.toISOString(),
+        stoppedAt: new Date(start.getTime() + responseTime).toISOString(),
+        responseTime
+      };
     }
-    if (typeof sessionName === "string") {
-      return sessionName;
+    const now = Date.now();
+    return {
+      startedAt: startTime?.toISOString() ?? (/* @__PURE__ */ new Date()).toISOString(),
+      stoppedAt: new Date(now).toISOString(),
+      responseTime: startTime ? Math.round(now - startTime.getTime()) : 0
+    };
+  }
+  async function uploadAssets(log, zipPath, zipSizeBytes) {
+    if (!api || !testSession || zipSizeBytes === 0) return void 0;
+    const firstResult = testSession.testResults[0];
+    if (!firstResult) return void 0;
+    log("\u{1F4E4} Uploading assets", { size: `${(zipSizeBytes / 1024).toFixed(1)}KB` });
+    try {
+      const assets = fs5.createReadStream(zipPath);
+      const uploadResponse = await api.testSessions.uploadAsset(
+        testSession.testSessionId,
+        firstResult.testResultId,
+        assets
+      );
+      log("\u2705 Assets uploaded", { assetId: uploadResponse.assetId });
+      return uploadResponse.assetId;
+    } catch (err2) {
+      console.error("[Checkly] Asset upload failed:", err2);
+      return void 0;
     }
-    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;
+  async function uploadResults(log, report, zipPath, entries) {
+    if (!api || !testSession || testSession.testResults.length === 0) return;
+    try {
+      const { failed, flaky } = testCounts;
+      const overallStatus = failed > 0 ? "FAILED" : "PASSED";
+      const isDegraded = failed === 0 && flaky > 0;
+      const timing = calculateTiming(report);
+      const zipSizeBytes = (await fs5.promises.stat(zipPath)).size;
+      const assetId = await uploadAssets(log, zipPath, zipSizeBytes);
+      const firstResult = testSession.testResults[0];
+      log("\u{1F4DD} Updating test result", { status: overallStatus, isDegraded });
+      await api.testSessions.updateResult(testSession.testSessionId, firstResult.testResultId, {
+        status: overallStatus,
+        assetEntries: assetId ? entries : void 0,
+        isDegraded,
+        ...timing,
+        metadata: { usageData: { s3PostTotalBytes: zipSizeBytes } }
+      });
+    } catch (err2) {
+      console.error("[Checkly] Failed to upload results:", err2);
     }
-    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 {
+    name: "checkly-upload",
+    onBegin: ({ config, suite, log }) => {
+      startTime = /* @__PURE__ */ new Date();
+      resolvedOutputDir = options.outputDir ?? config.projects[0]?.outputDir ?? "test-results";
+      const zipPath = path4.join(resolvedOutputDir, "checkly-report.zip");
+      assetCollector = new AssetCollector(resolvedOutputDir);
+      zipper = new Zipper({ outputPath: zipPath });
+      if (!canUpload) {
+        if (!dryRun && (!apiKey || !accountId)) {
+          log("\u26A0\uFE0F Skipping upload (missing API credentials)");
+        }
         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".';
+      }
+      api = createClient({
+        apiKey,
+        accountId,
+        baseUrl,
+        telemetry: {
+          reporterVersion,
+          playwrightVersion: config.version,
+          ciProvider: ciInfo.ciProvider,
+          ciEnvironment: ciInfo.environment,
+          nodeVersion: process.version
         }
-        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.`;
+      });
+      sessionCreationPromise = createSession(config, suite, log);
+    },
+    onTestEnd: ({ test, result }) => {
+      checkTraceAttachment(test, result);
+      const outcome = test.outcome();
+      const testIsComplete = result.retry === test.retries || outcome !== "unexpected";
+      if (!testIsComplete) return;
+      if (outcome === "flaky") {
+        testCounts.flaky++;
+        testCounts.passed++;
+      } else if (result.status === "passed") {
+        testCounts.passed++;
+      } else if (result.status === "failed" || result.status === "timedOut") {
+        testCounts.failed++;
+      }
+    },
+    onEnd: async ({ report, log, addSummaryLine }) => {
+      try {
+        if (sessionCreationPromise) {
+          await sessionCreationPromise;
         }
-        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".`;
+        await extractDataFromTraces(log);
+        injectDataIntoReport(report);
+        fs5.mkdirSync(resolvedOutputDir, { recursive: true });
+        const tempReportPath = path4.join(resolvedOutputDir, `.checkly-report-${Date.now()}.json`);
+        fs5.writeFileSync(tempReportPath, JSON.stringify(report, null, 2));
+        const assets = await assetCollector.collectAssets(report);
+        const zipResult = await zipper.createZip(tempReportPath, assets);
+        log("\u{1F4E6} ZIP created", { path: zipResult.zipPath, size: `${(zipResult.size / 1024).toFixed(1)}KB` });
+        if (api && testSession) {
+          await uploadResults(log, report, zipResult.zipPath, zipResult.entries);
+          if (!dryRun) {
+            try {
+              fs5.unlinkSync(zipResult.zipPath);
+            } catch {
+            }
+          }
+          if (testSession.link) {
+            addSummaryLine(`\u{1F517} Checkly Test Session: ${testSession.link}`);
+          }
         }
-        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".';
+        try {
+          fs5.unlinkSync(tempReportPath);
+        } catch {
         }
-        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.`;
+      } catch (err2) {
+        console.error("[Checkly] Error in onEnd:", err2);
+      }
     }
-    const warnings = this.warningsMap.get(warningsKey) || [];
-    warnings.push({ type: warningType, message });
-    this.warningsMap.set(warningsKey, warnings);
+  };
+}
+
+// src/reporter.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function getPackageVersion2() {
+  try {
+    const packageJson = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(__dirname, "..", "package.json"), "utf-8"));
+    return packageJson.version;
+  } catch {
+    return "unknown";
+  }
+}
+var pluralRules = new Intl.PluralRules("en-US");
+var projectForms = {
+  zero: "Project",
+  one: "Project",
+  two: "Projects",
+  few: "Projects",
+  many: "Projects",
+  other: "Projects"
+};
+var BaseReporter = class {
+  config;
+  suite;
+  startTime;
+  options;
+  verbose;
+  globalErrors = [];
+  tests = /* @__PURE__ */ new Map();
+  expectedCount = 0;
+  unexpectedCount = 0;
+  flakyCount = 0;
+  skippedCount = 0;
+  _report = null;
+  extensions = [];
+  summaryLines = [];
+  // Reconstructed projects for merge-reports scenarios
+  reconstructedProjects = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.options = options;
+    this.verbose = options.verbose ?? process.env.CHECKLY_REPORTER_VERBOSE === "true";
+  }
+  use(extension) {
+    this.extensions.push(extension);
+    return this;
+  }
+  log(message, data) {
+    if (!this.verbose) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[1].slice(0, 12);
+    const prefix = `[Checkly ${timestamp}]`;
+    if (data && Object.keys(data).length > 0) {
+      console.log(`${prefix} ${message}`, data);
+    } else {
+      console.log(`${prefix} ${message}`);
+    }
+  }
+  createExtensionLogger(extensionName) {
+    return (message, data) => {
+      this.log(`[${extensionName}] ${message}`, data);
+    };
   }
-  /**
-   * Called once before running tests
-   * Creates test session in Checkly if credentials provided
-   */
   onBegin(config, suite) {
+    const deprecated = ["outputFile", "testResultsDir", "outputPath"];
+    const opts = this.options;
+    for (const key of deprecated) {
+      if (key in opts && opts[key] !== void 0) {
+        throw new Error(`[Checkly] "${key}" option is no longer supported. Use outputDir instead.`);
+      }
+    }
+    this.config = config;
+    this.suite = suite;
     this.startTime = /* @__PURE__ */ new Date();
-    if (!this.testResults) {
-      return;
+    this.tests.clear();
+    this.globalErrors = [];
+    this.expectedCount = 0;
+    this.unexpectedCount = 0;
+    this.flakyCount = 0;
+    this.skippedCount = 0;
+    this._report = null;
+    this.reconstructedProjects.clear();
+    this.reconstructProjectsIfNeeded();
+    const testCount = this.countTests(suite);
+    const projectNames = config.projects.length > 0 ? config.projects.map((p) => p.name).join(", ") : Array.from(this.reconstructedProjects.keys()).join(", ") || "default";
+    this.log(`\u{1F3AC} Starting test run`, { tests: testCount, projects: projectNames, workers: config.workers });
+    for (const ext of this.extensions) {
+      ext.onBegin?.({ config, suite, log: this.createExtensionLogger(ext.name) });
     }
-    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);
+  }
+  onTestBegin(test, result) {
+    for (const ext of this.extensions) {
+      ext.onTestBegin?.({ test, result, log: this.createExtensionLogger(ext.name) });
+    }
+  }
+  onStepBegin(test, result, step) {
+    for (const ext of this.extensions) {
+      ext.onStepBegin?.({ test, result, step, log: this.createExtensionLogger(ext.name) });
+    }
+  }
+  onStepEnd(test, result, step) {
+    for (const ext of this.extensions) {
+      ext.onStepEnd?.({ test, result, step, log: this.createExtensionLogger(ext.name) });
     }
   }
-  /**
-   * 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 testId = test.id;
+    let testData = this.tests.get(testId);
+    if (!testData) {
+      testData = { testCase: test, results: [] };
+      this.tests.set(testId, testData);
+    }
+    testData.results.push(result);
+    for (const ext of this.extensions) {
+      ext.onTestEnd?.({ test, result, log: this.createExtensionLogger(ext.name) });
+    }
+  }
+  onStdOut(chunk, test, result) {
+    for (const ext of this.extensions) {
+      ext.onStdOut?.({ chunk, test, result, log: this.createExtensionLogger(ext.name) });
+    }
+  }
+  onStdErr(chunk, test, result) {
+    for (const ext of this.extensions) {
+      ext.onStdErr?.({ chunk, test, result, log: this.createExtensionLogger(ext.name) });
+    }
+  }
+  onError(error) {
+    this.globalErrors.push(error);
+    this.log(`\u{1F4A5} Global error`, { message: error.message?.slice(0, 100) });
+    for (const ext of this.extensions) {
+      ext.onError?.({ error, log: this.createExtensionLogger(ext.name) });
+    }
+  }
+  async onEnd(result) {
+    for (const testData of this.tests.values()) {
+      switch (testData.testCase.outcome()) {
+        case "expected":
+          this.expectedCount++;
+          break;
+        case "unexpected":
+          this.unexpectedCount++;
+          break;
+        case "flaky":
+          this.flakyCount++;
+          break;
+        case "skipped":
+          this.skippedCount++;
+          break;
       }
-      const outcome = test.outcome();
-      const testIsComplete = result.retry === test.retries || outcome !== "unexpected";
-      if (!testIsComplete) {
-        return;
+    }
+    this._report = this.buildReport(result);
+    this.log(`\u{1F3C1} Test run finished`, {
+      status: result.status,
+      duration: `${result.duration}ms`,
+      passed: this.expectedCount,
+      failed: this.unexpectedCount,
+      flaky: this.flakyCount,
+      skipped: this.skippedCount
+    });
+    const outputDir = this.options.outputDir;
+    if (outputDir) {
+      const fs6 = await import("fs");
+      fs6.mkdirSync(outputDir, { recursive: true });
+      const outputPath = `${outputDir}/checkly-report.json`;
+      fs6.writeFileSync(outputPath, JSON.stringify(this._report, null, 2));
+      this.log(`\u{1F4C4} Report saved`, { path: outputPath });
+    }
+    for (const ext of this.extensions) {
+      await ext.onEnd?.({
+        result,
+        report: this._report,
+        log: this.createExtensionLogger(ext.name),
+        addSummaryLine: (line) => this.summaryLines.push(line)
+      });
+    }
+    this.printSummary();
+  }
+  async onExit() {
+    this.log(`\u{1F44B} Reporter exiting`);
+    for (const ext of this.extensions) {
+      await ext.onExit?.({ log: this.createExtensionLogger(ext.name) });
+    }
+  }
+  printsToStdio() {
+    return false;
+  }
+  getReport() {
+    if (this._report) return this._report;
+    return this.buildReport({
+      status: "passed",
+      startTime: this.startTime,
+      duration: Date.now() - this.startTime.getTime()
+    });
+  }
+  buildReport(fullResult) {
+    return {
+      config: this.serializeConfig(),
+      suites: this.serializeSuites(),
+      errors: this.globalErrors.map((e) => this.serializeError(e, true)),
+      stats: {
+        startTime: this.startTime.toISOString(),
+        duration: fullResult.duration,
+        expected: this.expectedCount,
+        unexpected: this.unexpectedCount,
+        flaky: this.flakyCount,
+        skipped: this.skippedCount
       }
-      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++;
+    };
+  }
+  reconstructProjectsIfNeeded() {
+    if (this.config.projects.length > 0) {
+      return;
+    }
+    this.log("\u{1F504} Detected merge-reports scenario (empty config.projects), reconstructing projects");
+    for (const projectSuite of this.suite.suites) {
+      const project = projectSuite.project();
+      if (project) {
+        const name = project.name || "default";
+        if (!this.reconstructedProjects.has(name)) {
+          this.reconstructedProjects.set(name, {
+            id: name,
+            name,
+            testDir: project.testDir,
+            outputDir: project.outputDir,
+            timeout: project.timeout,
+            retries: project.retries,
+            repeatEach: project.repeatEach,
+            metadata: project.metadata ?? {},
+            testMatch: Array.isArray(project.testMatch) ? project.testMatch.map(String) : [String(project.testMatch)],
+            testIgnore: Array.isArray(project.testIgnore) ? project.testIgnore.map(String) : [String(project.testIgnore)]
+          });
         }
       }
-    } catch (error) {
-      console.error("[Checkly Reporter] Error in onTestEnd:", error);
     }
+    if (this.reconstructedProjects.size === 0) {
+      this.collectProjectsFromTests(this.suite);
+    }
+    this.log("\u{1F504} Reconstructed projects", {
+      count: this.reconstructedProjects.size,
+      names: Array.from(this.reconstructedProjects.keys())
+    });
   }
-  /**
-   * 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}`);
-          }
+  collectProjectsFromTests(suite) {
+    for (const test of suite.allTests()) {
+      const project = test.parent.project();
+      const projectName = project?.name || "default";
+      if (!this.reconstructedProjects.has(projectName)) {
+        if (project) {
+          this.reconstructedProjects.set(projectName, {
+            id: projectName,
+            name: projectName,
+            testDir: project.testDir,
+            outputDir: project.outputDir,
+            timeout: project.timeout,
+            retries: project.retries,
+            repeatEach: project.repeatEach,
+            metadata: project.metadata ?? {},
+            testMatch: Array.isArray(project.testMatch) ? project.testMatch.map(String) : [String(project.testMatch)],
+            testIgnore: Array.isArray(project.testIgnore) ? project.testIgnore.map(String) : [String(project.testIgnore)]
+          });
+        } else {
+          this.reconstructedProjects.set(projectName, {
+            id: projectName,
+            name: projectName,
+            testDir: "",
+            outputDir: "",
+            timeout: 0,
+            retries: 0,
+            repeatEach: 1,
+            metadata: {},
+            testMatch: [],
+            testIgnore: []
+          });
         }
       }
-      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======================================================");
+  serializeConfig() {
+    const c = this.config;
+    const projects = c.projects.length > 0 ? c.projects.map((p) => this.serializeProject(p)) : Array.from(this.reconstructedProjects.values());
+    return {
+      rootDir: c.rootDir,
+      configFile: c.configFile ?? void 0,
+      version: c.version,
+      workers: c.workers,
+      fullyParallel: c.fullyParallel,
+      forbidOnly: c.forbidOnly,
+      globalTimeout: c.globalTimeout,
+      maxFailures: c.maxFailures,
+      metadata: c.metadata ?? {},
+      projects,
+      shard: c.shard ?? null,
+      tags: c.tags ?? [],
+      updateSourceMethod: c.updateSourceMethod,
+      preserveOutput: c.preserveOutput,
+      quiet: c.quiet,
+      reportSlowTests: c.reportSlowTests ?? null,
+      webServer: c.webServer ?? null,
+      globalSetup: c.globalSetup ?? null,
+      globalTeardown: c.globalTeardown ?? null,
+      grep: c.grep,
+      grepInvert: c.grepInvert,
+      reporter: c.reporter,
+      updateSnapshots: c.updateSnapshots
+    };
   }
-  /**
-   * 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);
+  serializeProject(p) {
+    return {
+      id: p.name,
+      name: p.name,
+      testDir: p.testDir,
+      outputDir: p.outputDir,
+      timeout: p.timeout,
+      retries: p.retries,
+      repeatEach: p.repeatEach,
+      metadata: p.metadata ?? {},
+      testMatch: Array.isArray(p.testMatch) ? p.testMatch.map(String) : [String(p.testMatch)],
+      testIgnore: Array.isArray(p.testIgnore) ? p.testIgnore.map(String) : [String(p.testIgnore)]
+    };
+  }
+  serializeSuites() {
+    const fileSuites = /* @__PURE__ */ new Map();
+    for (const projectSuite of this.suite.suites) {
+      for (const fileSuite of projectSuite.suites) {
+        const file = fileSuite.location?.file;
+        if (!file) continue;
+        const fileName = this.getFileName(file);
+        const serialized = this.serializeSuite(fileSuite, fileName);
+        if (!serialized) continue;
+        const existing = fileSuites.get(file);
+        if (existing) {
+          this.mergeSuites(existing, serialized);
+        } else {
+          fileSuites.set(file, serialized);
         }
       }
-    };
-    for (const suite of report.suites) {
-      processSuite(suite);
     }
-    this.reconstructProjectsFromTests(report);
+    return Array.from(fileSuites.values());
   }
-  /**
-   * Reconstructs config.projects and test.projectId from test data
-   * This is necessary for blob merge scenarios where Playwright's JSON reporter
-   * doesn't populate projects array or projectId fields
-   */
-  reconstructProjectsFromTests(report) {
-    const projectNames = /* @__PURE__ */ new Set();
-    const collectProjectNames = (suite) => {
-      for (const spec of suite.specs) {
-        for (const test of spec.tests) {
-          const testAny = test;
-          if (testAny.projectName) {
-            projectNames.add(testAny.projectName);
-          }
-          if (testAny.projectName && !testAny.projectId) {
-            testAny.projectId = testAny.projectName;
-          }
-        }
+  serializeSuite(suite, fileName) {
+    const allTests = suite.allTests();
+    if (allTests.length === 0) return null;
+    const childSuites = [];
+    for (const child of suite.suites) {
+      const serialized = this.serializeSuite(child, fileName);
+      if (serialized) childSuites.push(serialized);
+    }
+    const specs = [];
+    for (const test of suite.tests) {
+      const testData = this.tests.get(test.id);
+      if (testData) {
+        specs.push(this.serializeSpec(testData));
       }
-      if (suite.suites) {
-        for (const nestedSuite of suite.suites) {
-          collectProjectNames(nestedSuite);
-        }
+    }
+    return {
+      title: suite.title || fileName,
+      file: fileName,
+      line: suite.location?.line ?? 0,
+      column: suite.location?.column ?? 0,
+      specs,
+      suites: childSuites.length ? childSuites : void 0
+    };
+  }
+  mergeSuites(to, from) {
+    for (const fromSuite of from.suites || []) {
+      const toSuite = to.suites?.find(
+        (s) => s.title === fromSuite.title && s.line === fromSuite.line && s.column === fromSuite.column
+      );
+      if (toSuite) {
+        this.mergeSuites(toSuite, fromSuite);
+      } else {
+        to.suites = to.suites ?? [];
+        to.suites.push(fromSuite);
       }
+    }
+    to.specs.push(...from.specs);
+  }
+  serializeSpec(data) {
+    const { testCase } = data;
+    const outcome = testCase.outcome();
+    return {
+      id: testCase.id,
+      title: testCase.title,
+      file: this.getFileName(testCase.location.file),
+      line: testCase.location.line,
+      column: testCase.location.column,
+      tags: this.extractTags(testCase),
+      ok: outcome === "expected" || outcome === "flaky" || outcome === "skipped",
+      tests: [this.serializeTest(data)]
+    };
+  }
+  extractTags(testCase) {
+    const runtimeTags = testCase.tags;
+    if (runtimeTags && runtimeTags.length > 0) {
+      return runtimeTags.map((t) => t.replace(/^@/, ""));
+    }
+    const titleTags = testCase.title.match(/@[\w-]+/g);
+    return titleTags?.map((t) => t.replace(/^@/, "")) ?? [];
+  }
+  serializeTest(data) {
+    const { testCase, results } = data;
+    const projectName = this.getProjectName(testCase);
+    return {
+      projectId: projectName,
+      projectName,
+      timeout: testCase.timeout,
+      expectedStatus: testCase.expectedStatus,
+      annotations: this.serializeAnnotations(testCase.annotations),
+      results: results.map((r) => this.serializeTestResult(r)),
+      status: this.mapOutcome(testCase.outcome())
     };
-    for (const suite of report.suites) {
-      collectProjectNames(suite);
+  }
+  getProjectName(testCase) {
+    const project = testCase.parent.project();
+    if (project && typeof project.name === "string") {
+      return project.name;
     }
-    const configAny = report.config;
-    if ((!configAny.projects || configAny.projects.length === 0) && projectNames.size > 0) {
-      configAny.projects = Array.from(projectNames).map((name) => ({
-        id: name,
-        name
-      }));
+    let current = testCase.parent;
+    while (current) {
+      const suiteProject = current.project();
+      if (suiteProject && typeof suiteProject.name === "string") {
+        return suiteProject.name;
+      }
+      current = current.parent;
     }
+    return "default";
   }
-  /**
-   * Uploads test results to Checkly API
-   */
-  async uploadResults(report, zipPath, entries) {
-    if (!this.testResults || !this.testSession) {
-      return;
+  serializeTestResult(r) {
+    return {
+      workerIndex: r.workerIndex,
+      parallelIndex: r.parallelIndex ?? 0,
+      status: r.status,
+      duration: r.duration,
+      startTime: r.startTime.toISOString(),
+      retry: r.retry,
+      errors: r.errors.map((e) => this.serializeError(e, true)),
+      error: r.error ? this.serializeError(r.error, false) : void 0,
+      errorLocation: r.error?.location,
+      stdout: r.stdout.map(
+        (s) => typeof s === "string" ? { text: s } : Buffer.isBuffer(s) ? { buffer: s.toString("base64") } : s
+      ),
+      stderr: r.stderr.map(
+        (s) => typeof s === "string" ? { text: s } : Buffer.isBuffer(s) ? { buffer: s.toString("base64") } : s
+      ),
+      attachments: r.attachments.map((a) => ({
+        name: a.name,
+        contentType: a.contentType,
+        path: a.path,
+        body: a.body ? a.body.toString("base64") : void 0
+      })),
+      steps: r.steps.map((s) => this.serializeStep(s)),
+      annotations: this.serializeAnnotations(
+        r.annotations ?? []
+      )
+    };
+  }
+  serializeStep(step) {
+    return {
+      title: step.title,
+      duration: step.duration,
+      error: step.error ? this.serializeError(step.error, false) : void 0,
+      steps: step.steps?.map((s) => this.serializeStep(s))
+    };
+  }
+  serializeError(error, includeContext) {
+    if (error.value !== void 0) {
+      return { message: error.value, value: error.value };
     }
-    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
-            }
-          }
-        });
+    let msg = error.message ?? "Unknown error";
+    if (includeContext && !/^(\w+Error|Error):/.test(msg)) {
+      msg = "Error: " + msg;
+    }
+    if (includeContext) {
+      if (error.snippet) msg += "\n\n" + error.snippet;
+      if (error.stack) {
+        const frames = error.stack.split("\n").filter((l) => l.trim().startsWith("at "));
+        if (frames.length) msg += "\n" + frames.join("\n");
+      } else if (error.location) {
+        msg += `
+    at ${error.location.file}:${error.location.line}:${error.location.column}`;
       }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("[Checkly Reporter] Failed to upload results:", errorMessage);
     }
+    return {
+      message: msg,
+      location: error.location,
+      stack: error.stack,
+      snippet: error.snippet
+    };
   }
-  /**
-   * Called when a global error occurs
-   */
-  onError(error) {
-    console.error("[Checkly Reporter] Global error:", error);
+  serializeAnnotations(annotations) {
+    return annotations.map((a) => ({ type: a.type, description: a.description, location: a.location }));
+  }
+  countTests(suite) {
+    let count = suite.tests?.length ?? 0;
+    for (const child of suite.suites ?? []) {
+      count += this.countTests(child);
+    }
+    return count;
+  }
+  getFileName(filePath) {
+    return filePath.split("/").pop() ?? filePath;
+  }
+  mapOutcome(outcome) {
+    if (outcome === "expected" || outcome === "unexpected" || outcome === "flaky" || outcome === "skipped") {
+      return outcome;
+    }
+    return "unexpected";
+  }
+  printSummary() {
+    const pkgVersion = getPackageVersion2();
+    const playwrightVersion = this.config.version;
+    const projectNames = this.config.projects.length > 0 ? this.config.projects.map((p) => p.name).join(", ") : Array.from(this.reconstructedProjects.keys()).join(", ") || "default";
+    const projectCount = this.config.projects.length > 0 ? this.config.projects.length : this.reconstructedProjects.size || 1;
+    const rule = pluralRules.select(projectCount);
+    console.log("\n======================================================\n");
+    console.log(`\u{1F99D} Checkly reporter: ${pkgVersion}`);
+    console.log(`\u{1F3AD} Playwright: ${playwrightVersion}`);
+    console.log(`\u{1F4D4} ${projectForms[rule]}: ${projectNames}`);
+    for (const line of this.summaryLines) {
+      console.log(line);
+    }
+    console.log("\n======================================================");
   }
 };
-export {
-  AssetCollector,
-  ChecklyReporter,
-  Zipper,
-  ChecklyReporter as default
+
+// src/index.ts
+var ChecklyReporter = class extends BaseReporter {
+  constructor(options = {}) {
+    super(options);
+    this.use(checklyUpload(options));
+  }
 };
+var index_default = ChecklyReporter;
+function createChecklyReporter(options = {}) {
+  return ["@checkly/playwright-reporter", options];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createChecklyReporter
+});