@step-forge/step-forge 0.0.21 → 0.0.22

package/dist/hooks-BDCMKeNq.js

@@ -0,0 +1,71 @@
+//#region src/runtime/registry.ts
+/**
+* A collection of registered steps. Deliberately a plain instance (not a hidden
+* module global) so tests and the Vitest plugin can create isolated registries.
+* `globalRegistry` is the default sink that `.step()` writes to.
+*/
+var StepRegistry = class {
+	steps = [];
+	add(step) {
+		this.steps.push(step);
+	}
+	all() {
+		return this.steps;
+	}
+	clear() {
+		this.steps = [];
+	}
+};
+const globalRegistry = new StepRegistry();
+//#endregion
+//#region src/runtime/hooks.ts
+/**
+* Collection of registered hooks. Like {@link StepRegistry}, a plain instance
+* (not a hidden global) so tests can isolate; `globalHookRegistry` is the
+* default sink the public `beforeScenario`/`afterAll`/etc helpers write to.
+*/
+var HookRegistry = class {
+	hooks = [];
+	add(hook) {
+		this.hooks.push(hook);
+	}
+	/**
+	* Hooks for a scope+timing. `before` hooks run in registration order;
+	* `after` hooks run in reverse (LIFO), so teardown unwinds setup.
+	*/
+	for(scope, timing) {
+		const matching = this.hooks.filter((h) => h.scope === scope && h.timing === timing);
+		return timing === "after" ? matching.reverse() : matching;
+	}
+	clear() {
+		this.hooks = [];
+	}
+};
+const globalHookRegistry = new HookRegistry();
+/**
+* Run every registered hook of a scope+timing **in registration order** (after
+* hooks reversed by {@link HookRegistry.for}, so teardown unwinds setup). Used
+* for feature hooks, where ordering matters. Throws if a hook throws, so the
+* runner reports it against the enclosing boundary.
+*/
+async function runHooks(scope, timing, registry = globalHookRegistry) {
+	for (const hook of registry.for(scope, timing)) await hook.fn();
+}
+/**
+* Run every registered hook of a scope+timing **concurrently**, resolving once
+* all of them settle. This is how global `beforeAll`/`afterAll` run: independent
+* setup/teardown steps fire in parallel with no ordering between them. A hook
+* with a sequential requirement should sequence that work inside a single hook.
+*
+* The runner calls this exactly once for `beforeAll` (before any scenario
+* starts) and once for `afterAll` (after every scenario is done), so global
+* setup/teardown brackets the whole run deterministically. Rejects if any hook
+* rejects (via `Promise.all`), surfacing the first failure to the caller.
+*/
+async function runHooksParallel(scope, timing, registry = globalHookRegistry) {
+	await Promise.all(registry.for(scope, timing).map((hook) => hook.fn()));
+}
+//#endregion
+export { StepRegistry as a, runHooksParallel as i, globalHookRegistry as n, globalRegistry as o, runHooks as r, HookRegistry as t };
+
+//# sourceMappingURL=hooks-BDCMKeNq.js.map

package/dist/{hooks-CywugMQQ.js.map → hooks-BDCMKeNq.js.map}

