@qualflare/cucumberjs 0.1.0

package/dist/formatter/index.js

@@ -0,0 +1,1410 @@
+// src/formatter/formatter.ts
+import { Formatter } from "@cucumber/cucumber";
+
+// 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;
+}
+var QualflareConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QualflareConfigError";
+  }
+};
+function resolveConfig(options, deps = {}) {
+  const doDetectGit = deps.detectGit ?? detectGit;
+  const doDetectCi = deps.detectCi ?? detectCi;
+  const enabled = options.enabled ?? envBool("QUALFLARE_ENABLED") ?? true;
+  const token = options.token ?? firstEnv2("QUALFLARE_TOKEN", "QF_TOKEN") ?? "";
+  if (enabled && token === "") {
+    throw new QualflareConfigError(
+      "qualflare-cucumberjs: no token configured. Set the `token` format option or the QUALFLARE_TOKEN (or QF_TOKEN) environment variable, or pass `enabled: false` to disable this formatter."
+    );
+  }
+  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 {
+    token,
+    apiEndpoint: options.apiEndpoint ?? firstEnv2("QUALFLARE_API_ENDPOINT") ?? "https://api.qualflare.com",
+    // `||` (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`, and since
+    // `failOnUploadError` defaults `false`, that would fail the entire
+    // upload with no visible error by default). 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 || "cucumber",
+    os: options.os,
+    browser: options.browser,
+    properties: options.properties,
+    ciProvider,
+    ciBuildNumber,
+    ciRunUrl,
+    ciPrNumber,
+    timeoutMs: options.timeoutMs ?? envInt("QUALFLARE_TIMEOUT_MS") ?? 12e4,
+    retry: {
+      max: options.retry?.max ?? envInt("QUALFLARE_RETRY_MAX", "QF_RETRY_MAX") ?? 3,
+      baseDelayMs: options.retry?.baseDelayMs ?? envInt("QUALFLARE_RETRY_BASE_DELAY_MS") ?? 1e3,
+      maxDelayMs: options.retry?.maxDelayMs ?? envInt("QUALFLARE_RETRY_MAX_DELAY_MS") ?? 3e4
+    },
+    failOnUploadError: options.failOnUploadError ?? envBool("QUALFLARE_FAIL_ON_UPLOAD_ERROR") ?? false,
+    attachScreenshots: options.attachScreenshots ?? envBool("QUALFLARE_ATTACH_SCREENSHOTS") ?? true,
+    includeStepHooks: options.includeStepHooks ?? envBool("QUALFLARE_INCLUDE_STEP_HOOKS") ?? false,
+    maxAttachmentBytes: options.maxAttachmentBytes ?? envInt("QUALFLARE_MAX_ATTACHMENT_BYTES") ?? 15e5,
+    maxTotalAttachmentBytes: options.maxTotalAttachmentBytes ?? envInt("QUALFLARE_MAX_TOTAL_ATTACHMENT_BYTES") ?? 75e4,
+    debug: options.debug ?? envBool("QUALFLARE_DEBUG", "QF_DEBUG") ?? false,
+    enabled
+  };
+}
+
+// src/http/client.ts
+import { request } from "undici";
+
+// src/shared/constants.ts
+var RESERVED_MESSAGE_MEDIA_TYPE = "application/vnd.qualflare.message+json";
+var HEADER_TOKEN = "QF_TOKEN";
+var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
+var HEADER_CONTENT_TYPE = "Content-Type";
+var HEADER_ACCEPT = "Accept";
+var HEADER_USER_AGENT = "User-Agent";
+var MAX_SUITES_PER_LAUNCH = 2e3;
+var MAX_CASES_PER_SUITE = 5e3;
+var MAX_TAGS_PER_CASE = 64;
+var MAX_IDEMPOTENCY_KEY_CHARS = 255;
+var MAX_STEPS_PER_TEST_ATTEMPT = 300;
+
+// src/shared/logger.ts
+var PREFIX = "[qualflare-cucumberjs]";
+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/http/backoff.ts
+function computeDelay(attempt, baseDelayMs, maxDelayMs, retryAfterMs) {
+  const exponential = baseDelayMs * 2 ** Math.max(0, attempt - 1);
+  const jittered = Math.random() * Math.min(exponential, maxDelayMs);
+  const floor = retryAfterMs !== void 0 ? retryAfterMs : 0;
+  return Math.min(Math.max(jittered, floor), maxDelayMs);
+}
+
+// src/http/errors.ts
+function friendlyHint(code) {
+  switch (code) {
+    case "environment.not_found":
+      return "Environment not found. Check the `environment` option or create it in Qualflare.";
+    case "milestone.not_found":
+      return "Milestone not found. Check the `milestone` option or its sequence number in Qualflare.";
+    case "common.validation_failed":
+      return "Validation failed. Check the request data below.";
+    default:
+      return void 0;
+  }
+}
+function actionHint(statusCode) {
+  switch (statusCode) {
+    case 401:
+      return "the configured token is missing or invalid \u2014 check `token`/QUALFLARE_TOKEN";
+    case 403:
+      return "the token lacks access to this project";
+    case 402:
+      return "a plan limit was reached \u2014 check your Qualflare subscription";
+    default:
+      return void 0;
+  }
+}
+function renderFields(fields) {
+  if (!fields || fields.length === 0) {
+    return void 0;
+  }
+  return fields.map((f) => {
+    const rule = f.rule ? ` (${f.rule})` : "";
+    const msg = f.message ? `: ${f.message}` : "";
+    return `${f.field}${rule}${msg}`;
+  }).join("; ");
+}
+var QualflareApiError = class extends Error {
+  code;
+  statusCode;
+  requestId;
+  fields;
+  constructor(init) {
+    const parts = [init.message];
+    const fieldsRendered = renderFields(init.fields);
+    if (fieldsRendered) {
+      parts.push(`fields: ${fieldsRendered}`);
+    }
+    const hint = actionHint(init.statusCode);
+    if (hint) {
+      parts.push(`(${hint})`);
+    }
+    if (init.requestId) {
+      parts.push(`[request_id: ${init.requestId}]`);
+    }
+    super(parts.join(" \u2014 "), init.cause !== void 0 ? { cause: init.cause } : void 0);
+    this.name = "QualflareApiError";
+    this.code = init.code;
+    this.statusCode = init.statusCode;
+    this.requestId = init.requestId;
+    this.fields = init.fields;
+  }
+};
+function buildApiError(statusCode, body) {
+  const code = body?.code;
+  const message = body?.message || friendlyHint(code) || body?.error || `request failed with status ${statusCode}`;
+  return new QualflareApiError({
+    message,
+    code,
+    statusCode,
+    requestId: body?.request_id,
+    fields: body?.fields
+  });
+}
+
+// src/http/idempotency.ts
+import { randomUUID } from "crypto";
+function newIdempotencyKey() {
+  const key = randomUUID();
+  if (key.length > MAX_IDEMPOTENCY_KEY_CHARS) {
+    return key.slice(0, MAX_IDEMPOTENCY_KEY_CHARS);
+  }
+  return key;
+}
+
+// src/http/client.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function redactToken(token) {
+  return token.length > 0 ? "***REDACTED***" : "(none)";
+}
+var QualflareHttpClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async send(collect) {
+    const url = `${this.opts.endpoint.replace(/\/+$/, "")}/api/v1/collect`;
+    const idempotencyKey = newIdempotencyKey();
+    const body = JSON.stringify(collect);
+    const maxAttempts = Math.max(1, this.opts.retry.max + 1);
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      if (this.opts.debug) {
+        logger.debug(
+          `POST ${url} (attempt ${attempt}/${maxAttempts}, QF_TOKEN: ${redactToken(this.opts.token)})`
+        );
+      }
+      let statusCode;
+      let responseBody;
+      let responseHeaders;
+      try {
+        const res = await request(url, {
+          method: "POST",
+          headers: {
+            [HEADER_TOKEN]: this.opts.token,
+            [HEADER_CONTENT_TYPE]: "application/json",
+            [HEADER_ACCEPT]: "application/json",
+            [HEADER_USER_AGENT]: this.opts.userAgent,
+            [HEADER_IDEMPOTENCY_KEY]: idempotencyKey
+          },
+          body,
+          maxRedirections: 0,
+          signal: AbortSignal.timeout(this.opts.timeoutMs)
+        });
+        statusCode = res.statusCode;
+        responseHeaders = res.headers;
+        responseBody = await res.body.text();
+      } catch (err) {
+        lastError = err;
+        if (this.opts.debug) {
+          logger.debug(`attempt ${attempt} transport error: ${err?.message ?? err}`);
+        }
+        if (attempt < maxAttempts) {
+          await sleep(computeDelay(attempt, this.opts.retry.baseDelayMs, this.opts.retry.maxDelayMs));
+          continue;
+        }
+        throw new QualflareApiError({
+          message: `failed to send request to ${url}`,
+          cause: err
+        });
+      }
+      if (this.opts.debug) {
+        logger.debug(`attempt ${attempt} response: ${statusCode}`);
+      }
+      if (statusCode >= 200 && statusCode < 300) {
+        return parseSuccess(responseBody);
+      }
+      const parsedError = parseErrorBody(responseBody);
+      if (!RETRYABLE_STATUS_CODES.has(statusCode) || attempt === maxAttempts) {
+        throw buildApiError(statusCode, parsedError);
+      }
+      const retryAfterMs = parseRetryAfter(responseHeaders["retry-after"]);
+      const delay = computeDelay(
+        attempt,
+        this.opts.retry.baseDelayMs,
+        this.opts.retry.maxDelayMs,
+        retryAfterMs
+      );
+      if (this.opts.debug) {
+        logger.debug(`retrying after ${Math.round(delay)}ms (status ${statusCode})`);
+      }
+      await sleep(delay);
+    }
+    throw lastError instanceof Error ? lastError : new QualflareApiError({ message: "request failed for an unknown reason" });
+  }
+};
+function parseSuccess(responseBody) {
+  try {
+    const parsed = JSON.parse(responseBody);
+    if (typeof parsed.seq !== "number") {
+      throw new Error('response body missing numeric "seq"');
+    }
+    return parsed;
+  } catch (err) {
+    throw new QualflareApiError({
+      message: "server returned a success status but an unparseable body",
+      cause: err
+    });
+  }
+}
+function parseErrorBody(responseBody) {
+  if (!responseBody) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(responseBody);
+  } catch {
+    return void 0;
+  }
+}
+function parseRetryAfter(value) {
+  const raw = Array.isArray(value) ? value[0] : value;
+  if (!raw) {
+    return void 0;
+  }
+  const seconds = Number(raw);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/config/version.ts
+var PACKAGE_VERSION = "0.1.0";
+
+// src/formatter/attachment-budget.ts
+import * as fs from "fs";
+import * as path from "path";
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".webm", ".mov", ".avi", ".mkv"]);
+var AttachmentBudget = class {
+  constructor(maxTotalBytes) {
+    this.maxTotalBytes = maxTotalBytes;
+  }
+  maxTotalBytes;
+  used = 0;
+  /** Atomically checks-and-reserves `bytes` against the remaining budget.
+   * Returns false (reserving nothing) if it would exceed the total. */
+  tryReserve(bytes) {
+    if (this.used + bytes > this.maxTotalBytes) {
+      return false;
+    }
+    this.used += bytes;
+    return true;
+  }
+  get usedBytes() {
+    return this.used;
+  }
+};
+function isVideoLike(mimeType, filePath) {
+  if (mimeType?.toLowerCase().startsWith("video/")) {
+    return true;
+  }
+  if (filePath && VIDEO_EXTENSIONS.has(path.extname(filePath).toLowerCase())) {
+    return true;
+  }
+  return false;
+}
+function readAttachmentFile(filePath, maxAttachmentBytes, budget) {
+  let size;
+  try {
+    size = fs.statSync(filePath).size;
+  } catch (err) {
+    return { skipped: true, reason: `could not stat file: ${err.message}` };
+  }
+  if (size > maxAttachmentBytes) {
+    return {
+      skipped: true,
+      reason: `${size} bytes exceeds the configured per-attachment cap of ${maxAttachmentBytes} bytes`
+    };
+  }
+  if (!budget.tryReserve(size)) {
+    return {
+      skipped: true,
+      reason: `would exceed this run's total attachment budget (${budget.usedBytes} bytes already used)`
+    };
+  }
+  try {
+    const content = fs.readFileSync(filePath).toString("base64");
+    return { skipped: false, content };
+  } catch (err) {
+    return { skipped: true, reason: `could not read file: ${err.message}` };
+  }
+}
+function resolvePendingAttachment(pending, config, budget) {
+  if (!config.attachScreenshots) {
+    return void 0;
+  }
+  if (isVideoLike(pending.mimeType, pending.path)) {
+    logger.warn(
+      `refusing to attach "${pending.name}": video attachments are not supported yet (${pending.path ?? pending.mimeType ?? "unknown"}).`
+    );
+    return void 0;
+  }
+  if (pending.content !== void 0) {
+    const bytes = Buffer.byteLength(pending.content, "base64");
+    if (bytes > config.maxAttachmentBytes) {
+      logger.warn(
+        `skipping attachment "${pending.name}": ${bytes} bytes exceeds the configured per-attachment cap of ${config.maxAttachmentBytes} bytes`
+      );
+      return void 0;
+    }
+    if (!budget.tryReserve(bytes)) {
+      logger.warn(
+        `skipping attachment "${pending.name}": would exceed this run's total attachment budget (${budget.usedBytes} bytes already used)`
+      );
+      return void 0;
+    }
+    return { name: pending.name, mimeType: pending.mimeType, content: pending.content, stepIndex: pending.stepIndex };
+  }
+  if (pending.path) {
+    const result = readAttachmentFile(pending.path, config.maxAttachmentBytes, budget);
+    if (result.skipped) {
+      logger.warn(`skipping attachment "${pending.name}" (${pending.path}): ${result.reason}`);
+      return void 0;
+    }
+    return {
+      name: pending.name,
+      mimeType: pending.mimeType,
+      content: result.content,
+      path: pending.path,
+      stepIndex: pending.stepIndex
+    };
+  }
+  return void 0;
+}
+
+// src/formatter/attempt-tracker.ts
+import {
+  getWorstTestStepResult
+} from "@cucumber/messages";
+
+// src/shared/duration.ts
+var NS_PER_MS = 1e6;
+var NS_PER_SECOND = 1e9;
+function msToNs(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return 0;
+  }
+  return Math.round(ms * NS_PER_MS);
+}
+function messageDurationToNs(duration) {
+  if (!duration || !Number.isFinite(duration.seconds) || !Number.isFinite(duration.nanos)) {
+    return 0;
+  }
+  const total = duration.seconds * NS_PER_SECOND + duration.nanos;
+  return total > 0 ? Math.round(total) : 0;
+}
+
+// src/formatter/case-builder.ts
+function combineSteps(realSteps, manualSteps) {
+  if (realSteps.length === 0 && manualSteps.length === 0) {
+    return void 0;
+  }
+  const offsetManual = manualSteps.map((record) => {
+    const step = {
+      name: record.name,
+      status: record.status,
+      duration: msToNs(record.durationMs ?? 0)
+    };
+    if (record.error) step.error = record.error;
+    if (record.parentIndex !== void 0) step.parentIndex = record.parentIndex + realSteps.length;
+    if (record.parameters && record.parameters.length > 0) step.parameters = record.parameters;
+    return step;
+  });
+  return [...realSteps, ...offsetManual];
+}
+function collapseAttempts(attempts) {
+  if (attempts.length === 0) {
+    throw new Error("collapseAttempts: at least one attempt is required");
+  }
+  const final = attempts[attempts.length - 1];
+  const retryCount = attempts.length - 1;
+  const isFlaky = retryCount > 0 && final.status === "passed" && attempts.some((a) => a.status !== "passed");
+  const duration = attempts.reduce((sum, a) => sum + a.duration, 0);
+  return {
+    status: final.status,
+    duration,
+    retryCount,
+    isFlaky,
+    error: final.status === "passed" ? void 0 : final.error,
+    steps: combineSteps(final.steps, final.manualSteps),
+    labels: final.labels,
+    links: final.links,
+    tags: final.tags,
+    description: final.description,
+    priority: final.priority,
+    properties: final.properties,
+    attachments: final.attachments
+  };
+}
+function buildCase(uri, pickle, collapsed, gherkin) {
+  const entry = gherkin.get(uri);
+  const scenarioId = pickle.astNodeIds[0];
+  const scenarioEntry = scenarioId ? entry?.scenarioById.get(scenarioId) : void 0;
+  const featureName = entry?.featureName;
+  const ruleName = scenarioEntry?.ruleName;
+  const className = ruleName ? `${featureName ?? ""} > ${ruleName}` : featureName;
+  const labels = [...collapsed.labels];
+  if (featureName) {
+    labels.push({ name: "feature", value: featureName });
+  }
+  if (ruleName) {
+    labels.push({ name: "rule", value: ruleName });
+  }
+  const properties = { ...examplesRowProperties(scenarioEntry, pickle), ...collapsed.properties };
+  const staticTags = pickle.tags.map((t) => t.name.replace(/^@/, ""));
+  const tags = [.../* @__PURE__ */ new Set([...staticTags, ...collapsed.tags])].slice(0, MAX_TAGS_PER_CASE);
+  const kase = {
+    // Stable across runs (unchanged unless the file is edited), and
+    // includes the source line specifically so two identically-named
+    // Scenarios in one feature file can never collide — the exact bug
+    // that's open upstream in allure-js (allure-framework/allure-js#1502).
+    id: `${uri}:${pickle.location?.line ?? 0}#${pickle.name}`,
+    name: pickle.name,
+    status: collapsed.status,
+    duration: collapsed.duration,
+    retryCount: collapsed.retryCount || void 0,
+    isFlaky: collapsed.isFlaky || void 0,
+    error: collapsed.error,
+    tags: tags.length > 0 ? tags : void 0,
+    steps: collapsed.steps,
+    labels: labels.length > 0 ? labels : void 0,
+    links: collapsed.links.length > 0 ? collapsed.links : void 0,
+    // `||`, not `??`: cucumber-js's `Scenario.description` is always a
+    // defined string, `''` when the Gherkin source has none — `??` would
+    // never fall through and every scenario without one would send an
+    // empty-string description instead of omitting the field (found via a
+    // real tarball-installed smoke test, not just reasoning about types).
+    description: collapsed.description || scenarioEntry?.scenario.description || void 0,
+    priority: collapsed.priority,
+    properties: Object.keys(properties).length > 0 ? properties : void 0,
+    attachments: collapsed.attachments.length > 0 ? collapsed.attachments : void 0
+  };
+  if (className) {
+    kase.className = className;
+  }
+  return { uri, case: kase };
+}
+function examplesRowProperties(scenarioEntry, pickle) {
+  if (!scenarioEntry) {
+    return {};
+  }
+  const rowAstIds = new Set(pickle.astNodeIds);
+  for (const examples of scenarioEntry.scenario.examples) {
+    const header = examples.tableHeader?.cells;
+    if (!header) {
+      continue;
+    }
+    const row = examples.tableBody.find((r) => rowAstIds.has(r.id));
+    if (!row) {
+      continue;
+    }
+    const properties = {};
+    header.forEach((cell, i) => {
+      const value = row.cells[i]?.value;
+      if (cell.value && value !== void 0) {
+        properties[cell.value] = value;
+      }
+    });
+    return properties;
+  }
+  return {};
+}
+
+// src/formatter/step-mapper.ts
+import { TestStepResultStatus } from "@cucumber/messages";
+function mapStatus(status) {
+  switch (status) {
+    case TestStepResultStatus.PASSED:
+      return "passed";
+    case TestStepResultStatus.FAILED:
+      return "failed";
+    case TestStepResultStatus.SKIPPED:
+      return "skipped";
+    case TestStepResultStatus.PENDING:
+      return "pending";
+    case TestStepResultStatus.UNDEFINED:
+    case TestStepResultStatus.AMBIGUOUS:
+    case TestStepResultStatus.UNKNOWN:
+    default:
+      return "error";
+  }
+}
+function formatError(result) {
+  return result.message || result.exception?.stackTrace || result.exception?.message;
+}
+function pickleStepArgumentToParameters(argument) {
+  if (!argument) {
+    return void 0;
+  }
+  const params = [];
+  if (argument.docString) {
+    params.push({ name: "docString", value: argument.docString.content });
+  }
+  if (argument.dataTable) {
+    const rows = argument.dataTable.rows.map((row) => row.cells.map((cell) => cell.value));
+    params.push({ name: "dataTable", value: JSON.stringify(rows) });
+  }
+  return params.length > 0 ? params : void 0;
+}
+function mapPickleStep(uri, pickleStep, result, gherkin) {
+  const resolved = gherkin.resolveKeyword(uri, pickleStep.astNodeIds);
+  const step = {
+    name: pickleStep.text,
+    status: mapStatus(result.status),
+    duration: messageDurationToNs(result.duration)
+  };
+  if (resolved?.keyword) {
+    step.keyword = resolved.keyword.trim();
+  }
+  const error = formatError(result);
+  if (error) {
+    step.error = error;
+  }
+  const parameters = pickleStepArgumentToParameters(pickleStep.argument);
+  if (parameters) {
+    step.parameters = parameters;
+  }
+  return step;
+}
+var HOOK_LABELS = {
+  before: "Before",
+  after: "After",
+  beforeStep: "BeforeStep",
+  afterStep: "AfterStep",
+  beforeAll: "BeforeAll",
+  afterAll: "AfterAll"
+};
+function mapHookStep(hook, result) {
+  const label = HOOK_LABELS[hook.kind];
+  const step = {
+    name: hook.name || `${label} hook`,
+    keyword: label,
+    status: mapStatus(result.status),
+    duration: messageDurationToNs(result.duration)
+  };
+  const error = formatError(result);
+  if (error) {
+    step.error = error;
+  }
+  return step;
+}
+
+// src/formatter/attempt-tracker.ts
+var AttemptTracker = class {
+  constructor(hookIndex, gherkin, config, attachmentBudget) {
+    this.hookIndex = hookIndex;
+    this.gherkin = gherkin;
+    this.config = config;
+    this.attachmentBudget = attachmentBudget;
+  }
+  hookIndex;
+  gherkin;
+  config;
+  attachmentBudget;
+  byTestCaseId = /* @__PURE__ */ new Map();
+  byTestCaseStartedId = /* @__PURE__ */ new Map();
+  begin(e, testCase, pickle) {
+    const record = {
+      testCase,
+      pickle,
+      attempt: e.attempt,
+      startedAtMs: timestampMs(e.timestamp),
+      steps: [],
+      stepResults: [],
+      stepIndexByTestStepId: /* @__PURE__ */ new Map(),
+      manualSteps: [],
+      manualStepStack: [],
+      labels: [],
+      links: [],
+      tags: [],
+      properties: {},
+      attachments: [],
+      stepCapWarned: false
+    };
+    this.byTestCaseStartedId.set(e.id, record);
+    const attempts = this.byTestCaseId.get(testCase.id) ?? [];
+    attempts.push(record);
+    this.byTestCaseId.set(testCase.id, attempts);
+  }
+  stepStarted(e) {
+    const record = this.byTestCaseStartedId.get(e.testCaseStartedId);
+    if (!record) {
+      return;
+    }
+    record.currentTestStepId = e.testStepId;
+  }
+  stepFinished(e) {
+    const record = this.byTestCaseStartedId.get(e.testCaseStartedId);
+    if (!record) {
+      return;
+    }
+    record.currentTestStepId = void 0;
+    record.stepResults.push(e.testStepResult);
+    const testStep = record.testCase.testSteps.find((s) => s.id === e.testStepId);
+    if (!testStep) {
+      return;
+    }
+    let step;
+    if (testStep.pickleStepId) {
+      const pickleStep = record.pickle.steps.find((s) => s.id === testStep.pickleStepId);
+      if (pickleStep) {
+        step = mapPickleStep(record.pickle.uri, pickleStep, e.testStepResult, this.gherkin);
+      }
+    } else if (testStep.hookId) {
+      const hook = this.hookIndex.get(testStep.hookId);
+      if (hook && (hook.kind === "before" || hook.kind === "after")) {
+        step = mapHookStep(hook, e.testStepResult);
+      } else if (hook && (hook.kind === "beforeStep" || hook.kind === "afterStep") && this.config.includeStepHooks) {
+        step = mapHookStep(hook, e.testStepResult);
+      }
+    }
+    if (!step) {
+      return;
+    }
+    if (record.steps.length >= MAX_STEPS_PER_TEST_ATTEMPT) {
+      if (!record.stepCapWarned) {
+        record.stepCapWarned = true;
+        logger.warn(
+          `reached the ${MAX_STEPS_PER_TEST_ATTEMPT}-step-per-attempt cap \u2014 further steps in this scenario attempt will not be uploaded.`
+        );
+      }
+      return;
+    }
+    record.stepIndexByTestStepId.set(e.testStepId, record.steps.length);
+    record.steps.push(step);
+  }
+  /** Handles both a real user `World.attach()` call (becomes a wire
+   * `Attachment`) and a `qualflare.*()` reserved-media-type message
+   * (unwrapped and applied as a model mutation instead). */
+  attachment(e) {
+    if (!e.testCaseStartedId) {
+      return;
+    }
+    const record = this.byTestCaseStartedId.get(e.testCaseStartedId);
+    if (!record) {
+      return;
+    }
+    if (e.mediaType === RESERVED_MESSAGE_MEDIA_TYPE) {
+      let message;
+      try {
+        message = JSON.parse(e.contentEncoding === "BASE64" ? Buffer.from(e.body, "base64").toString("utf8") : e.body);
+      } catch {
+        logger.warn("received a malformed qualflare runtime message \u2014 ignoring it.");
+        return;
+      }
+      this.applyRuntimeMessage(record, message, e.testStepId);
+      return;
+    }
+    const stepIndex = this.resolveStepIndex(record, e.testStepId);
+    const content = e.contentEncoding === "BASE64" ? e.body : Buffer.from(e.body, "utf8").toString("base64");
+    const resolved = resolvePendingAttachment(
+      { name: e.fileName || "attachment", mimeType: e.mediaType, content, stepIndex },
+      this.config,
+      this.attachmentBudget
+    );
+    if (resolved) {
+      record.attachments.push(resolved);
+    }
+  }
+  /** Resolves which step index an attachment (real or `qualflare.*()`
+   * message) belongs to. `stepIndexByTestStepId` only gets an entry once a
+   * step is FINISHED — but `World.attach()` (the only channel available,
+   * used by both a real user attachment and every `qualflare.*()` call) is
+   * always called from WITHIN a step's body, i.e. strictly BETWEEN that
+   * step's `testStepStarted` and `testStepFinished`. So the map lookup
+   * alone can never resolve the step that's currently attaching — this was
+   * a real bug found in self-review, caught by a unit test that attaches
+   * mid-step instead of only after it finishes. While a step is in flight,
+   * `record.steps.length` (the array's CURRENT length, before that step has
+   * been pushed) is exactly the index it will occupy once it does finish —
+   * single-threaded, event-ordered execution guarantees nothing else can be
+   * pushed in between. */
+  resolveStepIndex(record, testStepId) {
+    if (testStepId === void 0) {
+      return void 0;
+    }
+    if (record.currentTestStepId === testStepId) {
+      return record.steps.length;
+    }
+    return record.stepIndexByTestStepId.get(testStepId);
+  }
+  applyRuntimeMessage(record, message, testStepId) {
+    switch (message.type) {
+      case "label":
+        record.labels.push({ name: message.name, value: message.value });
+        return;
+      case "link":
+        record.links.push({ type: message.linkType ?? "custom", name: message.name, url: message.url });
+        return;
+      case "tag":
+        record.tags.push(...message.tags);
+        return;
+      case "description":
+        record.description = message.text;
+        return;
+      case "priority":
+        record.priority = message.value;
+        return;
+      case "parameter": {
+        const openStepIndex = record.manualStepStack[record.manualStepStack.length - 1];
+        if (openStepIndex !== void 0) {
+          const step = record.manualSteps[openStepIndex];
+          step.parameters = step.parameters ?? [];
+          step.parameters.push({ name: message.name, value: message.value, masked: message.masked });
+        } else {
+          record.properties[message.name] = message.value ?? "";
+        }
+        return;
+      }
+      case "attachment": {
+        const stepIndex = testStepId !== void 0 ? record.stepIndexByTestStepId.get(testStepId) : void 0;
+        const resolved = resolvePendingAttachment(
+          { name: message.name, mimeType: message.mimeType, content: message.contentBase64, stepIndex },
+          this.config,
+          this.attachmentBudget
+        );
+        if (resolved) {
+          record.attachments.push(resolved);
+        }
+        return;
+      }
+      case "attachment_from_file": {
+        const stepIndex = testStepId !== void 0 ? record.stepIndexByTestStepId.get(testStepId) : void 0;
+        const resolved = resolvePendingAttachment(
+          { name: message.name, mimeType: message.mimeType, path: message.path, stepIndex },
+          this.config,
+          this.attachmentBudget
+        );
+        if (resolved) {
+          record.attachments.push(resolved);
+        }
+        return;
+      }
+      case "step_start": {
+        const parentIndex = record.manualStepStack.length > 0 ? record.manualStepStack[record.manualStepStack.length - 1] : void 0;
+        const step = { name: message.name, status: "passed", startedAt: message.timestamp, parentIndex };
+        record.manualStepStack.push(record.manualSteps.length);
+        record.manualSteps.push(step);
+        return;
+      }
+      case "step_stop": {
+        const openIndex = record.manualStepStack.pop();
+        if (openIndex === void 0) {
+          return;
+        }
+        const step = record.manualSteps[openIndex];
+        step.status = message.status;
+        step.error = message.error;
+        step.durationMs = Math.max(0, message.timestamp - step.startedAt);
+        return;
+      }
+    }
+  }
+  /** Returns the collapsed result once all attempts of this logical
+   * scenario have arrived, or `undefined` if more attempts are coming
+   * (`willBeRetried === true`). */
+  finish(e) {
+    const record = this.byTestCaseStartedId.get(e.testCaseStartedId);
+    this.byTestCaseStartedId.delete(e.testCaseStartedId);
+    if (!record) {
+      return void 0;
+    }
+    if (e.willBeRetried) {
+      return void 0;
+    }
+    const testCaseId = record.testCase.id;
+    const attempts = this.byTestCaseId.get(testCaseId) ?? [record];
+    this.byTestCaseId.delete(testCaseId);
+    const snapshots = attempts.map((a) => {
+      const worst = a.stepResults.length > 0 ? getWorstTestStepResult(a.stepResults) : void 0;
+      const duration = a.stepResults.reduce((sum, r) => sum + messageDurationToNs(r.duration), 0);
+      return {
+        status: worst ? mapStatus(worst.status) : "passed",
+        duration,
+        // `message` first — see `step-mapper.ts`'s `formatError()` doc
+        // comment for why (verified empirically across the peer-dependency
+        // range; `exception.stackTrace` is not version-safe).
+        error: worst?.message || worst?.exception?.stackTrace || worst?.exception?.message,
+        steps: a.steps,
+        manualSteps: a.manualSteps,
+        labels: a.labels,
+        links: a.links,
+        tags: a.tags,
+        description: a.description,
+        priority: a.priority,
+        properties: a.properties,
+        attachments: a.attachments
+      };
+    });
+    return {
+      uri: record.pickle.uri,
+      pickleId: record.testCase.pickleId,
+      collapsed: collapseAttempts(snapshots)
+    };
+  }
+};
+function timestampMs(ts) {
+  return ts.seconds * 1e3 + Math.floor(ts.nanos / 1e6);
+}
+
+// src/formatter/collect-builder.ts
+import * as os from "os";
+function resolveOs(config) {
+  if (config.os) {
+    return config.os;
+  }
+  return `${os.type()} ${os.release()}`;
+}
+function buildCollectPayload(suites, config) {
+  return {
+    framework: config.framework,
+    platform: config.platform,
+    os: resolveOs(config),
+    browser: config.browser ?? "",
+    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-cucumberjs"
+    },
+    properties: config.properties,
+    suites,
+    ciProvider: config.ciProvider,
+    ciBuildNumber: config.ciBuildNumber,
+    ciRunUrl: config.ciRunUrl,
+    ciPrNumber: config.ciPrNumber
+  };
+}
+
+// src/formatter/gherkin-index.ts
+var GherkinIndex = class {
+  byUri = /* @__PURE__ */ new Map();
+  add(doc) {
+    if (!doc.uri || !doc.feature) {
+      return;
+    }
+    const entry = {
+      featureName: doc.feature.name || void 0,
+      stepMap: /* @__PURE__ */ new Map(),
+      scenarioById: /* @__PURE__ */ new Map()
+    };
+    for (const child of doc.feature.children) {
+      if (child.background) {
+        this.indexSteps(entry, child.background.steps);
+      }
+      if (child.scenario) {
+        entry.scenarioById.set(child.scenario.id, { scenario: child.scenario });
+        this.indexSteps(entry, child.scenario.steps);
+      }
+      if (child.rule) {
+        for (const ruleChild of child.rule.children) {
+          if (ruleChild.background) {
+            this.indexSteps(entry, ruleChild.background.steps);
+          }
+          if (ruleChild.scenario) {
+            entry.scenarioById.set(ruleChild.scenario.id, {
+              scenario: ruleChild.scenario,
+              ruleName: child.rule.name || void 0
+            });
+            this.indexSteps(entry, ruleChild.scenario.steps);
+          }
+        }
+      }
+    }
+    this.byUri.set(doc.uri, entry);
+  }
+  indexSteps(entry, steps) {
+    for (const step of steps) {
+      entry.stepMap.set(step.id, { keyword: step.keyword, text: step.text });
+    }
+  }
+  get(uri) {
+    return this.byUri.get(uri);
+  }
+  /** Resolves the literal Given/When/Then/And/But keyword text for a
+   * compiled `PickleStep`, by walking its `astNodeIds` back to the first
+   * one present in this feature's `stepMap` (a Background step referenced
+   * by a scenario has exactly one AST id; a step reusing a parameter type
+   * from an outline row can have more than one — the first match is always
+   * the step's own defining AST node). */
+  resolveKeyword(uri, astNodeIds) {
+    const entry = this.byUri.get(uri);
+    if (!entry) {
+      return void 0;
+    }
+    for (const id of astNodeIds) {
+      const found = entry.stepMap.get(id);
+      if (found) {
+        return found;
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/formatter/hook-index.ts
+function buildHookIndex(supportCodeLibrary) {
+  const index = /* @__PURE__ */ new Map();
+  for (const def of supportCodeLibrary.beforeTestCaseHookDefinitions) {
+    index.set(def.id, { kind: "before", name: def.name || void 0 });
+  }
+  for (const def of supportCodeLibrary.afterTestCaseHookDefinitions) {
+    index.set(def.id, { kind: "after", name: def.name || void 0 });
+  }
+  for (const def of supportCodeLibrary.beforeTestStepHookDefinitions) {
+    index.set(def.id, { kind: "beforeStep" });
+  }
+  for (const def of supportCodeLibrary.afterTestStepHookDefinitions) {
+    index.set(def.id, { kind: "afterStep" });
+  }
+  for (const def of supportCodeLibrary.beforeTestRunHookDefinitions) {
+    index.set(def.id, { kind: "beforeAll" });
+  }
+  for (const def of supportCodeLibrary.afterTestRunHookDefinitions) {
+    index.set(def.id, { kind: "afterAll" });
+  }
+  return index;
+}
+
+// src/formatter/run-hook-tracker.ts
+var RunHookTracker = class {
+  /** `testRunHookStartedId` -> the hook it started, so `finish()` can look
+   * up its kind/name. `TestRunHookFinished.result.duration` already gives
+   * an accurate duration directly — no start/finish timestamp delta needed. */
+  started = /* @__PURE__ */ new Map();
+  failed = [];
+  start(e) {
+    this.started.set(e.id, e.hookId);
+  }
+  finish(e, hookIndex) {
+    const hookId = this.started.get(e.testRunHookStartedId);
+    this.started.delete(e.testRunHookStartedId);
+    const status = mapStatus(e.result.status);
+    if (status === "passed" || status === "skipped") {
+      return;
+    }
+    const hook = hookId ? hookIndex.get(hookId) : void 0;
+    const label = hook?.kind === "afterAll" ? "AfterAll hook" : "BeforeAll hook";
+    this.failed.push({
+      id: `global-hook:${e.testRunHookStartedId}`,
+      name: hook?.name || label,
+      status,
+      duration: messageDurationToNs(e.result.duration),
+      // `result.message` first — see `step-mapper.ts`'s `formatError()` doc
+      // comment for why (verified empirically to be the version-safe field
+      // across the peer-dependency range; `exception.stackTrace` is not).
+      error: e.result.message || e.result.exception?.stackTrace || e.result.exception?.message
+    });
+  }
+  /** Returns `undefined` if no run-hook failed — see the class doc comment
+   * for why a passing BeforeAll/AfterAll produces no Case at all. */
+  buildSuite() {
+    if (this.failed.length === 0) {
+      return void 0;
+    }
+    return {
+      name: "(global hooks)",
+      category: "bdd",
+      duration: this.failed.reduce((sum, c) => sum + c.duration, 0),
+      cases: this.failed
+    };
+  }
+};
+
+// src/formatter/suite-builder.ts
+import * as path2 from "path";
+function groupIntoSuites(cases, cwd, extraSuite) {
+  const byUri = /* @__PURE__ */ new Map();
+  for (const { uri, case: kase } of cases) {
+    const bucket = byUri.get(uri);
+    if (bucket) {
+      bucket.push(kase);
+    } else {
+      byUri.set(uri, [kase]);
+    }
+  }
+  const suites = [];
+  for (const [uri, kases] of byUri) {
+    if (kases.length > MAX_CASES_PER_SUITE) {
+      logger.warn(
+        `feature file "${uri}" reported ${kases.length} scenarios \u2014 only the first ${MAX_CASES_PER_SUITE} will be uploaded (server cap).`
+      );
+    }
+    suites.push({
+      name: relativizeUri(uri, cwd),
+      category: "bdd",
+      duration: kases.reduce((sum, c) => sum + c.duration, 0),
+      cases: kases.slice(0, MAX_CASES_PER_SUITE)
+    });
+  }
+  if (extraSuite) {
+    suites.push(extraSuite);
+  }
+  if (suites.length > MAX_SUITES_PER_LAUNCH) {
+    logger.warn(
+      `this run reported ${suites.length} feature-file suites \u2014 only the first ${MAX_SUITES_PER_LAUNCH} will be uploaded (server cap).`
+    );
+  }
+  return suites.slice(0, MAX_SUITES_PER_LAUNCH);
+}
+function relativizeUri(uri, cwd) {
+  let normalized = uri;
+  if (normalized.startsWith("file://")) {
+    normalized = new URL(normalized).pathname;
+  }
+  if (path2.isAbsolute(normalized)) {
+    normalized = path2.relative(cwd, normalized);
+  }
+  return normalized.split(path2.sep).join("/");
+}
+
+// src/formatter/formatter.ts
+var QualflareCucumberFormatter = class extends Formatter {
+  config;
+  gherkin = new GherkinIndex();
+  hookIndex;
+  pickleIndex = /* @__PURE__ */ new Map();
+  testCaseIndex = /* @__PURE__ */ new Map();
+  attachmentBudget;
+  attemptTracker;
+  runHookTracker = new RunHookTracker();
+  finishedCases = [];
+  constructor(options) {
+    super(options);
+    this.config = resolveConfig(options.parsedArgvOptions);
+    this.hookIndex = buildHookIndex(options.supportCodeLibrary);
+    this.attachmentBudget = new AttachmentBudget(this.config.maxTotalAttachmentBytes);
+    this.attemptTracker = new AttemptTracker(this.hookIndex, this.gherkin, this.config, this.attachmentBudget);
+    if (!this.config.enabled) {
+      return;
+    }
+    options.eventBroadcaster.on("envelope", (envelope) => this.onEnvelope(envelope));
+  }
+  onEnvelope(envelope) {
+    try {
+      this.dispatch(envelope);
+    } catch (err) {
+      logger.error("failed to process a cucumber-js event:", err);
+    }
+  }
+  dispatch(envelope) {
+    if (envelope.gherkinDocument) {
+      this.onGherkinDocument(envelope.gherkinDocument);
+      return;
+    }
+    if (envelope.pickle) {
+      this.pickleIndex.set(envelope.pickle.id, envelope.pickle);
+      return;
+    }
+    if (envelope.testCase) {
+      this.testCaseIndex.set(envelope.testCase.id, envelope.testCase);
+      return;
+    }
+    if (envelope.testCaseStarted) {
+      const testCase = this.testCaseIndex.get(envelope.testCaseStarted.testCaseId);
+      const pickle = testCase ? this.pickleIndex.get(testCase.pickleId) : void 0;
+      if (testCase && pickle) {
+        this.attemptTracker.begin(envelope.testCaseStarted, testCase, pickle);
+      } else {
+        logger.warn(
+          `could not resolve testCase/pickle for testCaseStarted "${envelope.testCaseStarted.id}" \u2014 this scenario attempt will not be uploaded.`
+        );
+      }
+      return;
+    }
+    if (envelope.testStepStarted) {
+      this.attemptTracker.stepStarted(envelope.testStepStarted);
+      return;
+    }
+    if (envelope.testStepFinished) {
+      this.attemptTracker.stepFinished(envelope.testStepFinished);
+      return;
+    }
+    if (envelope.attachment) {
+      this.attemptTracker.attachment(envelope.attachment);
+      return;
+    }
+    if (envelope.testCaseFinished) {
+      const finished = this.attemptTracker.finish(envelope.testCaseFinished);
+      if (finished) {
+        const pickle = this.pickleIndex.get(finished.pickleId);
+        if (pickle) {
+          this.finishedCases.push(buildCase(finished.uri, pickle, finished.collapsed, this.gherkin));
+        } else {
+          logger.warn(`could not resolve pickle "${finished.pickleId}" for a finished scenario \u2014 it will not be uploaded.`);
+        }
+      }
+      return;
+    }
+    if (envelope.testRunHookStarted) {
+      this.runHookTracker.start(envelope.testRunHookStarted);
+      return;
+    }
+    if (envelope.testRunHookFinished) {
+      this.runHookTracker.finish(envelope.testRunHookFinished, this.hookIndex);
+      return;
+    }
+  }
+  onGherkinDocument(doc) {
+    this.gherkin.add(doc);
+  }
+  async finished() {
+    try {
+      if (this.config.enabled) {
+        await this.uploadResults();
+      }
+    } finally {
+      await super.finished();
+    }
+  }
+  async uploadResults() {
+    const suites = groupIntoSuites(this.finishedCases, this.cwd, this.runHookTracker.buildSuite());
+    if (suites.length === 0) {
+      if (this.config.debug) {
+        logger.debug("no scenarios reported \u2014 skipping upload.");
+      }
+      return;
+    }
+    const payload = buildCollectPayload(suites, this.config);
+    const client = new QualflareHttpClient({
+      endpoint: this.config.apiEndpoint,
+      token: this.config.token,
+      timeoutMs: this.config.timeoutMs,
+      retry: this.config.retry,
+      userAgent: `qualflare-cucumberjs/${PACKAGE_VERSION}`,
+      debug: this.config.debug
+    });
+    try {
+      const result = await client.send(payload);
+      if (this.config.debug) {
+        logger.debug(`uploaded launch #${result.seq}.`);
+      }
+    } catch (err) {
+      if (this.config.failOnUploadError) {
+        throw err;
+      }
+      logger.error("failed to upload results to Qualflare:", err);
+    }
+  }
+};
+export {
+  QualflareCucumberFormatter as default
+};
+//# sourceMappingURL=index.js.map