@step-forge/step-forge 0.0.20 → 0.0.21

package/dist/engine-DPRxs6eC.js

@@ -0,0 +1,181 @@
+import { r as globalHookRegistry } from "./hooks-CywugMQQ.js";
+import { CucumberExpression, ParameterType, ParameterTypeRegistry } from "@cucumber/cucumber-expressions";
+//#region src/runtime/engine.ts
+const keywordToStepType = {
+	Given: "given",
+	When: "when",
+	Then: "then"
+};
+var UndefinedStepError = class extends Error {
+	step;
+	constructor(step) {
+		super(`Undefined step: ${step.effectiveKeyword} ${step.text}`);
+		this.step = step;
+		this.name = "UndefinedStepError";
+	}
+};
+var AmbiguousStepError = class extends Error {
+	step;
+	matches;
+	constructor(step, matches) {
+		super(`Ambiguous step: "${step.text}" matched ${matches.length} definitions:\n` + matches.map((m) => `  - ${m.expression}`).join("\n"));
+		this.step = step;
+		this.matches = matches;
+		this.name = "AmbiguousStepError";
+	}
+};
+/**
+* Compile a registry's steps into matchable Cucumber expressions **once** per
+* run. The result is reused for every scenario — compilation is pure and depends
+* only on the registry, so recompiling per scenario (as an earlier version did)
+* was wasted work proportional to scenarios × steps.
+*/
+function compileRegistry(registry) {
+	return registry.all().map((step) => {
+		const paramRegistry = new ParameterTypeRegistry();
+		for (const parser of step.parsers) {
+			if (paramRegistry.lookupByTypeName(parser.name)) continue;
+			const regexps = Array.isArray(parser.regexp) ? parser.regexp : [parser.regexp];
+			paramRegistry.defineParameterType(new ParameterType(parser.name, regexps, null, (value) => parser.parse(value)));
+		}
+		return {
+			step,
+			expression: new CucumberExpression(step.expression, paramRegistry)
+		};
+	});
+}
+/**
+* Find the single step definition matching a Gherkin step. Matching is
+* opinionated and strict: the keyword must line up with the step type, exactly
+* one definition must match, and undefined/ambiguous both throw rather than
+* silently skipping (unlike Cucumber's pending/undefined dance).
+*/
+function matchStep(step, compiled) {
+	const expectedType = keywordToStepType[step.effectiveKeyword];
+	const matches = [];
+	for (const { step: def, expression } of compiled) {
+		if (def.stepType !== expectedType) continue;
+		const result = expression.match(step.text);
+		if (result) matches.push({
+			step: def,
+			args: result.map((a) => a.getValue(null))
+		});
+	}
+	if (matches.length === 0) throw new UndefinedStepError(step);
+	if (matches.length > 1) throw new AmbiguousStepError(step, matches.map((m) => m.step));
+	return matches[0];
+}
+/**
+* Run one scenario against a pre-compiled step table. A fresh world is created
+* per scenario (state never leaks between scenarios). On the first failing step
+* the remaining steps are marked skipped, matching Cucumber's execution
+* semantics.
+*
+* Never throws for step or hook failures: it always resolves to a
+* `ScenarioResult` carrying the per-step breakdown and (on failure) the first
+* `error` with a synthetic `.feature` stack frame attached. Callers decide what
+* to do with a failure — the CLI runner reports it, a test-runner adapter can
+* re-throw `result.error`. It still rejects for truly exceptional conditions
+* (e.g. a bug in the engine itself), never for a normal test failure.
+*
+* Pass the compiled table from {@link compileRegistry} once and reuse it across
+* every scenario in the run.
+*/
+async function runScenario(scenario, compiled, makeWorld, hooks = globalHookRegistry) {
+	const start = now();
+	const world = makeWorld();
+	const scenarioInfo = {
+		name: scenario.name,
+		file: scenario.file
+	};
+	const steps = [];
+	let failed = false;
+	let firstError;
+	const fail = (err) => {
+		if (failed) return;
+		failed = true;
+		firstError = err instanceof Error ? err : new Error(String(err));
+	};
+	try {
+		for (const hook of hooks.for("scenario", "before")) await hook.fn({
+			world,
+			scenario: scenarioInfo
+		});
+	} catch (err) {
+		fail(err);
+	}
+	for (const step of scenario.steps) {
+		if (failed) {
+			steps.push({
+				step,
+				status: "skipped"
+			});
+			continue;
+		}
+		try {
+			const { step: def, args } = matchStep(step, compiled);
+			await def.execute(world, args);
+			steps.push({
+				step,
+				status: "passed"
+			});
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			steps.push({
+				step,
+				status: "failed",
+				error
+			});
+			fail(error);
+		}
+	}
+	for (const hook of hooks.for("scenario", "after")) try {
+		await hook.fn({
+			world,
+			scenario: scenarioInfo
+		});
+	} catch (err) {
+		fail(err);
+	}
+	if (failed && firstError) {
+		const failing = steps.find((s) => s.status === "failed");
+		if (failing) attachFeatureFrame(firstError, scenario.file, failing.step);
+	}
+	return {
+		scenario,
+		status: failed ? "failed" : "passed",
+		steps,
+		error: firstError,
+		durationMs: now() - start
+	};
+}
+/**
+* Monotonic-ish millisecond clock. `performance.now()` where available (Node &
+* Bun both expose it globally), falling back to `Date.now()`. Kept in one place
+* so timing is consistent across scenarios.
+*/
+function now() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+/**
+* Prepend a synthetic stack frame pointing at the failing Gherkin step. Because
+* the frame's file is the real `.feature` on disk, the test runner treats it as
+* a source location and shows a code frame at the step — instead of us jamming
+* `file:line` into the error message. The frame goes *above* the real stack, so
+* the step-definition frames (the actual throw site) are preserved below it.
+*/
+function attachFeatureFrame(error, file, step) {
+	const frame = `    at ${`${step.effectiveKeyword} ${step.text}`} (${file}:${step.line}:${step.column})`;
+	const stack = error.stack;
+	if (!stack) {
+		error.stack = `${error.name}: ${error.message}\n${frame}`;
+		return;
+	}
+	const firstFrame = stack.indexOf("\n    at ");
+	if (firstFrame === -1) error.stack = `${stack}\n${frame}`;
+	else error.stack = stack.slice(0, firstFrame) + `\n${frame}` + stack.slice(firstFrame);
+}
+//#endregion
+export { runScenario as i, UndefinedStepError as n, compileRegistry as r, AmbiguousStepError as t };
+
+//# sourceMappingURL=engine-DPRxs6eC.js.map

