@qualflare/playwright 0.1.0

package/dist/reporter/index.js

@@ -0,0 +1,916 @@
+// src/reporter/reporter.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/shared/constants.ts
+var RESERVED_MESSAGE_MEDIA_TYPE = "application/vnd.qualflare.message+json";
+var MAX_SUITES_PER_LAUNCH = 2e3;
+var MAX_CASES_PER_SUITE = 5e3;
+var MAX_ATTACHMENTS_PER_CASE = 50;
+var MAX_LABELS_PER_CASE = 100;
+var MAX_LINKS_PER_CASE = 20;
+var MAX_TAGS_PER_CASE = 64;
+var MAX_TAG_LENGTH = 255;
+var MAX_VIDEO_UPLOAD_BYTES = 50 * 1024 * 1024;
+var MAX_STEPS_PER_TEST_ATTEMPT = 300;
+
+// src/config/ci-detect.ts
+import * as ciInfo from "ci-info";
+function parsePositiveInt(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 1 ? n : void 0;
+}
+function nonEmpty(raw) {
+  return raw && raw.length > 0 ? raw : void 0;
+}
+var PROVIDERS = [
+  {
+    detect: (env) => env.GITHUB_ACTIONS === "true",
+    providerName: "GitHub Actions",
+    buildNumber: (env) => nonEmpty(env.GITHUB_RUN_NUMBER),
+    runUrl: (env) => env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY && env.GITHUB_RUN_ID ? `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}` : void 0,
+    prNumber: (env) => {
+      const match = /^refs\/pull\/(\d+)\/merge$/.exec(env.GITHUB_REF ?? "");
+      return match ? parsePositiveInt(match[1]) : void 0;
+    }
+  },
+  {
+    detect: (env) => env.GITLAB_CI === "true",
+    providerName: "GitLab CI",
+    buildNumber: (env) => nonEmpty(env.CI_PIPELINE_IID),
+    runUrl: (env) => nonEmpty(env.CI_PIPELINE_URL),
+    prNumber: (env) => parsePositiveInt(env.CI_MERGE_REQUEST_IID)
+  },
+  {
+    detect: (env) => env.CIRCLECI === "true",
+    providerName: "CircleCI",
+    buildNumber: (env) => nonEmpty(env.CIRCLE_BUILD_NUM),
+    runUrl: (env) => nonEmpty(env.CIRCLE_BUILD_URL),
+    prNumber: (env) => parsePositiveInt(env.CIRCLE_PR_NUMBER)
+  },
+  {
+    detect: (env) => env.BUILDKITE === "true",
+    providerName: "Buildkite",
+    buildNumber: (env) => nonEmpty(env.BUILDKITE_BUILD_NUMBER),
+    runUrl: (env) => nonEmpty(env.BUILDKITE_BUILD_URL),
+    prNumber: (env) => {
+      const raw = env.BUILDKITE_PULL_REQUEST;
+      if (!raw || raw === "false") {
+        return void 0;
+      }
+      return parsePositiveInt(raw);
+    }
+  },
+  {
+    // Jenkins has no simple `JENKINS=true`-style flag; JENKINS_URL is always
+    // set by the Jenkins agent and is the conventional detection signal.
+    detect: (env) => Boolean(env.JENKINS_URL),
+    providerName: "Jenkins",
+    buildNumber: (env) => nonEmpty(env.BUILD_NUMBER),
+    runUrl: (env) => nonEmpty(env.BUILD_URL)
+    // Jenkins has no standardized PR-number env var across its many PR
+    // plugins (Multibranch, GitHub Branch Source, etc.) — deliberately
+    // omitted rather than guessing at a plugin-specific variable.
+  },
+  {
+    detect: (env) => env.TF_BUILD === "True" || env.TF_BUILD === "true",
+    providerName: "Azure Pipelines",
+    buildNumber: (env) => nonEmpty(env.BUILD_BUILDID),
+    runUrl: (env) => {
+      const collectionUri = env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI;
+      const project = env.SYSTEM_TEAMPROJECT;
+      const buildId = env.BUILD_BUILDID;
+      if (!collectionUri || !project || !buildId) {
+        return void 0;
+      }
+      return `${collectionUri.replace(/\/+$/, "")}/${encodeURIComponent(project)}/_build/results?buildId=${buildId}`;
+    },
+    prNumber: (env) => parsePositiveInt(env.SYSTEM_PULLREQUEST_PULLREQUESTNUMBER)
+  },
+  {
+    detect: (env) => Boolean(env.BITBUCKET_BUILD_NUMBER),
+    providerName: "Bitbucket Pipelines",
+    buildNumber: (env) => nonEmpty(env.BITBUCKET_BUILD_NUMBER),
+    runUrl: (env) => {
+      const origin = env.BITBUCKET_GIT_HTTP_ORIGIN;
+      if (!origin) {
+        return void 0;
+      }
+      const resultsId = env.BITBUCKET_PIPELINE_UUID ?? env.BITBUCKET_BUILD_NUMBER;
+      return resultsId ? `${origin}/addon/pipelines/home#!/results/${resultsId}` : void 0;
+    },
+    prNumber: (env) => parsePositiveInt(env.BITBUCKET_PR_ID)
+  }
+];
+function detectCi(env = process.env) {
+  const provider = PROVIDERS.find((p) => p.detect(env));
+  if (provider) {
+    const result = { ciProvider: provider.providerName };
+    const buildNumber = provider.buildNumber?.(env);
+    if (buildNumber !== void 0) result.ciBuildNumber = buildNumber;
+    const runUrl = provider.runUrl?.(env);
+    if (runUrl !== void 0) result.ciRunUrl = runUrl;
+    const prNumber = provider.prNumber?.(env);
+    if (prNumber !== void 0) result.ciPrNumber = prNumber;
+    return result;
+  }
+  if (ciInfo.name) {
+    return { ciProvider: ciInfo.name };
+  }
+  return {};
+}
+
+// src/config/git-detect.ts
+import { execFileSync } from "child_process";
+var defaultExecGit = (args, cwd) => execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+function firstEnv(env, ...names) {
+  for (const name2 of names) {
+    const value = env[name2];
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function detectBranchFromGit(exec, cwd) {
+  try {
+    const out = exec(["symbolic-ref", "--short", "-q", "HEAD"], cwd).trim();
+    return out || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectCommitFromGit(exec, cwd) {
+  try {
+    const out = exec(["rev-parse", "HEAD"], cwd).trim();
+    return out || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectGit(env = process.env, cwd = process.cwd(), exec = defaultExecGit) {
+  const branch = firstEnv(env, "GIT_BRANCH", "GITHUB_REF_NAME", "CI_COMMIT_REF_NAME", "BITBUCKET_BRANCH") ?? detectBranchFromGit(exec, cwd);
+  const commit = firstEnv(env, "GIT_COMMIT", "GITHUB_SHA", "CI_COMMIT_SHA", "BITBUCKET_COMMIT") ?? detectCommitFromGit(exec, cwd);
+  const result = {};
+  if (branch !== void 0) result.branch = branch;
+  if (commit !== void 0) result.commit = commit;
+  return result;
+}
+
+// src/config/resolve-config.ts
+function firstEnv2(...names) {
+  for (const name2 of names) {
+    const value = process.env[name2];
+    if (value !== void 0 && value !== "") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function envBool(...names) {
+  const raw = firstEnv2(...names);
+  if (raw === void 0) {
+    return void 0;
+  }
+  return raw === "true" || raw === "1";
+}
+function envInt(...names) {
+  const raw = firstEnv2(...names);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function resolveConfig(options, deps = {}) {
+  const doDetectGit = deps.detectGit ?? detectGit;
+  const doDetectCi = deps.detectCi ?? detectCi;
+  const enabled = options.enabled ?? envBool("QUALFLARE_ENABLED") ?? true;
+  const outputDir = options.outputDir || firstEnv2("QUALFLARE_OUTPUT_DIR") || "./qualflare-results";
+  const shardIndex = options.shardIndex ?? envInt("QUALFLARE_SHARD_INDEX") ?? deps.detectedShardIndex;
+  const milestoneRaw = options.milestone !== void 0 ? options.milestone : envInt("QUALFLARE_MILESTONE", "QF_MILESTONE");
+  const milestone = milestoneRaw !== void 0 && milestoneRaw !== null && milestoneRaw >= 1 ? milestoneRaw : null;
+  const envBranch = firstEnv2("QUALFLARE_BRANCH", "QF_BRANCH");
+  const envCommit = firstEnv2("QUALFLARE_COMMIT", "QF_COMMIT");
+  const needsGitDetection = options.branch === void 0 && envBranch === void 0 || options.commit === void 0 && envCommit === void 0;
+  const detectedGit = needsGitDetection ? doDetectGit() : {};
+  const branch = options.branch !== void 0 ? options.branch : envBranch ?? detectedGit.branch ?? null;
+  const commit = options.commit !== void 0 ? options.commit : envCommit ?? detectedGit.commit ?? null;
+  const detectedCi = doDetectCi();
+  const ciProvider = options.ciProvider ?? detectedCi.ciProvider;
+  const ciBuildNumber = options.ciBuildNumber ?? detectedCi.ciBuildNumber;
+  const ciRunUrl = options.ciRunUrl ?? detectedCi.ciRunUrl;
+  const ciPrNumber = options.ciPrNumber ?? detectedCi.ciPrNumber;
+  return {
+    // `||` (truthy check), not `??`, for these three REQUIRED-non-empty wire
+    // fields — an explicit `''` option must not silently win over the
+    // default (the server rejects an empty `environment`). Ported verbatim from
+    // qualflare-cypress, where this was found via deep adversarial review.
+    environment: (options.environment || void 0) ?? firstEnv2("QUALFLARE_ENVIRONMENT", "QF_ENVIRONMENT") ?? "development",
+    language: (options.language || void 0) ?? firstEnv2("QUALFLARE_LANGUAGE", "QF_LANGUAGE") ?? "en-US",
+    milestone,
+    branch,
+    commit,
+    platform: options.platform ?? "web",
+    framework: options.framework || "playwright",
+    os: options.os,
+    browser: options.browser,
+    properties: options.properties,
+    ciProvider,
+    ciBuildNumber,
+    ciRunUrl,
+    ciPrNumber,
+    attachScreenshots: options.attachScreenshots ?? envBool("QUALFLARE_ATTACH_SCREENSHOTS") ?? true,
+    includeApiSteps: options.includeApiSteps ?? envBool("QUALFLARE_INCLUDE_API_STEPS") ?? false,
+    maxAttachmentBytes: options.maxAttachmentBytes ?? envInt("QUALFLARE_MAX_ATTACHMENT_BYTES") ?? 15e5,
+    maxTotalAttachmentBytes: options.maxTotalAttachmentBytes ?? envInt("QUALFLARE_MAX_TOTAL_ATTACHMENT_BYTES") ?? 75e4,
+    maxVideoBytes: options.maxVideoBytes ?? envInt("QUALFLARE_MAX_VIDEO_BYTES") ?? MAX_VIDEO_UPLOAD_BYTES,
+    debug: options.debug ?? envBool("QUALFLARE_DEBUG", "QF_DEBUG") ?? false,
+    enabled,
+    outputDir,
+    shardIndex
+  };
+}
+
+// src/shared/logger.ts
+var PREFIX = "[qualflare-playwright]";
+var logger = {
+  debug(...args) {
+    console.debug(PREFIX, ...args);
+  },
+  info(...args) {
+    console.log(PREFIX, ...args);
+  },
+  warn(...args) {
+    console.warn(PREFIX, ...args);
+  },
+  error(...args) {
+    console.error(PREFIX, ...args);
+  }
+};
+
+// src/reporter/attachment-reader.ts
+import * as fs2 from "fs";
+
+// src/reporter/video-writer.ts
+import * as fs from "fs";
+import * as path from "path";
+import { randomUUID } from "crypto";
+var VIDEO_MIME_TYPES_BY_EXTENSION = {
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime"
+};
+function copyVideoAttachment(filePath, outputDir, maxVideoBytes) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType = VIDEO_MIME_TYPES_BY_EXTENSION[ext];
+  if (!mimeType) {
+    logger.warn(`skipping video attachment "${filePath}": unsupported video format.`);
+    return void 0;
+  }
+  let fileSize;
+  try {
+    fileSize = fs.statSync(filePath).size;
+  } catch (err) {
+    logger.warn(`skipping video attachment "${filePath}": could not stat file: ${err.message}`);
+    return void 0;
+  }
+  if (fileSize > maxVideoBytes) {
+    logger.warn(
+      `skipping video attachment "${filePath}": ${fileSize} bytes exceeds the configured maxVideoBytes cap of ${maxVideoBytes} bytes.`
+    );
+    return void 0;
+  }
+  const localVideoPath = `${randomUUID()}${ext}`;
+  try {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.copyFileSync(filePath, path.join(outputDir, localVideoPath));
+  } catch (err) {
+    logger.warn(`skipping video attachment "${filePath}": could not copy file: ${err.message}`);
+    return void 0;
+  }
+  return { localVideoPath, fileSize, mimeType };
+}
+
+// src/reporter/attachment-reader.ts
+var AttachmentBudget = class {
+  constructor(maxTotalBytes) {
+    this.maxTotalBytes = maxTotalBytes;
+  }
+  maxTotalBytes;
+  used = 0;
+  tryReserve(bytes) {
+    if (this.used + bytes > this.maxTotalBytes) {
+      return false;
+    }
+    this.used += bytes;
+    return true;
+  }
+  /** Returns bytes to the budget when the attachment they were reserved for
+   * turns out to be discarded — a retried test's superseded attempt. Without
+   * this, a flaky test consumes budget twice and a LATER test silently loses
+   * its screenshot to an attachment nobody will ever see. */
+  release(bytes) {
+    this.used = Math.max(0, this.used - bytes);
+  }
+  get usedBytes() {
+    return this.used;
+  }
+};
+var NAME_VIDEO = "video";
+var NAME_TRACE = "trace";
+function isVideo(a) {
+  return a.name === NAME_VIDEO || (a.contentType?.startsWith("video/") ?? false);
+}
+function resolveAttachments(result, config, budget) {
+  if (!config.attachScreenshots) {
+    return [];
+  }
+  const out = [];
+  let capWarned = false;
+  for (const a of result.attachments) {
+    if (a.contentType === RESERVED_MESSAGE_MEDIA_TYPE) {
+      continue;
+    }
+    if (out.length >= MAX_ATTACHMENTS_PER_CASE) {
+      if (!capWarned) {
+        capWarned = true;
+        logger.warn(`a test produced more than ${MAX_ATTACHMENTS_PER_CASE} attachments; the rest were dropped.`);
+      }
+      break;
+    }
+    if (a.name === NAME_TRACE || a.contentType === "application/zip") {
+      continue;
+    }
+    if (isVideo(a)) {
+      if (!a.path) {
+        logger.warn(`skipping in-memory video attachment "${a.name}": only file-backed videos are supported.`);
+        continue;
+      }
+      const copied = copyVideoAttachment(a.path, config.outputDir, config.maxVideoBytes);
+      if (copied) {
+        out.push({
+          name: a.name,
+          mimeType: copied.mimeType,
+          localVideoPath: copied.localVideoPath,
+          fileSize: copied.fileSize
+        });
+      }
+      continue;
+    }
+    const inlined = inlineAttachment(a, config, budget);
+    if (inlined) {
+      out.push(inlined);
+    }
+  }
+  return out;
+}
+function inlineFromBuffer(name2, bytes, mimeType, config, budget) {
+  if (bytes.byteLength > config.maxAttachmentBytes) {
+    logger.warn(
+      `skipping attachment "${name2}": ${bytes.byteLength} bytes exceeds the configured maxAttachmentBytes cap of ${config.maxAttachmentBytes} bytes.`
+    );
+    return void 0;
+  }
+  if (!budget.tryReserve(bytes.byteLength)) {
+    logger.warn(
+      `skipping attachment "${name2}": this run's total inline-attachment budget of ${config.maxTotalAttachmentBytes} bytes is exhausted.`
+    );
+    return void 0;
+  }
+  return {
+    name: name2,
+    ...mimeType ? { mimeType } : {},
+    content: bytes.toString("base64"),
+    fileSize: bytes.byteLength
+  };
+}
+function inlineFromFile(name2, filePath, mimeType, config, budget) {
+  let size;
+  try {
+    size = fs2.statSync(filePath).size;
+  } catch (err) {
+    logger.warn(`skipping attachment "${name2}": could not stat ${filePath}: ${err.message}`);
+    return void 0;
+  }
+  if (size > config.maxAttachmentBytes) {
+    logger.warn(
+      `skipping attachment "${name2}": ${size} bytes exceeds the configured maxAttachmentBytes cap of ${config.maxAttachmentBytes} bytes.`
+    );
+    return void 0;
+  }
+  let bytes;
+  try {
+    bytes = fs2.readFileSync(filePath);
+  } catch (err) {
+    logger.warn(`skipping attachment "${name2}": could not read ${filePath}: ${err.message}`);
+    return void 0;
+  }
+  return inlineFromBuffer(name2, bytes, mimeType, config, budget);
+}
+function inlineAttachment(a, config, budget) {
+  if (a.body) {
+    return inlineFromBuffer(a.name, a.body, a.contentType, config, budget);
+  }
+  if (a.path) {
+    return inlineFromFile(a.name, a.path, a.contentType, config, budget);
+  }
+  return void 0;
+}
+
+// src/shared/duration.ts
+var NS_PER_MS = 1e6;
+function msToNs(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return 0;
+  }
+  return Math.round(ms * NS_PER_MS);
+}
+
+// src/reporter/step-mapper.ts
+var CATEGORY_TEST_STEP = "test.step";
+var CATEGORY_EXPECT = "expect";
+var CATEGORY_HOOK = "hook";
+var CATEGORY_FIXTURE = "fixture";
+var CATEGORY_PW_API = "pw:api";
+var MAX_STEP_DEPTH = 10;
+function isReportable(step, includeApiSteps) {
+  if (step.error) {
+    return true;
+  }
+  switch (step.category) {
+    case CATEGORY_TEST_STEP:
+    case CATEGORY_EXPECT:
+    case CATEGORY_HOOK:
+      return true;
+    case CATEGORY_PW_API:
+    case CATEGORY_FIXTURE:
+      return includeApiSteps;
+    default:
+      return true;
+  }
+}
+function formatLocation(step) {
+  if (!step.location) {
+    return void 0;
+  }
+  return `${step.location.file}:${step.location.line}`;
+}
+function mapSteps(steps, includeApiSteps) {
+  const out = [];
+  let capWarned = false;
+  const walk = (nodes, parentIndex, depth) => {
+    for (const node of nodes) {
+      if (!isReportable(node, includeApiSteps)) {
+        walk(node.steps, parentIndex, depth);
+        continue;
+      }
+      if (out.length >= MAX_STEPS_PER_TEST_ATTEMPT) {
+        if (!capWarned) {
+          capWarned = true;
+          logger.warn(
+            `a test produced more than ${MAX_STEPS_PER_TEST_ATTEMPT} reportable steps; the rest were dropped. Set \`includeApiSteps: false\` (the default) or reduce step nesting if this is unexpected.`
+          );
+        }
+        return;
+      }
+      const index = out.length;
+      out.push({
+        name: node.title,
+        keyword: node.category,
+        status: node.error ? "failed" : "passed",
+        duration: msToNs(node.duration),
+        ...node.error ? { error: formatStepError(node) } : {},
+        ...formatLocation(node) ? { location: formatLocation(node) } : {},
+        ...parentIndex !== void 0 ? { parentIndex } : {}
+      });
+      const nextParent = depth + 1 >= MAX_STEP_DEPTH ? parentIndex : index;
+      walk(node.steps, nextParent, depth + 1);
+    }
+  };
+  walk(steps, void 0, 0);
+  return out;
+}
+function formatStepError(step) {
+  const err = step.error;
+  if (!err) {
+    return "";
+  }
+  return err.message ?? err.value ?? "step failed";
+}
+
+// src/reporter/case-builder.ts
+function mapStatus(status) {
+  switch (status) {
+    case "passed":
+      return "passed";
+    case "failed":
+      return "failed";
+    case "timedOut":
+      return "timeout";
+    case "interrupted":
+      return "aborted";
+    case "skipped":
+      return "skipped";
+    default:
+      return "error";
+  }
+}
+var ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_PATTERN, "");
+}
+function formatError(result) {
+  const err = result.error;
+  if (!err) {
+    return void 0;
+  }
+  const head = err.message ?? err.value ?? "test failed";
+  const parts = [stripAnsi(head)];
+  if (err.snippet) {
+    parts.push("", stripAnsi(err.snippet));
+  }
+  if (err.stack && !head.includes(err.stack)) {
+    parts.push("", stripAnsi(err.stack));
+  }
+  return parts.join("\n");
+}
+function replayMetadata(result, config, budget) {
+  const meta = {
+    labels: [],
+    links: [],
+    tags: [],
+    caseParameters: [],
+    stepParameters: /* @__PURE__ */ new Map(),
+    attachments: []
+  };
+  const openSteps = [];
+  for (const a of result.attachments) {
+    if (a.contentType !== RESERVED_MESSAGE_MEDIA_TYPE || !a.body) {
+      continue;
+    }
+    let message;
+    try {
+      message = JSON.parse(a.body.toString("utf8"));
+    } catch {
+      logger.warn("ignoring an unparseable qualflare runtime message.");
+      continue;
+    }
+    switch (message.type) {
+      case "label":
+        meta.labels.push({ name: message.name, value: message.value });
+        break;
+      case "link":
+        meta.links.push({
+          type: message.linkType ?? "custom",
+          ...message.name ? { name: message.name } : {},
+          url: message.url
+        });
+        break;
+      case "tag":
+        meta.tags.push(...message.tags);
+        break;
+      case "description":
+        meta.description = message.text;
+        break;
+      case "priority":
+        meta.priority = message.value;
+        break;
+      case "parameter": {
+        const param = {
+          name: message.name,
+          ...message.value !== void 0 ? { value: message.value } : {},
+          ...message.masked ? { masked: true } : {}
+        };
+        const openStep = openSteps[openSteps.length - 1];
+        if (openStep === void 0) {
+          meta.caseParameters.push(param);
+        } else {
+          const existing = meta.stepParameters.get(openStep) ?? [];
+          existing.push(param);
+          meta.stepParameters.set(openStep, existing);
+        }
+        break;
+      }
+      case "attachment": {
+        const inlined = inlineFromBuffer(
+          message.name,
+          Buffer.from(message.contentBase64, "base64"),
+          message.mimeType,
+          config,
+          budget
+        );
+        if (inlined) {
+          meta.attachments.push(inlined);
+        }
+        break;
+      }
+      case "attachment_from_file": {
+        const fromFile = inlineFromFile(message.name, message.path, message.mimeType, config, budget);
+        if (fromFile) {
+          meta.attachments.push(fromFile);
+        }
+        break;
+      }
+      case "step_start":
+        openSteps.push(message.name);
+        break;
+      case "step_stop":
+        openSteps.pop();
+        break;
+    }
+  }
+  return meta;
+}
+function capTags(tags) {
+  const unique = [...new Set(tags.map((t) => t.slice(0, MAX_TAG_LENGTH)))];
+  return unique.slice(0, MAX_TAGS_PER_CASE);
+}
+function buildCase(test, config, attachmentsByResult, budget) {
+  const results = test.results.filter((r) => r.workerIndex !== -1);
+  if (results.length === 0) {
+    return void 0;
+  }
+  const final = results[results.length - 1];
+  const outcome = test.outcome();
+  const expectedFailure = outcome === "expected" && final.status === "failed";
+  const status = expectedFailure ? "passed" : mapStatus(final.status);
+  const meta = replayMetadata(final, config, budget);
+  const steps = mapSteps(final.steps, config.includeApiSteps);
+  for (const [stepName, params] of meta.stepParameters) {
+    for (let i = steps.length - 1; i >= 0; i -= 1) {
+      if (steps[i].name === stepName) {
+        steps[i].parameters = [...steps[i].parameters ?? [], ...params];
+        break;
+      }
+    }
+  }
+  const projectName = test.parent.project()?.name;
+  const properties = {
+    file: test.location.file,
+    ...projectName ? { project: projectName } : {}
+  };
+  for (const p of meta.caseParameters) {
+    properties[p.name] = p.value ?? "";
+  }
+  const attachments = [...attachmentsByResult.get(`${test.id}:${final.retry}`) ?? [], ...meta.attachments];
+  const nativeTags = test.tags ?? [];
+  const tags = capTags([...nativeTags, ...meta.tags]);
+  const error = formatError(final);
+  return {
+    id: test.id,
+    name: test.title,
+    className: test.location.file,
+    status,
+    duration: msToNs(final.duration),
+    retryCount: results.length - 1,
+    isFlaky: outcome === "flaky",
+    ...error ? { error } : {},
+    ...meta.priority ? { priority: meta.priority } : {},
+    ...meta.description ? { description: meta.description } : {},
+    ...tags.length > 0 ? { tags } : {},
+    properties,
+    ...attachments.length > 0 ? { attachments } : {},
+    ...steps.length > 0 ? { steps } : {},
+    ...meta.labels.length > 0 ? { labels: meta.labels.slice(0, MAX_LABELS_PER_CASE) } : {},
+    ...meta.links.length > 0 ? { links: meta.links.slice(0, MAX_LINKS_PER_CASE) } : {},
+    startedAt: final.startTime.toISOString()
+  };
+}
+
+// src/reporter/collect-builder.ts
+import * as os from "os";
+
+// src/config/version.ts
+var PACKAGE_VERSION = "0.1.0";
+
+// src/reporter/collect-builder.ts
+function resolveOs(config) {
+  if (config.os) {
+    return config.os;
+  }
+  return `${os.type()} ${os.release()}`;
+}
+function resolveBrowser(config, browsers) {
+  if (config.browser) {
+    return config.browser;
+  }
+  return [...new Set(browsers)].sort().join(", ");
+}
+function buildCollectPayload(suites, config, browsers = []) {
+  return {
+    framework: config.framework,
+    platform: config.platform,
+    os: resolveOs(config),
+    browser: resolveBrowser(config, browsers),
+    branch: config.branch,
+    commit: config.commit,
+    environment: config.environment,
+    language: config.language,
+    milestone: config.milestone,
+    metadata: {
+      version: PACKAGE_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cliName: "qualflare-playwright"
+    },
+    properties: config.properties,
+    suites,
+    ciProvider: config.ciProvider,
+    ciBuildNumber: config.ciBuildNumber,
+    ciRunUrl: config.ciRunUrl,
+    ciPrNumber: config.ciPrNumber
+  };
+}
+
+// src/reporter/suite-builder.ts
+import * as path2 from "path";
+function relativizeFile(file, rootDir) {
+  const relative2 = path2.isAbsolute(file) ? path2.relative(rootDir, file) : file;
+  return relative2.split(path2.sep).join("/");
+}
+function groupIntoSuites(cases) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const entry of cases) {
+    const existing = byFile.get(entry.file);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      byFile.set(entry.file, [entry]);
+    }
+  }
+  const suites = [];
+  for (const [file, entries] of byFile) {
+    let kept = entries;
+    if (kept.length > MAX_CASES_PER_SUITE) {
+      logger.warn(
+        `suite "${file}" produced ${kept.length} cases, over the server's limit of ${MAX_CASES_PER_SUITE}; the rest were dropped.`
+      );
+      kept = kept.slice(0, MAX_CASES_PER_SUITE);
+    }
+    const browsers = [...new Set(kept.map((e) => e.browser).filter((b) => Boolean(b)))].sort();
+    suites.push({
+      name: file,
+      category: "playwright",
+      duration: kept.reduce((sum, e) => sum + e.testCase.duration, 0),
+      ...browsers.length > 0 ? { browser: browsers.join(", ") } : {},
+      cases: kept.map((e) => e.testCase)
+    });
+  }
+  if (suites.length > MAX_SUITES_PER_LAUNCH) {
+    logger.warn(
+      `this run produced ${suites.length} suites, over the server's limit of ${MAX_SUITES_PER_LAUNCH}; the rest were dropped.`
+    );
+    return suites.slice(0, MAX_SUITES_PER_LAUNCH);
+  }
+  return suites;
+}
+
+// src/reporter/reporter.ts
+var QualflareReporter = class {
+  options;
+  config;
+  rootDir = process.cwd();
+  cases = [];
+  browsers = /* @__PURE__ */ new Set();
+  budget = new AttachmentBudget(0);
+  rootSuite;
+  attachmentsByResult = /* @__PURE__ */ new Map();
+  latestAttemptByTest = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** Returning false tells Playwright to auto-inject a terminal reporter
+   * (`line` locally, `dot` on CI) so a user who registers only this one is
+   * not left staring at a blank console. This reporter prints nothing but
+   * warnings and a single completion line. */
+  printsToStdio() {
+    return false;
+  }
+  onBegin(config, suite) {
+    this.guard("onBegin", () => {
+      this.rootSuite = suite;
+      this.rootDir = config.rootDir || process.cwd();
+      const detectedShardIndex = config.shard ? config.shard.current - 1 : void 0;
+      this.config = resolveConfig(this.options, { detectedShardIndex });
+      this.budget = new AttachmentBudget(this.config.maxTotalAttachmentBytes);
+      for (const project of config.projects) {
+        const browserName = project.use?.browserName;
+        if (browserName) {
+          this.browsers.add(browserName);
+        }
+      }
+    });
+  }
+  onTestEnd(test, result) {
+    this.guard("onTestEnd", () => {
+      const config = this.config;
+      if (!config || !config.enabled) {
+        return;
+      }
+      this.discardSupersededAttempt(test.id, result.retry, config.outputDir);
+      this.attachmentsByResult.set(`${test.id}:${result.retry}`, resolveAttachments(result, config, this.budget));
+      this.latestAttemptByTest.set(test.id, result.retry);
+    });
+  }
+  async onEnd(_result) {
+    await Promise.resolve();
+    this.guard("onEnd", () => {
+      const config = this.config;
+      if (!config || !config.enabled) {
+        return;
+      }
+      this.writeReport(config);
+    });
+  }
+  /** Collects every test from the (possibly nested) suite tree. */
+  collectCases(root, config) {
+    for (const test of root.allTests()) {
+      const built = buildCase(test, config, this.attachmentsByResult, this.budget);
+      if (!built) {
+        continue;
+      }
+      const file = relativizeFile(test.location.file, this.rootDir);
+      built.className = file;
+      if (built.properties) {
+        built.properties["file"] = file;
+      }
+      const browserName = test.parent.project()?.use?.browserName;
+      this.cases.push({
+        file,
+        ...browserName ? { browser: browserName } : {},
+        testCase: built
+      });
+    }
+  }
+  writeReport(config) {
+    if (this.rootSuite) {
+      this.collectCases(this.rootSuite, config);
+    }
+    const suites = groupIntoSuites(this.cases);
+    if (suites.length === 0) {
+      logger.info("no test results were captured this run \u2014 skipping file write.");
+      return;
+    }
+    const collect = buildCollectPayload(suites, config, [...this.browsers]);
+    if (config.shardIndex !== void 0) {
+      for (const suite of collect.suites) {
+        for (const testCase of suite.cases) {
+          testCase.shardIndex = config.shardIndex;
+        }
+      }
+    }
+    const outputDir = this.resolveOutputDir(config.outputDir);
+    fs3.mkdirSync(outputDir, { recursive: true });
+    const outputPath = path3.join(outputDir, `${randomUUID2()}.json`);
+    fs3.writeFileSync(outputPath, JSON.stringify(collect));
+    logger.info(`wrote Collect payload to ${outputPath} \u2014 run \`qualflare-cli collect ${outputDir}\` to upload it.`);
+  }
+  /** Relative `outputDir` resolves against the Playwright config's own
+   * directory, not the shell's cwd — a user running `npx playwright test`
+   * from a monorepo root should still write next to their config. */
+  resolveOutputDir(outputDir) {
+    return path3.isAbsolute(outputDir) ? outputDir : path3.resolve(this.options.configDir ?? this.rootDir, outputDir);
+  }
+  /** Drops everything an earlier, now-superseded attempt produced: deletes the
+   * video copied into outputDir and refunds its bytes to the run budget. */
+  discardSupersededAttempt(testId, retry, outputDir) {
+    const previous = this.latestAttemptByTest.get(testId);
+    if (previous === void 0 || previous >= retry) {
+      return;
+    }
+    const key = `${testId}:${previous}`;
+    for (const attachment of this.attachmentsByResult.get(key) ?? []) {
+      if (attachment.localVideoPath) {
+        try {
+          fs3.rmSync(path3.join(this.resolveOutputDir(outputDir), attachment.localVideoPath), { force: true });
+        } catch {
+        }
+      }
+      if (attachment.fileSize && attachment.content) {
+        this.budget.release(attachment.fileSize);
+      }
+    }
+    this.attachmentsByResult.delete(key);
+  }
+  /**
+   * Playwright SWALLOWS anything a reporter throws (Multiplexer._wrap catches
+   * it and re-dispatches as onError), so an unguarded bug here vanishes
+   * silently and the user just gets no report. Every hook body runs through
+   * this instead, which at least says what broke and where.
+   */
+  guard(hook, fn) {
+    try {
+      fn();
+    } catch (err) {
+      logger.error(`${hook} failed: ${err.message}`);
+    }
+  }
+};
+export {
+  QualflareReporter as default
+};
+//# sourceMappingURL=index.js.map