@flakiness/cucumberjs 1.0.0-alpha.0 → 1.0.0-alpha.1

package/lib/formatter.js

@@ -0,0 +1,438 @@
+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();
+    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);
+      test.attempts.push({
+        environmentIdx: 0,
+        startTimestamp,
+        duration: Math.max(0, finishTimestamp - startTimestamp),
+        status: toFKStatus(attemptData.worstTestStepResult.status),
+        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,6 @@
 {
   "name": "@flakiness/cucumberjs",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.1",
   "description": "",
   "exports": {
     ".": {
@@ -11,11 +11,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",
@@ -33,5 +28,10 @@
     "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"
   }
-}
+}

package/types/src/formatter.d.ts

@@ -0,0 +1,23 @@
+import type { IFormatterOptions } from '@cucumber/cucumber';
+import { Formatter } from '@cucumber/cucumber';
+export default class FlakinessCucumberFormatter extends Formatter {
+    static documentation: string;
+    private _config;
+    private _cpuUtilization;
+    private _ramUtilization;
+    private _startTimestamp;
+    private _outputFolder;
+    private _telemetryTimer?;
+    private _finishedPromise;
+    private _testCaseStartedById;
+    private _testCaseFinishedById;
+    constructor(options: IFormatterOptions);
+    private _onTestRunStarted;
+    private _onTestCaseStarted;
+    private _onTestCaseFinished;
+    finished(): Promise<void>;
+    private _sampleSystem;
+    private _onTestRunFinished;
+    private _collectSuites;
+}
+//# sourceMappingURL=formatter.d.ts.map

package/types/src/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../src/formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAoB,MAAM,oBAAoB,CAAC;AAiDjE,MAAM,CAAC,OAAO,OAAO,0BAA2B,SAAQ,SAAS;IAC/D,MAAM,CAAC,aAAa,SAAwD;IAE5E,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,eAAe,CAAyC;IAChE,OAAO,CAAC,eAAe,CAAyC;IAChE,OAAO,CAAC,eAAe,CAAoC;IAC3D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,eAAe,CAAC,CAAiB;IAEzC,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,oBAAoB,CAAsC;IAClE,OAAO,CAAC,qBAAqB,CAAuC;gBAExD,OAAO,EAAE,iBAAiB;IA0BtC,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,mBAAmB;IAIZ,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxC,OAAO,CAAC,aAAa;YAMP,kBAAkB;YAsDlB,cAAc;CA+E7B"}

package/.github/workflows/flakiness-upload-fork-prs.yml

@@ -1,30 +0,0 @@
-name: Upload Flakiness.io report (fork PRs)
-on:
-  workflow_run:
-    # Must match the name(s) of workflows that produce flakiness-report artifacts
-    workflows: ["Tests"]
-    types: [completed]
-
-jobs:
-  upload-flakiness-report:
-    runs-on: ubuntu-latest
-    if: >-
-      (github.event.workflow_run.conclusion == 'success' || github.event.workflow_run.conclusion == 'failure')
-      && github.event.workflow_run.event == 'pull_request'
-      && github.event.workflow_run.head_repository.full_name != github.event.workflow_run.repository.full_name
-    permissions:
-      actions: read
-      contents: read
-      id-token: write
-    steps:
-      - name: Install Flakiness CLI
-        run: curl -LsSf https://cli.flakiness.io/install.sh | sh
-
-      - name: Download flakiness-report artifacts
-        env:
-          GH_TOKEN: ${{ github.token }}
-          RUN_ID: ${{ github.event.workflow_run.id }}
-        run: gh run download "$RUN_ID" --repo "$GITHUB_REPOSITORY" --pattern 'flakiness-report-*' --dir .
-
-      - name: Upload to Flakiness.io
-        run: find . -path '*/flakiness-report-*/report.json' -exec flakiness upload {} \;

package/.github/workflows/publish-npm.yml

@@ -1,41 +0,0 @@
-name: Publish to NPM
-
-on:
-  release:
-    types: [published]
-
-permissions:
-  id-token: write  # Required for OIDC
-  contents: read
-
-jobs:
-  publish-to-npm:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 24
-
-      - name: Setup PNPM
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-
-      - name: Build & Publish
-        run: |
-          pnpm i --frozen-lockfile
-          pnpm build
-
-          VERSION=${GITHUB_REF_NAME#v}
-
-          if [[ "$VERSION" == *"-"* ]]; then
-            echo "Publishing prerelease to @next"
-            pnpm publish --access=public --no-git-checks --tag next
-          else
-            echo "Publishing stable to @latest"
-            pnpm publish --access=public --no-git-checks
-          fi

package/.github/workflows/tests.yml

@@ -1,45 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-permissions:
-  contents: read
-  id-token: write
-
-jobs:
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: lts/*
-          cache: pnpm
-
-      # Since tests initialize git repositories, we have
-      # to configure git to avoid warnings.
-      - run: git config --global init.defaultBranch main
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm build
-      - run: pnpm test
-      - name: Upload Flakiness report artifact (for Pull Requests from forks)
-        if: always() && github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork
-        uses: actions/upload-artifact@v4
-        with:
-          name: flakiness-report-${{ github.job }}-${{ strategy.job-index }}
-          path: flakiness-report/
-          retention-days: 1

package/CONTRIBUTING.md

@@ -1,58 +0,0 @@
-# Contributing
-
-## Prerequisites
-
-- Node.js 22+
-- [pnpm](https://pnpm.io/)
-
-## Getting Started
-
-Clone the repo and install dependencies:
-
-```bash
-git clone https://github.com/flakiness/cucumberjs.git fk-cucumber
-cd fk-cucumber
-pnpm install
-```
-
-## Building
-
-This project uses [Kubik](https://github.com/flakiness/kubik) as its build system. The build script is defined in `build.mts`.
-
-To build:
-
-```bash
-pnpm build
-```
-
-To watch:
-
-```bash
-pnpm build -w
-```
-
-This will bundle the source with esbuild and generate TypeScript declarations.
-
-## Releasing
-
-To release a new version:
-
-1. Bump the version:
-
-   ```bash
-   # For a stable minor release
-   pnpm version minor
-
-   # For an alpha pre-release
-   pnpm version preminor --preid=alpha
-   ```
-
-2. Push the commit and tag:
-
-   ```bash
-   git push --follow-tags
-   ```
-
-3. [Create a GitHub Release](https://github.com/flakiness/cucumberjs/releases/new) for the new tag and publish it.
-
-   CI will handle publishing to npm. Pre-releases are published under @next tag.

package/agenda.md

@@ -1,2 +0,0 @@
-- descriptions as annotations
-