@step-forge/step-forge 0.0.20 → 0.0.22

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","names":[],"sources":["../../src/runtime/config.ts","../../src/runtime/filter.ts","../../src/runtime/reporters.ts","../../src/runtime/runner.ts","../../src/runtime/cli.ts"],"sourcesContent":["import * as path from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\nimport { access } from \"node:fs/promises\";\n\n/**\n * User-facing runner configuration. The same shape is accepted from a\n * `step-forge.config.ts` file (default export) and from CLI flags, with flags\n * taking precedence. Everything is optional; {@link resolveConfig} fills in\n * defaults.\n */\nexport interface RunnerOptions {\n  /** Feature-file glob(s), relative to `cwd`. Defaults to every `.feature` file. */\n  features?: string | string[];\n  /** Step-module glob(s), relative to `cwd`. Defaults to every `.steps.ts` file. */\n  steps?: string | string[];\n  /**\n   * Module that default-exports a world factory `() => world`, relative to\n   * `cwd`. When omitted each scenario gets a fresh `BasicWorld`.\n   */\n  world?: string;\n  /**\n   * Max scenarios in flight at once. Defaults to `1` (serial), matching\n   * Cucumber's default execution model — scenarios often share module-level\n   * state via hooks, which only holds under serial execution. Raise it to opt\n   * into parallelism for isolated, I/O-bound suites.\n   */\n  concurrency?: number;\n  /** Reporter name. Default `pretty`. */\n  reporter?: \"pretty\" | \"progress\";\n  /**\n   * Verbose output: report every scenario (pass, fail, skip) instead of only\n   * failures. Passed to whichever reporter is active. Default `false`.\n   */\n  verbose?: boolean;\n  /** Only run scenarios whose name matches this (string → substring/regex). */\n  name?: string;\n  /** Cucumber tag expression, e.g. `@smoke and not @wip`. */\n  tags?: string;\n}\n\n/** Fully-resolved config: no optionals, globs kept as arrays, paths absolute. */\nexport interface ResolvedConfig {\n  cwd: string;\n  features: string[];\n  steps: string[];\n  world?: string;\n  concurrency: number;\n  reporter: \"pretty\" | \"progress\";\n  verbose: boolean;\n  name?: string;\n  tags?: string;\n}\n\nconst DEFAULT_FEATURES = \"**/*.feature\";\nconst DEFAULT_STEPS = \"**/*.steps.ts\";\nconst CONFIG_BASENAMES = [\n  \"step-forge.config.ts\",\n  \"step-forge.config.mts\",\n  \"step-forge.config.js\",\n  \"step-forge.config.mjs\",\n];\n\nfunction toArray<T>(value: T | T[] | undefined): T[] {\n  if (value === undefined) return [];\n  return Array.isArray(value) ? value : [value];\n}\n\nasync function exists(p: string): Promise<boolean> {\n  try {\n    await access(p);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Locate and import a `step-forge.config.*` file from `cwd`, returning its\n * default export (or `{}` if none is present). Imported by absolute file URL so\n * Bun transpiles the TypeScript config natively.\n */\nexport async function loadConfigFile(cwd: string): Promise<RunnerOptions> {\n  for (const basename of CONFIG_BASENAMES) {\n    const candidate = path.join(cwd, basename);\n    if (!(await exists(candidate))) continue;\n    const mod = await import(pathToFileURL(candidate).href);\n    return (mod.default ?? mod) as RunnerOptions;\n  }\n  return {};\n}\n\n/**\n * Merge file config with CLI overrides and apply defaults. CLI overrides win\n * field-by-field; array globs are normalised to arrays and default when neither\n * source provides them.\n */\nexport function resolveConfig(\n  cwd: string,\n  file: RunnerOptions,\n  cli: RunnerOptions\n): ResolvedConfig {\n  const pick = <K extends keyof RunnerOptions>(key: K): RunnerOptions[K] =>\n    cli[key] ?? file[key];\n\n  const features = toArray(pick(\"features\"));\n  const steps = toArray(pick(\"steps\"));\n\n  return {\n    cwd,\n    features: features.length ? features : [DEFAULT_FEATURES],\n    steps: steps.length ? steps : [DEFAULT_STEPS],\n    world: pick(\"world\"),\n    concurrency: pick(\"concurrency\") ?? 1,\n    reporter: pick(\"reporter\") ?? \"pretty\",\n    verbose: pick(\"verbose\") ?? false,\n    name: pick(\"name\"),\n    tags: pick(\"tags\"),\n  };\n}\n","import { ParsedScenario } from \"../analyzer/types\";\n\n/**\n * A predicate over a scenario's tags, compiled from a Cucumber tag expression.\n * Supports `and`, `or`, `not`, parentheses, and bare `@tag` atoms — the common\n * subset of Cucumber's tag-expression language. Kept dependency-free; swap for\n * `@cucumber/tag-expressions` if fuller parity is needed.\n */\nexport type TagPredicate = (tags: readonly string[]) => boolean;\n\n/** Tokenise a tag expression into atoms, operators, and parentheses. */\nfunction tokenize(expr: string): string[] {\n  const tokens: string[] = [];\n  const re = /\\s*(\\(|\\)|@[^\\s()]+|\\band\\b|\\bor\\b|\\bnot\\b)\\s*/gy;\n  let index = 0;\n  while (index < expr.length) {\n    re.lastIndex = index;\n    const m = re.exec(expr);\n    if (!m || m.index !== index) {\n      throw new Error(`Invalid tag expression near: ${expr.slice(index)}`);\n    }\n    tokens.push(m[1]);\n    index = re.lastIndex;\n  }\n  return tokens;\n}\n\n/**\n * Compile a tag expression into a predicate via recursive descent\n * (or → and → not → primary). Throws on malformed input so a bad `--tags` flag\n * fails loudly rather than silently matching nothing.\n */\nexport function compileTagExpression(expr: string): TagPredicate {\n  const tokens = tokenize(expr);\n  let pos = 0;\n\n  const peek = () => tokens[pos];\n  const next = () => tokens[pos++];\n\n  const parseOr = (): TagPredicate => {\n    let left = parseAnd();\n    while (peek() === \"or\") {\n      next();\n      const right = parseAnd();\n      const l = left;\n      left = tags => l(tags) || right(tags);\n    }\n    return left;\n  };\n\n  const parseAnd = (): TagPredicate => {\n    let left = parseNot();\n    while (peek() === \"and\") {\n      next();\n      const right = parseNot();\n      const l = left;\n      left = tags => l(tags) && right(tags);\n    }\n    return left;\n  };\n\n  const parseNot = (): TagPredicate => {\n    if (peek() === \"not\") {\n      next();\n      const operand = parseNot();\n      return tags => !operand(tags);\n    }\n    return parsePrimary();\n  };\n\n  const parsePrimary = (): TagPredicate => {\n    const token = next();\n    if (token === \"(\") {\n      const inner = parseOr();\n      if (next() !== \")\") throw new Error(\"Unbalanced parentheses in tags\");\n      return inner;\n    }\n    if (token === undefined || !token.startsWith(\"@\")) {\n      throw new Error(`Expected a tag, got: ${token ?? \"end of input\"}`);\n    }\n    return tags => tags.includes(token);\n  };\n\n  const predicate = parseOr();\n  if (pos !== tokens.length) {\n    throw new Error(`Unexpected token in tag expression: ${peek()}`);\n  }\n  return predicate;\n}\n\nexport interface SelectOptions {\n  /** Substring or `/regex/flags` match against the scenario (or outline) name. */\n  name?: string;\n  /** Cucumber tag expression. */\n  tags?: string;\n}\n\n/** Parse a `/pattern/flags` string into a RegExp, else treat it as a substring. */\nfunction toNameMatcher(name: string): (candidate: string) => boolean {\n  const delim = /^\\/(.*)\\/([a-z]*)$/.exec(name);\n  if (delim) {\n    const re = new RegExp(delim[1], delim[2]);\n    return candidate => re.test(candidate);\n  }\n  return candidate => candidate.includes(name);\n}\n\n/**\n * Narrow scenarios by name and tags, then apply `@only` focus. `@skip` is *not*\n * applied here — skipped scenarios stay in the set so the runner can report them\n * as skipped rather than silently dropping them. Returns scenarios in input\n * order.\n *\n * `@only` semantics mirror the Vitest plugin: if any surviving scenario is\n * tagged `@only` (and not `@skip`), the run is focused to just those.\n */\nexport function selectScenarios(\n  scenarios: ParsedScenario[],\n  options: SelectOptions\n): ParsedScenario[] {\n  let selected = scenarios;\n\n  if (options.name) {\n    const matches = toNameMatcher(options.name);\n    selected = selected.filter(\n      s => matches(s.name) || (s.outline ? matches(s.outline.name) : false)\n    );\n  }\n\n  if (options.tags) {\n    const predicate = compileTagExpression(options.tags);\n    selected = selected.filter(s => predicate(s.tags));\n  }\n\n  const focused = selected.filter(\n    s => s.tags.includes(\"@only\") && !s.tags.includes(\"@skip\")\n  );\n  return focused.length ? focused : selected;\n}\n","import { relative } from \"node:path\";\nimport { relativeFrame, relativeLocation, userFrames } from \"../sourceLocation\";\nimport { ScenarioResult, StepResult } from \"./engine\";\n\n/**\n * A reporter observes the run. `onScenarioEnd` fires as each scenario finishes\n * (completion order, non-deterministic under concurrency); `onComplete` fires\n * once with every result for the end-of-run output.\n *\n * Every reporter accepts a `verbose` flag: without it a reporter reports only\n * failures (plus a summary); with it, it reports every scenario. A reporter may\n * render the same either way — `verbose` is a request, not a requirement.\n */\nexport interface Reporter {\n  onScenarioEnd?(result: ScenarioResult): void;\n  onComplete(results: ScenarioResult[], durationMs: number): void;\n}\n\nexport interface ReporterOptions {\n  cwd?: string;\n  verbose?: boolean;\n}\n\n// --- ANSI colouring -------------------------------------------------------\nconst useColor =\n  !process.env.NO_COLOR && (process.stdout.isTTY ?? false) === true;\n\nconst wrap = (open: number, close: number) => (s: string) =>\n  useColor ? `\\x1b[${open}m${s}\\x1b[${close}m` : s;\n\nconst c = {\n  green: wrap(32, 39),\n  red: wrap(31, 39),\n  yellow: wrap(33, 39),\n  dim: wrap(2, 22),\n  bold: wrap(1, 22),\n};\n\nconst STATUS_MARK: Record<StepResult[\"status\"], string> = {\n  passed: c.green(\"✓\"),\n  failed: c.red(\"✗\"),\n  skipped: c.yellow(\"-\"),\n};\n\n/** ✓ / ✗ / - for a whole scenario (skipped = every step skipped). */\nfunction scenarioMark(result: ScenarioResult): string {\n  if (result.status === \"failed\") return c.red(\"✗\");\n  if (result.steps.every(s => s.status === \"skipped\")) return c.yellow(\"-\");\n  return c.green(\"✓\");\n}\n\n/** Dot per scenario for the live heartbeat: `.` pass / `F` fail / `-` skip. */\nfunction scenarioDot(result: ScenarioResult): string {\n  if (result.status === \"failed\") return c.red(\"F\");\n  if (result.steps.every(s => s.status === \"skipped\")) return c.yellow(\"-\");\n  return c.green(\".\");\n}\n\n/** Indent every non-empty line of a block by `pad` spaces. */\nfunction indent(text: string, pad: number): string {\n  const prefix = \" \".repeat(pad);\n  return text\n    .split(\"\\n\")\n    .map(line => (line ? prefix + line : line))\n    .join(\"\\n\");\n}\n\n/**\n * The error, trimmed to user frames: `Name: message` followed by only the\n * caller's own stack frames (library/engine and `node_modules` frames removed),\n * source-mapped by Bun to the original `.ts`. Falls back to just the message\n * when nothing user-owned is left (e.g. an undefined-step error).\n */\nfunction renderError(error: Error, cwd: string): string {\n  const header = `${error.name}: ${error.message}`;\n  const frames = userFrames(error.stack).map(\n    f => `    at ${relativeFrame(f, cwd)}`\n  );\n  return frames.length ? `${header}\\n${frames.join(\"\\n\")}` : header;\n}\n\n/**\n * The detail block shown beneath a failing step: the `.feature` line, the step\n * definition location, and the trimmed error — the two coordinates that make a\n * failure easy to chase (where in the feature, which step definition).\n */\nfunction failureDetail(\n  stepResult: StepResult,\n  result: ScenarioResult,\n  cwd: string\n): string {\n  const lines = [\n    `feature: ${relative(cwd, result.scenario.file)}:${stepResult.step.line}`,\n  ];\n  if (stepResult.source) {\n    lines.push(`defined: ${relativeLocation(stepResult.source, cwd)}`);\n  }\n  if (stepResult.error) lines.push(renderError(stepResult.error, cwd));\n  return indent(c.red(lines.join(\"\\n\")), 6);\n}\n\n/**\n * One scenario as a Cucumber-style block: a marked header with its `.feature`\n * location, then each step with its mark (and, in `verbose`, the step\n * definition location as a trailing comment). A failing step is followed by its\n * failure detail; a scenario-level error (a failing hook, no step to blame) is\n * appended at the end.\n */\nfunction renderScenario(\n  result: ScenarioResult,\n  cwd: string,\n  opts: { stepSource: boolean }\n): string {\n  const label = result.scenario.outline\n    ? `${result.scenario.outline.name} › ${result.scenario.name}`\n    : result.scenario.name;\n  const lines: string[] = [`${scenarioMark(result)} ${c.bold(label)}`];\n\n  const loc = result.scenario.line\n    ? `${relative(cwd, result.scenario.file)}:${result.scenario.line}`\n    : relative(cwd, result.scenario.file);\n  lines.push(indent(c.dim(loc), 4));\n  lines.push(\"\");\n\n  for (const step of result.scenario.steps) {\n    const sr = result.steps.find(s => s.step === step);\n    const status = sr?.status ?? \"skipped\";\n    const comment =\n      opts.stepSource && sr?.source\n        ? c.dim(`  # ${relativeLocation(sr.source, cwd)}`)\n        : \"\";\n    lines.push(\n      `  ${STATUS_MARK[status]} ${c.dim(step.effectiveKeyword)} ${step.text}${comment}`\n    );\n    if (sr?.status === \"failed\") lines.push(failureDetail(sr, result, cwd));\n  }\n\n  // A hook failure has no failing step; surface its error at scenario level.\n  const stepFailed = result.steps.some(s => s.status === \"failed\");\n  if (result.error && !stepFailed) {\n    lines.push(indent(c.red(renderError(result.error, cwd)), 4));\n  }\n\n  return lines.join(\"\\n\");\n}\n\n// --- Summary --------------------------------------------------------------\ninterface Totals {\n  scenarios: { passed: number; failed: number; skipped: number };\n  steps: { passed: number; failed: number; skipped: number };\n}\n\nfunction tally(results: ScenarioResult[]): Totals {\n  const totals: Totals = {\n    scenarios: { passed: 0, failed: 0, skipped: 0 },\n    steps: { passed: 0, failed: 0, skipped: 0 },\n  };\n  for (const result of results) {\n    if (result.status === \"failed\") totals.scenarios.failed++;\n    else if (result.steps.every(s => s.status === \"skipped\"))\n      totals.scenarios.skipped++;\n    else totals.scenarios.passed++;\n    for (const step of result.steps) totals.steps[step.status]++;\n  }\n  return totals;\n}\n\nfunction renderSummary(results: ScenarioResult[], durationMs: number): string {\n  const t = tally(results);\n  const scenarioTotal =\n    t.scenarios.passed + t.scenarios.failed + t.scenarios.skipped;\n  const stepTotal = t.steps.passed + t.steps.failed + t.steps.skipped;\n\n  const part = (n: number, label: string, color: (s: string) => string) =>\n    n > 0 ? color(`${n} ${label}`) : null;\n\n  const line = (\n    total: number,\n    noun: string,\n    counts: { passed: number; failed: number; skipped: number }\n  ) => {\n    const parts = [\n      part(counts.passed, \"passed\", c.green),\n      part(counts.failed, \"failed\", c.red),\n      part(counts.skipped, \"skipped\", c.yellow),\n    ].filter((x): x is string => x !== null);\n    return `${total} ${noun}${total === 1 ? \"\" : \"s\"} (${parts.join(\", \")})`;\n  };\n\n  return [\n    line(scenarioTotal, \"scenario\", t.scenarios),\n    line(stepTotal, \"step\", t.steps),\n    c.dim(`${(durationMs / 1000).toFixed(2)}s`),\n  ].join(\"\\n\");\n}\n\nfunction write(text: string): void {\n  process.stdout.write(text);\n}\n\n/** Feature-grouped tree of every scenario (used by `--verbose`). */\nfunction renderFullTree(results: ScenarioResult[], cwd: string): string {\n  const groups = new Map<string, ScenarioResult[]>();\n  for (const r of results) {\n    const bucket = groups.get(r.scenario.file) ?? [];\n    bucket.push(r);\n    groups.set(r.scenario.file, bucket);\n  }\n  const out: string[] = [];\n  for (const [file, group] of groups) {\n    out.push(c.bold(`Feature: ${relative(cwd, file)}`), \"\");\n    for (const r of group)\n      out.push(indent(renderScenario(r, cwd, { stepSource: true }), 2), \"\");\n  }\n  return out.join(\"\\n\");\n}\n\n/** The failing scenarios only (used by the default, non-verbose output). */\nfunction renderFailures(results: ScenarioResult[], cwd: string): string {\n  const failed = results.filter(r => r.status === \"failed\");\n  if (!failed.length) return \"\";\n  return (\n    failed\n      .map(r => renderScenario(r, cwd, { stepSource: false }))\n      .join(\"\\n\\n\") + \"\\n\\n\"\n  );\n}\n\n/**\n * Default reporter. Non-verbose: a dot per scenario as a heartbeat, then the\n * failing scenarios in Cucumber-style detail, then the summary. Verbose: the\n * full feature → scenario → step tree instead of just failures.\n */\nexport function prettyReporter(opts: ReporterOptions = {}): Reporter {\n  const cwd = opts.cwd ?? process.cwd();\n  const verbose = opts.verbose ?? false;\n  return {\n    onScenarioEnd(result) {\n      if (!verbose) write(scenarioDot(result));\n    },\n    onComplete(results, durationMs) {\n      const body = verbose\n        ? `\\n${renderFullTree(results, cwd)}\\n`\n        : `\\n\\n${renderFailures(results, cwd)}`;\n      write(`${body}${renderSummary(results, durationMs)}\\n`);\n    },\n  };\n}\n\n/**\n * Compact reporter: a dot per scenario, then failures in detail and the\n * summary. Always minimal — `verbose` is accepted for interface parity but does\n * not expand the output (use `pretty --verbose` for the full tree).\n */\nexport function progressReporter(opts: ReporterOptions = {}): Reporter {\n  const cwd = opts.cwd ?? process.cwd();\n  return {\n    onScenarioEnd(result) {\n      write(scenarioDot(result));\n    },\n    onComplete(results, durationMs) {\n      write(\n        `\\n\\n${renderFailures(results, cwd)}${renderSummary(results, durationMs)}\\n`\n      );\n    },\n  };\n}\n\nexport function makeReporter(\n  name: \"pretty\" | \"progress\",\n  opts: ReporterOptions = {}\n): Reporter {\n  return name === \"progress\" ? progressReporter(opts) : prettyReporter(opts);\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport * as path from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\nimport { ParsedScenario } from \"../analyzer/types\";\nimport { parseFeatureFiles } from \"../analyzer/gherkinParser\";\nimport { globFiles } from \"../globFiles\";\nimport { BasicWorld, MergeableWorld } from \"../world\";\nimport {\n  compileRegistry,\n  CompiledStep,\n  runScenario,\n  ScenarioResult,\n} from \"./engine\";\nimport { globalHookRegistry, runHooks, runHooksParallel } from \"./hooks\";\nimport { globalRegistry } from \"./registry\";\nimport { selectScenarios } from \"./filter\";\nimport { makeReporter, Reporter } from \"./reporters\";\nimport { ResolvedConfig } from \"./config\";\n\ntype WorldFactory = () => MergeableWorld<any, any, any>;\n\n/**\n * Import every step-definition module so its `.step(...)` calls self-register\n * into the shared `globalRegistry`. Imported by file URL so Bun transpiles the\n * TypeScript natively.\n */\nasync function importSteps(files: string[]): Promise<void> {\n  for (const file of files) {\n    await import(pathToFileURL(file).href);\n  }\n}\n\n/** Load the configured world factory, or default to a fresh `BasicWorld`. */\nasync function loadWorldFactory(\n  world: string | undefined,\n  cwd: string\n): Promise<WorldFactory> {\n  if (!world) return () => new BasicWorld();\n  const resolved = path.resolve(cwd, world);\n  const mod = await import(pathToFileURL(resolved).href);\n  const factory = mod.default ?? mod;\n  if (typeof factory !== \"function\") {\n    throw new Error(\n      `World module ${world} must default-export a factory function () => world`\n    );\n  }\n  return factory as WorldFactory;\n}\n\n/** A scenario carrying `@skip` never runs: report it with all steps skipped. */\nfunction skippedResult(scenario: ParsedScenario): ScenarioResult {\n  return {\n    scenario,\n    status: \"passed\",\n    steps: scenario.steps.map(step => ({ step, status: \"skipped\" as const })),\n  };\n}\n\n/**\n * Run `items` through `worker`, at most `limit` in flight. Results come back in\n * input order even though completion order is not deterministic. A minimal\n * dependency-free pool — the whole point of the single-process model.\n */\nasync function runPool<T, R>(\n  items: T[],\n  limit: number,\n  worker: (item: T, index: number) => Promise<R>\n): Promise<R[]> {\n  const results = new Array<R>(items.length);\n  let cursor = 0;\n  const runNext = async (): Promise<void> => {\n    while (cursor < items.length) {\n      const index = cursor++;\n      results[index] = await worker(items[index], index);\n    }\n  };\n  const workers = Array.from(\n    { length: Math.min(Math.max(1, limit), items.length) },\n    runNext\n  );\n  await Promise.all(workers);\n  return results;\n}\n\nexport interface RunResult {\n  results: ScenarioResult[];\n  passed: boolean;\n  durationMs: number;\n}\n\n/**\n * Execute a whole run end to end: discover and import steps, load the world,\n * parse and select scenarios, then run them concurrently against a\n * compiled-once step table with global/feature hooks around the batch. Never\n * throws for test failures — inspect `RunResult.passed`.\n */\nexport async function run(\n  config: ResolvedConfig,\n  reporter: Reporter = makeReporter(config.reporter, {\n    cwd: config.cwd,\n    verbose: config.verbose,\n  })\n): Promise<RunResult> {\n  const start =\n    typeof performance !== \"undefined\" ? performance.now() : Date.now();\n\n  const [featureFiles, stepFiles] = await Promise.all([\n    globFiles(config.features, config.cwd),\n    globFiles(config.steps, config.cwd),\n  ]);\n\n  await importSteps(stepFiles);\n  const makeWorld = await loadWorldFactory(config.world, config.cwd);\n\n  const compiled: CompiledStep[] = compileRegistry(globalRegistry);\n  const allScenarios = parseFeatureFiles(featureFiles);\n  const selected = selectScenarios(allScenarios, {\n    name: config.name,\n    tags: config.tags,\n  });\n\n  // Global `beforeAll` hooks run once, in parallel, before any scenario starts;\n  // feature before/after bracket the whole batch inside them. (Hooks aren't\n  // file-scoped in the registry, so per-file bracketing would be meaningless\n  // under concurrent execution.)\n  await runHooksParallel(\"global\", \"before\", globalHookRegistry);\n  await runHooks(\"feature\", \"before\", globalHookRegistry);\n\n  const results = await runPool(\n    selected,\n    config.concurrency,\n    async scenario => {\n      const result = scenario.tags.includes(\"@skip\")\n        ? skippedResult(scenario)\n        : await runScenario(scenario, compiled, makeWorld, globalHookRegistry);\n      reporter.onScenarioEnd?.(result);\n      return result;\n    }\n  );\n\n  await runHooks(\"feature\", \"after\", globalHookRegistry);\n  // Global `afterAll` hooks run once, in parallel, after every scenario is done.\n  await runHooksParallel(\"global\", \"after\", globalHookRegistry);\n\n  const durationMs =\n    (typeof performance !== \"undefined\" ? performance.now() : Date.now()) -\n    start;\n  reporter.onComplete(results, durationMs);\n\n  return {\n    results,\n    passed: results.every(r => r.status !== \"failed\"),\n    durationMs,\n  };\n}\n","#!/usr/bin/env bun\nimport { parseArgs } from \"node:util\";\nimport * as path from \"node:path\";\nimport { loadConfigFile, resolveConfig, RunnerOptions } from \"./config\";\nimport { run } from \"./runner\";\n\nconst HELP = `step-forge — native TypeScript runner for Gherkin step definitions\n\nUsage:\n  step-forge [options] [feature globs...]\n\nOptions:\n  -t, --tags <expr>        Tag expression, e.g. \"@smoke and not @wip\"\n  -n, --name <pattern>     Only scenarios whose name matches (substring or /regex/)\n  -s, --steps <glob>       Step-definition module glob (repeatable)\n  -w, --world <module>     World factory module (default export () => world)\n  -c, --concurrency <n>    Max scenarios in flight (default: 1, i.e. serial)\n  -r, --reporter <name>    \"pretty\" (default) or \"progress\"\n  -v, --verbose            Report every scenario, not just failures\n      --config <path>      Config file directory (default: cwd)\n  -h, --help               Show this help\n\nPositional arguments are feature globs and override the configured features.\n`;\n\n/** Parse argv into config overrides. Positional args become feature globs. */\nfunction parseCli(argv: string[]): { cwd: string; overrides: RunnerOptions } {\n  const { values, positionals } = parseArgs({\n    args: argv,\n    allowPositionals: true,\n    options: {\n      tags: { type: \"string\", short: \"t\" },\n      name: { type: \"string\", short: \"n\" },\n      steps: { type: \"string\", short: \"s\", multiple: true },\n      world: { type: \"string\", short: \"w\" },\n      concurrency: { type: \"string\", short: \"c\" },\n      reporter: { type: \"string\", short: \"r\" },\n      verbose: { type: \"boolean\", short: \"v\" },\n      config: { type: \"string\" },\n      help: { type: \"boolean\", short: \"h\" },\n    },\n  });\n\n  if (values.help) {\n    process.stdout.write(HELP);\n    process.exit(0);\n  }\n\n  const overrides: RunnerOptions = {};\n  if (positionals.length) overrides.features = positionals;\n  if (values.tags) overrides.tags = values.tags;\n  if (values.name) overrides.name = values.name;\n  if (values.steps) overrides.steps = values.steps;\n  if (values.world) overrides.world = values.world;\n  if (values.verbose) overrides.verbose = true;\n  if (values.reporter) {\n    if (values.reporter !== \"pretty\" && values.reporter !== \"progress\") {\n      throw new Error(`Unknown reporter: ${values.reporter}`);\n    }\n    overrides.reporter = values.reporter;\n  }\n  if (values.concurrency !== undefined) {\n    const n = Number(values.concurrency);\n    if (!Number.isInteger(n) || n < 1) {\n      throw new Error(`--concurrency must be a positive integer`);\n    }\n    overrides.concurrency = n;\n  }\n\n  const cwd = values.config\n    ? path.resolve(process.cwd(), values.config)\n    : process.cwd();\n  return { cwd, overrides };\n}\n\nasync function main(): Promise<void> {\n  const { cwd, overrides } = parseCli(process.argv.slice(2));\n  const fileConfig = await loadConfigFile(cwd);\n  const config = resolveConfig(cwd, fileConfig, overrides);\n  const { passed } = await run(config);\n  process.exitCode = passed ? 0 : 1;\n}\n\nmain().catch(err => {\n  process.stderr.write(`${err instanceof Error ? err.stack : String(err)}\\n`);\n  process.exitCode = 1;\n});\n"],"mappings":"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"}