@@ -1 +1 @@
-{"version":3,"file":"hooks-CywugMQQ.js","names":[],"sources":["../../src/runtime/registry.ts","../../src/runtime/hooks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Parser } from \"../parsers\";\nimport { MergeableWorld } from \"../world\";\n\nexport type StepType = \"given\" | \"when\" | \"then\";\n\n/**\n * A step definition as it exists at *runtime*, independent of any test runner.\n *\n * `execute` is the fully-wired step body: given a world and the raw values\n * captured from a Gherkin step, it applies parsers, validates + narrows\n * dependencies, runs the user's step function, and merges the result back into\n * the world. The engine never needs to know how any of that works — it just\n * matches text to a step and calls `execute`.\n */\nexport interface RegisteredStep {\n  stepType: StepType;\n  /** The Cucumber-expression source, e.g. `a user named {string}`. */\n  expression: string;\n  /** Parsers, one per captured variable, applied after expression capture. */\n  parsers: Parser<any>[];\n  execute: (\n    world: MergeableWorld<any, any, any>,\n    capturedArgs: unknown[]\n  ) => Promise<void>;\n  /** Where the step was defined, for ambiguous-match diagnostics. */\n  source?: string;\n}\n\n/**\n * A collection of registered steps. Deliberately a plain instance (not a hidden\n * module global) so tests and the Vitest plugin can create isolated registries.\n * `globalRegistry` is the default sink that `.step()` writes to.\n */\nexport class StepRegistry {\n  private steps: RegisteredStep[] = [];\n\n  add(step: RegisteredStep): void {\n    this.steps.push(step);\n  }\n\n  all(): readonly RegisteredStep[] {\n    return this.steps;\n  }\n\n  clear(): void {\n    this.steps = [];\n  }\n}\n\nexport const globalRegistry = new StepRegistry();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MergeableWorld } from \"../world\";\n\n/**\n * Hooks are side-effect callbacks that run around scenarios, feature files, or\n * the whole run. Unlike steps they never seed state: state is owned end to end\n * by the typed dependency graph (given/when/then), and hooks exist for setup and\n * teardown (opening a DB, starting a server, resetting mocks). A scenario hook\n * may *read* the world, but its return value is ignored.\n */\nexport type HookScope = \"scenario\" | \"feature\" | \"global\";\nexport type HookTiming = \"before\" | \"after\";\n\n/** Lightweight scenario identity handed to per-scenario hooks. */\nexport interface ScenarioInfo {\n  name: string;\n  file: string;\n}\n\n/** A per-scenario hook: gets the scenario's world (read-only in spirit). */\nexport type ScenarioHookFn = (context: {\n  world: MergeableWorld<any, any, any>;\n  scenario: ScenarioInfo;\n}) => void | Promise<void>;\n\n/** A per-feature-file or global hook: no world exists at these boundaries. */\nexport type PlainHookFn = () => void | Promise<void>;\n\nexport interface RegisteredHook {\n  scope: HookScope;\n  timing: HookTiming;\n  fn: ScenarioHookFn | PlainHookFn;\n}\n\n/**\n * Collection of registered hooks. Like {@link StepRegistry}, a plain instance\n * (not a hidden global) so tests can isolate; `globalHookRegistry` is the\n * default sink the public `beforeScenario`/`afterAll`/etc helpers write to.\n */\nexport class HookRegistry {\n  private hooks: RegisteredHook[] = [];\n\n  add(hook: RegisteredHook): void {\n    this.hooks.push(hook);\n  }\n\n  /**\n   * Hooks for a scope+timing. `before` hooks run in registration order;\n   * `after` hooks run in reverse (LIFO), so teardown unwinds setup.\n   */\n  for(scope: HookScope, timing: HookTiming): RegisteredHook[] {\n    const matching = this.hooks.filter(\n      h => h.scope === scope && h.timing === timing\n    );\n    return timing === \"after\" ? matching.reverse() : matching;\n  }\n\n  clear(): void {\n    this.hooks = [];\n  }\n}\n\nexport const globalHookRegistry = new HookRegistry();\n\n/**\n * Run every registered feature/global hook of a scope+timing in order. Used by\n * the generated test modules (feature hooks). Throws if a hook throws, so the\n * runner reports it against the enclosing boundary.\n */\nexport async function runHooks(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  for (const hook of registry.for(scope, timing)) {\n    await (hook.fn as PlainHookFn)();\n  }\n}\n\n// Process-global (via Symbol.for so it survives module duplication) guard so\n// global hooks fire exactly once per worker, no matter how many feature modules\n// call in.\nconst GLOBAL_GUARD = Symbol.for(\"step-forge.globalHooksStarted\");\n\n/**\n * Run global before-hooks once per worker, ahead of that worker's first\n * scenario, and schedule global after-hooks for worker exit. Idempotent: every\n * feature module calls this in a `beforeAll`, but only the first call in a given\n * worker does anything.\n *\n * Semantics & caveats (the once-per-worker model):\n * - Runs in the *same* realm as steps, so global setup may touch in-process\n *   state that steps later read.\n * - \"Once per worker\", not strictly once per run — with multiple workers it runs\n *   in each. Size global setup to be worker-safe (e.g. a server per worker).\n * - Teardown is best-effort: after-hooks start on the worker's `beforeExit` and\n *   are not awaited by the runner, so keep them fast/synchronous.\n */\nexport async function ensureGlobalHooks(\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  const store = globalThis as Record<symbol, boolean>;\n  if (store[GLOBAL_GUARD]) return;\n  store[GLOBAL_GUARD] = true;\n\n  for (const hook of registry.for(\"global\", \"before\")) {\n    await (hook.fn as PlainHookFn)();\n  }\n\n  process.once(\"beforeExit\", () => {\n    void (async () => {\n      for (const hook of registry.for(\"global\", \"after\")) {\n        await (hook.fn as PlainHookFn)();\n      }\n    })();\n  });\n}\n"],"mappings":";;;;;;AAkCA,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;CAEA,MAAiC;EAC/B,OAAO,KAAK;CACd;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,iBAAiB,IAAI,aAAa;;;;;;;;ACX/C,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;;;;;CAMA,IAAI,OAAkB,QAAsC;EAC1D,MAAM,WAAW,KAAK,MAAM,QAC1B,MAAK,EAAE,UAAU,SAAS,EAAE,WAAW,MACzC;EACA,OAAO,WAAW,UAAU,SAAS,QAAQ,IAAI;CACnD;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,qBAAqB,IAAI,aAAa;;;;;;AAOnD,eAAsB,SACpB,OACA,QACA,WAAyB,oBACV;CACf,KAAK,MAAM,QAAQ,SAAS,IAAI,OAAO,MAAM,GAC3C,MAAO,KAAK,GAAmB;AAEnC;AAKA,MAAM,eAAe,OAAO,IAAI,+BAA+B;;;;;;;;;;;;;;;AAgB/D,eAAsB,kBACpB,WAAyB,oBACV;CACf,MAAM,QAAQ;CACd,IAAI,MAAM,eAAe;CACzB,MAAM,gBAAgB;CAEtB,KAAK,MAAM,QAAQ,SAAS,IAAI,UAAU,QAAQ,GAChD,MAAO,KAAK,GAAmB;CAGjC,QAAQ,KAAK,oBAAoB;EAC/B,CAAM,YAAY;GAChB,KAAK,MAAM,QAAQ,SAAS,IAAI,UAAU,OAAO,GAC/C,MAAO,KAAK,GAAmB;EAEnC,EAAA,CAAG;CACL,CAAC;AACH"}
+{"version":3,"file":"hooks-BDCMKeNq.js","names":[],"sources":["../../src/runtime/registry.ts","../../src/runtime/hooks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Parser } from \"../parsers\";\nimport { MergeableWorld } from \"../world\";\n\nexport type StepType = \"given\" | \"when\" | \"then\";\n\n/**\n * A step definition as it exists at *runtime*, independent of any test runner.\n *\n * `execute` is the fully-wired step body: given a world and the raw values\n * captured from a Gherkin step, it applies parsers, validates + narrows\n * dependencies, runs the user's step function, and merges the result back into\n * the world. The engine never needs to know how any of that works — it just\n * matches text to a step and calls `execute`.\n */\nexport interface RegisteredStep {\n  stepType: StepType;\n  /** The Cucumber-expression source, e.g. `a user named {string}`. */\n  expression: string;\n  /** Parsers, one per captured variable, applied after expression capture. */\n  parsers: Parser<any>[];\n  execute: (\n    world: MergeableWorld<any, any, any>,\n    capturedArgs: unknown[]\n  ) => Promise<void>;\n  /** Where the step was defined, for ambiguous-match diagnostics. */\n  source?: string;\n}\n\n/**\n * A collection of registered steps. Deliberately a plain instance (not a hidden\n * module global) so tests and the Vitest plugin can create isolated registries.\n * `globalRegistry` is the default sink that `.step()` writes to.\n */\nexport class StepRegistry {\n  private steps: RegisteredStep[] = [];\n\n  add(step: RegisteredStep): void {\n    this.steps.push(step);\n  }\n\n  all(): readonly RegisteredStep[] {\n    return this.steps;\n  }\n\n  clear(): void {\n    this.steps = [];\n  }\n}\n\nexport const globalRegistry = new StepRegistry();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MergeableWorld } from \"../world\";\n\n/**\n * Hooks are side-effect callbacks that run around scenarios, feature files, or\n * the whole run. Unlike steps they never seed state: state is owned end to end\n * by the typed dependency graph (given/when/then), and hooks exist for setup and\n * teardown (opening a DB, starting a server, resetting mocks). A scenario hook\n * may *read* the world, but its return value is ignored.\n */\nexport type HookScope = \"scenario\" | \"feature\" | \"global\";\nexport type HookTiming = \"before\" | \"after\";\n\n/** Lightweight scenario identity handed to per-scenario hooks. */\nexport interface ScenarioInfo {\n  name: string;\n  file: string;\n}\n\n/** A per-scenario hook: gets the scenario's world (read-only in spirit). */\nexport type ScenarioHookFn = (context: {\n  world: MergeableWorld<any, any, any>;\n  scenario: ScenarioInfo;\n}) => void | Promise<void>;\n\n/** A per-feature-file or global hook: no world exists at these boundaries. */\nexport type PlainHookFn = () => void | Promise<void>;\n\nexport interface RegisteredHook {\n  scope: HookScope;\n  timing: HookTiming;\n  fn: ScenarioHookFn | PlainHookFn;\n}\n\n/**\n * Collection of registered hooks. Like {@link StepRegistry}, a plain instance\n * (not a hidden global) so tests can isolate; `globalHookRegistry` is the\n * default sink the public `beforeScenario`/`afterAll`/etc helpers write to.\n */\nexport class HookRegistry {\n  private hooks: RegisteredHook[] = [];\n\n  add(hook: RegisteredHook): void {\n    this.hooks.push(hook);\n  }\n\n  /**\n   * Hooks for a scope+timing. `before` hooks run in registration order;\n   * `after` hooks run in reverse (LIFO), so teardown unwinds setup.\n   */\n  for(scope: HookScope, timing: HookTiming): RegisteredHook[] {\n    const matching = this.hooks.filter(\n      h => h.scope === scope && h.timing === timing\n    );\n    return timing === \"after\" ? matching.reverse() : matching;\n  }\n\n  clear(): void {\n    this.hooks = [];\n  }\n}\n\nexport const globalHookRegistry = new HookRegistry();\n\n/**\n * Run every registered hook of a scope+timing **in registration order** (after\n * hooks reversed by {@link HookRegistry.for}, so teardown unwinds setup). Used\n * for feature hooks, where ordering matters. Throws if a hook throws, so the\n * runner reports it against the enclosing boundary.\n */\nexport async function runHooks(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  for (const hook of registry.for(scope, timing)) {\n    await (hook.fn as PlainHookFn)();\n  }\n}\n\n/**\n * Run every registered hook of a scope+timing **concurrently**, resolving once\n * all of them settle. This is how global `beforeAll`/`afterAll` run: independent\n * setup/teardown steps fire in parallel with no ordering between them. A hook\n * with a sequential requirement should sequence that work inside a single hook.\n *\n * The runner calls this exactly once for `beforeAll` (before any scenario\n * starts) and once for `afterAll` (after every scenario is done), so global\n * setup/teardown brackets the whole run deterministically. Rejects if any hook\n * rejects (via `Promise.all`), surfacing the first failure to the caller.\n */\nexport async function runHooksParallel(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  await Promise.all(\n    registry.for(scope, timing).map(hook => (hook.fn as PlainHookFn)())\n  );\n}\n"],"mappings":";;;;;;AAkCA,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;CAEA,MAAiC;EAC/B,OAAO,KAAK;CACd;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,iBAAiB,IAAI,aAAa;;;;;;;;ACX/C,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;;;;;CAMA,IAAI,OAAkB,QAAsC;EAC1D,MAAM,WAAW,KAAK,MAAM,QAC1B,MAAK,EAAE,UAAU,SAAS,EAAE,WAAW,MACzC;EACA,OAAO,WAAW,UAAU,SAAS,QAAQ,IAAI;CACnD;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,qBAAqB,IAAI,aAAa;;;;;;;AAQnD,eAAsB,SACpB,OACA,QACA,WAAyB,oBACV;CACf,KAAK,MAAM,QAAQ,SAAS,IAAI,OAAO,MAAM,GAC3C,MAAO,KAAK,GAAmB;AAEnC;;;;;;;;;;;;AAaA,eAAsB,iBACpB,OACA,QACA,WAAyB,oBACV;CACf,MAAM,QAAQ,IACZ,SAAS,IAAI,OAAO,MAAM,CAAC,CAAC,KAAI,SAAS,KAAK,GAAmB,CAAC,CACpE;AACF"}

