@step-forge/step-forge 0.0.20 → 0.0.22

package/dist/runtime.cjs

@@ -1,168 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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";
-	}
-};
-function compile(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 registry. 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.
-*
-* Throws on failure so it maps cleanly onto a test runner's `test()` body, but
-* the returned/attached `ScenarioResult` carries the per-step breakdown.
-*/
-async function runScenario(scenario, registry, makeWorld, hooks = require_hooks.globalHookRegistry) {
-	const compiled = compile(registry);
-	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);
-	}
-	const result = {
-		scenario,
-		status: failed ? "failed" : "passed",
-		steps
-	};
-	if (failed && firstError) {
-		const failing = steps.find((s) => s.status === "failed");
-		if (failing) attachFeatureFrame(firstError, scenario.file, failing.step);
-		throw firstError;
-	}
-	return result;
-}
-/**
-* 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
-exports.AmbiguousStepError = AmbiguousStepError;
+const require_hooks = require("./hooks-Be0cjULN.cjs");
+const require_engine = require("./engine-vqA-eL_T.cjs");
+exports.AmbiguousStepError = require_engine.AmbiguousStepError;
 exports.HookRegistry = require_hooks.HookRegistry;
 exports.StepRegistry = require_hooks.StepRegistry;
-exports.UndefinedStepError = UndefinedStepError;
-exports.ensureGlobalHooks = require_hooks.ensureGlobalHooks;
+exports.UndefinedStepError = require_engine.UndefinedStepError;
+exports.compileRegistry = require_engine.compileRegistry;
 exports.globalHookRegistry = require_hooks.globalHookRegistry;
 exports.globalRegistry = require_hooks.globalRegistry;
 exports.runHooks = require_hooks.runHooks;
-exports.runScenario = runScenario;
-
-//# sourceMappingURL=runtime.cjs.map
+exports.runHooksParallel = require_hooks.runHooksParallel;
+exports.runScenario = require_engine.runScenario;

package/dist/runtime.d.cts

@@ -1,4 +1,5 @@
-import { a as RegisteredHook, b as Parser, c as ensureGlobalHooks, g as ParsedStep, h as ParsedScenario, i as PlainHookFn, l as globalHookRegistry, n as HookScope, o as ScenarioHookFn, r as HookTiming, s as ScenarioInfo, t as HookRegistry, u as runHooks, y as MergeableWorld } from "./hooks-Dar49TtT.cjs";
+import { S as Parser, _ as ParsedScenario, a as HookTiming, c as ScenarioHookFn, d as runHooks, f as runHooksParallel, i as HookScope, l as ScenarioInfo, n as RunnerOptions, o as PlainHookFn, r as HookRegistry, s as RegisteredHook, t as ResolvedConfig, u as globalHookRegistry, v as ParsedStep, x as MergeableWorld } from "./config-C7PCYgYy.cjs";
+import { CucumberExpression } from "@cucumber/cucumber-expressions";
 
 //#region src/runtime/registry.d.ts
 type StepType = "given" | "when" | "then";
@@ -35,6 +36,11 @@ declare class StepRegistry {
 declare const globalRegistry: StepRegistry;
 //#endregion
 //#region src/runtime/engine.d.ts
+/** A registered step paired with its compiled Cucumber expression. */
+interface CompiledStep {
+  step: RegisteredStep;
+  expression: CucumberExpression;
+}
 declare class UndefinedStepError extends Error {
   readonly step: ParsedStep;
   constructor(step: ParsedStep);
@@ -44,26 +50,56 @@ declare class AmbiguousStepError extends Error {
   readonly matches: RegisteredStep[];
   constructor(step: ParsedStep, matches: RegisteredStep[]);
 }
+/**
+ * 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.
+ */
+declare function compileRegistry(registry: StepRegistry): CompiledStep[];
 interface StepResult {
   step: ParsedStep;
   status: "passed" | "failed" | "skipped";
   error?: Error;
+  /**
+   * Absolute `file:line:column` where the matched step is *defined* (its
+   * `.step(...)` call site), for Cucumber-style reporting. Absent when no step
+   * matched (undefined/ambiguous) or the step was skipped.
+   */
+  source?: string;
   durationMs?: number;
 }
 interface ScenarioResult {
   scenario: ParsedScenario;
   status: "passed" | "failed";
   steps: StepResult[];
+  /**
+   * The scenario's first error, if it failed. Usually the same object as the
+   * failing step's `error`; for a hook failure there's no step to point at, so
+   * this is the only place it surfaces. Reporters read this; the runner never
+   * throws it.
+   */
+  error?: Error;
+  /** Wall-clock duration of the whole scenario, in milliseconds. */
+  durationMs?: number;
 }
 /**
- * Run one scenario against a registry. 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.
+ * 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.
  *
- * Throws on failure so it maps cleanly onto a test runner's `test()` body, but
- * the returned/attached `ScenarioResult` carries the per-step breakdown.
+ * Pass the compiled table from {@link compileRegistry} once and reuse it across
+ * every scenario in the run.
  */
-declare function runScenario(scenario: ParsedScenario, registry: StepRegistry, makeWorld: () => MergeableWorld<any, any, any>, hooks?: HookRegistry): Promise<ScenarioResult>;
+declare function runScenario(scenario: ParsedScenario, compiled: CompiledStep[], makeWorld: () => MergeableWorld<any, any, any>, hooks?: HookRegistry): Promise<ScenarioResult>;
 //#endregion
-export { AmbiguousStepError, HookRegistry, type HookScope, type HookTiming, type PlainHookFn, type RegisteredHook, type RegisteredStep, type ScenarioHookFn, type ScenarioInfo, type ScenarioResult, StepRegistry, type StepResult, type StepType, UndefinedStepError, ensureGlobalHooks, globalHookRegistry, globalRegistry, runHooks, runScenario };
+export { AmbiguousStepError, type CompiledStep, HookRegistry, type HookScope, type HookTiming, type PlainHookFn, type RegisteredHook, type RegisteredStep, type ResolvedConfig, type RunnerOptions, type ScenarioHookFn, type ScenarioInfo, type ScenarioResult, StepRegistry, type StepResult, type StepType, UndefinedStepError, compileRegistry, globalHookRegistry, globalRegistry, runHooks, runHooksParallel, runScenario };
 //# sourceMappingURL=runtime.d.cts.map

package/dist/runtime.d.ts

@@ -1,4 +1,5 @@
-import { a as RegisteredHook, b as Parser, c as ensureGlobalHooks, g as ParsedStep, h as ParsedScenario, i as PlainHookFn, l as globalHookRegistry, n as HookScope, o as ScenarioHookFn, r as HookTiming, s as ScenarioInfo, t as HookRegistry, u as runHooks, y as MergeableWorld } from "./hooks-Dar49TtT.js";
+import { S as Parser, _ as ParsedScenario, a as HookTiming, c as ScenarioHookFn, d as runHooks, f as runHooksParallel, i as HookScope, l as ScenarioInfo, n as RunnerOptions, o as PlainHookFn, r as HookRegistry, s as RegisteredHook, t as ResolvedConfig, u as globalHookRegistry, v as ParsedStep, x as MergeableWorld } from "./config-C7PCYgYy.js";
+import { CucumberExpression } from "@cucumber/cucumber-expressions";
 
 //#region src/runtime/registry.d.ts
 type StepType = "given" | "when" | "then";
@@ -35,6 +36,11 @@ declare class StepRegistry {
 declare const globalRegistry: StepRegistry;
 //#endregion
 //#region src/runtime/engine.d.ts
+/** A registered step paired with its compiled Cucumber expression. */
+interface CompiledStep {
+  step: RegisteredStep;
+  expression: CucumberExpression;
+}
 declare class UndefinedStepError extends Error {
   readonly step: ParsedStep;
   constructor(step: ParsedStep);
@@ -44,26 +50,56 @@ declare class AmbiguousStepError extends Error {
   readonly matches: RegisteredStep[];
   constructor(step: ParsedStep, matches: RegisteredStep[]);
 }
+/**
+ * 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.
+ */
+declare function compileRegistry(registry: StepRegistry): CompiledStep[];
 interface StepResult {
   step: ParsedStep;
   status: "passed" | "failed" | "skipped";
   error?: Error;
+  /**
+   * Absolute `file:line:column` where the matched step is *defined* (its
+   * `.step(...)` call site), for Cucumber-style reporting. Absent when no step
+   * matched (undefined/ambiguous) or the step was skipped.
+   */
+  source?: string;
   durationMs?: number;
 }
 interface ScenarioResult {
   scenario: ParsedScenario;
   status: "passed" | "failed";
   steps: StepResult[];
+  /**
+   * The scenario's first error, if it failed. Usually the same object as the
+   * failing step's `error`; for a hook failure there's no step to point at, so
+   * this is the only place it surfaces. Reporters read this; the runner never
+   * throws it.
+   */
+  error?: Error;
+  /** Wall-clock duration of the whole scenario, in milliseconds. */
+  durationMs?: number;
 }
 /**
- * Run one scenario against a registry. 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.
+ * 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.
  *
- * Throws on failure so it maps cleanly onto a test runner's `test()` body, but
- * the returned/attached `ScenarioResult` carries the per-step breakdown.
+ * Pass the compiled table from {@link compileRegistry} once and reuse it across
+ * every scenario in the run.
  */
-declare function runScenario(scenario: ParsedScenario, registry: StepRegistry, makeWorld: () => MergeableWorld<any, any, any>, hooks?: HookRegistry): Promise<ScenarioResult>;
+declare function runScenario(scenario: ParsedScenario, compiled: CompiledStep[], makeWorld: () => MergeableWorld<any, any, any>, hooks?: HookRegistry): Promise<ScenarioResult>;
 //#endregion
-export { AmbiguousStepError, HookRegistry, type HookScope, type HookTiming, type PlainHookFn, type RegisteredHook, type RegisteredStep, type ScenarioHookFn, type ScenarioInfo, type ScenarioResult, StepRegistry, type StepResult, type StepType, UndefinedStepError, ensureGlobalHooks, globalHookRegistry, globalRegistry, runHooks, runScenario };
+export { AmbiguousStepError, type CompiledStep, HookRegistry, type HookScope, type HookTiming, type PlainHookFn, type RegisteredHook, type RegisteredStep, type ResolvedConfig, type RunnerOptions, type ScenarioHookFn, type ScenarioInfo, type ScenarioResult, StepRegistry, type StepResult, type StepType, UndefinedStepError, compileRegistry, globalHookRegistry, globalRegistry, runHooks, runHooksParallel, runScenario };
 //# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.js

@@ -1,159 +1,3 @@
-import { a as StepRegistry, i as runHooks, n as ensureGlobalHooks, o as globalRegistry, r as globalHookRegistry, t as HookRegistry } 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";
-	}
-};
-function compile(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 registry. 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.
-*
-* Throws on failure so it maps cleanly onto a test runner's `test()` body, but
-* the returned/attached `ScenarioResult` carries the per-step breakdown.
-*/
-async function runScenario(scenario, registry, makeWorld, hooks = globalHookRegistry) {
-	const compiled = compile(registry);
-	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);
-	}
-	const result = {
-		scenario,
-		status: failed ? "failed" : "passed",
-		steps
-	};
-	if (failed && firstError) {
-		const failing = steps.find((s) => s.status === "failed");
-		if (failing) attachFeatureFrame(firstError, scenario.file, failing.step);
-		throw firstError;
-	}
-	return result;
-}
-/**
-* 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 { AmbiguousStepError, HookRegistry, StepRegistry, UndefinedStepError, ensureGlobalHooks, globalHookRegistry, globalRegistry, runHooks, runScenario };
-
-//# sourceMappingURL=runtime.js.map
+import { a as StepRegistry, i as runHooksParallel, n as globalHookRegistry, o as globalRegistry, r as runHooks, t as HookRegistry } from "./hooks-BDCMKeNq.js";
+import { i as runScenario, n as UndefinedStepError, r as compileRegistry, t as AmbiguousStepError } from "./engine-DPVLEHBi.js";
+export { AmbiguousStepError, HookRegistry, StepRegistry, UndefinedStepError, compileRegistry, globalHookRegistry, globalRegistry, runHooks, runHooksParallel, runScenario };