package/dist/engine-DPRxs6eC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-DPRxs6eC.js","names":[],"sources":["../../src/runtime/engine.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  CucumberExpression,\n  ParameterType,\n  ParameterTypeRegistry,\n} from \"@cucumber/cucumber-expressions\";\nimport { ParsedScenario, ParsedStep } from \"../analyzer/types\";\nimport { MergeableWorld } from \"../world\";\nimport { globalHookRegistry, HookRegistry, ScenarioHookFn } from \"./hooks\";\nimport { RegisteredStep, StepRegistry, StepType } from \"./registry\";\n\nconst keywordToStepType: Record<ParsedStep[\"effectiveKeyword\"], StepType> = {\n  Given: \"given\",\n  When: \"when\",\n  Then: \"then\",\n};\n\n/** A registered step paired with its compiled Cucumber expression. */\nexport interface CompiledStep {\n  step: RegisteredStep;\n  expression: CucumberExpression;\n}\n\nexport class UndefinedStepError extends Error {\n  constructor(public readonly step: ParsedStep) {\n    super(`Undefined step: ${step.effectiveKeyword} ${step.text}`);\n    this.name = \"UndefinedStepError\";\n  }\n}\n\nexport class AmbiguousStepError extends Error {\n  constructor(\n    public readonly step: ParsedStep,\n    public readonly matches: RegisteredStep[]\n  ) {\n    super(\n      `Ambiguous step: \"${step.text}\" matched ${matches.length} definitions:\\n` +\n        matches.map(m => `  - ${m.expression}`).join(\"\\n\")\n    );\n    this.name = \"AmbiguousStepError\";\n  }\n}\n\n/**\n * Compile a registry's steps into matchable Cucumber expressions **once** per\n * run. The result is reused for every scenario — compilation is pure and depends\n * only on the registry, so recompiling per scenario (as an earlier version did)\n * was wasted work proportional to scenarios × steps.\n */\nexport function compileRegistry(registry: StepRegistry): CompiledStep[] {\n  return registry.all().map(step => {\n    // Each step gets its own parameter-type registry (seeded with the\n    // built-ins). A parser whose name is already registered — the built-in\n    // `{int}`/`{float}`/`{string}`, or a repeat within the same step — reuses\n    // that type; a novel name (e.g. `{boolean}`, `{color}`) is registered from\n    // the parser's regexp + parse, so matching and coercion happen in one pass.\n    const paramRegistry = new ParameterTypeRegistry();\n    for (const parser of step.parsers) {\n      if (paramRegistry.lookupByTypeName(parser.name)) continue;\n      const regexps = Array.isArray(parser.regexp)\n        ? parser.regexp\n        : [parser.regexp];\n      paramRegistry.defineParameterType(\n        new ParameterType(parser.name, regexps, null, (value: string) =>\n          parser.parse(value)\n        )\n      );\n    }\n    return {\n      step,\n      expression: new CucumberExpression(step.expression, paramRegistry),\n    };\n  });\n}\n\n/**\n * Find the single step definition matching a Gherkin step. Matching is\n * opinionated and strict: the keyword must line up with the step type, exactly\n * one definition must match, and undefined/ambiguous both throw rather than\n * silently skipping (unlike Cucumber's pending/undefined dance).\n */\nfunction matchStep(\n  step: ParsedStep,\n  compiled: CompiledStep[]\n): { step: RegisteredStep; args: unknown[] } {\n  const expectedType = keywordToStepType[step.effectiveKeyword];\n  const matches: { step: RegisteredStep; args: unknown[] }[] = [];\n\n  for (const { step: def, expression } of compiled) {\n    if (def.stepType !== expectedType) continue;\n    const result = expression.match(step.text);\n    if (result) {\n      // The parsers are registered as the expression's parameter types, so the\n      // captured values are already coerced (`{int}` → number, `{color}` → the\n      // parser's T). `execute` consumes them as-is.\n      matches.push({ step: def, args: result.map(a => a.getValue(null)) });\n    }\n  }\n\n  if (matches.length === 0) throw new UndefinedStepError(step);\n  if (matches.length > 1) {\n    throw new AmbiguousStepError(\n      step,\n      matches.map(m => m.step)\n    );\n  }\n  return matches[0];\n}\n\nexport interface StepResult {\n  step: ParsedStep;\n  status: \"passed\" | \"failed\" | \"skipped\";\n  error?: Error;\n  durationMs?: number;\n}\n\nexport interface ScenarioResult {\n  scenario: ParsedScenario;\n  status: \"passed\" | \"failed\";\n  steps: StepResult[];\n  /**\n   * The scenario's first error, if it failed. Usually the same object as the\n   * failing step's `error` (with a synthetic `.feature` stack frame attached),\n   * but for a hook failure there's no step to point at, so this is the only\n   * place it surfaces. Reporters read this; the runner never throws it.\n   */\n  error?: Error;\n  /** Wall-clock duration of the whole scenario, in milliseconds. */\n  durationMs?: number;\n}\n\n/**\n * Run one scenario against a pre-compiled step table. A fresh world is created\n * per scenario (state never leaks between scenarios). On the first failing step\n * the remaining steps are marked skipped, matching Cucumber's execution\n * semantics.\n *\n * Never throws for step or hook failures: it always resolves to a\n * `ScenarioResult` carrying the per-step breakdown and (on failure) the first\n * `error` with a synthetic `.feature` stack frame attached. Callers decide what\n * to do with a failure — the CLI runner reports it, a test-runner adapter can\n * re-throw `result.error`. It still rejects for truly exceptional conditions\n * (e.g. a bug in the engine itself), never for a normal test failure.\n *\n * Pass the compiled table from {@link compileRegistry} once and reuse it across\n * every scenario in the run.\n */\nexport async function runScenario(\n  scenario: ParsedScenario,\n  compiled: CompiledStep[],\n  makeWorld: () => MergeableWorld<any, any, any>,\n  hooks: HookRegistry = globalHookRegistry\n): Promise<ScenarioResult> {\n  const start = now();\n  const world = makeWorld();\n  const scenarioInfo = { name: scenario.name, file: scenario.file };\n  const steps: StepResult[] = [];\n  let failed = false;\n  let firstError: Error | undefined;\n\n  const fail = (err: unknown) => {\n    if (failed) return;\n    failed = true;\n    firstError = err instanceof Error ? err : new Error(String(err));\n  };\n\n  // before-scenario hooks: a throw here aborts the scenario before any step.\n  try {\n    for (const hook of hooks.for(\"scenario\", \"before\")) {\n      await (hook.fn as ScenarioHookFn)({ world, scenario: scenarioInfo });\n    }\n  } catch (err) {\n    fail(err);\n  }\n\n  for (const step of scenario.steps) {\n    if (failed) {\n      steps.push({ step, status: \"skipped\" });\n      continue;\n    }\n    try {\n      const { step: def, args } = matchStep(step, compiled);\n      await def.execute(world, args);\n      steps.push({ step, status: \"passed\" });\n    } catch (err) {\n      const error = err instanceof Error ? err : new Error(String(err));\n      steps.push({ step, status: \"failed\", error });\n      fail(error);\n    }\n  }\n\n  // after-scenario hooks always run (teardown), even on failure. A hook failure\n  // only becomes the scenario's error if nothing else failed first.\n  for (const hook of hooks.for(\"scenario\", \"after\")) {\n    try {\n      await (hook.fn as ScenarioHookFn)({ world, scenario: scenarioInfo });\n    } catch (err) {\n      fail(err);\n    }\n  }\n\n  if (failed && firstError) {\n    // Surface the failing Gherkin line as a real stack frame so reporters render\n    // a code frame from the `.feature` file itself. Hook failures have no step\n    // to point at, so they surface with their own stack unchanged.\n    const failing = steps.find(s => s.status === \"failed\");\n    if (failing) attachFeatureFrame(firstError, scenario.file, failing.step);\n  }\n\n  return {\n    scenario,\n    status: failed ? \"failed\" : \"passed\",\n    steps,\n    error: firstError,\n    durationMs: now() - start,\n  };\n}\n\n/**\n * Monotonic-ish millisecond clock. `performance.now()` where available (Node &\n * Bun both expose it globally), falling back to `Date.now()`. Kept in one place\n * so timing is consistent across scenarios.\n */\nfunction now(): number {\n  return typeof performance !== \"undefined\" ? performance.now() : Date.now();\n}\n\n/**\n * Prepend a synthetic stack frame pointing at the failing Gherkin step. Because\n * the frame's file is the real `.feature` on disk, the test runner treats it as\n * a source location and shows a code frame at the step — instead of us jamming\n * `file:line` into the error message. The frame goes *above* the real stack, so\n * the step-definition frames (the actual throw site) are preserved below it.\n */\nfunction attachFeatureFrame(\n  error: Error,\n  file: string,\n  step: ParsedStep\n): void {\n  const label = `${step.effectiveKeyword} ${step.text}`;\n  const frame = `    at ${label} (${file}:${step.line}:${step.column})`;\n  const stack = error.stack;\n  if (!stack) {\n    error.stack = `${error.name}: ${error.message}\\n${frame}`;\n    return;\n  }\n  // A message can span multiple lines, so split on the first frame marker\n  // rather than the first newline to find where the header ends.\n  const firstFrame = stack.indexOf(\"\\n    at \");\n  if (firstFrame === -1) {\n    error.stack = `${stack}\\n${frame}`;\n  } else {\n    error.stack =\n      stack.slice(0, firstFrame) + `\\n${frame}` + stack.slice(firstFrame);\n  }\n}\n"],"mappings":"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"}