package/dist/{hooks-Dar49TtT.d.ts → config-C7PCYgYy.d.cts}

@@ -71,6 +71,8 @@ interface StepDefinitionMeta {
 interface ParsedScenario {
   name: string;
   file: string;
+  /** 1-based line of the `Scenario:`/`Scenario Outline:` keyword in the file. */
+  line?: number;
   steps: ParsedStep[];
   /**
    * Gherkin tags in effect for this scenario, each including the leading `@`
@@ -164,26 +166,73 @@ declare class HookRegistry {
 }
 declare const globalHookRegistry: 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.
  */
 declare function runHooks(scope: "feature" | "global", timing: HookTiming, registry?: HookRegistry): Promise<void>;
 /**
- * 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.
  */
-declare function ensureGlobalHooks(registry?: HookRegistry): Promise<void>;
+declare function runHooksParallel(scope: "feature" | "global", timing: HookTiming, registry?: HookRegistry): Promise<void>;
 //#endregion
-export { numberParser as C, intParser as S, StepDefinitionMeta as _, RegisteredHook as a, Parser as b, ensureGlobalHooks as c, AnalysisRule as d, AnalyzerConfig as f, ParsedStep as g, ParsedScenario as h, PlainHookFn as i, globalHookRegistry as l, MatchedStep as m, HookScope as n, ScenarioHookFn as o, Diagnostic as p, HookTiming as r, ScenarioInfo as s, HookRegistry as t, runHooks as u, BasicWorld as v, stringParser as w, booleanParser as x, MergeableWorld as y };
-//# sourceMappingURL=hooks-Dar49TtT.d.ts.map
+//#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";
+  /**
+   * Verbose output: report every scenario (pass, fail, skip) instead of only
+   * failures. Passed to whichever reporter is active. Default `false`.
+   */
+  verbose?: boolean;
+  /** 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";
+  verbose: boolean;
+  name?: string;
+  tags?: string;
+}
+//#endregion
+export { booleanParser as C, stringParser as E, Parser as S, numberParser as T, ParsedScenario as _, HookTiming as a, BasicWorld as b, ScenarioHookFn as c, runHooks as d, runHooksParallel as f, MatchedStep as g, Diagnostic as h, HookScope as i, ScenarioInfo as l, AnalyzerConfig as m, RunnerOptions as n, PlainHookFn as o, AnalysisRule as p, HookRegistry as r, RegisteredHook as s, ResolvedConfig as t, globalHookRegistry as u, ParsedStep as v, intParser as w, MergeableWorld as x, StepDefinitionMeta as y };
+//# sourceMappingURL=config-C7PCYgYy.d.cts.map

package/dist/{hooks-Dar49TtT.d.cts → config-C7PCYgYy.d.ts}

@@ -71,6 +71,8 @@ interface StepDefinitionMeta {
 interface ParsedScenario {
   name: string;
   file: string;
+  /** 1-based line of the `Scenario:`/`Scenario Outline:` keyword in the file. */
+  line?: number;
   steps: ParsedStep[];
   /**
    * Gherkin tags in effect for this scenario, each including the leading `@`
@@ -164,26 +166,73 @@ declare class HookRegistry {
 }
 declare const globalHookRegistry: 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.
  */
 declare function runHooks(scope: "feature" | "global", timing: HookTiming, registry?: HookRegistry): Promise<void>;
 /**
- * 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.
  */
-declare function ensureGlobalHooks(registry?: HookRegistry): Promise<void>;
+declare function runHooksParallel(scope: "feature" | "global", timing: HookTiming, registry?: HookRegistry): Promise<void>;
 //#endregion
-export { numberParser as C, intParser as S, StepDefinitionMeta as _, RegisteredHook as a, Parser as b, ensureGlobalHooks as c, AnalysisRule as d, AnalyzerConfig as f, ParsedStep as g, ParsedScenario as h, PlainHookFn as i, globalHookRegistry as l, MatchedStep as m, HookScope as n, ScenarioHookFn as o, Diagnostic as p, HookTiming as r, ScenarioInfo as s, HookRegistry as t, runHooks as u, BasicWorld as v, stringParser as w, booleanParser as x, MergeableWorld as y };
-//# sourceMappingURL=hooks-Dar49TtT.d.cts.map
+//#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";
+  /**
+   * Verbose output: report every scenario (pass, fail, skip) instead of only
+   * failures. Passed to whichever reporter is active. Default `false`.
+   */
+  verbose?: boolean;
+  /** 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";
+  verbose: boolean;
+  name?: string;
+  tags?: string;
+}
+//#endregion
+export { booleanParser as C, stringParser as E, Parser as S, numberParser as T, ParsedScenario as _, HookTiming as a, BasicWorld as b, ScenarioHookFn as c, runHooks as d, runHooksParallel as f, MatchedStep as g, Diagnostic as h, HookScope as i, ScenarioInfo as l, AnalyzerConfig as m, RunnerOptions as n, PlainHookFn as o, AnalysisRule as p, HookRegistry as r, RegisteredHook as s, ResolvedConfig as t, globalHookRegistry as u, ParsedStep as v, intParser as w, MergeableWorld as x, StepDefinitionMeta as y };
+//# sourceMappingURL=config-C7PCYgYy.d.ts.map

package/dist/engine-DPVLEHBi.js

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

package/dist/engine-DPVLEHBi.js.map

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