package/dist/{hooks-CGYzwDOv.cjs → hooks-Be0cjULN.cjs}

@@ -43,38 +43,27 @@ var HookRegistry = class {
 };
 const globalHookRegistry = new HookRegistry();
 /**
-* Run every registered feature/global hook of a scope+timing in order. Used by
-* the generated test modules (feature hooks). Throws if a hook throws, so the
+* Run every registered hook of a scope+timing **in registration order** (after
+* hooks reversed by {@link HookRegistry.for}, so teardown unwinds setup). Used
+* for feature hooks, where ordering matters. Throws if a hook throws, so the
 * runner reports it against the enclosing boundary.
 */
 async function runHooks(scope, timing, registry = globalHookRegistry) {
 	for (const hook of registry.for(scope, timing)) await hook.fn();
 }
-const GLOBAL_GUARD = Symbol.for("step-forge.globalHooksStarted");
 /**
-* Run global before-hooks once per worker, ahead of that worker's first
-* scenario, and schedule global after-hooks for worker exit. Idempotent: every
-* feature module calls this in a `beforeAll`, but only the first call in a given
-* worker does anything.
+* Run every registered hook of a scope+timing **concurrently**, resolving once
+* all of them settle. This is how global `beforeAll`/`afterAll` run: independent
+* setup/teardown steps fire in parallel with no ordering between them. A hook
+* with a sequential requirement should sequence that work inside a single hook.
 *
-* Semantics & caveats (the once-per-worker model):
-* - Runs in the *same* realm as steps, so global setup may touch in-process
-*   state that steps later read.
-* - "Once per worker", not strictly once per run — with multiple workers it runs
-*   in each. Size global setup to be worker-safe (e.g. a server per worker).
-* - Teardown is best-effort: after-hooks start on the worker's `beforeExit` and
-*   are not awaited by the runner, so keep them fast/synchronous.
+* The runner calls this exactly once for `beforeAll` (before any scenario
+* starts) and once for `afterAll` (after every scenario is done), so global
+* setup/teardown brackets the whole run deterministically. Rejects if any hook
+* rejects (via `Promise.all`), surfacing the first failure to the caller.
 */
