@qualflare/cucumberjs 0.1.0 → 0.2.0

package/dist/formatter/index.js

@@ -1,6 +1,17 @@
 // src/formatter/formatter.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import * as fs3 from "fs";
+import * as path4 from "path";
 import { Formatter } from "@cucumber/cucumber";
 
+// 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_TAGS_PER_CASE = 64;
+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) {
@@ -172,22 +183,30 @@ function envInt(...names) {
   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 argvShardIndex(argv = process.argv) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === void 0) {
+      continue;
+    }
+    const raw = arg === "--shard" ? argv[i + 1] : arg.startsWith("--shard=") ? arg.slice("--shard=".length) : void 0;
+    if (raw === void 0) {
+      continue;
+    }
+    if (!/^\d+\/\d+$/.test(raw)) {
+      return void 0;
+    }
+    const oneBased = Number.parseInt(raw.split("/")[0] ?? "", 10);
+    return Number.isFinite(oneBased) && oneBased >= 1 ? oneBased - 1 : void 0;
   }
-};
+  return 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 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 outputDir = options.outputDir || firstEnv2("QUALFLARE_OUTPUT_DIR") || "./qualflare-results";
+  const shardIndex = options.shardIndex ?? envInt("QUALFLARE_SHARD_INDEX") ?? argvShardIndex();
   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");
@@ -202,13 +221,9 @@ function resolveConfig(options, deps = {}) {
   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
+    // 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",
@@ -224,38 +239,18 @@ function resolveConfig(options, deps = {}) {
     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,
+    maxVideoBytes: options.maxVideoBytes ?? envInt("QUALFLARE_MAX_VIDEO_BYTES") ?? MAX_VIDEO_UPLOAD_BYTES,
     debug: options.debug ?? envBool("QUALFLARE_DEBUG", "QF_DEBUG") ?? false,
-    enabled
+    enabled,
+    outputDir,
+    shardIndex
   };
 }
 
-// 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 = {
@@ -273,220 +268,86 @@ var logger = {
   }
 };
 
-// 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/formatter/attachment-budget.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
 
-// 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;
-  }
+// src/formatter/video-uploader.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var VIDEO_MIME_TYPES_BY_EXTENSION = {
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime"
+};
+var EXTENSION_BY_VIDEO_MIME_TYPE = {
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "video/quicktime": ".mov"
+};
+function resolveVideoMimeType(mimeType, filePath) {
+  if (filePath) {
+    const extension2 = path.extname(filePath).toLowerCase();
+    const resolvedMimeType = VIDEO_MIME_TYPES_BY_EXTENSION[extension2];
+    return resolvedMimeType ? { mimeType: resolvedMimeType, extension: extension2 } : void 0;
+  }
+  const normalized = mimeType?.toLowerCase();
+  const extension = normalized ? EXTENSION_BY_VIDEO_MIME_TYPE[normalized] : void 0;
+  return normalized && extension ? { mimeType: normalized, extension } : void 0;
 }
