@step-forge/step-forge 0.0.21 → 0.0.23

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 };