@flakiness/cucumberjs 1.0.0-alpha.0 → 1.0.1

package/README.md

@@ -0,0 +1,201 @@
+[![Tests](https://img.shields.io/endpoint?url=https%3A%2F%2Fflakiness.io%2Fapi%2Fbadge%3Finput%3D%257B%2522badgeToken%2522%253A%2522badge-2XD99RoRXgOvFfVcxVMJ0l%2522%257D)](https://flakiness.io/flakiness/cucumberjs)
+
+# Flakiness.io CucumberJS Formatter
+
+A custom CucumberJS formatter that generates Flakiness Reports from your Cucumber test runs. The formatter automatically converts CucumberJS test results into the standardized [Flakiness JSON format](https://github.com/flakiness/flakiness-report), preserving complete Gherkin structure, test outcomes, and environment information.
+
+## Supported Gherkin Features
+
+- Scenarios & Scenario Outlines (with multiple Examples blocks)
+- Rules
+- Tags & tag inheritance (Feature → Rule → Scenario → Examples)
+- Steps (Given/When/Then with keyword prefix)
+- Data Tables
+- Before & After Hooks (named and unnamed)
+- Feature, Rule, and Scenario descriptions
+- Attachments (`this.attach()` and `this.log()`)
+- Retries (`--retry`)
+- Parallel execution (`--parallel`)
+- All statuses: passed, failed, pending, undefined, ambiguous, skipped
+
+## Table of Contents
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Uploading Reports](#uploading-reports)
+- [Viewing Reports](#viewing-reports)
+- [Features](#features)
+  - [Environment Detection](#environment-detection)
+  - [CI Integration](#ci-integration)
+- [Configuration Options](#configuration-options)
+  - [`flakinessProject?: string`](#flakinessproject-string)
+  - [`endpoint?: string`](#endpoint-string)
+  - [`token?: string`](#token-string)
+  - [`outputFolder?: string`](#outputfolder-string)
+  - [`disableUpload?: boolean`](#disableupload-boolean)
+- [Example Configuration](#example-configuration)
+
+## Requirements
+
+- `@cucumber/cucumber` 12.0 or higher
+- Node.js project with a git repository (for commit information)
+
+## Installation
+
+```bash
+npm install -D @flakiness/cucumberjs
+```
+
+## Quick Start
+
+Add the formatter to your `cucumber.mjs`:
+
+```javascript
+export default {
+  paths: ['features/**/*.feature'],
+  import: ['features/support/**/*.ts'],
+  format: ['@flakiness/cucumberjs', 'progress'],
+  formatOptions: {
+    flakinessProject: 'my-org/my-project',
+  },
+};
+```
+
+Run your tests. The report will be automatically generated in the `./flakiness-report` folder:
+
+```bash
+npx cucumber-js
+```
+
+View the interactive report:
+
+```bash
+npx flakiness show ./flakiness-report
+```
+
+## Uploading Reports
+
+Reports are automatically uploaded to Flakiness.io after test completion. Authentication can be done in two ways:
+
+- **Access token**: Provide a token via the `token` format option or the `FLAKINESS_ACCESS_TOKEN` environment variable.
+- **GitHub OIDC**: When running in GitHub Actions, the formatter can authenticate using GitHub's OIDC token — no access token needed. See [GitHub Actions integration](https://docs.flakiness.io/ci/github-actions/) for setup instructions.
+
+If upload fails, the report is still available locally in the output folder.
+
+## Viewing Reports
+
+After test execution, you can view the report using:
+
+```bash
+npx flakiness show ./flakiness-report
+```
+
+## Features
+
+### Environment Detection
+
+Environment variables prefixed with `FK_ENV_` are automatically included in the environment metadata. The prefix is stripped and the key is converted to lowercase.
+
+**Example:**
+
+```bash
+export FK_ENV_DEPLOYMENT=staging
+export FK_ENV_REGION=us-east-1
+```
+
+This will result in the environment containing:
+```json
+{
+  "metadata": {
+    "deployment": "staging",
+    "region": "us-east-1"
+  }
+}
+```
+
+Flakiness.io will create a dedicated history for tests executed in each unique environment. This means tests run with `FK_ENV_DEPLOYMENT=staging` will have a separate timeline from tests run with `FK_ENV_DEPLOYMENT=production`, allowing you to track flakiness patterns specific to each deployment environment.
+
+### CI Integration
+
+The formatter automatically detects CI environments and includes:
+- CI run URLs (GitHub Actions, Azure DevOps, Jenkins, GitLab CI)
+- Git commit information
+- System environment data
+
+## Configuration Options
+
+All options are passed via CucumberJS's `formatOptions` in your configuration file.
+
+### `flakinessProject?: string`
+
+The Flakiness.io project identifier in `org/project` format. Used for GitHub OIDC authentication — when set, and the Flakiness.io project is bound to the GitHub repository running the workflow, the formatter authenticates uploads via GitHub Actions OIDC token with no access token required.
+
+```javascript
+formatOptions: {
+  flakinessProject: 'my-org/my-project',
+}
+```
+
+### `endpoint?: string`
+
+Custom Flakiness.io endpoint URL for uploading reports. Defaults to the `FLAKINESS_ENDPOINT` environment variable, or `https://flakiness.io` if not set.
+
+Use this option to point to a custom or self-hosted Flakiness.io instance.
+
+```javascript
+formatOptions: {
+  endpoint: 'https://custom.flakiness.io',
+}
+```
+
+### `token?: string`
+
+Access token for authenticating with Flakiness.io when uploading reports. Defaults to the `FLAKINESS_ACCESS_TOKEN` environment variable.
+
+If no token is provided, the formatter will attempt to authenticate using GitHub OIDC.
+
+```javascript
+formatOptions: {
+  token: 'your-access-token',
+}
+```
+
+### `outputFolder?: string`
+
+Directory path where the Flakiness report will be written. Defaults to `flakiness-report` in the current working directory, or the `FLAKINESS_OUTPUT_DIR` environment variable if set.
+
+```javascript
+formatOptions: {
+  outputFolder: './test-results/flakiness',
+}
+```
+
+### `disableUpload?: boolean`
+
+When set to `true`, prevents uploading the report to Flakiness.io. The report is still generated locally. Can also be controlled via the `FLAKINESS_DISABLE_UPLOAD` environment variable.
+
+```javascript
+formatOptions: {
+  disableUpload: true,
+}
+```
+
+## Example Configuration
+
+Here's a complete example with all options:
+
+```javascript
+export default {
+  paths: ['features/**/*.feature'],
+  import: ['features/support/**/*.ts'],
+  format: ['@flakiness/cucumberjs', 'progress'],
+  formatOptions: {
+    flakinessProject: 'my-org/my-project',
+    endpoint: process.env.FLAKINESS_ENDPOINT,
+    token: process.env.FLAKINESS_ACCESS_TOKEN,
+    outputFolder: './flakiness-report',
+    disableUpload: false,
+  },
+};
+```

package/lib/formatter.js

@@ -0,0 +1,448 @@
+import { Formatter, formatterHelpers } from "@cucumber/cucumber";
+import { AttachmentContentEncoding, TestStepResultStatus } from "@cucumber/messages";
+import {
+  CIUtils,
+  CPUUtilization,
+  GitWorktree,
+  RAMUtilization,
+  ReportUtils,
+  uploadReport,
+  writeReport
+} from "@flakiness/sdk";
+import fs from "node:fs";
+import path from "node:path";
+const CUCUMBER_LOG_MEDIA_TYPE = "text/x.cucumber.log+plain";
+class FlakinessCucumberFormatter extends Formatter {
+  static documentation = "Generates a Flakiness report for a CucumberJS run.";
+  _config;
+  _cpuUtilization = new CPUUtilization({ precision: 10 });
+  _ramUtilization = new RAMUtilization({ precision: 10 });
+  _startTimestamp = Date.now();
+  _outputFolder;
+  _telemetryTimer;
+  _finishedPromise = new ManualPromise();
+  _testCaseStartedById = /* @__PURE__ */ new Map();
+  _testCaseFinishedById = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super(options);
+    this._config = parseFormatterConfig(options.parsedArgvOptions);
+    this._outputFolder = path.resolve(this.cwd, this._config.outputFolder ?? process.env.FLAKINESS_OUTPUT_DIR ?? "flakiness-report");
+    this._sampleSystem = this._sampleSystem.bind(this);
+    this._sampleSystem();
+    options.eventBroadcaster.on("envelope", (envelope) => {
+      if (envelope.testRunStarted)
+        this._onTestRunStarted(envelope.testRunStarted);
+      if (envelope.testCaseStarted)
+        this._onTestCaseStarted(envelope.testCaseStarted);
+      if (envelope.testCaseFinished)
+        this._onTestCaseFinished(envelope.testCaseFinished);
+      if (envelope.testRunFinished) {
+        this._onTestRunFinished(envelope.testRunFinished).then(() => this._finishedPromise.resolve(void 0)).catch((e) => this._finishedPromise.reject(e));
+      }
+    });
+  }
+  _onTestRunStarted(testRunStarted) {
+    this._startTimestamp = toUnixTimestampMS(testRunStarted.timestamp);
+  }
+  _onTestCaseStarted(testCaseStarted) {
+    this._testCaseStartedById.set(testCaseStarted.id, testCaseStarted);
+  }
+  _onTestCaseFinished(testCaseFinished) {
+    this._testCaseFinishedById.set(testCaseFinished.testCaseStartedId, testCaseFinished);
+  }
+  async finished() {
+    if (this._telemetryTimer)
+      clearTimeout(this._telemetryTimer);
+    try {
+      await this._finishedPromise.promise;
+    } catch (error) {
+      console.error(`[flakiness.io] Failed to generate report: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+    }
+    await super.finished();
+  }
+  _sampleSystem() {
+    this._cpuUtilization.sample();
+    this._ramUtilization.sample();
+    this._telemetryTimer = setTimeout(this._sampleSystem, 1e3);
+  }
+  async _onTestRunFinished(testRunFinished) {
+    this._cpuUtilization.sample();
+    this._ramUtilization.sample();
+    let worktree;
+    let commitId;
+    try {
+      worktree = GitWorktree.create(this.cwd);
+      commitId = worktree.headCommitId();
+    } catch {
+      console.warn("[flakiness.io] Failed to fetch commit info - is this a git repo?");
+      console.error("[flakiness.io] Report is NOT generated.");
+      return;
+    }
+    const { attachments, suites } = await this._collectSuites(worktree);
+    const report = ReportUtils.normalizeReport({
+      category: "cucumberjs",
+      commitId,
+      duration: toUnixTimestampMS(testRunFinished.timestamp) - this._startTimestamp,
+      environments: [
+        ReportUtils.createEnvironment({
+          name: "cucumberjs"
+        })
+      ],
+      flakinessProject: this._config.flakinessProject,
+      suites,
+      startTimestamp: this._startTimestamp,
+      url: CIUtils.runUrl()
+    });
+    ReportUtils.collectSources(worktree, report);
+    this._cpuUtilization.enrich(report);
+    this._ramUtilization.enrich(report);
+    await writeReport(report, attachments, this._outputFolder);
+    const disableUpload = this._config.disableUpload ?? envBool("FLAKINESS_DISABLE_UPLOAD");
+    if (!disableUpload) {
+      await uploadReport(report, attachments, {
+        flakinessAccessToken: this._config.token,
+        flakinessEndpoint: this._config.endpoint
+      });
+    }
+    const defaultOutputFolder = path.join(this.cwd, "flakiness-report");
+    const folder = defaultOutputFolder === this._outputFolder ? "" : path.relative(this.cwd, this._outputFolder);
+    this.log(`
+To open last Flakiness report, run:
+
+  npx flakiness show ${folder}
+`);
+  }
+  async _collectSuites(worktree) {
+    const suitesByKey = /* @__PURE__ */ new Map();
+    const testsById = /* @__PURE__ */ new Map();
+    const attachments = /* @__PURE__ */ new Map();
+    const parallelIndexByWorkerId = /* @__PURE__ */ new Map();
+    for (const [testCaseStartedId, testCaseStarted] of this._testCaseStartedById) {
+      const attemptData = this.eventDataCollector.getTestCaseAttempt(testCaseStartedId);
+      const parsedAttempt = formatterHelpers.parseTestCaseAttempt({
+        testCaseAttempt: attemptData,
+        snippetBuilder: this.snippetBuilder,
+        supportCodeLibrary: this.supportCodeLibrary
+      });
+      const featureUri = attemptData.pickle.uri;
+      const fileSuite = getOrCreateFileSuite(suitesByKey, worktree, this.cwd, featureUri);
+      const featureSuite = getOrCreateFeatureSuite(
+        suitesByKey,
+        fileSuite,
+        worktree,
+        this.cwd,
+        featureUri,
+        attemptData.gherkinDocument
+      );
+      const rule = findRuleForPickle(attemptData.gherkinDocument, attemptData.pickle);
+      const parentSuite = rule ? getOrCreateRuleSuite(suitesByKey, featureSuite, worktree, this.cwd, featureUri, rule) : featureSuite;
+      let test = testsById.get(attemptData.testCase.id);
+      if (!test) {
+        test = {
+          title: toFKTestTitle(attemptData.gherkinDocument, attemptData.pickle),
+          location: attemptData.pickle.location ? createLocation(worktree, this.cwd, featureUri, attemptData.pickle.location) : void 0,
+          tags: attemptData.pickle.tags.map((tag) => stripTagPrefix(tag.name)),
+          attempts: []
+        };
+        testsById.set(attemptData.testCase.id, test);
+        parentSuite.tests.push(test);
+      }
+      const testCaseFinished = this._testCaseFinishedById.get(testCaseStartedId);
+      const startTimestamp = toUnixTimestampMS(testCaseStarted.timestamp);
+      const finishTimestamp = testCaseFinished ? toUnixTimestampMS(testCaseFinished.timestamp) : startTimestamp;
+      const errors = parsedAttempt.testSteps.map((step) => extractErrorFromStep(worktree, this.cwd, step)).filter((error) => !!error);
+      const stdio = extractSTDIOFromTestSteps(parsedAttempt.testSteps, startTimestamp);
+      let parallelIndex;
+      if (testCaseStarted.workerId) {
+        parallelIndex = parallelIndexByWorkerId.get(testCaseStarted.workerId);
+        if (parallelIndex === void 0) {
+          parallelIndex = parallelIndexByWorkerId.size;
+          parallelIndexByWorkerId.set(testCaseStarted.workerId, parallelIndex);
+        }
+      }
+      test.attempts.push({
+        environmentIdx: 0,
+        startTimestamp,
+        duration: Math.max(0, finishTimestamp - startTimestamp),
+        status: toFKStatus(attemptData.worstTestStepResult.status),
+        parallelIndex,
+        annotations: extractAttemptAnnotations(worktree, this.cwd, featureUri, attemptData.gherkinDocument, attemptData.pickle),
+        errors: errors.length ? errors : void 0,
+        attachments: await extractAttachmentsFromTestSteps(parsedAttempt.testSteps, attachments),
+        stdio: stdio.length ? stdio : void 0,
+        steps: parsedAttempt.testSteps.map((step) => ({
+          title: toFKStepTitle(step),
+          duration: toDurationMS(step.result.duration),
+          error: extractErrorFromStep(worktree, this.cwd, step),
+          location: step.sourceLocation ? createLineAndUriLocation(worktree, this.cwd, step.sourceLocation) : step.actionLocation ? createLineAndUriLocation(worktree, this.cwd, step.actionLocation) : void 0
+        }))
+      });
+    }
+    return {
+      attachments: Array.from(attachments.values()),
+      suites: Array.from(suitesByKey.values()).filter((suite) => suite.type === "file")
+    };
+  }
+}
+function envBool(name) {
+  return ["1", "true"].includes(process.env[name]?.toLowerCase() ?? "");
+}
+function parseFormatterConfig(parsedArgvOptions) {
+  return {
+    disableUpload: typeof parsedArgvOptions.disableUpload === "boolean" ? parsedArgvOptions.disableUpload : void 0,
+    endpoint: typeof parsedArgvOptions.endpoint === "string" ? parsedArgvOptions.endpoint : void 0,
+    flakinessProject: typeof parsedArgvOptions.flakinessProject === "string" ? parsedArgvOptions.flakinessProject : void 0,
+    outputFolder: typeof parsedArgvOptions.outputFolder === "string" ? parsedArgvOptions.outputFolder : void 0,
+    token: typeof parsedArgvOptions.token === "string" ? parsedArgvOptions.token : void 0
+  };
+}
+function createLocation(worktree, cwd, relativeFile, location) {
+  return {
+    file: worktree.gitPath(canonicalizeAbsolutePath(path.resolve(cwd, relativeFile))),
+    line: location.line,
+    column: location.column ?? 1
+  };
+}
+function stripTagPrefix(tag) {
+  return tag.startsWith("@") ? tag.slice(1) : tag;
+}
+function getOrCreateFileSuite(suitesByKey, worktree, cwd, featureUri) {
+  const key = `file:${featureUri}`;
+  let suite = suitesByKey.get(key);
+  if (!suite) {
+    suite = {
+      type: "file",
+      title: path.basename(featureUri),
+      location: createLocation(worktree, cwd, featureUri, { line: 0, column: 0 }),
+      suites: []
+    };
+    suitesByKey.set(key, suite);
+  }
+  return suite;
+}
+function getOrCreateFeatureSuite(suitesByKey, fileSuite, worktree, cwd, featureUri, gherkinDocument) {
+  const key = `feature:${featureUri}`;
+  let suite = suitesByKey.get(key);
+  if (!suite) {
+    suite = {
+      type: "suite",
+      title: gherkinDocument.feature?.name ?? "",
+      location: gherkinDocument.feature?.location ? createLocation(worktree, cwd, featureUri, gherkinDocument.feature.location) : void 0,
+      suites: [],
+      tests: []
+    };
+    suitesByKey.set(key, suite);
+    fileSuite.suites.push(suite);
+  }
+  return suite;
+}
+function getOrCreateRuleSuite(suitesByKey, featureSuite, worktree, cwd, featureUri, rule) {
+  const key = `rule:${featureUri}:${rule.id}`;
+  let suite = suitesByKey.get(key);
+  if (!suite) {
+    suite = {
+      type: "suite",
+      title: rule.name,
+      location: createLocation(worktree, cwd, featureUri, rule.location),
+      tests: []
+    };
+    suitesByKey.set(key, suite);
+    featureSuite.suites.push(suite);
+  }
+  return suite;
+}
+function extractAttemptAnnotations(worktree, cwd, featureUri, gherkinDocument, pickle) {
+  const annotations = [
+    createDescriptionAnnotation("feature", worktree, cwd, featureUri, gherkinDocument.feature),
+    createDescriptionAnnotation("rule", worktree, cwd, featureUri, findRuleForPickle(gherkinDocument, pickle)),
+    createDescriptionAnnotation("scenario", worktree, cwd, featureUri, findScenarioForPickle(gherkinDocument, pickle))
+  ].filter((annotation) => !!annotation);
+  return annotations.length ? annotations : void 0;
+}
+function createDescriptionAnnotation(type, worktree, cwd, featureUri, node) {
+  const description = normalizeDescription(node?.description);
+  if (!description || !node)
+    return void 0;
+  return {
+    type,
+    description,
+    location: createLocation(worktree, cwd, featureUri, node.location)
+  };
+}
+function findRuleForPickle(gherkinDocument, pickle) {
+  const astNodeIds = new Set(pickle.astNodeIds);
+  for (const child of gherkinDocument.feature?.children ?? []) {
+    if (!child.rule)
+      continue;
+    const hasScenario = child.rule.children.some((ruleChild) => ruleChild.scenario && astNodeIds.has(ruleChild.scenario.id));
+    if (hasScenario)
+      return child.rule;
+  }
+  return void 0;
+}
+function findScenarioForPickle(gherkinDocument, pickle) {
+  const astNodeIds = new Set(pickle.astNodeIds);
+  return collectScenarios(gherkinDocument.feature).find((scenario) => astNodeIds.has(scenario.id));
+}
+function toFKTestTitle(gherkinDocument, pickle) {
+  const exampleValues = extractScenarioOutlineValues(gherkinDocument, pickle);
+  if (exampleValues)
+    return `${pickle.name} [${exampleValues.map(([key, value]) => `${key}=${value}`).join(", ")}]`;
+  return pickle.name;
+}
+function extractScenarioOutlineValues(gherkinDocument, pickle) {
+  if (pickle.astNodeIds.length < 2)
+    return void 0;
+  const exampleRowId = pickle.astNodeIds[pickle.astNodeIds.length - 1];
+  for (const scenario of collectScenarios(gherkinDocument.feature)) {
+    for (const examples of scenario.examples) {
+      const row = examples.tableBody.find((row2) => row2.id === exampleRowId);
+      if (!row)
+        continue;
+      const headers = examples.tableHeader?.cells.map((cell) => cell.value) ?? [];
+      return row.cells.map((cell, index) => [headers[index] ?? `column${index + 1}`, cell.value]);
+    }
+  }
+  return void 0;
+}
+function collectScenarios(feature) {
+  return (feature?.children ?? []).flatMap((child) => {
+    if (child.rule)
+      return child.rule.children.flatMap((ruleChild) => ruleChild.scenario ? [ruleChild.scenario] : []);
+    return child.scenario ? [child.scenario] : [];
+  });
+}
+function normalizeDescription(description) {
+  const value = description?.trim();
+  if (!value)
+    return void 0;
+  const lines = value.split("\n");
+  const commonIndent = lines.slice(1).filter((line) => line.trim()).reduce((indent, line) => Math.min(indent, line.match(/^ */)?.[0].length ?? 0), Number.POSITIVE_INFINITY);
+  if (!Number.isFinite(commonIndent) || commonIndent === 0)
+    return value;
+  return [
+    lines[0],
+    ...lines.slice(1).map((line) => line.slice(commonIndent))
+  ].join("\n");
+}
+function toFKStatus(status) {
+  switch (status) {
+    case TestStepResultStatus.PASSED:
+      return "passed";
+    case TestStepResultStatus.SKIPPED:
+      return "skipped";
+    case TestStepResultStatus.UNKNOWN:
+      return "interrupted";
+    case TestStepResultStatus.PENDING:
+    case TestStepResultStatus.UNDEFINED:
+    case TestStepResultStatus.AMBIGUOUS:
+    case TestStepResultStatus.FAILED:
+      return "failed";
+    default:
+      return "interrupted";
+  }
+}
+function toUnixTimestampMS(timestamp) {
+  return timestamp.seconds * 1e3 + Math.floor(timestamp.nanos / 1e6);
+}
+function toDurationMS(timestamp) {
+  return timestamp.seconds * 1e3 + Math.floor(timestamp.nanos / 1e6);
+}
+function createLineAndUriLocation(worktree, cwd, location) {
+  return {
+    file: worktree.gitPath(canonicalizeAbsolutePath(path.resolve(cwd, location.uri))),
+    line: location.line,
+    column: 1
+  };
+}
+function canonicalizeAbsolutePath(absolutePath) {
+  try {
+    return fs.realpathSync.native(absolutePath);
+  } catch {
+    return absolutePath;
+  }
+}
+function toFKStepTitle(step) {
+  return step.text ? `${step.keyword}${step.text}`.trim() : step.name ? `${step.keyword} (${step.name})` : step.keyword;
+}
+function extractErrorFromStep(worktree, cwd, step) {
+  const status = step.result.status;
+  if (status === TestStepResultStatus.PASSED || status === TestStepResultStatus.SKIPPED || status === TestStepResultStatus.UNKNOWN) {
+    return void 0;
+  }
+  const message = step.result.exception?.message ?? step.result.message ?? (status === TestStepResultStatus.PENDING ? "Step is pending" : status === TestStepResultStatus.UNDEFINED ? "Undefined step" : void 0);
+  const location = step.sourceLocation ? createLineAndUriLocation(worktree, cwd, step.sourceLocation) : step.actionLocation ? createLineAndUriLocation(worktree, cwd, step.actionLocation) : void 0;
+  return message ? {
+    location,
+    message,
+    stack: step.result.exception?.stackTrace,
+    snippet: step.snippet
+  } : void 0;
+}
+function extractSTDIOFromTestSteps(steps, startTimestamp) {
+  const stdio = [];
+  let previousTimestamp = startTimestamp;
+  for (const step of steps) {
+    for (const attachment of step.attachments) {
+      if (attachment.mediaType !== CUCUMBER_LOG_MEDIA_TYPE)
+        continue;
+      const timestamp = attachment.timestamp ? toUnixTimestampMS(attachment.timestamp) : previousTimestamp;
+      stdio.push({
+        ...attachment.contentEncoding === AttachmentContentEncoding.BASE64 ? {
+          buffer: attachment.body
+        } : {
+          text: attachment.body
+        },
+        dts: Math.max(0, timestamp - previousTimestamp)
+      });
+      previousTimestamp = timestamp;
+    }
+  }
+  return stdio;
+}
+async function extractAttachmentsFromTestSteps(steps, attachments) {
+  const fkAttachments = [];
+  for (const step of steps) {
+    for (const attachment of step.attachments) {
+      if (attachment.mediaType === CUCUMBER_LOG_MEDIA_TYPE)
+        continue;
+      const dataAttachment = await ReportUtils.createDataAttachment(
+        attachment.mediaType,
+        decodeAttachmentBody(attachment)
+      );
+      attachments.set(dataAttachment.id, dataAttachment);
+      fkAttachments.push({
+        id: dataAttachment.id,
+        name: attachment.fileName ?? `attachment-${fkAttachments.length + 1}`,
+        contentType: attachment.mediaType
+      });
+    }
+  }
+  return fkAttachments;
+}
+function decodeAttachmentBody(attachment) {
+  if (attachment.contentEncoding === AttachmentContentEncoding.BASE64)
+    return Buffer.from(attachment.body, "base64");
+  return Buffer.from(attachment.body, "utf8");
+}
+class ManualPromise {
+  promise;
+  _resolve;
+  _reject;
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(e) {
+    this._resolve(e);
+  }
+  reject(e) {
+    this._reject(e);
+  }
+}
+export {
+  FlakinessCucumberFormatter as default
+};
+//# sourceMappingURL=formatter.js.map

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@flakiness/cucumberjs",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flakiness/cucumberjs.git"
+  },
   "description": "",
   "exports": {
     ".": {
@@ -11,11 +15,6 @@
   },
   "main": "./lib/formatter.js",
   "types": "./types/src/formatter.d.ts",
-  "scripts": {
-    "build": "kubik build.mts",
-    "test": "cucumber-js",
-    "coverage": "c8 --reporter=text --reporter=html --include=lib/formatter.js cucumber-js"
-  },
   "keywords": [],
   "author": "",
   "license": "MIT",
@@ -27,11 +26,17 @@
   "devDependencies": {
     "@cucumber/cucumber": "^12.7.0",
     "@cucumber/messages": "^32.2.0",
+    "@flakiness/cucumberjs": "1.0.0-alpha.1",
     "@types/node": "^25.5.0",
     "c8": "^11.0.0",
     "esbuild": "^0.27.4",
     "kubik": "^0.24.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "kubik build.mts",
+    "test": "cucumber-js",
+    "coverage": "c8 --reporter=text --reporter=html --include=lib/formatter.js cucumber-js"
   }
-}
+}