package/dist/engine-DWAIlwWp.cjs

@@ -0,0 +1,204 @@
+const require_hooks = require("./hooks-CGYzwDOv.cjs");
+let _cucumber_cucumber_expressions = require("@cucumber/cucumber-expressions");
+//#region src/runtime/engine.ts
+const keywordToStepType = {
+	Given: "given",
+	When: "when",
+	Then: "then"
+};
+var UndefinedStepError = class extends Error {
+	step;
+	constructor(step) {
+		super(`Undefined step: ${step.effectiveKeyword} ${step.text}`);
+		this.step = step;
+		this.name = "UndefinedStepError";
+	}
+};
+var AmbiguousStepError = class extends Error {
+	step;
+	matches;
+	constructor(step, matches) {
+		super(`Ambiguous step: "${step.text}" matched ${matches.length} definitions:\n` + matches.map((m) => `  - ${m.expression}`).join("\n"));
+		this.step = step;
+		this.matches = matches;
+		this.name = "AmbiguousStepError";
+	}
+};
+/**
+* Compile a registry's steps into matchable Cucumber expressions **once** per
+* run. The result is reused for every scenario — compilation is pure and depends
+* only on the registry, so recompiling per scenario (as an earlier version did)
+* was wasted work proportional to scenarios × steps.
+*/
+function compileRegistry(registry) {
+	return registry.all().map((step) => {
+		const paramRegistry = new _cucumber_cucumber_expressions.ParameterTypeRegistry();
+		for (const parser of step.parsers) {
+			if (paramRegistry.lookupByTypeName(parser.name)) continue;
+			const regexps = Array.isArray(parser.regexp) ? parser.regexp : [parser.regexp];
+			paramRegistry.defineParameterType(new _cucumber_cucumber_expressions.ParameterType(parser.name, regexps, null, (value) => parser.parse(value)));
+		}
+		return {
+			step,
+			expression: new _cucumber_cucumber_expressions.CucumberExpression(step.expression, paramRegistry)
+		};
+	});
+}
+/**
+* Find the single step definition matching a Gherkin step. Matching is
+* opinionated and strict: the keyword must line up with the step type, exactly
+* one definition must match, and undefined/ambiguous both throw rather than
+* silently skipping (unlike Cucumber's pending/undefined dance).
+*/
+function matchStep(step, compiled) {
+	const expectedType = keywordToStepType[step.effectiveKeyword];
+	const matches = [];
+	for (const { step: def, expression } of compiled) {
+		if (def.stepType !== expectedType) continue;
+		const result = expression.match(step.text);
+		if (result) matches.push({
+			step: def,
+			args: result.map((a) => a.getValue(null))
+		});
+	}
+	if (matches.length === 0) throw new UndefinedStepError(step);
+	if (matches.length > 1) throw new AmbiguousStepError(step, matches.map((m) => m.step));
+	return matches[0];
+}
+/**
+* Run one scenario against a pre-compiled step table. A fresh world is created
+* per scenario (state never leaks between scenarios). On the first failing step
+* the remaining steps are marked skipped, matching Cucumber's execution
+* semantics.
+*
+* Never throws for step or hook failures: it always resolves to a
+* `ScenarioResult` carrying the per-step breakdown and (on failure) the first
+* `error` with a synthetic `.feature` stack frame attached. Callers decide what
+* to do with a failure — the CLI runner reports it, a test-runner adapter can
+* re-throw `result.error`. It still rejects for truly exceptional conditions
+* (e.g. a bug in the engine itself), never for a normal test failure.
+*
+* Pass the compiled table from {@link compileRegistry} once and reuse it across
+* every scenario in the run.
+*/
+async function runScenario(scenario, compiled, makeWorld, hooks = require_hooks.globalHookRegistry) {
+	const start = now();
+	const world = makeWorld();
+	const scenarioInfo = {
+		name: scenario.name,
+		file: scenario.file
+	};
+	const steps = [];
+	let failed = false;
+	let firstError;
+	const fail = (err) => {
+		if (failed) return;
+		failed = true;
+		firstError = err instanceof Error ? err : new Error(String(err));
+	};
+	try {
+		for (const hook of hooks.for("scenario", "before")) await hook.fn({
+			world,
+			scenario: scenarioInfo
+		});
+	} catch (err) {
+		fail(err);
+	}
+	for (const step of scenario.steps) {
+		if (failed) {
+			steps.push({
+				step,
+				status: "skipped"
+			});
+			continue;
+		}
+		try {
+			const { step: def, args } = matchStep(step, compiled);
+			await def.execute(world, args);
+			steps.push({
+				step,
+				status: "passed"
+			});
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			steps.push({
+				step,
+				status: "failed",
+				error
+			});
+			fail(error);
+		}
+	}
+	for (const hook of hooks.for("scenario", "after")) try {
+		await hook.fn({
+			world,
+			scenario: scenarioInfo
+		});
+	} catch (err) {
+		fail(err);
+	}
+	if (failed && firstError) {
+		const failing = steps.find((s) => s.status === "failed");
+		if (failing) attachFeatureFrame(firstError, scenario.file, failing.step);
+	}
+	return {
+		scenario,
+		status: failed ? "failed" : "passed",
+		steps,
+		error: firstError,
+		durationMs: now() - start
+	};
+}
+/**
+* Monotonic-ish millisecond clock. `performance.now()` where available (Node &
+* Bun both expose it globally), falling back to `Date.now()`. Kept in one place
+* so timing is consistent across scenarios.
+*/
+function now() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+/**
+* Prepend a synthetic stack frame pointing at the failing Gherkin step. Because
+* the frame's file is the real `.feature` on disk, the test runner treats it as
+* a source location and shows a code frame at the step — instead of us jamming
+* `file:line` into the error message. The frame goes *above* the real stack, so
+* the step-definition frames (the actual throw site) are preserved below it.
+*/
+function attachFeatureFrame(error, file, step) {
+	const frame = `    at ${`${step.effectiveKeyword} ${step.text}`} (${file}:${step.line}:${step.column})`;
+	const stack = error.stack;
+	if (!stack) {
+		error.stack = `${error.name}: ${error.message}\n${frame}`;
+		return;
+	}
+	const firstFrame = stack.indexOf("\n    at ");
+	if (firstFrame === -1) error.stack = `${stack}\n${frame}`;
+	else error.stack = stack.slice(0, firstFrame) + `\n${frame}` + stack.slice(firstFrame);
+}
+//#endregion
+Object.defineProperty(exports, "AmbiguousStepError", {
+	enumerable: true,
+	get: function() {
+		return AmbiguousStepError;
+	}
+});
+Object.defineProperty(exports, "UndefinedStepError", {
+	enumerable: true,
+	get: function() {
+		return UndefinedStepError;
+	}
+});
+Object.defineProperty(exports, "compileRegistry", {
+	enumerable: true,
+	get: function() {
+		return compileRegistry;
+	}
+});
+Object.defineProperty(exports, "runScenario", {
+	enumerable: true,
+	get: function() {
+		return runScenario;
+	}
+});
+
+//# sourceMappingURL=engine-DWAIlwWp.cjs.map