-async function ensureGlobalHooks(registry = globalHookRegistry) {
-	const store = globalThis;
-	if (store[GLOBAL_GUARD]) return;
-	store[GLOBAL_GUARD] = true;
-	for (const hook of registry.for("global", "before")) await hook.fn();
-	process.once("beforeExit", () => {
-		(async () => {
-			for (const hook of registry.for("global", "after")) await hook.fn();
-		})();
-	});
+async function runHooksParallel(scope, timing, registry = globalHookRegistry) {
+	await Promise.all(registry.for(scope, timing).map((hook) => hook.fn()));
 }
 //#endregion
 Object.defineProperty(exports, "HookRegistry", {
@@ -89,12 +78,6 @@ Object.defineProperty(exports, "StepRegistry", {
 		return StepRegistry;
 	}
 });
-Object.defineProperty(exports, "ensureGlobalHooks", {
-	enumerable: true,
-	get: function() {
-		return ensureGlobalHooks;
-	}
-});
 Object.defineProperty(exports, "globalHookRegistry", {
 	enumerable: true,
 	get: function() {
@@ -113,5 +96,11 @@ Object.defineProperty(exports, "runHooks", {
 		return runHooks;
 	}
 });
+Object.defineProperty(exports, "runHooksParallel", {
+	enumerable: true,
+	get: function() {
+		return runHooksParallel;
+	}
+});
 
-//# sourceMappingURL=hooks-CGYzwDOv.cjs.map
+//# sourceMappingURL=hooks-Be0cjULN.cjs.map

package/dist/{hooks-CGYzwDOv.cjs.map → hooks-Be0cjULN.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"hooks-CGYzwDOv.cjs","names":[],"sources":["../../src/runtime/registry.ts","../../src/runtime/hooks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Parser } from \"../parsers\";\nimport { MergeableWorld } from \"../world\";\n\nexport type StepType = \"given\" | \"when\" | \"then\";\n\n/**\n * A step definition as it exists at *runtime*, independent of any test runner.\n *\n * `execute` is the fully-wired step body: given a world and the raw values\n * captured from a Gherkin step, it applies parsers, validates + narrows\n * dependencies, runs the user's step function, and merges the result back into\n * the world. The engine never needs to know how any of that works — it just\n * matches text to a step and calls `execute`.\n */\nexport interface RegisteredStep {\n  stepType: StepType;\n  /** The Cucumber-expression source, e.g. `a user named {string}`. */\n  expression: string;\n  /** Parsers, one per captured variable, applied after expression capture. */\n  parsers: Parser<any>[];\n  execute: (\n    world: MergeableWorld<any, any, any>,\n    capturedArgs: unknown[]\n  ) => Promise<void>;\n  /** Where the step was defined, for ambiguous-match diagnostics. */\n  source?: string;\n}\n\n/**\n * A collection of registered steps. Deliberately a plain instance (not a hidden\n * module global) so tests and the Vitest plugin can create isolated registries.\n * `globalRegistry` is the default sink that `.step()` writes to.\n */\nexport class StepRegistry {\n  private steps: RegisteredStep[] = [];\n\n  add(step: RegisteredStep): void {\n    this.steps.push(step);\n  }\n\n  all(): readonly RegisteredStep[] {\n    return this.steps;\n  }\n\n  clear(): void {\n    this.steps = [];\n  }\n}\n\nexport const globalRegistry = new StepRegistry();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MergeableWorld } from \"../world\";\n\n/**\n * Hooks are side-effect callbacks that run around scenarios, feature files, or\n * the whole run. Unlike steps they never seed state: state is owned end to end\n * by the typed dependency graph (given/when/then), and hooks exist for setup and\n * teardown (opening a DB, starting a server, resetting mocks). A scenario hook\n * may *read* the world, but its return value is ignored.\n */\nexport type HookScope = \"scenario\" | \"feature\" | \"global\";\nexport type HookTiming = \"before\" | \"after\";\n\n/** Lightweight scenario identity handed to per-scenario hooks. */\nexport interface ScenarioInfo {\n  name: string;\n  file: string;\n}\n\n/** A per-scenario hook: gets the scenario's world (read-only in spirit). */\nexport type ScenarioHookFn = (context: {\n  world: MergeableWorld<any, any, any>;\n  scenario: ScenarioInfo;\n}) => void | Promise<void>;\n\n/** A per-feature-file or global hook: no world exists at these boundaries. */\nexport type PlainHookFn = () => void | Promise<void>;\n\nexport interface RegisteredHook {\n  scope: HookScope;\n  timing: HookTiming;\n  fn: ScenarioHookFn | PlainHookFn;\n}\n\n/**\n * Collection of registered hooks. Like {@link StepRegistry}, a plain instance\n * (not a hidden global) so tests can isolate; `globalHookRegistry` is the\n * default sink the public `beforeScenario`/`afterAll`/etc helpers write to.\n */\nexport class HookRegistry {\n  private hooks: RegisteredHook[] = [];\n\n  add(hook: RegisteredHook): void {\n    this.hooks.push(hook);\n  }\n\n  /**\n   * Hooks for a scope+timing. `before` hooks run in registration order;\n   * `after` hooks run in reverse (LIFO), so teardown unwinds setup.\n   */\n  for(scope: HookScope, timing: HookTiming): RegisteredHook[] {\n    const matching = this.hooks.filter(\n      h => h.scope === scope && h.timing === timing\n    );\n    return timing === \"after\" ? matching.reverse() : matching;\n  }\n\n  clear(): void {\n    this.hooks = [];\n  }\n}\n\nexport const globalHookRegistry = new HookRegistry();\n\n/**\n * Run every registered feature/global hook of a scope+timing in order. Used by\n * the generated test modules (feature hooks). Throws if a hook throws, so the\n * runner reports it against the enclosing boundary.\n */\nexport async function runHooks(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  for (const hook of registry.for(scope, timing)) {\n    await (hook.fn as PlainHookFn)();\n  }\n}\n\n// Process-global (via Symbol.for so it survives module duplication) guard so\n// global hooks fire exactly once per worker, no matter how many feature modules\n// call in.\nconst GLOBAL_GUARD = Symbol.for(\"step-forge.globalHooksStarted\");\n\n/**\n * Run global before-hooks once per worker, ahead of that worker's first\n * scenario, and schedule global after-hooks for worker exit. Idempotent: every\n * feature module calls this in a `beforeAll`, but only the first call in a given\n * worker does anything.\n *\n * Semantics & caveats (the once-per-worker model):\n * - Runs in the *same* realm as steps, so global setup may touch in-process\n *   state that steps later read.\n * - \"Once per worker\", not strictly once per run — with multiple workers it runs\n *   in each. Size global setup to be worker-safe (e.g. a server per worker).\n * - Teardown is best-effort: after-hooks start on the worker's `beforeExit` and\n *   are not awaited by the runner, so keep them fast/synchronous.\n */\nexport async function ensureGlobalHooks(\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  const store = globalThis as Record<symbol, boolean>;\n  if (store[GLOBAL_GUARD]) return;\n  store[GLOBAL_GUARD] = true;\n\n  for (const hook of registry.for(\"global\", \"before\")) {\n    await (hook.fn as PlainHookFn)();\n  }\n\n  process.once(\"beforeExit\", () => {\n    void (async () => {\n      for (const hook of registry.for(\"global\", \"after\")) {\n        await (hook.fn as PlainHookFn)();\n      }\n    })();\n  });\n}\n"],"mappings":";;;;;;AAkCA,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;CAEA,MAAiC;EAC/B,OAAO,KAAK;CACd;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,iBAAiB,IAAI,aAAa;;;;;;;;ACX/C,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;;;;;CAMA,IAAI,OAAkB,QAAsC;EAC1D,MAAM,WAAW,KAAK,MAAM,QAC1B,MAAK,EAAE,UAAU,SAAS,EAAE,WAAW,MACzC;EACA,OAAO,WAAW,UAAU,SAAS,QAAQ,IAAI;CACnD;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,qBAAqB,IAAI,aAAa;;;;;;AAOnD,eAAsB,SACpB,OACA,QACA,WAAyB,oBACV;CACf,KAAK,MAAM,QAAQ,SAAS,IAAI,OAAO,MAAM,GAC3C,MAAO,KAAK,GAAmB;AAEnC;AAKA,MAAM,eAAe,OAAO,IAAI,+BAA+B;;;;;;;;;;;;;;;AAgB/D,eAAsB,kBACpB,WAAyB,oBACV;CACf,MAAM,QAAQ;CACd,IAAI,MAAM,eAAe;CACzB,MAAM,gBAAgB;CAEtB,KAAK,MAAM,QAAQ,SAAS,IAAI,UAAU,QAAQ,GAChD,MAAO,KAAK,GAAmB;CAGjC,QAAQ,KAAK,oBAAoB;EAC/B,CAAM,YAAY;GAChB,KAAK,MAAM,QAAQ,SAAS,IAAI,UAAU,OAAO,GAC/C,MAAO,KAAK,GAAmB;EAEnC,EAAA,CAAG;CACL,CAAC;AACH"}
+{"version":3,"file":"hooks-Be0cjULN.cjs","names":[],"sources":["../../src/runtime/registry.ts","../../src/runtime/hooks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Parser } from \"../parsers\";\nimport { MergeableWorld } from \"../world\";\n\nexport type StepType = \"given\" | \"when\" | \"then\";\n\n/**\n * A step definition as it exists at *runtime*, independent of any test runner.\n *\n * `execute` is the fully-wired step body: given a world and the raw values\n * captured from a Gherkin step, it applies parsers, validates + narrows\n * dependencies, runs the user's step function, and merges the result back into\n * the world. The engine never needs to know how any of that works — it just\n * matches text to a step and calls `execute`.\n */\nexport interface RegisteredStep {\n  stepType: StepType;\n  /** The Cucumber-expression source, e.g. `a user named {string}`. */\n  expression: string;\n  /** Parsers, one per captured variable, applied after expression capture. */\n  parsers: Parser<any>[];\n  execute: (\n    world: MergeableWorld<any, any, any>,\n    capturedArgs: unknown[]\n  ) => Promise<void>;\n  /** Where the step was defined, for ambiguous-match diagnostics. */\n  source?: string;\n}\n\n/**\n * A collection of registered steps. Deliberately a plain instance (not a hidden\n * module global) so tests and the Vitest plugin can create isolated registries.\n * `globalRegistry` is the default sink that `.step()` writes to.\n */\nexport class StepRegistry {\n  private steps: RegisteredStep[] = [];\n\n  add(step: RegisteredStep): void {\n    this.steps.push(step);\n  }\n\n  all(): readonly RegisteredStep[] {\n    return this.steps;\n  }\n\n  clear(): void {\n    this.steps = [];\n  }\n}\n\nexport const globalRegistry = new StepRegistry();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MergeableWorld } from \"../world\";\n\n/**\n * Hooks are side-effect callbacks that run around scenarios, feature files, or\n * the whole run. Unlike steps they never seed state: state is owned end to end\n * by the typed dependency graph (given/when/then), and hooks exist for setup and\n * teardown (opening a DB, starting a server, resetting mocks). A scenario hook\n * may *read* the world, but its return value is ignored.\n */\nexport type HookScope = \"scenario\" | \"feature\" | \"global\";\nexport type HookTiming = \"before\" | \"after\";\n\n/** Lightweight scenario identity handed to per-scenario hooks. */\nexport interface ScenarioInfo {\n  name: string;\n  file: string;\n}\n\n/** A per-scenario hook: gets the scenario's world (read-only in spirit). */\nexport type ScenarioHookFn = (context: {\n  world: MergeableWorld<any, any, any>;\n  scenario: ScenarioInfo;\n}) => void | Promise<void>;\n\n/** A per-feature-file or global hook: no world exists at these boundaries. */\nexport type PlainHookFn = () => void | Promise<void>;\n\nexport interface RegisteredHook {\n  scope: HookScope;\n  timing: HookTiming;\n  fn: ScenarioHookFn | PlainHookFn;\n}\n\n/**\n * Collection of registered hooks. Like {@link StepRegistry}, a plain instance\n * (not a hidden global) so tests can isolate; `globalHookRegistry` is the\n * default sink the public `beforeScenario`/`afterAll`/etc helpers write to.\n */\nexport class HookRegistry {\n  private hooks: RegisteredHook[] = [];\n\n  add(hook: RegisteredHook): void {\n    this.hooks.push(hook);\n  }\n\n  /**\n   * Hooks for a scope+timing. `before` hooks run in registration order;\n   * `after` hooks run in reverse (LIFO), so teardown unwinds setup.\n   */\n  for(scope: HookScope, timing: HookTiming): RegisteredHook[] {\n    const matching = this.hooks.filter(\n      h => h.scope === scope && h.timing === timing\n    );\n    return timing === \"after\" ? matching.reverse() : matching;\n  }\n\n  clear(): void {\n    this.hooks = [];\n  }\n}\n\nexport const globalHookRegistry = new HookRegistry();\n\n/**\n * Run every registered hook of a scope+timing **in registration order** (after\n * hooks reversed by {@link HookRegistry.for}, so teardown unwinds setup). Used\n * for feature hooks, where ordering matters. Throws if a hook throws, so the\n * runner reports it against the enclosing boundary.\n */\nexport async function runHooks(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  for (const hook of registry.for(scope, timing)) {\n    await (hook.fn as PlainHookFn)();\n  }\n}\n\n/**\n * Run every registered hook of a scope+timing **concurrently**, resolving once\n * all of them settle. This is how global `beforeAll`/`afterAll` run: independent\n * setup/teardown steps fire in parallel with no ordering between them. A hook\n * with a sequential requirement should sequence that work inside a single hook.\n *\n * The runner calls this exactly once for `beforeAll` (before any scenario\n * starts) and once for `afterAll` (after every scenario is done), so global\n * setup/teardown brackets the whole run deterministically. Rejects if any hook\n * rejects (via `Promise.all`), surfacing the first failure to the caller.\n */\nexport async function runHooksParallel(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  await Promise.all(\n    registry.for(scope, timing).map(hook => (hook.fn as PlainHookFn)())\n  );\n}\n"],"mappings":";;;;;;AAkCA,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;CAEA,MAAiC;EAC/B,OAAO,KAAK;CACd;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,iBAAiB,IAAI,aAAa;;;;;;;;ACX/C,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;;;;;CAMA,IAAI,OAAkB,QAAsC;EAC1D,MAAM,WAAW,KAAK,MAAM,QAC1B,MAAK,EAAE,UAAU,SAAS,EAAE,WAAW,MACzC;EACA,OAAO,WAAW,UAAU,SAAS,QAAQ,IAAI;CACnD;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,qBAAqB,IAAI,aAAa;;;;;;;AAQnD,eAAsB,SACpB,OACA,QACA,WAAyB,oBACV;CACf,KAAK,MAAM,QAAQ,SAAS,IAAI,OAAO,MAAM,GAC3C,MAAO,KAAK,GAAmB;AAEnC;;;;;;;;;;;;AAaA,eAAsB,iBACpB,OACA,QACA,WAAyB,oBACV;CACf,MAAM,QAAQ,IACZ,SAAS,IAAI,OAAO,MAAM,CAAC,CAAC,KAAI,SAAS,KAAK,GAAmB,CAAC,CACpE;AACF"}

package/dist/runtime.cjs

@@ -1,13 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_hooks = require("./hooks-CGYzwDOv.cjs");
-const require_engine = require("./engine-DWAIlwWp.cjs");
+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 = require_engine.UndefinedStepError;
 exports.compileRegistry = require_engine.compileRegistry;
-exports.ensureGlobalHooks = require_hooks.ensureGlobalHooks;
 exports.globalHookRegistry = require_hooks.globalHookRegistry;
 exports.globalRegistry = require_hooks.globalRegistry;
 exports.runHooks = require_hooks.runHooks;
+exports.runHooksParallel = require_hooks.runHooksParallel;
 exports.runScenario = require_engine.runScenario;

package/dist/runtime.d.cts

@@ -1,4 +1,4 @@
-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
@@ -61,6 +61,12 @@ 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 {
@@ -69,9 +75,9 @@ interface ScenarioResult {
   steps: StepResult[];
   /**
    * The scenario's first error, if it failed. Usually the same object as the
-   * failing step's `error` (with a synthetic `.feature` stack frame attached),
-   * but 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.
+   * 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. */
@@ -95,48 +101,5 @@ interface ScenarioResult {
  */
 declare function runScenario(scenario: ParsedScenario, compiled: CompiledStep[], makeWorld: () => MergeableWorld<any, any, any>, hooks?: HookRegistry): Promise<ScenarioResult>;
 //#endregion
-//#region src/runtime/config.d.ts
-/**
- * User-facing runner configuration. The same shape is accepted from a
- * `step-forge.config.ts` file (default export) and from CLI flags, with flags
- * taking precedence. Everything is optional; {@link resolveConfig} fills in
- * defaults.
- */
-interface RunnerOptions {
-  /** Feature-file glob(s), relative to `cwd`. Defaults to every `.feature` file. */
-  features?: string | string[];
-  /** Step-module glob(s), relative to `cwd`. Defaults to every `.steps.ts` file. */
-  steps?: string | string[];
-  /**
-   * Module that default-exports a world factory `() => world`, relative to
-   * `cwd`. When omitted each scenario gets a fresh `BasicWorld`.
-   */
-  world?: string;
-  /**
-   * Max scenarios in flight at once. Defaults to `1` (serial), matching
-   * Cucumber's default execution model — scenarios often share module-level
-   * state via hooks, which only holds under serial execution. Raise it to opt
-   * into parallelism for isolated, I/O-bound suites.
-   */
-  concurrency?: number;
-  /** Reporter name. Default `pretty`. */
-  reporter?: "pretty" | "progress";
-  /** Only run scenarios whose name matches this (string → substring/regex). */
-  name?: string;
-  /** Cucumber tag expression, e.g. `@smoke and not @wip`. */
-  tags?: string;
-}
-/** Fully-resolved config: no optionals, globs kept as arrays, paths absolute. */
-interface ResolvedConfig {
-  cwd: string;
-  features: string[];
-  steps: string[];
-  world?: string;
-  concurrency: number;
-  reporter: "pretty" | "progress";
-  name?: string;
-  tags?: string;
-}
-//#endregion
-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, 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,4 @@
-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
@@ -61,6 +61,12 @@ 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 {
@@ -69,9 +75,9 @@ interface ScenarioResult {
   steps: StepResult[];
   /**
    * The scenario's first error, if it failed. Usually the same object as the
-   * failing step's `error` (with a synthetic `.feature` stack frame attached),
-   * but 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.
+   * 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. */
@@ -95,48 +101,5 @@ interface ScenarioResult {
  */
 declare function runScenario(scenario: ParsedScenario, compiled: CompiledStep[], makeWorld: () => MergeableWorld<any, any, any>, hooks?: HookRegistry): Promise<ScenarioResult>;
 //#endregion
-//#region src/runtime/config.d.ts
-/**
- * User-facing runner configuration. The same shape is accepted from a
- * `step-forge.config.ts` file (default export) and from CLI flags, with flags
- * taking precedence. Everything is optional; {@link resolveConfig} fills in
- * defaults.
- */
-interface RunnerOptions {
-  /** Feature-file glob(s), relative to `cwd`. Defaults to every `.feature` file. */
-  features?: string | string[];
-  /** Step-module glob(s), relative to `cwd`. Defaults to every `.steps.ts` file. */
-  steps?: string | string[];
-  /**
-   * Module that default-exports a world factory `() => world`, relative to
-   * `cwd`. When omitted each scenario gets a fresh `BasicWorld`.
-   */
-  world?: string;
-  /**
-   * Max scenarios in flight at once. Defaults to `1` (serial), matching
-   * Cucumber's default execution model — scenarios often share module-level
-   * state via hooks, which only holds under serial execution. Raise it to opt
-   * into parallelism for isolated, I/O-bound suites.
-   */
-  concurrency?: number;
-  /** Reporter name. Default `pretty`. */
-  reporter?: "pretty" | "progress";
-  /** Only run scenarios whose name matches this (string → substring/regex). */
-  name?: string;
-  /** Cucumber tag expression, e.g. `@smoke and not @wip`. */
-  tags?: string;
-}
-/** Fully-resolved config: no optionals, globs kept as arrays, paths absolute. */
-interface ResolvedConfig {
-  cwd: string;
-  features: string[];
-  steps: string[];
-  world?: string;
-  concurrency: number;
-  reporter: "pretty" | "progress";
-  name?: string;
-  tags?: string;
-}
-//#endregion
-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, 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,3 +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 { i as runScenario, n as UndefinedStepError, r as compileRegistry, t as AmbiguousStepError } from "./engine-DPRxs6eC.js";
-export { AmbiguousStepError, HookRegistry, StepRegistry, UndefinedStepError, compileRegistry, ensureGlobalHooks, globalHookRegistry, globalRegistry, runHooks, runScenario };
+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 };

package/dist/step-forge.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_gherkinParser = require("./gherkinParser-CHpkEwii.cjs");
-const require_hooks = require("./hooks-CGYzwDOv.cjs");
+const require_gherkinParser = require("./gherkinParser-BT40q_i3.cjs");
+const require_hooks = require("./hooks-Be0cjULN.cjs");
 let lodash = require("lodash");
 lodash = require_gherkinParser.__toESM(lodash, 1);
 let typescript = require("typescript");
@@ -117,11 +117,13 @@ const addStep = (statement, stepType, dependencies = {
 		});
 		world[stepType].merge({ ...result });
 	};
+	const source = require_gherkinParser.captureDefinitionSite();
 	require_hooks.globalRegistry.add({
 		stepType,
 		expression,
 		parsers,
-		execute
+		execute,
+		source
 	});
 	return {
 		statement,
@@ -202,6 +204,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 = typescript.default.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 = typescript.default.sys.readFile(filePath);
+	if (text === void 0) return null;
+	const scriptKind = filePath.endsWith(".tsx") ? typescript.default.ScriptKind.TSX : typescript.default.ScriptKind.TS;
+	return typescript.default.createSourceFile(filePath, text, typescript.default.ScriptTarget.ESNext, true, scriptKind);
+}
+/** Resolve compiler options from tsconfig (fallback to sane defaults). */
+function resolveCompilerOptions(tsConfigPath) {
 	const configPath = tsConfigPath ?? typescript.default.findConfigFile(process.cwd(), typescript.default.sys.fileExists);
 	let compilerOptions = {
 		target: typescript.default.ScriptTarget.ESNext,
@@ -215,22 +232,25 @@ function extractStepDefinitions(filePaths, tsConfigPath) {
 		if (!configFile.error) compilerOptions = typescript.default.parseJsonConfigFileContent(configFile.config, typescript.default.sys, configPath.replace(/[/\\][^/\\]+$/, "")).options;
 	}
 	compilerOptions.noEmit = true;
-	const program = typescript.default.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 (typescript.default.isCallExpression(node) && typescript.default.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);
 		}
 		typescript.default.forEachChild(node, visit);
@@ -238,7 +258,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;
@@ -253,7 +273,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") {
@@ -270,7 +290,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;
@@ -357,33 +377,37 @@ function extractDependencies(depsCall) {
 	}
 	return deps;
 }
-function extractProducedKeys(stepCall, checker) {
+function extractProducedKeys(stepCall, ctx) {
 	const callback = stepCall.arguments[0];
 	if (!callback) return [];
-	if (typescript.default.isArrowFunction(callback) || typescript.default.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, checker);
+	if (typescript.default.isArrowFunction(callback) || typescript.default.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, ctx);
 	return [];
 }
-function extractProducedKeysFromCallback(callback, checker) {
+function extractProducedKeysFromCallback(callback, ctx) {
 	const body = callback.body;
-	if (!typescript.default.isBlock(body)) return extractKeysFromExpression(body, checker);
+	if (!typescript.default.isBlock(body)) return extractKeysFromExpression(body, ctx);
 	const keys = /* @__PURE__ */ new Set();
 	function visitReturn(node) {
-		if (typescript.default.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, checker)) keys.add(key);
+		if (typescript.default.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, ctx)) keys.add(key);
 		typescript.default.forEachChild(node, visitReturn);
 	}
 	visitReturn(body);
 	return [...keys];
 }
-function extractKeysFromExpression(expr, checker) {
+function extractKeysFromExpression(expr, ctx) {
 	while (typescript.default.isParenthesizedExpression(expr)) expr = expr.expression;
 	if (typescript.default.isObjectLiteralExpression(expr)) return expr.properties.filter((p) => typescript.default.isPropertyAssignment(p) || typescript.default.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;
@@ -391,7 +415,11 @@ function resolveReExportedCall(chain, checker) {
 	if (typescript.default.isIdentifier(expr)) identifier = expr;
 	else if (typescript.default.isPropertyAccessExpression(expr) && typescript.default.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 || !typescript.default.isVariableDeclaration(decl) || !decl.initializer) return null;
@@ -611,7 +639,12 @@ function afterFeature(fn) {
 		fn
 	});
 }
-/** Run once before the entire test run, across all feature files. */
+/**
+* Run once before the entire run, ahead of any scenario (and before
+* concurrency starts). Multiple `beforeAll` hooks run **in parallel** with no
+* ordering between them — if a step of setup must precede another, sequence both
+* inside a single hook.
+*/
 function beforeAll(fn) {
 	require_hooks.globalHookRegistry.add({
 		scope: "global",
@@ -619,7 +652,11 @@ function beforeAll(fn) {
 		fn
 	});
 }
-/** Run once after the entire test run (reverse registration order). */
+/**
+* Run once after the entire run, once every scenario is done. Multiple
+* `afterAll` hooks run **in parallel** with no ordering between them — sequence
+* dependent teardown inside a single hook.
+*/
 function afterAll(fn) {
 	require_hooks.globalHookRegistry.add({
 		scope: "global",