-function renderFields(fields) {
-  if (!fields || fields.length === 0) {
+function writeVideoAttachment(pending, outputDir, maxVideoBytes) {
+  const resolved = resolveVideoMimeType(pending.mimeType, pending.path);
+  if (!resolved) {
+    logger.warn(`skipping video attachment "${pending.name}": unsupported video format.`);
     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 localVideoPath = `${randomUUID()}${resolved.extension}`;
+  const destination = path.join(outputDir, localVideoPath);
+  if (pending.path !== void 0) {
+    let fileSize;
+    try {
+      fileSize = fs.statSync(pending.path).size;
+    } catch (err) {
+      logger.warn(`skipping video attachment "${pending.path}": could not stat file: ${err.message}`);
+      return void 0;
     }
-    const hint = actionHint(init.statusCode);
-    if (hint) {
-      parts.push(`(${hint})`);
+    if (fileSize > maxVideoBytes) {
+      logger.warn(
+        `skipping video attachment "${pending.path}": ${fileSize} bytes exceeds the configured maxVideoBytes cap of ${maxVideoBytes} bytes.`
+      );
+      return void 0;
     }
-    if (init.requestId) {
-      parts.push(`[request_id: ${init.requestId}]`);
+    try {
+      fs.mkdirSync(outputDir, { recursive: true });
+      fs.copyFileSync(pending.path, destination);
+    } catch (err) {
+      logger.warn(`skipping video attachment "${pending.path}": could not copy file: ${err.message}`);
+      return void 0;
     }
-    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;
+    return { localVideoPath, fileSize, mimeType: resolved.mimeType };
   }
-};
-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 (pending.content !== void 0) {
+    const fileSize = Buffer.byteLength(pending.content, "base64");
+    if (fileSize > maxVideoBytes) {
+      logger.warn(
+        `skipping video attachment "${pending.name}": ${fileSize} bytes exceeds the configured maxVideoBytes cap of ${maxVideoBytes} bytes.`
       );
-      if (this.opts.debug) {
-        logger.debug(`retrying after ${Math.round(delay)}ms (status ${statusCode})`);
-      }
-      await sleep(delay);
+      return void 0;
     }
-    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"');
+    try {
+      fs.mkdirSync(outputDir, { recursive: true });
+      fs.writeFileSync(destination, Buffer.from(pending.content, "base64"));
+    } catch (err) {
+      logger.warn(`skipping video attachment "${pending.name}": could not write file: ${err.message}`);
+      return void 0;
     }
-    return parsed;
-  } catch (err) {
-    throw new QualflareApiError({
-      message: "server returned a success status but an unparseable body",
-      cause: err
-    });
+    return { localVideoPath, fileSize, mimeType: resolved.mimeType };
   }
+  return void 0;
 }
-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) {
@@ -511,7 +372,7 @@ function isVideoLike(mimeType, filePath) {
   if (mimeType?.toLowerCase().startsWith("video/")) {
     return true;
   }
-  if (filePath && VIDEO_EXTENSIONS.has(path.extname(filePath).toLowerCase())) {
+  if (filePath && VIDEO_EXTENSIONS.has(path2.extname(filePath).toLowerCase())) {
     return true;
   }
   return false;
@@ -519,7 +380,7 @@ function isVideoLike(mimeType, filePath) {
 function readAttachmentFile(filePath, maxAttachmentBytes, budget) {
   let size;
   try {
-    size = fs.statSync(filePath).size;
+    size = fs2.statSync(filePath).size;
   } catch (err) {
     return { skipped: true, reason: `could not stat file: ${err.message}` };
   }
@@ -536,7 +397,7 @@ function readAttachmentFile(filePath, maxAttachmentBytes, budget) {
     };
   }
   try {
-    const content = fs.readFileSync(filePath).toString("base64");
+    const content = fs2.readFileSync(filePath).toString("base64");
     return { skipped: false, content };
   } catch (err) {
     return { skipped: true, reason: `could not read file: ${err.message}` };
@@ -546,12 +407,6 @@ 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) {
@@ -584,6 +439,22 @@ function resolvePendingAttachment(pending, config, budget) {
   }
   return void 0;
 }
+async function resolveVideoAttachment(pending, config) {
+  if (!config.attachScreenshots) {
+    return void 0;
+  }
+  const written = writeVideoAttachment(pending, config.outputDir, config.maxVideoBytes);
+  if (!written) {
+    return void 0;
+  }
+  return {
+    name: pending.name,
+    mimeType: written.mimeType,
+    localVideoPath: written.localVideoPath,
+    fileSize: written.fileSize,
+    stepIndex: pending.stepIndex
+  };
+}
 
 // src/formatter/attempt-tracker.ts
 import {
@@ -832,7 +703,8 @@ var AttemptTracker = class {
       tags: [],
       properties: {},
       attachments: [],
-      stepCapWarned: false
+      stepCapWarned: false,
+      pendingVideoWrites: []
     };
     this.byTestCaseStartedId.set(e.id, record);
     const attempts = this.byTestCaseId.get(testCase.id) ?? [];
@@ -910,11 +782,25 @@ var AttemptTracker = class {
     }
     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
-    );
+    this.resolveAttachment(record, { name: e.fileName || "attachment", mimeType: e.mediaType, content, stepIndex });
+  }
+  /** Resolves one pending attachment, routing a video-like one through the
+   * write-to-`outputDir` flow (tracked in `record.pendingVideoWrites` so
+   * `finish()` can wait for it) and everything else through the synchronous
+   * inline path — shared by the real `World.attach()` handler above and both
+   * `qualflare.attachment()`/`attachmentFromFile()` runtime-message cases
+   * below. */
+  resolveAttachment(record, pending) {
+    if (isVideoLike(pending.mimeType, pending.path)) {
+      const write = resolveVideoAttachment(pending, this.config).then((resolved2) => {
+        if (resolved2) {
+          record.attachments.push(resolved2);
+        }
+      });
+      record.pendingVideoWrites.push(write);
+      return;
+    }
+    const resolved = resolvePendingAttachment(pending, this.config, this.attachmentBudget);
     if (resolved) {
       record.attachments.push(resolved);
     }
@@ -971,26 +857,12 @@ var AttemptTracker = class {
       }
       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);
-        }
+        this.resolveAttachment(record, { name: message.name, mimeType: message.mimeType, content: message.contentBase64, stepIndex });
         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);
-        }
+        this.resolveAttachment(record, { name: message.name, mimeType: message.mimeType, path: message.path, stepIndex });
         return;
       }
       case "step_start": {
@@ -1015,8 +887,21 @@ var AttemptTracker = class {
   }
   /** Returns the collapsed result once all attempts of this logical
    * scenario have arrived, or `undefined` if more attempts are coming
-   * (`willBeRetried === true`). */
-  finish(e) {
+   * (`willBeRetried === true`).
+   *
+   * Async because it must first await every attempt's own
+   * `pendingVideoWrites` (any video attached anywhere across every retry
+   * of this scenario). This is load-bearing, not just tidiness:
+   * `collapseAttempts`/`buildCase` read `attachments` by REFERENCE, not by
+   * copy, and `buildCase` runs synchronously right after this resolves — a
+   * scenario whose ONLY attachment is a still-uploading video would have an
+   * EMPTY `attachments` array at that instant, and `buildCase` captures
+   * `attachments.length > 0 ? attachments : undefined` as a plain
+   * `undefined` VALUE right then, permanently — a later push onto the
+   * (still-live) array reference would no longer be visible through
+   * `undefined`. Awaiting here first guarantees `attachments` is complete
+   * before `buildCase` ever reads it. */
+  async finish(e) {
     const record = this.byTestCaseStartedId.get(e.testCaseStartedId);
     this.byTestCaseStartedId.delete(e.testCaseStartedId);
     if (!record) {
@@ -1028,6 +913,10 @@ var AttemptTracker = class {
     const testCaseId = record.testCase.id;
     const attempts = this.byTestCaseId.get(testCaseId) ?? [record];
     this.byTestCaseId.delete(testCaseId);
+    const pendingWrites = attempts.flatMap((a) => a.pendingVideoWrites);
+    if (pendingWrites.length > 0) {
+      await Promise.all(pendingWrites);
+    }
     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);
@@ -1062,6 +951,11 @@ function timestampMs(ts) {
 
 // src/formatter/collect-builder.ts
 import * as os from "os";
+
+// src/config/version.ts
+var PACKAGE_VERSION = "0.2.0";
+
+// src/formatter/collect-builder.ts
 function resolveOs(config) {
   if (config.os) {
     return config.os;
@@ -1221,7 +1115,7 @@ var RunHookTracker = class {
     }
     return {
       name: "(global hooks)",
-      category: "bdd",
+      category: "cucumber",
       duration: this.failed.reduce((sum, c) => sum + c.duration, 0),
       cases: this.failed
     };
@@ -1229,7 +1123,7 @@ var RunHookTracker = class {
 };
 
 // src/formatter/suite-builder.ts
-import * as path2 from "path";
+import * as path3 from "path";
 function groupIntoSuites(cases, cwd, extraSuite) {
   const byUri = /* @__PURE__ */ new Map();
   for (const { uri, case: kase } of cases) {
@@ -1249,7 +1143,7 @@ function groupIntoSuites(cases, cwd, extraSuite) {
     }
     suites.push({
       name: relativizeUri(uri, cwd),
-      category: "bdd",
+      category: "cucumber",
       duration: kases.reduce((sum, c) => sum + c.duration, 0),
       cases: kases.slice(0, MAX_CASES_PER_SUITE)
     });
@@ -1269,10 +1163,10 @@ function relativizeUri(uri, cwd) {
   if (normalized.startsWith("file://")) {
     normalized = new URL(normalized).pathname;
   }
-  if (path2.isAbsolute(normalized)) {
-    normalized = path2.relative(cwd, normalized);
+  if (path3.isAbsolute(normalized)) {
+    normalized = path3.relative(cwd, normalized);
   }
-  return normalized.split(path2.sep).join("/");
+  return normalized.split(path3.sep).join("/");
 }
 
 // src/formatter/formatter.ts
@@ -1286,12 +1180,25 @@ var QualflareCucumberFormatter = class extends Formatter {
   attemptTracker;
   runHookTracker = new RunHookTracker();
   finishedCases = [];
+  /** One promise per `testCaseFinished` envelope, resolving once that
+   * scenario's `AttemptTracker.finish()` (which itself awaits any pending
+   * video uploads — see its doc comment) has settled and, if it produced a
+   * result, been pushed into `finishedCases`. `finished()` awaits all of
+   * these before building/uploading the Collect payload, so a scenario
+   * whose only attachment is a still-uploading video is never silently
+   * dropped from the report. */
+  pendingCaseBuilds = [];
   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);
+    this.attemptTracker = new AttemptTracker(
+      this.hookIndex,
+      this.gherkin,
+      this.config,
+      this.attachmentBudget
+    );
     if (!this.config.enabled) {
       return;
     }
@@ -1342,15 +1249,20 @@ var QualflareCucumberFormatter = class extends Formatter {
       return;
     }
     if (envelope.testCaseFinished) {
-      const finished = this.attemptTracker.finish(envelope.testCaseFinished);
-      if (finished) {
+      const pending = this.attemptTracker.finish(envelope.testCaseFinished).then((finished) => {
+        if (!finished) {
+          return;
+        }
         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.`);
         }
-      }
+      }).catch((err) => {
+        logger.error("failed to process a cucumber-js event:", err);
+      });
+      this.pendingCaseBuilds.push(pending);
       return;
     }
     if (envelope.testRunHookStarted) {
@@ -1367,41 +1279,41 @@ var QualflareCucumberFormatter = class extends Formatter {
   }
   async finished() {
     try {
+      await Promise.all(this.pendingCaseBuilds);
       if (this.config.enabled) {
-        await this.uploadResults();
+        this.writeResults();
       }
     } finally {
       await super.finished();
     }
   }
-  async uploadResults() {
+  /** Writes this process's Collect payload into `outputDir` under a unique
+   * filename. Never uploads: `qualflare-cli collect <outputDir>` does that,
+   * merging every file it finds there into one Launch. Multiple shards can
+   * therefore share one directory safely — the UUID filename is what keeps
+   * them from overwriting each other. */
+  writeResults() {
     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.");
+        logger.debug("no scenarios reported \u2014 skipping file write.");
       }
       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;
+    if (this.config.shardIndex !== void 0) {
+      for (const suite of payload.suites) {
+        for (const c of suite.cases) {
+          c.shardIndex = this.config.shardIndex;
+        }
       }
-      logger.error("failed to upload results to Qualflare:", err);
     }
+    fs3.mkdirSync(this.config.outputDir, { recursive: true });
+    const outputPath = path4.join(this.config.outputDir, `${randomUUID2()}.json`);
+    fs3.writeFileSync(outputPath, JSON.stringify(payload));
+    logger.info(
+      `wrote Collect payload to ${outputPath} \u2014 run \`qualflare-cli collect ${this.config.outputDir}\` to upload it.`
+    );
   }
 };
 export {