package/dist/engine-DWAIlwWp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-DWAIlwWp.cjs","names":["ParameterTypeRegistry","ParameterType","CucumberExpression","globalHookRegistry"],"sources":["../../src/runtime/engine.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  CucumberExpression,\n  ParameterType,\n  ParameterTypeRegistry,\n} from \"@cucumber/cucumber-expressions\";\nimport { ParsedScenario, ParsedStep } from \"../analyzer/types\";\nimport { MergeableWorld } from \"../world\";\nimport { globalHookRegistry, HookRegistry, ScenarioHookFn } from \"./hooks\";\nimport { RegisteredStep, StepRegistry, StepType } from \"./registry\";\n\nconst keywordToStepType: Record<ParsedStep[\"effectiveKeyword\"], StepType> = {\n  Given: \"given\",\n  When: \"when\",\n  Then: \"then\",\n};\n\n/** A registered step paired with its compiled Cucumber expression. */\nexport interface CompiledStep {\n  step: RegisteredStep;\n  expression: CucumberExpression;\n}\n\nexport class UndefinedStepError extends Error {\n  constructor(public readonly step: ParsedStep) {\n    super(`Undefined step: ${step.effectiveKeyword} ${step.text}`);\n    this.name = \"UndefinedStepError\";\n  }\n}\n\nexport class AmbiguousStepError extends Error {\n  constructor(\n    public readonly step: ParsedStep,\n    public readonly matches: RegisteredStep[]\n  ) {\n    super(\n      `Ambiguous step: \"${step.text}\" matched ${matches.length} definitions:\\n` +\n        matches.map(m => `  - ${m.expression}`).join(\"\\n\")\n    );\n    this.name = \"AmbiguousStepError\";\n  }\n}\n\n/**\n * Compile a registry's steps into matchable Cucumber expressions **once** per\n * run. The result is reused for every scenario — compilation is pure and depends\n * only on the registry, so recompiling per scenario (as an earlier version did)\n * was wasted work proportional to scenarios × steps.\n */\nexport function compileRegistry(registry: StepRegistry): CompiledStep[] {\n  return registry.all().map(step => {\n    // Each step gets its own parameter-type registry (seeded with the\n    // built-ins). A parser whose name is already registered — the built-in\n    // `{int}`/`{float}`/`{string}`, or a repeat within the same step — reuses\n    // that type; a novel name (e.g. `{boolean}`, `{color}`) is registered from\n    // the parser's regexp + parse, so matching and coercion happen in one pass.\n    const paramRegistry = new ParameterTypeRegistry();\n    for (const parser of step.parsers) {\n      if (paramRegistry.lookupByTypeName(parser.name)) continue;\n      const regexps = Array.isArray(parser.regexp)\n        ? parser.regexp\n        : [parser.regexp];\n      paramRegistry.defineParameterType(\n        new ParameterType(parser.name, regexps, null, (value: string) =>\n          parser.parse(value)\n        )\n      );\n    }\n    return {\n      step,\n      expression: new CucumberExpression(step.expression, paramRegistry),\n    };\n  });\n}\n\n/**\n * Find the single step definition matching a Gherkin step. Matching is\n * opinionated and strict: the keyword must line up with the step type, exactly\n * one definition must match, and undefined/ambiguous both throw rather than\n * silently skipping (unlike Cucumber's pending/undefined dance).\n */\nfunction matchStep(\n  step: ParsedStep,\n  compiled: CompiledStep[]\n): { step: RegisteredStep; args: unknown[] } {\n  const expectedType = keywordToStepType[step.effectiveKeyword];\n  const matches: { step: RegisteredStep; args: unknown[] }[] = [];\n\n  for (const { step: def, expression } of compiled) {\n    if (def.stepType !== expectedType) continue;\n    const result = expression.match(step.text);\n    if (result) {\n      // The parsers are registered as the expression's parameter types, so the\n      // captured values are already coerced (`{int}` → number, `{color}` → the\n      // parser's T). `execute` consumes them as-is.\n      matches.push({ step: def, args: result.map(a => a.getValue(null)) });\n    }\n  }\n\n  if (matches.length === 0) throw new UndefinedStepError(step);\n  if (matches.length > 1) {\n    throw new AmbiguousStepError(\n      step,\n      matches.map(m => m.step)\n    );\n  }\n  return matches[0];\n}\n\nexport interface StepResult {\n  step: ParsedStep;\n  status: \"passed\" | \"failed\" | \"skipped\";\n  error?: Error;\n  durationMs?: number;\n}\n\nexport interface ScenarioResult {\n  scenario: ParsedScenario;\n  status: \"passed\" | \"failed\";\n  steps: StepResult[];\n  /**\n   * The scenario's first error, if it failed. Usually the same object as the\n   * failing step's `error` (with a synthetic `.feature` stack frame attached),\n   * but for a hook failure there's no step to point at, so this is the only\n   * place it surfaces. Reporters read this; the runner never throws it.\n   */\n  error?: Error;\n  /** Wall-clock duration of the whole scenario, in milliseconds. */\n  durationMs?: number;\n}\n\n/**\n * Run one scenario against a pre-compiled step table. A fresh world is created\n * per scenario (state never leaks between scenarios). On the first failing step\n * the remaining steps are marked skipped, matching Cucumber's execution\n * semantics.\n *\n * Never throws for step or hook failures: it always resolves to a\n * `ScenarioResult` carrying the per-step breakdown and (on failure) the first\n * `error` with a synthetic `.feature` stack frame attached. Callers decide what\n * to do with a failure — the CLI runner reports it, a test-runner adapter can\n * re-throw `result.error`. It still rejects for truly exceptional conditions\n * (e.g. a bug in the engine itself), never for a normal test failure.\n *\n * Pass the compiled table from {@link compileRegistry} once and reuse it across\n * every scenario in the run.\n */\nexport async function runScenario(\n  scenario: ParsedScenario,\n  compiled: CompiledStep[],\n  makeWorld: () => MergeableWorld<any, any, any>,\n  hooks: HookRegistry = globalHookRegistry\n): Promise<ScenarioResult> {\n  const start = now();\n  const world = makeWorld();\n  const scenarioInfo = { name: scenario.name, file: scenario.file };\n  const steps: StepResult[] = [];\n  let failed = false;\n  let firstError: Error | undefined;\n\n  const fail = (err: unknown) => {\n    if (failed) return;\n    failed = true;\n    firstError = err instanceof Error ? err : new Error(String(err));\n  };\n\n  // before-scenario hooks: a throw here aborts the scenario before any step.\n  try {\n    for (const hook of hooks.for(\"scenario\", \"before\")) {\n      await (hook.fn as ScenarioHookFn)({ world, scenario: scenarioInfo });\n    }\n  } catch (err) {\n    fail(err);\n  }\n\n  for (const step of scenario.steps) {\n    if (failed) {\n      steps.push({ step, status: \"skipped\" });\n      continue;\n    }\n    try {\n      const { step: def, args } = matchStep(step, compiled);\n      await def.execute(world, args);\n      steps.push({ step, status: \"passed\" });\n    } catch (err) {\n      const error = err instanceof Error ? err : new Error(String(err));\n      steps.push({ step, status: \"failed\", error });\n      fail(error);\n    }\n  }\n\n  // after-scenario hooks always run (teardown), even on failure. A hook failure\n  // only becomes the scenario's error if nothing else failed first.\n  for (const hook of hooks.for(\"scenario\", \"after\")) {\n    try {\n      await (hook.fn as ScenarioHookFn)({ world, scenario: scenarioInfo });\n    } catch (err) {\n      fail(err);\n    }\n  }\n\n  if (failed && firstError) {\n    // Surface the failing Gherkin line as a real stack frame so reporters render\n    // a code frame from the `.feature` file itself. Hook failures have no step\n    // to point at, so they surface with their own stack unchanged.\n    const failing = steps.find(s => s.status === \"failed\");\n    if (failing) attachFeatureFrame(firstError, scenario.file, failing.step);\n  }\n\n  return {\n    scenario,\n    status: failed ? \"failed\" : \"passed\",\n    steps,\n    error: firstError,\n    durationMs: now() - start,\n  };\n}\n\n/**\n * Monotonic-ish millisecond clock. `performance.now()` where available (Node &\n * Bun both expose it globally), falling back to `Date.now()`. Kept in one place\n * so timing is consistent across scenarios.\n */\nfunction now(): number {\n  return typeof performance !== \"undefined\" ? performance.now() : Date.now();\n}\n\n/**\n * Prepend a synthetic stack frame pointing at the failing Gherkin step. Because\n * the frame's file is the real `.feature` on disk, the test runner treats it as\n * a source location and shows a code frame at the step — instead of us jamming\n * `file:line` into the error message. The frame goes *above* the real stack, so\n * the step-definition frames (the actual throw site) are preserved below it.\n */\nfunction attachFeatureFrame(\n  error: Error,\n  file: string,\n  step: ParsedStep\n): void {\n  const label = `${step.effectiveKeyword} ${step.text}`;\n  const frame = `    at ${label} (${file}:${step.line}:${step.column})`;\n  const stack = error.stack;\n  if (!stack) {\n    error.stack = `${error.name}: ${error.message}\\n${frame}`;\n    return;\n  }\n  // A message can span multiple lines, so split on the first frame marker\n  // rather than the first newline to find where the header ends.\n  const firstFrame = stack.indexOf(\"\\n    at \");\n  if (firstFrame === -1) {\n    error.stack = `${stack}\\n${frame}`;\n  } else {\n    error.stack =\n      stack.slice(0, firstFrame) + `\\n${frame}` + stack.slice(firstFrame);\n  }\n}\n"],"mappings":"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"}

