@step-forge/step-forge 0.0.20 → 0.0.22

package/README.md

@@ -4,6 +4,8 @@ Step Forge is a typed wrapper around the Cucumber library. It provides an opinio
 
 This is just a primer, see the [official documentation site](https://step-forge.com) for more information.
 
+To run your `.feature` files against these steps, see the **[Runtime guide](./RUNTIME.md)** — configuration, the `step-forge` CLI, hooks, filtering, and concurrency.
+
 ## Installation
 
 ```bash

package/RUNTIME.md

@@ -0,0 +1,242 @@
+# Step Forge Runtime
+
+The Step Forge runtime executes your `.feature` files against your step
+definitions. It is a native TypeScript runner built for speed and Cucumber-like
+semantics — it does **not** run the Cucumber.js runtime, and it does not require
+a bundler or a separate test framework.
+
+If you only want to run features, this document is all you need. For how to
+_write_ steps, the world, parsers, and dependencies, see the main
+[README](./README.md).
+
+---
+
+## Requirements
+
+The runner executes under **[Bun](https://bun.sh)** so your TypeScript step
+files run directly, with no transpile/build step and no loader configuration.
+Bun is the one hard requirement:
+
+```bash
+curl -fsSL https://bun.sh/install | bash   # or: brew install oven-sh/bun/bun
+```
+
+Everything the runner touches beyond that uses standard `node:` APIs, so your
+step code stays ordinary TypeScript.
+
+## Install
+
+```bash
+npm install --save-dev @step-forge/step-forge
+```
+
+## Quickstart
+
+1. **Write step definitions.** A step self-registers the moment you call
+   `.step(...)` — no separate registration call. Put them in files matched by
+   your `steps` glob (default `**/*.steps.ts`).
+
+   ```ts
+   // features/steps/user.steps.ts
+   import { givenBuilder, thenBuilder } from "@step-forge/step-forge";
+
+   givenBuilder<{ user: string }>()
+     .statement((name: string) => `a user named ${name}`)
+     .step(({ variables: [name] }) => ({ user: name }));
+
+   thenBuilder<{ user: string }, {}, {}>()
+     .statement((name: string) => `the user is ${name}`)
+     .dependencies({ given: { user: "required" } })
+     .step(({ variables: [name], given: { user } }) => {
+       if (user !== name) throw new Error(`expected ${name}, got ${user}`);
+     });
+   ```
+
+2. **Provide a world factory** (optional). One fresh world is created per
+   scenario, so state never leaks between scenarios. Omit this to get a default
+   `BasicWorld`.
+
+   ```ts
+   // features/support/world.ts
+   import { BasicWorld } from "@step-forge/step-forge";
+   export default () => new BasicWorld();
+   ```
+
+3. **Add a config file** (optional but recommended).
+
+   ```ts
+   // step-forge.config.ts
+   import type { RunnerOptions } from "@step-forge/step-forge";
+
+   const config: RunnerOptions = {
+     features: "features/**/*.feature",
+     steps: "features/**/*.steps.ts",
+     world: "features/support/world.ts",
+   };
+   export default config;
+   ```
+
+4. **Run.**
+
+   ```bash
+   step-forge
+   ```
+
+   A typical `package.json` wires it as the test script:
+
+   ```json
+   { "scripts": { "test": "step-forge" } }
+   ```
+
+## Configuration
+
+Config is resolved from three sources, later ones overriding earlier ones:
+**defaults → `step-forge.config.ts` → CLI flags**. Every field is optional.
+
+| Field         | Type                      | Default            | Meaning                                                                 |
+| ------------- | ------------------------- | ------------------ | ----------------------------------------------------------------------- |
+| `features`    | `string \| string[]`      | `**/*.feature`     | Feature-file glob(s), relative to the config directory.                 |
+| `steps`       | `string \| string[]`      | `**/*.steps.ts`    | Step-module glob(s). Importing them is what registers your steps.       |
+| `world`       | `string`                  | `BasicWorld`       | Module that default-exports a world factory `() => world`.              |
+| `concurrency` | `number`                  | `1` (serial)       | Max scenarios in flight at once. See [Concurrency](#concurrency).       |
+| `reporter`    | `"pretty" \| "progress"`  | `pretty`           | Output style. See [Reporters & output](#reporters--output).             |
+| `verbose`     | `boolean`                 | `false`            | Report every scenario, not just failures.                               |
+| `name`        | `string`                  | —                  | Only scenarios whose name matches (substring, or `/regex/flags`).       |
+| `tags`        | `string`                  | —                  | Cucumber tag expression, e.g. `@smoke and not @wip`.                    |
+
+The config file is loaded by Bun, so it may be TypeScript and import the
+`RunnerOptions` type for editor help.
+
+## CLI
+
+```
+step-forge [options] [feature globs...]
+```
+
+Positional arguments are feature globs and **override** the configured
+`features`, so you can run a subset ad hoc.
+
+| Flag                    | Short | Description                                             |
+| ----------------------- | ----- | ------------------------------------------------------- |
+| `--tags <expr>`         | `-t`  | Tag expression, e.g. `"@smoke and not @wip"`.           |
+| `--name <pattern>`      | `-n`  | Only scenarios whose name matches (substring/`/regex/`).|
+| `--steps <glob>`        | `-s`  | Step-module glob (repeatable).                          |
+| `--world <module>`      | `-w`  | World factory module.                                   |
+| `--concurrency <n>`     | `-c`  | Max scenarios in flight (default `1`).                  |
+| `--reporter <name>`     | `-r`  | `pretty` (default) or `progress`.                       |
+| `--verbose`             | `-v`  | Report every scenario, not just failures.               |
+| `--config <path>`       |       | Directory to resolve the config file and globs from.    |
+| `--help`                | `-h`  | Show usage.                                             |
+
+Examples:
+
+```bash
+step-forge features/checkout.feature          # one file
+step-forge --tags "@smoke and not @wip"       # by tag
+step-forge --name "logs in"                    # by scenario name
+step-forge --concurrency 8 --reporter progress # parallel, compact output
+```
+
+The process exits `0` when every scenario passes and `1` when any scenario
+fails, so it drops straight into CI.
+
+## Hooks
+
+Hooks are side-effect callbacks for setup/teardown (start a server, reset a
+mock). They **never seed scenario state** — that flows exclusively through
+`given`/`when`/`then` so the typed dependency graph stays the single source of
+truth. Import them from the main entry:
+
+```ts
+import {
+  beforeAll,
+  afterAll,
+  beforeFeature,
+  afterFeature,
+  beforeScenario,
+  afterScenario,
+} from "@step-forge/step-forge";
+
+beforeScenario(({ world, scenario }) => {
+  /* fresh world available; reset external state here */
+});
+```
+
+| Hook                  | Runs                                             |
+| --------------------- | ------------------------------------------------ |
+| `beforeAll`/`afterAll` | Once around the entire run — `beforeAll` before concurrency starts, `afterAll` after every scenario is done. |
+| `beforeFeature`/`afterFeature` | Around each feature file.               |
+| `beforeScenario`/`afterScenario` | Around each scenario (gets its world).|
+
+Multiple `beforeAll` (and multiple `afterAll`) hooks run **in parallel** with no
+ordering between them — if one setup step must precede another, sequence both
+inside a single hook. Feature and scenario `after*` hooks instead run in reverse
+registration order so teardown unwinds setup, and `afterScenario` runs even when
+a step failed.
+
+## Filtering
+
+- **Tags** — `--tags` / `tags` accepts a Cucumber tag expression with `and`,
+  `or`, `not`, parentheses, and `@tag` atoms:
+  `@smoke and (@fast or not @flaky)`.
+- **Name** — `--name` / `name` is a substring by default, or a regex if written
+  as `/pattern/flags`.
+- **`@skip`** — a scenario tagged `@skip` is never executed and is reported as
+  skipped (not dropped silently).
+- **`@only`** — if any selected scenario is tagged `@only`, the run is focused to
+  just those. `@skip` wins over `@only`.
+
+## Concurrency
+
+Scenarios run **serially by default** (`concurrency: 1`), matching Cucumber.
+Raise `--concurrency` (or the `concurrency` config field) to run scenarios
+concurrently in a single process — ideal for I/O-bound suites.
+
+This is safe because of one opinionated invariant Step Forge holds:
+
+> **Module state is immutable and scenario-isolated.** All mutable scenario
+> state lives in the per-scenario world (already isolated); anything at module
+> scope is write-once configuration or pure lookups.
+
+Because mutable state can't be shared across scenarios, concurrent scenarios
+cannot corrupt one another — no worker threads or process isolation required.
+The corollary is a rule to follow in your own code: **do not have a hook or step
+write to a mutable module-level variable that another step reads.** That is a
+cross-scenario data race and the only way to break parallel runs. Keep
+per-scenario state in the world and you can turn concurrency up freely.
+
+## Reporters & output
+
+By default the runner is quiet: it prints a dot per scenario as a heartbeat
+(`.` pass, `F` fail, `-` skip), then **only the failing scenarios** in detail,
+then a summary. Pass `--verbose` (`-v`) to report every scenario instead.
+
+Each failure is shown Cucumber-style so it's easy to locate:
+
+```
+✗ a user can log in
+    features/auth.feature:12
+
+  ✓ Given a registered user
+  ✗ Then they reach the dashboard
+      feature: features/auth.feature:15
+      defined: features/steps/auth.steps.ts:40
+      AssertionError: expected "/login" to equal "/dashboard"
+          at features/steps/auth.steps.ts:42:18
+```
+
+- **`feature:`** — the `.feature` file and line of the failing step.
+- **`defined:`** — where that step is defined (its `.step(...)` call site).
+- The stack is trimmed to your own code (library, engine, and `node_modules`
+  frames removed) and source-mapped by Bun to the original TypeScript, so the
+  top frame is the line in your step that actually threw.
+
+Two styles are available via `--reporter`:
+
+- **`pretty`** (default) — honours `--verbose`: failures-only by default, or the
+  full feature → scenario → step tree (each step annotated with its definition
+  location) under `--verbose`.
+- **`progress`** — always compact (dots + failures + summary); ignores
+  `--verbose`.
+
+Colour is emitted only to a TTY and is disabled when `NO_COLOR` is set.

package/dist/{analyzer-DJyJbU_V.js → analyzer-byS8yRrY.js}

@@ -1,7 +1,42 @@
-import { n as parseFeatureFiles } from "./gherkinParser-Dp2d7JNr.js";
-import { glob } from "node:fs/promises";
+import { glob, stat } from "node:fs/promises";
 import * as path from "node:path";
 import ts from "typescript";
+import * as fs from "node:fs";
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
+import * as messages from "@cucumber/messages";
+//#region src/globFiles.ts
+/** Glob metacharacters. A pattern with none of these is a literal path. */
+const MAGIC = /[*?[\]{}!()]/;
+async function isFile(p) {
+	try {
+		return (await stat(p)).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve glob patterns to a de-duplicated list of absolute file paths, with one
+* important portability guarantee: a **literal absolute path** (no glob magic)
+* is returned directly if it exists, without being handed to `glob()`.
+*
+* This exists because `node:fs`'s `glob` diverges between runtimes — Node
+* matches an absolute-path pattern, Bun returns nothing for one. Rather than
+* depend on that behaviour, we only ever glob relative patterns (against `cwd`)
+* and short-circuit concrete absolute paths ourselves, so callers get identical
+* results under Node and Bun.
+*/
+async function globFiles(patterns, cwd = process.cwd()) {
+	const files = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) {
+		if (path.isAbsolute(pattern) && !MAGIC.test(pattern)) {
+			if (await isFile(pattern)) files.add(pattern);
+			continue;
+		}
+		for await (const match of glob(pattern, { cwd })) files.add(path.resolve(cwd, match));
+	}
+	return [...files];
+}
+//#endregion
 //#region src/analyzer/stepExtractor.ts
 const BUILDER_NAMES = {
 	givenBuilder: "given",
@@ -9,6 +44,21 @@ const BUILDER_NAMES = {
 	thenBuilder: "then"
 };
 function extractStepDefinitions(filePaths, tsConfigPath) {
+	const fast = extractWithSources(filePaths.map(parseSourceFile).filter((s) => s !== null), null);
+	if (!fast.needsChecker) return fast.results;
+	const program = ts.createProgram(filePaths, resolveCompilerOptions(tsConfigPath));
+	const checker = program.getTypeChecker();
+	return extractWithSources(filePaths.map((fp) => program.getSourceFile(fp)).filter((s) => s !== void 0), checker).results;
+}
+/** Parse a single file into an AST with no type resolution. */
+function parseSourceFile(filePath) {
+	const text = ts.sys.readFile(filePath);
+	if (text === void 0) return null;
+	const scriptKind = filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+	return ts.createSourceFile(filePath, text, ts.ScriptTarget.ESNext, true, scriptKind);
+}
+/** Resolve compiler options from tsconfig (fallback to sane defaults). */
+function resolveCompilerOptions(tsConfigPath) {
 	const configPath = tsConfigPath ?? ts.findConfigFile(process.cwd(), ts.sys.fileExists);
 	let compilerOptions = {
 		target: ts.ScriptTarget.ESNext,
@@ -22,22 +72,25 @@ function extractStepDefinitions(filePaths, tsConfigPath) {
 		if (!configFile.error) compilerOptions = ts.parseJsonConfigFileContent(configFile.config, ts.sys, configPath.replace(/[/\\][^/\\]+$/, "")).options;
 	}
 	compilerOptions.noEmit = true;
-	const program = ts.createProgram(filePaths, compilerOptions);
-	const checker = program.getTypeChecker();
+	return compilerOptions;
+}
+function extractWithSources(sources, checker) {
+	const ctx = {
+		checker,
+		needsChecker: false
+	};
 	const results = [];
-	for (const filePath of filePaths) {
-		const sourceFile = program.getSourceFile(filePath);
-		if (!sourceFile) continue;
-		const fileResults = extractFromSourceFile(sourceFile, checker);
-		results.push(...fileResults);
-	}
-	return results;
+	for (const sourceFile of sources) results.push(...extractFromSourceFile(sourceFile, ctx));
+	return {
+		results,
+		needsChecker: ctx.needsChecker
+	};
 }
-function extractFromSourceFile(sourceFile, checker) {
+function extractFromSourceFile(sourceFile, ctx) {
 	const results = [];
 	function visit(node) {
 		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "step") {
-			const meta = extractFromRegisterCall(node, sourceFile, checker);
+			const meta = extractFromRegisterCall(node, sourceFile, ctx);
 			if (meta) results.push(meta);
 		}
 		ts.forEachChild(node, visit);
@@ -45,7 +98,7 @@ function extractFromSourceFile(sourceFile, checker) {
 	visit(sourceFile);
 	return results;
 }
-function extractFromRegisterCall(registerCall, sourceFile, checker) {
+function extractFromRegisterCall(registerCall, sourceFile, ctx) {
 	const chain = collectCallChain(registerCall);
 	let stepType = null;
 	let expression = null;
@@ -60,7 +113,7 @@ function extractFromRegisterCall(registerCall, sourceFile, checker) {
 		if (!name) continue;
 		if (name === "register") continue;
 		if (name === "step") {
-			produces = extractProducedKeys(link, checker);
+			produces = extractProducedKeys(link, ctx);
 			continue;
 		}
 		if (name === "dependencies") {
@@ -77,7 +130,7 @@ function extractFromRegisterCall(registerCall, sourceFile, checker) {
 		}
 	}
 	if (!stepType || !expression) {
-		const reExport = resolveReExportedCall(chain, checker);
+		const reExport = resolveReExportedCall(chain, ctx);
 		if (reExport) {
 			if (!stepType) stepType = reExport.stepType;
 			if (!expression) expression = reExport.expression;
@@ -164,33 +217,37 @@ function extractDependencies(depsCall) {
 	}
 	return deps;
 }
-function extractProducedKeys(stepCall, checker) {
+function extractProducedKeys(stepCall, ctx) {
 	const callback = stepCall.arguments[0];
 	if (!callback) return [];
-	if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, checker);
+	if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, ctx);
 	return [];
 }
-function extractProducedKeysFromCallback(callback, checker) {
+function extractProducedKeysFromCallback(callback, ctx) {
 	const body = callback.body;
-	if (!ts.isBlock(body)) return extractKeysFromExpression(body, checker);
+	if (!ts.isBlock(body)) return extractKeysFromExpression(body, ctx);
 	const keys = /* @__PURE__ */ new Set();
 	function visitReturn(node) {
-		if (ts.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, checker)) keys.add(key);
+		if (ts.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, ctx)) keys.add(key);
 		ts.forEachChild(node, visitReturn);
 	}
 	visitReturn(body);
 	return [...keys];
 }
-function extractKeysFromExpression(expr, checker) {
+function extractKeysFromExpression(expr, ctx) {
 	while (ts.isParenthesizedExpression(expr)) expr = expr.expression;
 	if (ts.isObjectLiteralExpression(expr)) return expr.properties.filter((p) => ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)).map((p) => p.name.getText()).filter(Boolean);
+	if (!ctx.checker) {
+		ctx.needsChecker = true;
+		return [];
+	}
 	try {
-		return checker.getTypeAtLocation(expr).getProperties().map((p) => p.name).filter((n) => n !== "merge");
+		return ctx.checker.getTypeAtLocation(expr).getProperties().map((p) => p.name).filter((n) => n !== "merge");
 	} catch {
 		return [];
 	}
 }
-function resolveReExportedCall(chain, checker) {
+function resolveReExportedCall(chain, ctx) {
 	const lastCall = chain[chain.length - 1];
 	if (!lastCall) return null;
 	const expr = lastCall.expression;
@@ -198,7 +255,11 @@ function resolveReExportedCall(chain, checker) {
 	if (ts.isIdentifier(expr)) identifier = expr;
 	else if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression)) identifier = expr.expression;
 	if (!identifier) return null;
-	const symbol = checker.getSymbolAtLocation(identifier);
+	if (!ctx.checker) {
+		ctx.needsChecker = true;
+		return null;
+	}
+	const symbol = ctx.checker.getSymbolAtLocation(identifier);
 	if (!symbol) return null;
 	const decl = symbol.valueDeclaration;
 	if (!decl || !ts.isVariableDeclaration(decl) || !decl.initializer) return null;
@@ -219,6 +280,118 @@ function resolveReExportedCall(chain, checker) {
 	return null;
 }
 //#endregion
+//#region src/analyzer/gherkinParser.ts
+function parseFeatureFiles(filePaths) {
+	const scenarios = [];
+	for (const filePath of filePaths) {
+		const parsed = parseFeatureContent(fs.readFileSync(filePath, "utf-8"), filePath);
+		scenarios.push(...parsed);
+	}
+	return scenarios;
+}
+function parseFeatureContent(content, filePath) {
+	const feature = new Parser(new AstBuilder(messages.IdGenerator.uuid()), new GherkinClassicTokenMatcher()).parse(content).feature;
+	if (!feature) return [];
+	const featureBackground = [];
+	const scenarios = [];
+	const featureTags = tagNames(feature.tags);
+	for (const child of feature.children) {
+		if (child.background) featureBackground.push(...child.background.steps);
+		if (child.scenario) scenarios.push(...expandScenario(child.scenario, featureBackground, filePath, featureTags));
+		if (child.rule) {
+			const ruleBackground = [...featureBackground];
+			const ruleTags = [...featureTags, ...tagNames(child.rule.tags)];
+			for (const ruleChild of child.rule.children) {
+				if (ruleChild.background) ruleBackground.push(...ruleChild.background.steps);
+				if (ruleChild.scenario) scenarios.push(...expandScenario(ruleChild.scenario, ruleBackground, filePath, ruleTags));
+			}
+		}
+	}
+	return scenarios;
+}
+/** Extract tag names (each keeping its leading `@`), deduped in order. */
+function tagNames(tags) {
+	return [...new Set((tags ?? []).map((t) => t.name))];
+}
+function expandScenario(scenario, backgroundSteps, filePath, inheritedTags) {
+	const scenarioTags = [...inheritedTags, ...tagNames(scenario.tags)];
+	if (!(scenario.examples.length > 0 && scenario.examples.some((e) => e.tableBody.length > 0))) {
+		const bgParsed = convertSteps(backgroundSteps);
+		const scenarioParsed = convertSteps(scenario.steps);
+		const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);
+		return [{
+			name: scenario.name,
+			file: filePath,
+			line: scenario.location.line,
+			steps: allSteps,
+			tags: scenarioTags
+		}];
+	}
+	const results = [];
+	for (const example of scenario.examples) {
+		if (!example.tableHeader || example.tableBody.length === 0) continue;
+		const headers = example.tableHeader.cells.map((c) => c.value);
+		const exampleTags = [...scenarioTags, ...tagNames(example.tags)];
+		for (const row of example.tableBody) {
+			const values = row.cells.map((c) => c.value);
+			const substitution = {};
+			headers.forEach((h, i) => {
+				substitution[h] = values[i];
+			});
+			const bgParsed = convertSteps(backgroundSteps);
+			const scenarioSteps = convertSteps(scenario.steps).map((step) => ({
+				...step,
+				text: substituteExampleValues(step.text, substitution)
+			}));
+			const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);
+			results.push({
+				name: headers.map((h, i) => `${h}=${values[i]}`).join(", "),
+				file: filePath,
+				line: row.location.line,
+				steps: allSteps,
+				tags: exampleTags,
+				outline: { name: scenario.name }
+			});
+		}
+	}
+	return results;
+}
+function convertSteps(steps) {
+	return steps.map((step) => ({
+		keyword: normalizeKeyword(step.keyword),
+		text: step.text,
+		line: step.location.line,
+		column: (step.location.column ?? 1) + step.keyword.length
+	}));
+}
+function normalizeKeyword(keyword) {
+	const trimmed = keyword.trim();
+	if (trimmed === "Given") return "Given";
+	if (trimmed === "When") return "When";
+	if (trimmed === "Then") return "Then";
+	if (trimmed === "And") return "And";
+	if (trimmed === "But") return "But";
+	return "Given";
+}
+function resolveEffectiveKeywords(steps) {
+	let lastEffective = "Given";
+	return steps.map((step) => {
+		let effectiveKeyword;
+		if (step.keyword === "And" || step.keyword === "But") effectiveKeyword = lastEffective;
+		else effectiveKeyword = step.keyword;
+		lastEffective = effectiveKeyword;
+		return {
+			...step,
+			effectiveKeyword
+		};
+	});
+}
+function substituteExampleValues(text, substitution) {
+	let result = text;
+	for (const [key, value] of Object.entries(substitution)) result = result.replace(new RegExp(`<${key}>`, "g"), value);
+	return result;
+}
+//#endregion
 //#region src/analyzer/stepMatcher.ts
 function compileDefinitions(definitions) {
 	const compiled = [];
@@ -353,8 +526,8 @@ function runRules(rules, scenario, matchedSteps) {
 //#region src/analyzer/index.ts
 async function analyze(config, options) {
 	const rules = options?.rules ?? defaultRules;
-	const stepFilePaths = await resolveGlobs(config.stepFiles);
-	const featureFilePaths = await resolveGlobs(config.featureFiles);
+	const stepFilePaths = await globFiles(config.stepFiles);
+	const featureFilePaths = await globFiles(config.featureFiles);
 	if (stepFilePaths.length === 0) return [];
 	if (featureFilePaths.length === 0) return [];
 	const stepDefinitions = extractStepDefinitions(stepFilePaths, config.tsConfigPath);
@@ -366,12 +539,7 @@ async function analyze(config, options) {
 	}
 	return diagnostics;
 }
-async function resolveGlobs(patterns) {
-	const files = [];
-	for (const pattern of patterns) for await (const file of glob(pattern)) files.push(path.resolve(file));
-	return [...new Set(files)];
-}
 //#endregion
-export { extractStepDefinitions as a, matchScenarioSteps as i, defaultRules as n, findMatchingDefinitions as r, analyze as t };
+export { parseFeatureContent as a, matchScenarioSteps as i, defaultRules as n, parseFeatureFiles as o, findMatchingDefinitions as r, extractStepDefinitions as s, analyze as t };
 
-//# sourceMappingURL=analyzer-DJyJbU_V.js.map
+//# sourceMappingURL=analyzer-byS8yRrY.js.map