package/dist/gherkinParser-CHpkEwii.cjs

@@ -0,0 +1,243 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let lodash = require("lodash");
+lodash = __toESM(lodash, 1);
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let _cucumber_gherkin = require("@cucumber/gherkin");
+let _cucumber_messages = require("@cucumber/messages");
+_cucumber_messages = __toESM(_cucumber_messages, 1);
+//#region src/world.ts
+function mergeCustomizer(objValue, srcValue) {
+	if (lodash.default.isArray(objValue)) return objValue.concat(srcValue);
+	else if (objValue && !lodash.default.isPlainObject(objValue) && objValue !== srcValue) throw new Error(`Merge would have destroyed previous value ${objValue} with ${srcValue}`);
+	return objValue;
+}
+var BasicWorld = class {
+	givenState = {};
+	whenState = {};
+	thenState = {};
+	get given() {
+		return {
+			...this.givenState,
+			merge: (newState) => {
+				this.givenState = lodash.default.merge({ ...this.givenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get when() {
+		return {
+			...this.whenState,
+			merge: (newState) => {
+				this.whenState = lodash.default.merge({ ...this.whenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get then() {
+		return {
+			...this.thenState,
+			merge: (newState) => {
+				this.thenState = lodash.default.merge({ ...this.thenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+};
+//#endregion
+//#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 (0, node_fs_promises.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 (node_path.isAbsolute(pattern) && !MAGIC.test(pattern)) {
+			if (await isFile(pattern)) files.add(pattern);
+			continue;
+		}
+		for await (const match of (0, node_fs_promises.glob)(pattern, { cwd })) files.add(node_path.resolve(cwd, match));
+	}
+	return [...files];
+}
+//#endregion
+//#region src/analyzer/gherkinParser.ts
+function parseFeatureFiles(filePaths) {
+	const scenarios = [];
+	for (const filePath of filePaths) {
+		const parsed = parseFeatureContent(node_fs.readFileSync(filePath, "utf-8"), filePath);
+		scenarios.push(...parsed);
+	}
+	return scenarios;
+}
+function parseFeatureContent(content, filePath) {
+	const feature = new _cucumber_gherkin.Parser(new _cucumber_gherkin.AstBuilder(_cucumber_messages.IdGenerator.uuid()), new _cucumber_gherkin.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,
+			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,
+				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
+Object.defineProperty(exports, "BasicWorld", {
+	enumerable: true,
+	get: function() {
+		return BasicWorld;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "globFiles", {
+	enumerable: true,
+	get: function() {
+		return globFiles;
+	}
+});
+Object.defineProperty(exports, "parseFeatureContent", {
+	enumerable: true,
+	get: function() {
+		return parseFeatureContent;
+	}
+});
+Object.defineProperty(exports, "parseFeatureFiles", {
+	enumerable: true,
+	get: function() {
+		return parseFeatureFiles;
+	}
+});
+
+//# sourceMappingURL=gherkinParser-CHpkEwii.cjs.map