@autometa/cli 1.0.0-rc.2

package/dist/index.js

@@ -0,0 +1,2867 @@
+import { builtinModules, createRequire } from 'node:module';
+import { Command } from 'commander';
+import fs, { promises, constants, existsSync } from 'node:fs';
+import path2, { resolve, extname, relative, join, isAbsolute } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { HTTP, createLoggingPlugin } from '@autometa/http';
+import { CucumberRunner, STEPS_ENVIRONMENT_META } from '@autometa/runner';
+import { parseGherkin } from '@autometa/gherkin';
+import { rm, mkdir, writeFile, access } from 'node:fs/promises';
+import { build } from 'esbuild';
+import 'source-map-support/register';
+import pc5 from 'picocolors';
+import { getGherkinErrorContext } from '@autometa/errors';
+import { codeFrameColumns } from '@babel/code-frame';
+import fg from 'fast-glob';
+import { Config } from '@autometa/config';
+import { createHash as createHash$1 } from 'crypto';
+import { promises as promises$1 } from 'fs';
+import { builtinModules as builtinModules$1 } from 'module';
+import { resolve as resolve$1, extname as extname$1, isAbsolute as isAbsolute$1, dirname, join as join$1 } from 'path';
+import { pathToFileURL as pathToFileURL$1 } from 'url';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { spawn } from 'node:child_process';
+
+// src/index.ts
+var DEFAULT_FORMAT = "cjs";
+var DEFAULT_TARGET = "node20";
+var DEFAULT_SOURCEMAP = "inline";
+var DEFAULT_EXTERNALS = [
+  "p-limit",
+  "@autometa/*",
+  "@cucumber/*"
+];
+var BUILTIN_EXTERNALS = /* @__PURE__ */ new Set([
+  ...builtinModules,
+  ...builtinModules.map((moduleId) => `node:${moduleId}`)
+]);
+async function compileModules(orderedEntries, options) {
+  const format = options.builder?.format ?? DEFAULT_FORMAT;
+  const target = options.builder?.target ?? DEFAULT_TARGET;
+  const esbuildTarget = Array.isArray(target) ? [...target] : target;
+  const sourcemap = options.builder?.sourcemap ?? DEFAULT_SOURCEMAP;
+  const tsconfig = options.builder?.tsconfig ? resolve(options.cwd, options.builder.tsconfig) : void 0;
+  const userExternal = options.builder?.external ?? [];
+  const external = Array.from(
+    /* @__PURE__ */ new Set([...BUILTIN_EXTERNALS, ...DEFAULT_EXTERNALS, ...userExternal])
+  );
+  const baseOutDir = resolveOutputBase(options);
+  const outDir = join(baseOutDir, format);
+  const entryFile = await createAggregateEntryFile(orderedEntries, options);
+  await ensureOutputDirectory(outDir, format);
+  const resolvedEntries = orderedEntries.map(
+    (entry) => isAbsolute(entry) ? entry : resolve(options.cwd, entry)
+  );
+  const hookContext = {
+    cwd: options.cwd,
+    cacheDir: options.cacheDir,
+    outDir,
+    entries: resolvedEntries,
+    format,
+    ...target !== void 0 ? { target } : {},
+    ...sourcemap !== void 0 ? { sourcemap } : {},
+    ...tsconfig ? { tsconfig } : {},
+    ...external.length > 0 ? { external } : {}
+  };
+  await runHooks(options.builder?.hooks?.before, hookContext);
+  if (resolvedEntries.length > 0) {
+    const entryName = "__autometa_entry__";
+    const bundleFileName = format === "esm" ? "__modules__.mjs" : "__modules__.cjs";
+    const outfile = join(outDir, bundleFileName);
+    const buildOptions = {
+      absWorkingDir: options.cwd,
+      entryPoints: {
+        [entryName]: entryFile
+      },
+      outfile,
+      bundle: true,
+      format,
+      platform: "node",
+      target: esbuildTarget,
+      sourcemap,
+      splitting: false,
+      write: true,
+      external,
+      logLevel: "silent",
+      treeShaking: false,
+      ...tsconfig ? { tsconfig } : {}
+    };
+    await build(buildOptions);
+    await runHooks(options.builder?.hooks?.after, hookContext);
+    return {
+      bundlePath: outfile,
+      outDir,
+      format
+    };
+  }
+  await runHooks(options.builder?.hooks?.after, hookContext);
+  return {
+    bundlePath: entryFile,
+    format
+  };
+}
+function resolveOutputBase(options) {
+  if (!options.builder?.outDir) {
+    return join(options.cacheDir, "modules");
+  }
+  const configured = options.builder.outDir;
+  return isAbsolute(configured) ? configured : resolve(options.cwd, configured);
+}
+async function ensureOutputDirectory(outDir, format) {
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir(outDir, { recursive: true });
+  const packageJsonPath = join(outDir, "package.json");
+  const typeField = format === "esm" ? "module" : "commonjs";
+  await writeFile(packageJsonPath, JSON.stringify({ type: typeField }, null, 2), "utf8");
+}
+async function createAggregateEntryFile(entries, options) {
+  if (entries.length === 0) {
+    const stubPath = join(options.cacheDir, "modules", "__noop__.ts");
+    await mkdir(join(options.cacheDir, "modules"), { recursive: true });
+    await writeFile(stubPath, "export {};", "utf8");
+    return stubPath;
+  }
+  const modulesDir = join(options.cacheDir, "modules");
+  await mkdir(modulesDir, { recursive: true });
+  const aggregatePath = join(modulesDir, "__entry__.ts");
+  const uniqueEntries = Array.from(new Set(entries.map(
+    (entry) => isAbsolute(entry) ? entry : resolve(options.cwd, entry)
+  )));
+  const moduleIdentifiers = uniqueEntries.map((_, index) => `module_${index}`);
+  const imports = uniqueEntries.map((entry, index) => `import * as ${moduleIdentifiers[index]} from ${JSON.stringify(entry)};`).join("\n");
+  const stepsChecks = moduleIdentifiers.map((id) => {
+    return `  const val_${id} = ${id}['stepsEnvironment'];
+  if (val_${id}) return val_${id};`;
+  }).join("\n");
+  const contents = `${imports}
+
+function __findStepsEnvironment() {
+${stepsChecks}
+  return undefined;
+}
+
+export const stepsEnvironment = __findStepsEnvironment();
+export const modules = [${moduleIdentifiers.join(", ")}];
+export default modules;
+`;
+  await writeFile(aggregatePath, contents, "utf8");
+  return aggregatePath;
+}
+async function runHooks(hooks, context) {
+  if (!hooks || hooks.length === 0) {
+    return;
+  }
+  for (const hook of hooks) {
+    await hook(context);
+  }
+}
+function formatSourceLocation(location) {
+  return `${relativePath(location.filePath)}:${location.start.line}:${location.start.column}`;
+}
+function relativePath(filePath) {
+  const cwd = process.cwd();
+  const relative2 = path2.relative(cwd, filePath);
+  return relative2 || filePath;
+}
+
+// src/utils/reporting/step-summary.ts
+function describeStepSummary(step) {
+  const keyword = step.keyword?.trim();
+  const text = step.text?.trim();
+  const descriptionParts = [keyword, text].filter((value) => Boolean(value && value.length));
+  const description = descriptionParts.length ? descriptionParts.join(" ") : "Step";
+  const location = step.location ? pc5.dim(` (${formatSourceLocation(step.location)})`) : void 0;
+  return {
+    description,
+    ...location ? { location } : {}
+  };
+}
+function getScenarioStatusIcon(status) {
+  switch (status) {
+    case "passed":
+      return pc5.green("\u2713");
+    case "failed":
+      return pc5.red("\u2717");
+    case "skipped":
+      return pc5.yellow("\u25CB");
+    case "pending":
+      return pc5.cyan("\u25CC");
+    default:
+      return pc5.dim("?");
+  }
+}
+function colorizeScenarioStatus(text, status) {
+  switch (status) {
+    case "passed":
+      return pc5.green(text);
+    case "failed":
+      return pc5.red(text);
+    case "skipped":
+      return pc5.yellow(text);
+    case "pending":
+      return pc5.cyan(text);
+    default:
+      return text;
+  }
+}
+function getStepStatusIcon(status) {
+  switch (status) {
+    case "passed":
+      return pc5.green("\u2713");
+    case "failed":
+      return pc5.red("\u2717");
+    case "skipped":
+    default:
+      return pc5.yellow("\u25CB");
+  }
+}
+function colorizeStepDescription(description, status) {
+  switch (status) {
+    case "passed":
+      return pc5.green(description);
+    case "failed":
+      return pc5.red(description);
+    case "skipped":
+      return pc5.yellow(description);
+    default:
+      return description;
+  }
+}
+
+// src/utils/logging/hierarchical-log.ts
+var DEFAULT_INDENT = "  ";
+var BufferedHierarchicalLog = class {
+  constructor(sink = console.log, options = {}) {
+    this.sink = sink;
+    this.entries = [];
+    this.indent = options.indent ?? DEFAULT_INDENT;
+  }
+  write(line, depth = 0) {
+    const normalizedDepth = depth >= 0 ? depth : 0;
+    this.entries.push({ line, depth: normalizedDepth });
+  }
+  flush() {
+    if (this.entries.length === 0) {
+      return;
+    }
+    for (const entry of this.entries) {
+      if (entry.line.length === 0) {
+        this.sink("");
+        continue;
+      }
+      const indent = this.indent.repeat(entry.depth);
+      this.sink(`${indent}${entry.line}`);
+    }
+    this.entries.length = 0;
+  }
+  scoped(offset) {
+    const base = offset >= 0 ? offset : 0;
+    return new BufferedScopedHierarchicalLog(this, base);
+  }
+};
+var BufferedScopedHierarchicalLog = class _BufferedScopedHierarchicalLog {
+  constructor(root, base) {
+    this.root = root;
+    this.base = base;
+  }
+  write(line, depth = 0) {
+    const normalizedDepth = depth >= 0 ? depth : 0;
+    this.root.write(line, this.base + normalizedDepth);
+  }
+  flush() {
+    this.root.flush();
+  }
+  scoped(offset) {
+    const nextBase = this.base + (offset >= 0 ? offset : 0);
+    return new _BufferedScopedHierarchicalLog(this.root, nextBase);
+  }
+};
+var ImmediateHierarchicalLog = class {
+  constructor(sink = console.log, options = {}) {
+    this.sink = sink;
+    this.indent = options.indent ?? DEFAULT_INDENT;
+  }
+  write(line, depth = 0) {
+    const normalizedDepth = depth >= 0 ? depth : 0;
+    if (line.length === 0) {
+      this.sink("");
+      return;
+    }
+    const indent = this.indent.repeat(normalizedDepth);
+    this.sink(`${indent}${line}`);
+  }
+  flush() {
+  }
+  scoped(offset) {
+    const base = offset >= 0 ? offset : 0;
+    return new ImmediateScopedHierarchicalLog(this, base);
+  }
+};
+var ImmediateScopedHierarchicalLog = class _ImmediateScopedHierarchicalLog {
+  constructor(root, base) {
+    this.root = root;
+    this.base = base;
+  }
+  write(line, depth = 0) {
+    const normalizedDepth = depth >= 0 ? depth : 0;
+    this.root.write(line, this.base + normalizedDepth);
+  }
+  flush() {
+    this.root.flush();
+  }
+  scoped(offset) {
+    const nextBase = this.base + (offset >= 0 ? offset : 0);
+    return new _ImmediateScopedHierarchicalLog(this.root, nextBase);
+  }
+};
+
+// src/utils/reporting/scenario-error-renderer.ts
+var BaselineErrorRenderer = class {
+  constructor(contextPrinter, log = new ImmediateHierarchicalLog()) {
+    this.contextPrinter = contextPrinter;
+    this.log = log;
+  }
+  print(options) {
+    const {
+      context,
+      depth,
+      messageLines,
+      formattedStack,
+      truncated
+    } = options;
+    const scope = this.log.scoped(depth);
+    if (messageLines.length > 0) {
+      for (const line of messageLines) {
+        const trimmed = line.trimEnd();
+        if (trimmed.length === 0) {
+          scope.write("");
+          continue;
+        }
+        scope.write(pc5.red(trimmed));
+      }
+    }
+    if (context) {
+      this.contextPrinter.printContext(context, depth + 1);
+    }
+    for (const line of formattedStack) {
+      scope.write(pc5.dim(line));
+    }
+    if (truncated) {
+      scope.write(pc5.dim("    \u2026"));
+    }
+  }
+};
+var ScenarioErrorRenderer = class {
+  constructor(baselineRenderer, log = new ImmediateHierarchicalLog()) {
+    this.baselineRenderer = baselineRenderer;
+    this.log = log;
+  }
+  print(options) {
+    const {
+      context,
+      depth,
+      messageLines,
+      formattedStack,
+      truncated
+    } = options;
+    const steps = context.steps ?? [];
+    const failingIndex = steps.findIndex((step) => step.status === "failed");
+    if (steps.length === 0 || failingIndex === -1) {
+      this.baselineRenderer.print({
+        context,
+        depth,
+        messageLines,
+        formattedStack,
+        truncated
+      });
+      return;
+    }
+    const scope = this.log.scoped(depth);
+    let detailsPrinted = false;
+    for (const step of steps) {
+      const { description, location } = describeStepSummary(step);
+      const icon = getStepStatusIcon(step.status);
+      const coloredDescription = colorizeStepDescription(description, step.status);
+      const label = location ? `${coloredDescription}${location}` : coloredDescription;
+      scope.write(`${icon} ${label}`);
+      if (!detailsPrinted && step.status === "failed") {
+        this.baselineRenderer.print({
+          context,
+          depth: depth + 1,
+          messageLines,
+          formattedStack,
+          truncated
+        });
+        detailsPrinted = true;
+      }
+    }
+    if (!detailsPrinted) {
+      this.baselineRenderer.print({
+        context,
+        depth: depth + 1,
+        messageLines,
+        formattedStack,
+        truncated
+      });
+    }
+  }
+};
+var GherkinContextPrinter = class {
+  constructor(log = new ImmediateHierarchicalLog(), options = {}) {
+    this.log = log;
+    this.options = options;
+  }
+  printContext(context, depth) {
+    if (this.options.includeCodeFrame && context.gherkin) {
+      const details = this.describeGherkinSegment(context.gherkin);
+      const pathSegments = context.path;
+      this.printCodeFrameSection(
+        "Gherkin",
+        context.gherkin.location,
+        details,
+        depth,
+        {
+          includeLocation: !pathSegments || pathSegments.length === 0
+        }
+      );
+    }
+    if (this.options.includePath && context.path && context.path.length > 0) {
+      this.printGherkinPath(context.path, depth);
+    }
+    if (context.code) {
+      const details = this.describeCodeSegment(context.code);
+      this.printCodeFrameSection("Step implementation", context.code.location, details, depth);
+    }
+  }
+  printCodeFrameSection(title, location, details, depth, options = {}) {
+    const headerParts = [title];
+    if (details) {
+      headerParts.push(details);
+    }
+    if (options.includeLocation !== false) {
+      headerParts.push(pc5.dim(formatSourceLocation(location)));
+    }
+    const scope = this.log.scoped(depth);
+    scope.write(pc5.cyan(headerParts.join(" - ")));
+    const frame = this.buildCodeFrame(location);
+    if (!frame) {
+      scope.scoped(1).write(pc5.dim("Unable to read source snippet"));
+      return;
+    }
+    for (const line of frame) {
+      scope.scoped(1).write(line);
+    }
+  }
+  buildCodeFrame(location) {
+    try {
+      const contents = fs.readFileSync(location.filePath, "utf8");
+      const frame = codeFrameColumns(
+        contents,
+        {
+          start: location.start,
+          ...location.end ? { end: location.end } : {}
+        },
+        {
+          linesAbove: 2,
+          linesBelow: 2,
+          highlightCode: true
+        }
+      );
+      return frame.split("\n");
+    } catch {
+      return void 0;
+    }
+  }
+  printGherkinPath(pathSegments, depth) {
+    if (pathSegments.length === 0) {
+      return;
+    }
+    let scope = this.log.scoped(depth);
+    let previousKey;
+    for (const segment of pathSegments) {
+      const segmentKey = this.describePathKey(segment);
+      if (segmentKey === previousKey) {
+        continue;
+      }
+      previousKey = segmentKey;
+      scope.write(pc5.dim(`at ${this.describePathLabel(segment)}`));
+      scope = scope.scoped(1);
+    }
+  }
+  describeGherkinSegment(segment) {
+    if (!segment) {
+      return void 0;
+    }
+    const keyword = segment.stepKeyword?.trim();
+    const text = segment.stepText?.trim();
+    const parts = [keyword, text].filter((value) => Boolean(value && value.length));
+    if (parts.length) {
+      return parts.join(" ");
+    }
+    if (segment.featureName) {
+      return `Feature: ${segment.featureName}`;
+    }
+    return void 0;
+  }
+  describeCodeSegment(segment) {
+    if (!segment) {
+      return void 0;
+    }
+    return segment.functionName ?? void 0;
+  }
+  describePathKey(segment) {
+    return `${segment.role}|${segment.name ?? ""}|${segment.text ?? ""}|${segment.index ?? ""}`;
+  }
+  describePathLabel(segment) {
+    const location = formatSourceLocation(segment.location);
+    switch (segment.role) {
+      case "feature": {
+        const name = segment.name?.trim();
+        return name ? `Feature: ${name} (${location})` : `Feature (${location})`;
+      }
+      case "rule": {
+        const name = segment.name?.trim();
+        return name ? `Rule: ${name} (${location})` : `Rule (${location})`;
+      }
+      case "outline": {
+        const name = segment.name?.trim();
+        return name ? `Scenario Outline: ${name} (${location})` : `Scenario Outline (${location})`;
+      }
+      case "scenario": {
+        const name = segment.name?.trim();
+        return name ? `Scenario: ${name} (${location})` : `Scenario (${location})`;
+      }
+      case "example": {
+        const label = segment.name?.trim() ?? (segment.index !== void 0 ? `Example #${segment.index + 1}` : void 0);
+        return label ? `${label} (${location})` : `Example (${location})`;
+      }
+      case "step": {
+        const keyword = segment.keyword?.trim();
+        const text = segment.text?.trim();
+        const labelParts = [keyword, text].filter((value) => Boolean(value && value.length));
+        const label = labelParts.length ? labelParts.join(" ") : "Step";
+        return `Step: ${label} (${location})`;
+      }
+      default:
+        return `${segment.role} (${location})`;
+    }
+  }
+};
+function formatStackLines(lines, limit) {
+  const cwd = process.cwd();
+  const max = Math.max(limit, 0);
+  const normalized = [];
+  let count = 0;
+  for (const line of lines) {
+    if (max && count >= max) {
+      return { lines: filterFrameworkFrames(normalized), truncated: true };
+    }
+    const info = normalizeStackLine(line.trimEnd(), cwd);
+    normalized.push({
+      text: info.text,
+      framework: info.relativePath ? isFrameworkPath(info.relativePath) : false
+    });
+    count += 1;
+  }
+  return { lines: filterFrameworkFrames(normalized), truncated: false };
+}
+function partitionErrorLines(lines) {
+  const messageLines = [];
+  const stackLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (isStackLine(trimmed)) {
+      stackLines.push(line);
+    } else {
+      messageLines.push(line);
+    }
+  }
+  while (messageLines.length > 0) {
+    const last = messageLines[messageLines.length - 1];
+    if (!last || last.trim().length === 0) {
+      messageLines.pop();
+      continue;
+    }
+    break;
+  }
+  return { messageLines, stackLines };
+}
+function normalizeStackLine(line, cwd) {
+  const stackRegex = /(.*?\()?(?<filepath>(?:[a-zA-Z]:)?[\\/][^:\)]+)(?<position>:\d+:\d+)(\))?/;
+  const match = line.match(stackRegex);
+  if (!match || !match.groups) {
+    return { text: line };
+  }
+  const { filepath, position } = match.groups;
+  const absolute = path2.normalize(filepath);
+  const relative2 = path2.relative(cwd, absolute) || absolute;
+  return {
+    text: line.replace(`${filepath}${position}`, `${relative2}${position}`),
+    relativePath: relative2
+  };
+}
+function filterFrameworkFrames(frames) {
+  if (frames.length === 0) {
+    return [];
+  }
+  const filtered = frames.filter((frame, index) => index === 0 || !frame.framework);
+  if (filtered.length === 0) {
+    return frames.map((frame) => frame.text);
+  }
+  return filtered.map((frame) => frame.text);
+}
+function isFrameworkPath(relativePath2) {
+  const normalized = relativePath2.split(path2.sep).join("/");
+  return normalized.includes("node_modules/") || normalized.startsWith("packages/runner/") || normalized.startsWith("packages/executor/");
+}
+function isStackLine(line) {
+  if (!line) {
+    return false;
+  }
+  if (line.startsWith("at ")) {
+    return true;
+  }
+  return /\((?:[a-zA-Z]:)?[^():]+:\d+:\d+\)$/.test(line);
+}
+
+// src/utils/reporter.ts
+var HierarchicalReporter = class _HierarchicalReporter {
+  constructor(log = console.log, options = {}) {
+    this.suiteStack = [];
+    this.rootSuites = [];
+    this.testNodesByFullName = /* @__PURE__ */ new Map();
+    this.suiteMetadataCache = /* @__PURE__ */ new Map();
+    this.suiteFailureCache = /* @__PURE__ */ new WeakMap();
+    const useBuffer = options.bufferOutput ?? true;
+    this.log = useBuffer ? new BufferedHierarchicalLog(log) : new ImmediateHierarchicalLog(log);
+    const includeGherkinContext = options.showGherkinStack ?? false;
+    const printerOptions = {
+      includePath: includeGherkinContext,
+      includeCodeFrame: includeGherkinContext
+    };
+    this.gherkinContextPrinter = new GherkinContextPrinter(this.log, printerOptions);
+    this.baselineErrorRenderer = new BaselineErrorRenderer(this.gherkinContextPrinter, this.log);
+    this.scenarioErrorRenderer = new ScenarioErrorRenderer(this.baselineErrorRenderer, this.log);
+  }
+  async onRunStart() {
+    this.reset();
+  }
+  async onSuiteStart(event) {
+    const parentNames = event.ancestors;
+    const parentSuite = parentNames.length > 0 ? this.ensureSuitePathByNames(parentNames) : void 0;
+    let suiteNode;
+    if (parentSuite) {
+      suiteNode = this.findSuite(parentSuite.children, event.title);
+    } else {
+      suiteNode = this.findSuite(this.rootSuites, event.title);
+    }
+    if (!suiteNode) {
+      suiteNode = {
+        type: "suite",
+        name: event.title,
+        children: []
+      };
+      if (parentSuite) {
+        parentSuite.children.push(suiteNode);
+      } else {
+        this.rootSuites.push(suiteNode);
+      }
+    }
+    if (event.kind) {
+      suiteNode.kind = event.kind;
+    }
+    if (event.keyword) {
+      suiteNode.keyword = event.keyword;
+    }
+    const path3 = [...parentNames, event.title];
+    if (event.kind || event.keyword) {
+      this.updateSuiteMetadataCache(path3, {
+        ...event.kind ? { kind: event.kind } : {},
+        ...event.keyword ? { keyword: event.keyword } : {}
+      });
+    }
+    this.suiteStack.push({ node: suiteNode });
+  }
+  async onSuiteEnd() {
+    this.suiteStack.pop();
+  }
+  async onTestResult(event) {
+    const fullName = event.result.fullName;
+    const segments = fullName.split(" \u203A ");
+    const suiteNames = event.result.path && event.result.path.length > 0 ? [...event.result.path] : segments.slice(0, -1);
+    const parentSuite = this.ensureSuitePathByNames(suiteNames);
+    let testNode = this.testNodesByFullName.get(fullName);
+    if (!testNode) {
+      testNode = {
+        type: "test",
+        name: event.result.name,
+        logs: []
+      };
+      parentSuite.children.push(testNode);
+      this.testNodesByFullName.set(fullName, testNode);
+    }
+    testNode.status = event.result.status;
+    if (event.result.durationMs !== void 0) {
+      testNode.durationMs = event.result.durationMs;
+    } else {
+      delete testNode.durationMs;
+    }
+    if (event.result.error) {
+      testNode.error = event.result.error;
+    } else {
+      delete testNode.error;
+    }
+    if (event.result.reason) {
+      testNode.reason = event.result.reason;
+    } else {
+      delete testNode.reason;
+    }
+  }
+  onHookLog(event) {
+    const suiteNames = this.extractSuiteNames(event.path);
+    const scenarioSegment = this.findScenarioSegment(event.path);
+    const scenarioName = event.scenario?.name ?? scenarioSegment?.name;
+    const context = {
+      ...scenarioName ? { scenarioName } : {}
+    };
+    const formatted = this.formatHookMessage(event, context);
+    if (suiteNames.length === 0 && !scenarioSegment) {
+      this.log.write(formatted, 0);
+      return;
+    }
+    const parentSuite = this.ensureSuitePathByNames(suiteNames);
+    if (scenarioSegment) {
+      const testNode = this.ensureTestNode(parentSuite, suiteNames, scenarioSegment, event);
+      const offset = event.step ? 1 : 0;
+      testNode.logs.push({
+        type: "log",
+        message: formatted,
+        offset
+      });
+      return;
+    }
+    parentSuite.children.push({
+      type: "log",
+      message: formatted,
+      offset: 0
+    });
+  }
+  async onRunEnd() {
+    this.flush();
+  }
+  reset() {
+    this.suiteStack = [];
+    this.rootSuites = [];
+    this.testNodesByFullName.clear();
+    this.suiteFailureCache = /* @__PURE__ */ new WeakMap();
+  }
+  flush() {
+    for (const suite of this.rootSuites) {
+      this.printNode(suite, 0);
+    }
+    this.log.flush();
+  }
+  printNode(node, depth) {
+    if (node.type === "suite") {
+      const isSyntheticRoot = node.name === "(root)";
+      const nextDepth = isSyntheticRoot ? depth : depth + 1;
+      if (!isSyntheticRoot) {
+        const heading = this.formatSuiteHeading(node);
+        this.log.write(heading, depth);
+      }
+      for (const child of node.children) {
+        if (child.type === "log") {
+          if (this.suiteHasFailingDescendant(node)) {
+            this.log.write(child.message, nextDepth + child.offset);
+          }
+          continue;
+        }
+        this.printNode(child, nextDepth);
+      }
+      return;
+    }
+    if (node.type === "log") {
+      this.log.write(node.message, depth + node.offset);
+      return;
+    }
+    if (!node.status) {
+      return;
+    }
+    const icon = getScenarioStatusIcon(node.status);
+    const coloredName = colorizeScenarioStatus(node.name, node.status);
+    const duration = node.durationMs !== void 0 ? pc5.dim(` (${this.formatDuration(node.durationMs)})`) : "";
+    const scenarioLabel = `${pc5.bold("Scenario:")} ${coloredName}`;
+    this.log.write(`${icon} ${scenarioLabel}${duration}`, depth);
+    if (node.status !== "passed") {
+      for (const logEntry of node.logs) {
+        this.log.write(logEntry.message, depth + 1 + logEntry.offset);
+      }
+    }
+    if (node.error) {
+      this.printError(node.error, depth + 1);
+    } else if (node.reason) {
+      this.log.write(pc5.dim(`Reason: ${node.reason}`), depth + 1);
+    }
+  }
+  suiteHasFailingDescendant(node) {
+    const cached = this.suiteFailureCache.get(node);
+    if (cached !== void 0) {
+      return cached;
+    }
+    let hasFailure = false;
+    for (const child of node.children) {
+      if (child.type === "test") {
+        if (child.status === "failed") {
+          hasFailure = true;
+          break;
+        }
+        continue;
+      }
+      if (child.type === "suite") {
+        if (this.suiteHasFailingDescendant(child)) {
+          hasFailure = true;
+          break;
+        }
+      }
+    }
+    this.suiteFailureCache.set(node, hasFailure);
+    return hasFailure;
+  }
+  formatSuiteHeading(node) {
+    const keyword = this.resolveSuiteKeyword(node);
+    if (!keyword) {
+      return pc5.bold(node.name);
+    }
+    const prefix = this.highlightSuiteKeyword(keyword, node.kind);
+    const name = node.name ? this.sanitizeSuiteName(node.name, keyword) : void 0;
+    return name && name.length > 0 ? `${prefix} ${name}` : prefix;
+  }
+  resolveSuiteKeyword(node) {
+    const preferred = node.keyword;
+    const fallback = this.defaultSuiteKeyword(node.kind);
+    const chosen = (preferred ?? fallback)?.trim();
+    if (!chosen || chosen.length === 0) {
+      return void 0;
+    }
+    return chosen.replace(/:\s*$/u, "");
+  }
+  sanitizeSuiteName(name, keyword) {
+    const trimmed = name.trim();
+    if (trimmed.length === 0) {
+      return "";
+    }
+    const pattern = new RegExp(`^${_HierarchicalReporter.escapeRegExp(keyword)}\\s*:`, "i");
+    if (pattern.test(trimmed)) {
+      return trimmed.replace(pattern, "").trim();
+    }
+    return trimmed;
+  }
+  defaultSuiteKeyword(kind) {
+    switch (kind) {
+      case "feature":
+        return "Feature";
+      case "rule":
+        return "Rule";
+      case "scenarioOutline":
+        return "Scenario Outline";
+      case "examples":
+        return "Examples";
+      default:
+        return void 0;
+    }
+  }
+  highlightSuiteKeyword(keyword, kind) {
+    const label = `${keyword}:`;
+    switch (kind) {
+      case "feature":
+        return pc5.bold(pc5.cyan(label));
+      case "rule":
+        return pc5.bold(pc5.magenta(label));
+      case "scenarioOutline":
+        return pc5.bold(pc5.blue(label));
+      case "examples":
+        return pc5.bold(pc5.yellow(label));
+      default:
+        return pc5.bold(label);
+    }
+  }
+  ensureSuitePathByNames(names) {
+    if (names.length === 0) {
+      if (this.rootSuites.length === 0) {
+        const rootSuite = { type: "suite", name: "(root)", children: [] };
+        this.rootSuites.push(rootSuite);
+        return rootSuite;
+      }
+      const [first] = this.rootSuites;
+      if (first) {
+        return first;
+      }
+      const fallback = { type: "suite", name: "(root)", children: [] };
+      this.rootSuites.push(fallback);
+      return fallback;
+    }
+    let currentChildren = this.rootSuites;
+    let currentSuite;
+    const path3 = [];
+    for (const name of names) {
+      path3.push(name);
+      let suite = this.findSuite(currentChildren, name);
+      if (!suite) {
+        suite = { type: "suite", name, children: [] };
+        this.applyMetadataFromCache(path3, suite);
+        currentChildren.push(suite);
+      } else {
+        this.applyMetadataFromCache(path3, suite);
+      }
+      currentSuite = suite;
+      currentChildren = suite.children;
+    }
+    if (!currentSuite) {
+      return this.ensureSuitePathByNames([]);
+    }
+    return currentSuite;
+  }
+  findSuite(children, name) {
+    for (const child of children) {
+      if (child.type === "suite" && child.name === name) {
+        return child;
+      }
+    }
+    return void 0;
+  }
+  findSuiteByPath(path3) {
+    let currentChildren = this.rootSuites;
+    let current;
+    for (const name of path3) {
+      const next = this.findSuite(currentChildren, name);
+      if (!next) {
+        return void 0;
+      }
+      current = next;
+      currentChildren = next.children;
+    }
+    return current;
+  }
+  getSuitePathKey(path3) {
+    return path3.join(" \u203A ");
+  }
+  applyMetadataFromCache(path3, node) {
+    const cached = this.suiteMetadataCache.get(this.getSuitePathKey(path3));
+    if (!cached) {
+      return;
+    }
+    if (cached.kind) {
+      node.kind = cached.kind;
+    }
+    if (cached.keyword) {
+      node.keyword = cached.keyword;
+    }
+  }
+  updateSuiteMetadataCache(path3, metadata) {
+    const key = this.getSuitePathKey(path3);
+    const existing = this.suiteMetadataCache.get(key) ?? {};
+    this.suiteMetadataCache.set(key, { ...existing, ...metadata });
+    const node = this.findSuiteByPath(path3);
+    if (node) {
+      if (metadata.kind) {
+        node.kind = metadata.kind;
+      }
+      if (metadata.keyword) {
+        node.keyword = metadata.keyword;
+      }
+    }
+  }
+  ensureTestNode(parentSuite, suiteNames, scenarioSegment, event) {
+    const fullName = event.scenario?.fullName ?? [...suiteNames, scenarioSegment.name].join(" \u203A ");
+    let node = this.testNodesByFullName.get(fullName);
+    if (!node) {
+      node = {
+        type: "test",
+        name: event.scenario?.name ?? scenarioSegment.name,
+        logs: []
+      };
+      parentSuite.children.push(node);
+      this.testNodesByFullName.set(fullName, node);
+    }
+    return node;
+  }
+  extractSuiteNames(path3) {
+    const suites = [];
+    const currentPath = [];
+    for (const segment of path3) {
+      if (!segment) {
+        continue;
+      }
+      if (segment.kind === "feature" || segment.kind === "rule" || segment.kind === "scenarioOutline") {
+        suites.push(segment.name);
+        currentPath.push(segment.name);
+        const suiteKind = this.toSuiteHierarchyKind(segment.kind);
+        if (suiteKind) {
+          const metadata = {
+            kind: suiteKind,
+            ...segment.keyword ? { keyword: segment.keyword } : {}
+          };
+          this.updateSuiteMetadataCache(currentPath, metadata);
+        }
+      }
+    }
+    return suites;
+  }
+  toSuiteHierarchyKind(kind) {
+    switch (kind) {
+      case "feature":
+        return "feature";
+      case "rule":
+        return "rule";
+      case "scenarioOutline":
+        return "scenarioOutline";
+      default:
+        return void 0;
+    }
+  }
+  findScenarioSegment(path3) {
+    for (let index = path3.length - 1; index >= 0; index -= 1) {
+      const segment = path3[index];
+      if (!segment) {
+        continue;
+      }
+      if (segment.kind === "scenario") {
+        return segment;
+      }
+    }
+    return void 0;
+  }
+  formatHookMessage(event, context) {
+    const kind = this.getHookTargetKind(event.hookType);
+    if (kind === "step") {
+      return this.formatStepHookMessage(event, context);
+    }
+    return this.formatContainerHookMessage(event, kind, context);
+  }
+  getHookTargetKind(hookType) {
+    switch (hookType) {
+      case "beforeFeature":
+      case "afterFeature":
+        return "feature";
+      case "beforeRule":
+      case "afterRule":
+        return "rule";
+      case "beforeScenario":
+      case "afterScenario":
+      case "beforeStep":
+      case "afterStep":
+        return hookType === "beforeStep" || hookType === "afterStep" ? "step" : "scenario";
+      case "beforeScenarioOutline":
+      case "afterScenarioOutline":
+        return "scenarioOutline";
+      default:
+        return "scenario";
+    }
+  }
+  formatStepHookMessage(event, context) {
+    const phaseLabel = this.wrapPhaseLabel(event.phase);
+    const stepKeyword = this.extractStepKeyword(event) ?? "Step";
+    const coloredKeyword = this.wrapStepKeyword(stepKeyword);
+    const text = this.extractStepText(event, context);
+    const status = this.describeStepStatus(event.step?.status);
+    const parts = [phaseLabel, coloredKeyword];
+    if (text && text.length > 0) {
+      parts.push(text);
+    }
+    if (status) {
+      parts.push(status);
+    }
+    return parts.join(" ");
+  }
+  formatContainerHookMessage(event, kind, context) {
+    const phaseLabel = this.wrapPhaseLabel(event.phase);
+    const keyword = this.resolveTargetKeyword(kind, event) ?? this.describeFallbackTarget(kind, event);
+    const coloredKeyword = keyword ? this.wrapContainerKeyword(keyword) : void 0;
+    const message = this.sanitizeHookMessage(event.message, context);
+    if (coloredKeyword && message) {
+      return `${phaseLabel} ${coloredKeyword}: ${message}`;
+    }
+    if (coloredKeyword) {
+      return `${phaseLabel} ${coloredKeyword}`;
+    }
+    if (message) {
+      return `${phaseLabel} ${message}`;
+    }
+    return phaseLabel;
+  }
+  extractStepText(event, context) {
+    const text = event.step?.text?.trim();
+    if (text && text.length > 0) {
+      return text;
+    }
+    return this.sanitizeHookMessage(event.message, context);
+  }
+  sanitizeHookMessage(message, context) {
+    if (!message) {
+      return void 0;
+    }
+    let result = message.trim();
+    if (context.scenarioName) {
+      const escaped = _HierarchicalReporter.escapeRegExp(context.scenarioName);
+      const patterns = [
+        new RegExp(`^Scenario\\s+"?${escaped}"?\\s*::\\s*`, "i"),
+        new RegExp(`^Scenario\\s+"?${escaped}"?\\s*`, "i")
+      ];
+      for (const pattern of patterns) {
+        const updated = result.replace(pattern, "").trim();
+        if (updated !== result) {
+          result = updated;
+          break;
+        }
+      }
+    }
+    return result;
+  }
+  wrapPhaseLabel(phase) {
+    const label = phase === "before" ? "Before" : "After";
+    return phase === "before" ? pc5.cyan(label) : pc5.magenta(label);
+  }
+  wrapStepKeyword(keyword) {
+    const normalized = keyword.trim().toLowerCase();
+    switch (normalized) {
+      case "given":
+        return pc5.blue(keyword);
+      case "when":
+        return pc5.yellow(keyword);
+      case "then":
+        return pc5.green(keyword);
+      case "and":
+      case "but":
+        return pc5.cyan(keyword);
+      default:
+        return pc5.white(keyword);
+    }
+  }
+  wrapContainerKeyword(keyword) {
+    return pc5.bold(keyword);
+  }
+  describeStepStatus(status) {
+    if (!status) {
+      return void 0;
+    }
+    switch (status.toLowerCase()) {
+      case "passed":
+        return pc5.dim("(passed)");
+      case "failed":
+        return pc5.red("(failed)");
+      case "skipped":
+        return pc5.yellow("(skipped)");
+      default:
+        return pc5.dim(`(${status})`);
+    }
+  }
+  static escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  }
+  resolveTargetKeyword(kind, event) {
+    const normalized = (value) => {
+      if (!value) {
+        return void 0;
+      }
+      return this.cleanKeyword(value);
+    };
+    if (kind === "scenario") {
+      return normalized(event.scenario?.keyword) ?? normalized(event.targetKeyword) ?? normalized(this.findSegmentKeyword(kind, event.path));
+    }
+    if (kind === "scenarioOutline") {
+      return normalized(event.targetKeyword) ?? normalized(this.findSegmentKeyword(kind, event.path));
+    }
+    if (kind === "feature" || kind === "rule") {
+      return normalized(event.targetKeyword) ?? normalized(this.findSegmentKeyword(kind, event.path));
+    }
+    return void 0;
+  }
+  describeFallbackTarget(kind, _event) {
+    switch (kind) {
+      case "feature":
+        return "Feature";
+      case "rule":
+        return "Rule";
+      case "scenario":
+        return "Scenario";
+      case "scenarioOutline":
+        return "Scenario Outline";
+      case "step":
+      default:
+        return "Step";
+    }
+  }
+  extractStepKeyword(event) {
+    const keyword = event.step?.keyword;
+    if (!keyword || keyword.trim().length === 0) {
+      return void 0;
+    }
+    return this.cleanKeyword(keyword);
+  }
+  findSegmentKeyword(kind, path3) {
+    for (let index = path3.length - 1; index >= 0; index -= 1) {
+      const segment = path3[index];
+      if (!segment) {
+        continue;
+      }
+      if (segment.kind === kind && segment.keyword) {
+        return segment.keyword;
+      }
+    }
+    return void 0;
+  }
+  cleanKeyword(keyword) {
+    return keyword.trim().replace(/:\s*$/u, "");
+  }
+  formatDuration(ms) {
+    if (ms < 1) {
+      return `${ms.toFixed(2)} ms`;
+    }
+    if (ms < 1e3) {
+      return `${ms.toFixed(0)} ms`;
+    }
+    return `${(ms / 1e3).toFixed(2)} s`;
+  }
+  printError(error, depth) {
+    const stack = error.stack ?? error.message;
+    const lines = stack.split("\n");
+    if (lines.length === 0) {
+      this.log.write(pc5.red(error.message), depth);
+      return;
+    }
+    const [headline, ...rest] = lines;
+    this.log.write(pc5.red(headline), depth);
+    const { messageLines, stackLines } = partitionErrorLines(rest);
+    const { lines: formattedStack, truncated } = formatStackLines(stackLines, 4);
+    const context = getGherkinErrorContext(error);
+    if (context?.steps && context.steps.length > 0) {
+      this.scenarioErrorRenderer.print({
+        context,
+        depth,
+        messageLines,
+        formattedStack,
+        truncated
+      });
+      return;
+    }
+    this.baselineErrorRenderer.print({
+      ...context ? { context } : {},
+      depth,
+      messageLines,
+      formattedStack,
+      truncated
+    });
+  }
+};
+
+// src/runtime/cli-runtime.ts
+var clock = typeof globalThis.performance?.now === "function" ? globalThis.performance : { now: () => Date.now() };
+function createCliRuntime(options = {}) {
+  const root = {
+    title: "(root)",
+    mode: "default",
+    children: []
+  };
+  let currentSuite = root;
+  let hasFocusedBlock = false;
+  let currentTestName;
+  const state = {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    pending: 0,
+    success: true
+  };
+  let emitHookLog = () => void 0;
+  let pendingSuiteMetadata;
+  const assignMetadataHandler = (target) => {
+    const fn = target;
+    fn.__withMetadata = (metadata, register) => {
+      const previous = pendingSuiteMetadata;
+      pendingSuiteMetadata = metadata;
+      try {
+        register();
+      } finally {
+        pendingSuiteMetadata = previous;
+      }
+    };
+    return fn;
+  };
+  function registerSuite(mode, title, handler, timeout) {
+    const metadata = pendingSuiteMetadata;
+    const node = {
+      title,
+      mode,
+      ...timeout !== void 0 ? { timeout } : {},
+      ...currentSuite === root ? {} : { parent: currentSuite },
+      children: [],
+      ...metadata ? { metadata: { ...metadata } } : {}
+    };
+    currentSuite.children.push({ kind: "suite", node });
+    if (mode === "only") {
+      hasFocusedBlock = true;
+    }
+    if (mode === "skip" || !handler) {
+      return;
+    }
+    const previous = currentSuite;
+    currentSuite = node;
+    try {
+      handler();
+    } finally {
+      currentSuite = previous;
+    }
+  }
+  function registerTest(entry) {
+    const node = {
+      title: entry.title,
+      mode: entry.mode,
+      kind: entry.kind,
+      ...entry.handler ? { handler: entry.handler } : {},
+      ...entry.timeout !== void 0 ? { timeout: entry.timeout } : {},
+      ...entry.reason !== void 0 ? { reason: entry.reason } : {}
+    };
+    if (node.mode === "only") {
+      hasFocusedBlock = true;
+    }
+    currentSuite.children.push({ kind: "test", node });
+  }
+  const suiteDefault = assignMetadataHandler((title, handler, timeout) => {
+    registerSuite("default", title, handler, timeout);
+  });
+  const suiteSkip = assignMetadataHandler((title, _handler, timeout) => {
+    registerSuite("skip", title, void 0, timeout);
+  });
+  const suiteOnly = assignMetadataHandler((title, handler, timeout) => {
+    registerSuite("only", title, handler, timeout);
+  });
+  const suiteConcurrent = assignMetadataHandler((title, handler, timeout) => {
+    registerSuite("concurrent", title, handler, timeout);
+  });
+  suiteDefault.skip = suiteSkip;
+  suiteDefault.only = suiteOnly;
+  suiteDefault.concurrent = suiteConcurrent;
+  suiteSkip.skip = suiteSkip;
+  suiteSkip.only = suiteOnly;
+  suiteSkip.concurrent = suiteConcurrent;
+  suiteOnly.skip = suiteSkip;
+  suiteOnly.only = suiteOnly;
+  suiteOnly.concurrent = suiteConcurrent;
+  suiteConcurrent.skip = suiteSkip;
+  suiteConcurrent.only = suiteOnly;
+  suiteConcurrent.concurrent = suiteConcurrent;
+  const suite = suiteDefault;
+  const testDefault = (title, handler, timeout) => {
+    registerTest({
+      title,
+      handler,
+      ...timeout !== void 0 ? { timeout } : {},
+      mode: "default",
+      kind: "test"
+    });
+  };
+  const testSkip = (title, _handler, timeout) => {
+    registerTest({
+      title,
+      ...timeout !== void 0 ? { timeout } : {},
+      mode: "skip",
+      kind: "test"
+    });
+  };
+  const testOnly = (title, handler, timeout) => {
+    registerTest({
+      title,
+      handler,
+      ...timeout !== void 0 ? { timeout } : {},
+      mode: "only",
+      kind: "test"
+    });
+  };
+  const testConcurrent = (title, handler, timeout) => {
+    registerTest({
+      title,
+      handler,
+      ...timeout !== void 0 ? { timeout } : {},
+      mode: "concurrent",
+      kind: "test"
+    });
+  };
+  testDefault.skip = testSkip;
+  testDefault.only = testOnly;
+  testDefault.concurrent = testConcurrent;
+  testSkip.skip = testSkip;
+  testSkip.only = testOnly;
+  testSkip.concurrent = testConcurrent;
+  testOnly.skip = testSkip;
+  testOnly.only = testOnly;
+  testOnly.concurrent = testConcurrent;
+  testConcurrent.skip = testSkip;
+  testConcurrent.only = testOnly;
+  testConcurrent.concurrent = testConcurrent;
+  testDefault.todo = (title, reason) => {
+    registerTest({
+      title,
+      mode: "skip",
+      kind: "todo",
+      ...reason !== void 0 ? { reason } : {}
+    });
+  };
+  testDefault.pending = (title, reason) => {
+    registerTest({
+      title,
+      mode: "skip",
+      kind: "pending",
+      ...reason !== void 0 ? { reason } : {}
+    });
+  };
+  testSkip.todo = testDefault.todo;
+  testSkip.pending = testDefault.pending;
+  testOnly.todo = testDefault.todo;
+  testOnly.pending = testDefault.pending;
+  testConcurrent.todo = testDefault.todo;
+  testConcurrent.pending = testDefault.pending;
+  const test = testDefault;
+  function invokeHook(handler) {
+    const outcome = handler();
+    if (outcome && typeof outcome.then === "function") {
+      void outcome.catch((error) => {
+        console.error(error);
+      });
+    }
+  }
+  const runtime = {
+    suite,
+    test,
+    beforeAll(handler) {
+      invokeHook(handler);
+    },
+    afterAll(handler) {
+      invokeHook(handler);
+    },
+    beforeEach(handler) {
+      invokeHook(handler);
+    },
+    afterEach(handler) {
+      invokeHook(handler);
+    },
+    currentTestName: () => currentTestName
+  };
+  const hookLogger = (event) => {
+    emitHookLog(event);
+  };
+  async function execute() {
+    const startedAt = clock.now();
+    const reports = [];
+    const reporters = [
+      ...options.reporters ? [...options.reporters] : [new HierarchicalReporter(void 0, options.reporter?.hierarchical)]
+    ];
+    emitHookLog = (event) => {
+      for (const reporter of reporters) {
+        if (typeof reporter.onHookLog === "function") {
+          reporter.onHookLog(event);
+        }
+      }
+    };
+    await dispatchRunStart({ timestamp: startedAt });
+    await runSuite(root, {
+      skip: false,
+      focus: false,
+      path: []
+    });
+    const finishedAt = clock.now();
+    const summary = {
+      total: state.total,
+      passed: state.passed,
+      failed: state.failed,
+      skipped: state.skipped,
+      pending: state.pending,
+      durationMs: finishedAt - startedAt,
+      success: state.success,
+      scenarios: reports
+    };
+    await dispatchRunEnd({ timestamp: finishedAt, summary });
+    emitHookLog = () => void 0;
+    return summary;
+    async function runSuite(node, context) {
+      const skip = context.skip || node.mode === "skip";
+      const focus = context.focus || node.mode === "only";
+      const suitePath = node.parent ? [...context.path, node.title] : context.path;
+      const shouldTrack = node.title && node.title !== "(root)";
+      if (shouldTrack) {
+        await dispatchSuiteStart({
+          title: node.title,
+          ancestors: context.path,
+          path: suitePath,
+          ...node.metadata?.kind ? { kind: node.metadata.kind } : {},
+          ...node.metadata?.keyword ? { keyword: node.metadata.keyword } : {}
+        });
+      }
+      for (const child of node.children) {
+        if (child.kind === "suite") {
+          await runSuite(child.node, { skip, focus, path: suitePath });
+          continue;
+        }
+        await runTest(child.node, suitePath, skip, focus);
+      }
+      if (shouldTrack) {
+        await dispatchSuiteEnd({
+          title: node.title,
+          ancestors: context.path,
+          path: suitePath,
+          ...node.metadata?.kind ? { kind: node.metadata.kind } : {},
+          ...node.metadata?.keyword ? { keyword: node.metadata.keyword } : {}
+        });
+      }
+    }
+    async function runTest(node, ancestors, skipBranch, focusBranch) {
+      const suitePath = [...ancestors];
+      const fullPath = [...suitePath, node.title];
+      const fullName = fullPath.join(" \u203A ");
+      if (node.kind === "todo" || node.kind === "pending") {
+        await record({
+          status: "pending",
+          name: node.title,
+          fullName,
+          path: suitePath,
+          ...node.reason !== void 0 ? { reason: node.reason } : {}
+        });
+        return;
+      }
+      const skipDueToFocus = hasFocusedBlock && !focusBranch && node.mode !== "only";
+      const shouldSkip = skipBranch || node.mode === "skip" || skipDueToFocus;
+      if (options.dryRun) {
+        await record({
+          status: "pending",
+          name: node.title,
+          fullName,
+          path: suitePath,
+          reason: "dry run"
+        });
+        return;
+      }
+      if (shouldSkip || !node.handler) {
+        await record({
+          status: "skipped",
+          name: node.title,
+          fullName,
+          path: suitePath
+        });
+        return;
+      }
+      const startedAt2 = clock.now();
+      currentTestName = fullName;
+      try {
+        const result = node.handler();
+        if (result && typeof result.then === "function") {
+          await result;
+        }
+        const duration = clock.now() - startedAt2;
+        await record({
+          status: "passed",
+          name: node.title,
+          fullName,
+          path: suitePath,
+          durationMs: duration
+        });
+      } catch (error) {
+        const duration = clock.now() - startedAt2;
+        await record({
+          status: "failed",
+          name: node.title,
+          fullName,
+          path: suitePath,
+          durationMs: duration,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      } finally {
+        currentTestName = void 0;
+      }
+    }
+    async function record(report) {
+      state.total += 1;
+      switch (report.status) {
+        case "passed":
+          state.passed += 1;
+          break;
+        case "failed":
+          state.failed += 1;
+          state.success = false;
+          break;
+        case "skipped":
+          state.skipped += 1;
+          break;
+        case "pending":
+          state.pending += 1;
+          break;
+      }
+      reports.push(report);
+      await dispatchTestResult({ result: report });
+    }
+    async function dispatchRunStart(event) {
+      for (const reporter of reporters) {
+        if (typeof reporter.onRunStart === "function") {
+          await reporter.onRunStart(event);
+        }
+      }
+    }
+    async function dispatchSuiteStart(event) {
+      for (const reporter of reporters) {
+        if (typeof reporter.onSuiteStart === "function") {
+          await reporter.onSuiteStart(event);
+        }
+      }
+    }
+    async function dispatchSuiteEnd(event) {
+      for (const reporter of reporters) {
+        if (typeof reporter.onSuiteEnd === "function") {
+          await reporter.onSuiteEnd(event);
+        }
+      }
+    }
+    async function dispatchTestResult(event) {
+      for (const reporter of reporters) {
+        if (typeof reporter.onTestResult === "function") {
+          await reporter.onTestResult(event);
+        }
+      }
+    }
+    async function dispatchRunEnd(event) {
+      for (const reporter of reporters) {
+        if (typeof reporter.onRunEnd === "function") {
+          await reporter.onRunEnd(event);
+        }
+      }
+    }
+  }
+  return {
+    runtime,
+    hookLogger,
+    async execute() {
+      return execute();
+    }
+  };
+}
+async function expandFilePatterns(patterns, cwd) {
+  if (!patterns || patterns.length === 0) {
+    return [];
+  }
+  const normalized = patterns.map(
+    (pattern) => isAbsolute(pattern) ? pattern : resolve(cwd, pattern)
+  );
+  const entries = await fg(normalized, {
+    cwd,
+    absolute: true,
+    onlyFiles: true,
+    unique: true,
+    followSymbolicLinks: true
+  });
+  return entries.sort((a, b) => a.localeCompare(b));
+}
+async function resolveCliCacheDir(cwd) {
+  const envCacheDir = process.env.AUTOMETA_CACHE_DIR?.trim();
+  if (envCacheDir) {
+    return isAbsolute(envCacheDir) ? envCacheDir : resolve(cwd, envCacheDir);
+  }
+  const envHome = process.env.AUTOMETA_HOME?.trim();
+  if (envHome) {
+    const base = isAbsolute(envHome) ? envHome : resolve(cwd, envHome);
+    return join(base, "cache");
+  }
+  const nodeModules = join(cwd, "node_modules");
+  if (await pathExists(nodeModules)) {
+    return join(nodeModules, ".cache", "autometa");
+  }
+  const osBase = resolveOsCacheBase();
+  const projectKey = createHash("sha1").update(resolve(cwd)).digest("hex");
+  return join(osBase, projectKey, "cache");
+}
+function resolveOsCacheBase() {
+  const xdg = process.env.XDG_CACHE_HOME?.trim();
+  if (xdg) {
+    return join(xdg, "autometa");
+  }
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Caches", "autometa");
+  }
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA?.trim();
+    if (local) {
+      return join(local, "autometa", "Cache");
+    }
+    return join(homedir(), "AppData", "Local", "autometa", "Cache");
+  }
+  return join(homedir(), ".cache", "autometa");
+}
+async function pathExists(path3) {
+  try {
+    await access(path3, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/loaders/module-loader.ts
+var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".cts", ".mts"]);
+var BUILTIN_EXTERNALS2 = /* @__PURE__ */ new Set([
+  ...builtinModules$1,
+  ...builtinModules$1.map((moduleId) => `node:${moduleId}`)
+]);
+var DEFAULT_EXTERNALS2 = /* @__PURE__ */ new Set(["p-limit"]);
+async function loadModule(specifier, options) {
+  if (isBareSpecifier(specifier)) {
+    return import(specifier);
+  }
+  const resolvedPath = resolve$1(options.cwd, specifier);
+  const filePath = await resolveFilePath(resolvedPath);
+  const extension = extname$1(filePath).toLowerCase();
+  if (TS_EXTENSIONS.has(extension)) {
+    return loadTranspiledModule(filePath, options);
+  }
+  return import(pathToFileURL$1(filePath).href);
+}
+function isBareSpecifier(specifier) {
+  if (!specifier) {
+    return false;
+  }
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    return false;
+  }
+  return !isAbsolute$1(specifier);
+}
+async function resolveFilePath(pathCandidate) {
+  if (await pathExists2(pathCandidate)) {
+    return pathCandidate;
+  }
+  const directory = dirname(pathCandidate);
+  const fileName = pathCandidate.slice(directory.length + 1);
+  for (const extension of TS_EXTENSIONS) {
+    const candidate = join$1(directory, `${fileName}${extension}`);
+    if (await pathExists2(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to resolve module at ${pathCandidate}`);
+}
+async function loadTranspiledModule(filePath, options) {
+  const cacheDirectory = options.cacheDir ?? await resolveCliCacheDir(options.cwd);
+  await promises$1.mkdir(cacheDirectory, { recursive: true });
+  const stats = await promises$1.stat(filePath);
+  const cacheKey = createCacheKey(filePath, stats.mtimeMs);
+  const outputFile = join$1(cacheDirectory, `${cacheKey}.cjs`);
+  if (!await pathExists2(outputFile)) {
+    const external = /* @__PURE__ */ new Set([
+      ...BUILTIN_EXTERNALS2,
+      ...DEFAULT_EXTERNALS2,
+      ...options.external ?? []
+    ]);
+    const result = await build({
+      entryPoints: [filePath],
+      absWorkingDir: options.cwd,
+      bundle: true,
+      platform: "node",
+      format: "cjs",
+      target: "node20",
+      sourcemap: "inline",
+      write: false,
+      external: Array.from(external)
+    });
+    const output = result.outputFiles?.find((file) => !file.path.endsWith(".map"));
+    if (!output) {
+      throw new Error(`Failed to compile module at ${filePath}`);
+    }
+    await promises$1.writeFile(outputFile, output.text, "utf8");
+  }
+  const moduleUrl = `${pathToFileURL$1(outputFile).href}?v=${cacheKey}`;
+  return import(moduleUrl);
+}
+function createCacheKey(filePath, mtimeMs) {
+  return createHash$1("sha1").update(filePath).update(String(mtimeMs)).digest("hex");
+}
+async function pathExists2(path3) {
+  try {
+    await promises$1.access(path3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/loaders/config.ts
+var CONFIG_CANDIDATES = [
+  "autometa.config.ts",
+  "autometa.config.mts",
+  "autometa.config.cts",
+  "autometa.config.js",
+  "autometa.config.mjs",
+  "autometa.config.cjs"
+];
+async function loadExecutorConfig(cwd, options = {}) {
+  const configPath = await resolveConfigPath(cwd, options.configPath);
+  const module = await loadModule(configPath, createModuleLoadOptions(cwd, options));
+  const config = extractConfig(module);
+  if (!config) {
+    throw new Error(
+      `Failed to load Autometa config from "${configPath}". Ensure the module exports a Config instance (e.g. export default defineConfig({...})).`
+    );
+  }
+  const resolveOptions = {
+    ...options.environment && options.environment.trim().length > 0 ? { environment: options.environment } : {},
+    ...options.modules && options.modules.length > 0 ? { modules: options.modules } : {},
+    ...options.groups && options.groups.length > 0 ? { groups: options.groups } : {}
+  };
+  const resolved = config.resolve(
+    Object.keys(resolveOptions).length > 0 ? resolveOptions : void 0
+  );
+  return {
+    filePath: configPath,
+    config,
+    resolved
+  };
+}
+async function resolveConfigPath(cwd, explicitPath) {
+  if (explicitPath) {
+    const absolutePath = resolve(cwd, explicitPath);
+    await ensureFileExists(absolutePath);
+    return absolutePath;
+  }
+  for (const candidate of CONFIG_CANDIDATES) {
+    const absoluteCandidate = resolve(cwd, candidate);
+    if (await fileExists(absoluteCandidate)) {
+      return absoluteCandidate;
+    }
+  }
+  throw new Error(
+    `Unable to locate an Autometa config file in "${cwd}". Expected one of: ${CONFIG_CANDIDATES.join(
+      ", "
+    )}`
+  );
+}
+async function ensureFileExists(path3) {
+  try {
+    await access(path3, constants.F_OK);
+  } catch {
+    throw new Error(`Config file not found at "${path3}"`);
+  }
+}
+async function fileExists(path3) {
+  try {
+    await access(path3, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createModuleLoadOptions(cwd, options) {
+  return {
+    cwd,
+    ...options.cacheDir ? { cacheDir: options.cacheDir } : {},
+    ...options.external ? { external: options.external } : {}
+  };
+}
+function extractConfig(exports) {
+  const candidates = [];
+  if (exports.default !== void 0) {
+    candidates.push(exports.default);
+  }
+  for (const value of Object.values(exports)) {
+    candidates.push(value);
+  }
+  for (const candidate of candidates) {
+    const config = asConfig(candidate);
+    if (config) {
+      return config;
+    }
+  }
+  return void 0;
+}
+function asConfig(value) {
+  if (!value || typeof value !== "object" && typeof value !== "function") {
+    return void 0;
+  }
+  if (value instanceof Config) {
+    return value;
+  }
+  const maybeConfig = value;
+  if (typeof maybeConfig.resolve === "function" && typeof maybeConfig.current === "function") {
+    return maybeConfig;
+  }
+  const maybeDefault = value.default;
+  if (maybeDefault && maybeDefault !== value) {
+    return asConfig(maybeDefault);
+  }
+  return void 0;
+}
+function formatDuration(ms) {
+  if (ms < 1) {
+    return `${ms.toFixed(2)} ms`;
+  }
+  if (ms < 1e3) {
+    return `${ms.toFixed(0)} ms`;
+  }
+  return `${(ms / 1e3).toFixed(2)} s`;
+}
+function formatSummary(summary, context) {
+  const parts = [`Environment: ${pc5.cyan(context.environment)}`];
+  parts.push(`Total: ${pc5.bold(String(summary.total))}`);
+  if (summary.passed > 0) {
+    parts.push(`Passed: ${pc5.green(String(summary.passed))}`);
+  }
+  if (summary.failed > 0) {
+    parts.push(`Failed: ${pc5.red(String(summary.failed))}`);
+  }
+  if (summary.skipped > 0) {
+    parts.push(`Skipped: ${pc5.yellow(String(summary.skipped))}`);
+  }
+  if (summary.pending > 0) {
+    parts.push(`Pending: ${pc5.cyan(String(summary.pending))}`);
+  }
+  parts.push(`Duration: ${pc5.dim(formatDuration(summary.durationMs))}`);
+  return parts.join(" | ");
+}
+
+// src/utils/handover.ts
+function extractArgsAfterDoubleDash(rawArgv) {
+  const idx = rawArgv.indexOf("--");
+  if (idx < 0) {
+    return [];
+  }
+  return rawArgv.slice(idx + 1);
+}
+function stripTrailingArgs(all, suffix) {
+  if (suffix.length === 0) {
+    return [...all];
+  }
+  if (suffix.length > all.length) {
+    return [...all];
+  }
+  const start = all.length - suffix.length;
+  for (let i = 0; i < suffix.length; i += 1) {
+    if (all[start + i] !== suffix[i]) {
+      return [...all];
+    }
+  }
+  return all.slice(0, start);
+}
+function splitPatternsAndRunnerArgs(options) {
+  const runnerArgs = options.handover ? extractArgsAfterDoubleDash(options.rawArgv) : [];
+  const patterns = runnerArgs.length > 0 ? stripTrailingArgs(options.patterns, runnerArgs) : [...options.patterns];
+  return { patterns, runnerArgs };
+}
+function detectRunner(config, cwd) {
+  if (config.runner === "vitest") {
+    return "vitest";
+  }
+  if (config.runner === "jest") {
+    return "jest";
+  }
+  if (config.runner === "playwright") {
+    return "playwright";
+  }
+  if (existsSync(join(cwd, "vitest.config.ts")) || existsSync(join(cwd, "vitest.config.js"))) {
+    return "vitest";
+  }
+  if (existsSync(join(cwd, "jest.config.js")) || existsSync(join(cwd, "jest.config.cjs")) || existsSync(join(cwd, "jest.config.ts"))) {
+    return "jest";
+  }
+  if (existsSync(join(cwd, "playwright.config.ts")) || existsSync(join(cwd, "playwright.config.js"))) {
+    return "playwright";
+  }
+  return "default";
+}
+async function orchestrate(options) {
+  const { cwd, config, patterns = [], runnerArgs = [], dryRun = false, watch = false, verbose = false } = options;
+  const runner = detectRunner(config, cwd);
+  if (verbose) {
+    console.log(`[autometa] Detected runner: ${runner}`);
+  }
+  switch (runner) {
+    case "vitest":
+      return spawnVitest({ cwd, patterns, runnerArgs, dryRun, watch, verbose });
+    case "jest":
+      return spawnJest({ cwd, patterns, runnerArgs, dryRun, watch, verbose });
+    case "playwright":
+      return spawnPlaywright({ cwd, patterns, runnerArgs, dryRun, watch, verbose });
+    case "default":
+      return { success: true, exitCode: 0, runner: "default" };
+  }
+}
+async function spawnVitest(options) {
+  const { cwd, patterns, runnerArgs, dryRun, watch, verbose } = options;
+  const args = [];
+  if (!watch) {
+    args.push("run");
+  }
+  if (patterns.length > 0) {
+    args.push(...patterns);
+  }
+  if (dryRun) {
+    args.push("--passWithNoTests");
+  }
+  if (runnerArgs.length > 0) {
+    args.push(...runnerArgs);
+  }
+  if (verbose) {
+    console.log(`[autometa] Running: vitest ${args.join(" ")}`);
+  }
+  const result = await spawnRunner("vitest", args, { cwd });
+  return { ...result, runner: "vitest" };
+}
+async function spawnJest(options) {
+  const { cwd, patterns, runnerArgs, dryRun, watch, verbose } = options;
+  const args = [];
+  if (watch) {
+    args.push("--watch");
+  }
+  if (patterns.length > 0) {
+    args.push(...patterns);
+  }
+  if (dryRun) {
+    args.push("--listTests");
+  }
+  if (runnerArgs.length > 0) {
+    args.push(...runnerArgs);
+  }
+  if (verbose) {
+    console.log(`[autometa] Running: jest ${args.join(" ")}`);
+  }
+  const result = await spawnRunner("jest", args, { cwd });
+  return { ...result, runner: "jest" };
+}
+async function spawnPlaywright(options) {
+  const { cwd, patterns, runnerArgs, dryRun, watch, verbose } = options;
+  const args = ["test"];
+  if (patterns.length > 0) {
+    args.push(...patterns);
+  }
+  if (dryRun) {
+    args.push("--list");
+  }
+  if (watch) {
+    args.push("--ui");
+  }
+  if (runnerArgs.length > 0) {
+    args.push(...runnerArgs);
+  }
+  if (verbose) {
+    console.log(`[autometa] Running: playwright ${args.join(" ")}`);
+  }
+  const loaderImportFlag = "--import @autometa/playwright-loader/register";
+  const existingNodeOptions = process.env.NODE_OPTIONS ?? "";
+  const hasLoaderFlag = existingNodeOptions.includes(loaderImportFlag);
+  const nodeOptions = hasLoaderFlag ? existingNodeOptions : [existingNodeOptions, loaderImportFlag].filter(Boolean).join(" ").trim();
+  const result = await spawnRunner("playwright", args, {
+    cwd,
+    env: {
+      NODE_OPTIONS: nodeOptions
+    }
+  });
+  return { ...result, runner: "playwright" };
+}
+function spawnRunner(command, args, options) {
+  return new Promise((resolve4) => {
+    const spawnOptions = {
+      cwd: options.cwd,
+      stdio: "inherit",
+      shell: true,
+      env: {
+        ...process.env,
+        FORCE_COLOR: process.env.FORCE_COLOR ?? "1",
+        ...options.env ?? {}
+      }
+    };
+    const binPath = join(options.cwd, "node_modules", ".bin", command);
+    const actualCommand = existsSync(binPath) ? binPath : command;
+    const child = spawn(actualCommand, args, spawnOptions);
+    child.on("close", (code) => {
+      const exitCode = code ?? 0;
+      resolve4({
+        success: exitCode === 0,
+        exitCode
+      });
+    });
+    child.on("error", (error) => {
+      console.error(`[autometa] Failed to spawn ${command}:`, error.message);
+      resolve4({
+        success: false,
+        exitCode: 1
+      });
+    });
+  });
+}
+
+// src/commands/run.ts
+var STEP_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"]);
+var STEP_FALLBACK_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}";
+var FEATURE_FALLBACK_GLOB = "**/*.feature";
+var ROOT_LOAD_ORDER = ["parameterTypes", "support", "hooks", "app"];
+function normalizeGlobLikePath(input) {
+  return input.replace(/\\/g, "/").replace(/^\.\//u, "");
+}
+function patternIsUnderRoot(pattern, root) {
+  const p = normalizeGlobLikePath(pattern);
+  const r = normalizeGlobLikePath(root).replace(/\/+$/u, "");
+  if (!r) {
+    return false;
+  }
+  return p === r || p.startsWith(`${r}/`);
+}
+function flattenModuleDeclarations(declarations, prefix = []) {
+  if (!declarations || declarations.length === 0) {
+    return [];
+  }
+  const results = [];
+  for (const entry of declarations) {
+    if (typeof entry === "string") {
+      const next2 = [...prefix, entry];
+      results.push(next2);
+      continue;
+    }
+    const next = [...prefix, entry.name];
+    results.push(next);
+    const nested = flattenModuleDeclarations(entry.submodules ?? void 0, next);
+    for (const path3 of nested) {
+      results.push([...path3]);
+    }
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const path3 of results) {
+    unique.set(path3.join("/"), path3);
+  }
+  return Array.from(unique.values()).sort((a, b) => b.length - a.length);
+}
+function buildGroupIndex(config, cwd) {
+  const groups = config.modules?.groups;
+  if (!groups) {
+    return [];
+  }
+  return Object.entries(groups).map(([group, groupConfig]) => {
+    const rootAbs = resolve(cwd, groupConfig.root);
+    const modulePaths = flattenModuleDeclarations(groupConfig.modules);
+    return { group, rootAbs, modulePaths };
+  });
+}
+function normalizePathSegments(input) {
+  const normalized = input.replace(/\\/g, "/");
+  return normalized.split("/").filter(Boolean);
+}
+function isPathUnderRoot(fileAbs, rootAbs) {
+  const rel = relative(rootAbs, fileAbs);
+  if (rel === "") {
+    return true;
+  }
+  return !rel.startsWith("..") && !rel.startsWith("../") && !rel.startsWith("..\\");
+}
+function startsWithSegments(haystack, needle) {
+  if (needle.length > haystack.length) {
+    return false;
+  }
+  for (let i = 0; i < needle.length; i += 1) {
+    if (haystack[i] !== needle[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function resolveFileScope(fileAbs, groupIndex) {
+  if (fileAbs.startsWith("node:")) {
+    return { kind: "root" };
+  }
+  for (const entry of groupIndex) {
+    if (!isPathUnderRoot(fileAbs, entry.rootAbs)) {
+      continue;
+    }
+    const rel = relative(entry.rootAbs, fileAbs);
+    const segments = normalizePathSegments(rel);
+    for (const modulePath of entry.modulePaths) {
+      if (startsWithSegments(segments, modulePath)) {
+        return {
+          kind: "module",
+          group: entry.group,
+          modulePath
+        };
+      }
+    }
+    return {
+      kind: "group",
+      group: entry.group
+    };
+  }
+  return { kind: "root" };
+}
+function parseScopeOverrideTag(tags) {
+  if (!tags || tags.length === 0) {
+    return void 0;
+  }
+  for (const tag of tags) {
+    const match = tag.match(/^@scope(?::|=|\()(.+?)(?:\))?$/u);
+    if (!match) {
+      continue;
+    }
+    const raw = (match[1] ?? "").trim();
+    if (!raw) {
+      continue;
+    }
+    const normalized = raw.replace(/\//g, ":");
+    const parts = normalized.split(":").filter(Boolean);
+    const [group, ...rest] = parts;
+    if (!group) {
+      continue;
+    }
+    return rest.length > 0 ? { group, modulePath: rest } : { group };
+  }
+  return void 0;
+}
+function resolveFeatureScope(featureAbsPath, feature, groupIndex) {
+  const override = parseScopeOverrideTag(feature.tags);
+  if (override) {
+    if (override.modulePath && override.modulePath.length > 0) {
+      return { kind: "module", group: override.group, modulePath: override.modulePath };
+    }
+    return { kind: "group", group: override.group };
+  }
+  return resolveFileScope(featureAbsPath, groupIndex);
+}
+function isVisibleStepScope(stepScope, featureScope) {
+  if (featureScope.kind === "root") {
+    return stepScope.kind === "root";
+  }
+  if (featureScope.kind === "group") {
+    if (stepScope.kind === "root") {
+      return true;
+    }
+    return stepScope.kind === "group" && stepScope.group === featureScope.group;
+  }
+  if (stepScope.kind === "root") {
+    return true;
+  }
+  if (stepScope.kind === "group") {
+    return stepScope.group === featureScope.group;
+  }
+  if (stepScope.kind === "module") {
+    return stepScope.group === featureScope.group && startsWithSegments(featureScope.modulePath, stepScope.modulePath);
+  }
+  return false;
+}
+function stepScopeRank(scope) {
+  switch (scope.kind) {
+    case "module":
+      return 200 + scope.modulePath.length;
+    case "group":
+      return 100;
+    default:
+      return 0;
+  }
+}
+function collectRepeatedString(value, previous) {
+  return [...previous, value];
+}
+function registerRunCommand(program) {
+  return program.command("run").description("Execute Autometa feature files").argument("[patterns...]", "Feature files or glob patterns").option(
+    "--handover",
+    "Pass through runner args after '--' directly to the detected native runner (vitest/jest/playwright)"
+  ).option(
+    "--cache-dir <dir>",
+    "Directory for Autometa CLI cache (defaults to node_modules/.cache/autometa when available)"
+  ).option("--dry-run", "Collect scenarios without executing steps").option("--watch", "Run in watch mode (vitest/jest only)").option("--verbose", "Show detailed output including runner detection").option("--standalone", "Force standalone runtime instead of native runner").option("-e, --environment <environment>", "Select config environment").option(
+    "-g, --group <group>",
+    "Filter module groups to include (affects module/step loading; patterns are not auto-scoped)",
+    collectRepeatedString,
+    []
+  ).option(
+    "-m, --module <module>",
+    "Filter modules to include (by id or unambiguous suffix; affects module/step loading; patterns are not auto-scoped)",
+    collectRepeatedString,
+    []
+  ).action(async (patterns, flags) => {
+    try {
+      const split = flags?.handover === true ? splitPatternsAndRunnerArgs({ patterns, rawArgv: process.argv, handover: true }) : splitPatternsAndRunnerArgs({ patterns, rawArgv: process.argv });
+      const summary = await runFeatures({
+        cwd: process.cwd(),
+        ...typeof flags?.cacheDir === "string" && flags.cacheDir.trim().length > 0 ? { cacheDir: flags.cacheDir } : {},
+        ...split.patterns.length > 0 ? { patterns: split.patterns } : {},
+        ...split.runnerArgs.length > 0 ? { runnerArgs: split.runnerArgs } : {},
+        ...typeof flags?.dryRun === "boolean" ? { dryRun: flags.dryRun } : {},
+        ...typeof flags?.watch === "boolean" ? { watch: flags.watch } : {},
+        ...typeof flags?.verbose === "boolean" ? { verbose: flags.verbose } : {},
+        ...flags?.standalone ? { mode: "standalone" } : {},
+        ...typeof flags?.environment === "string" && flags.environment.trim().length > 0 ? { environment: flags.environment } : {},
+        ...Array.isArray(flags?.group) && flags.group.length > 0 ? { groups: flags.group } : {},
+        ...Array.isArray(flags?.module) && flags.module.length > 0 ? { modules: flags.module } : {}
+      });
+      if (!summary.success) {
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      const output = error instanceof Error ? error.stack ?? error.message : String(error);
+      console.error(output);
+      process.exitCode = 1;
+    }
+  });
+}
+function isScenario(element) {
+  return "steps" in element && !("exampleGroups" in element) && !("elements" in element);
+}
+function isScenarioOutline(element) {
+  return "steps" in element && "exampleGroups" in element;
+}
+function isRule(element) {
+  return "elements" in element && Array.isArray(element.elements);
+}
+function createFeatureScopePlan(feature, basePlan, options) {
+  const scopingMode = options.config.modules?.stepScoping ?? "global";
+  const useScopedSteps = scopingMode === "scoped" && options.groupIndex.length > 0;
+  const allSteps = Array.from(basePlan.stepsById.values());
+  const featureFileScope = useScopedSteps ? resolveFeatureScope(options.featureAbsPath, feature, options.groupIndex) : { kind: "root" };
+  const visibleSteps = useScopedSteps ? allSteps.filter((definition) => {
+    const file = definition.source?.file;
+    const stepScope = file ? resolveFileScope(resolve(options.cwd, file), options.groupIndex) : { kind: "root" };
+    return isVisibleStepScope(stepScope, featureFileScope);
+  }).sort((a, b) => {
+    const aFile = a.source?.file;
+    const bFile = b.source?.file;
+    const aScope = aFile ? resolveFileScope(resolve(options.cwd, aFile), options.groupIndex) : { kind: "root" };
+    const bScope = bFile ? resolveFileScope(resolve(options.cwd, bFile), options.groupIndex) : { kind: "root" };
+    const delta = stepScopeRank(bScope) - stepScopeRank(aScope);
+    return delta !== 0 ? delta : a.id.localeCompare(b.id);
+  }) : allSteps;
+  const scopedStepsById = useScopedSteps ? (() => {
+    const allowed = new Set(visibleSteps.map((step) => step.id));
+    const next = /* @__PURE__ */ new Map();
+    for (const [id, def] of basePlan.stepsById.entries()) {
+      if (allowed.has(id)) {
+        next.set(id, def);
+      }
+    }
+    return next;
+  })() : basePlan.stepsById;
+  const featureChildren = [];
+  const scopesById = new Map(basePlan.scopesById);
+  for (const element of feature.elements ?? []) {
+    if (isScenario(element) || isScenarioOutline(element)) {
+      const scenarioScope = {
+        id: element.id ?? element.name,
+        kind: isScenarioOutline(element) ? "scenarioOutline" : "scenario",
+        name: element.name,
+        mode: "default",
+        tags: element.tags ?? [],
+        steps: visibleSteps,
+        hooks: [],
+        children: [],
+        pending: false
+      };
+      featureChildren.push(scenarioScope);
+      scopesById.set(scenarioScope.id, scenarioScope);
+    } else if (isRule(element)) {
+      const ruleChildren = [];
+      for (const ruleElement of element.elements ?? []) {
+        if (isScenario(ruleElement) || isScenarioOutline(ruleElement)) {
+          const scenarioScope = {
+            id: ruleElement.id ?? ruleElement.name,
+            kind: isScenarioOutline(ruleElement) ? "scenarioOutline" : "scenario",
+            name: ruleElement.name,
+            mode: "default",
+            tags: ruleElement.tags ?? [],
+            steps: visibleSteps,
+            hooks: [],
+            children: [],
+            pending: false
+          };
+          ruleChildren.push(scenarioScope);
+          scopesById.set(scenarioScope.id, scenarioScope);
+        }
+      }
+      const ruleScope = {
+        id: element.id ?? element.name,
+        kind: "rule",
+        name: element.name,
+        mode: "default",
+        tags: element.tags ?? [],
+        steps: visibleSteps,
+        hooks: [],
+        children: ruleChildren,
+        pending: false
+      };
+      featureChildren.push(ruleScope);
+      scopesById.set(ruleScope.id, ruleScope);
+    }
+  }
+  const featureScope = {
+    id: feature.uri ?? feature.name,
+    kind: "feature",
+    name: feature.name,
+    mode: "default",
+    tags: feature.tags ?? [],
+    steps: visibleSteps,
+    hooks: [],
+    children: featureChildren,
+    pending: false
+  };
+  const existingRoot = basePlan.root;
+  const updatedRoot = {
+    ...existingRoot,
+    children: [...existingRoot.children, featureScope]
+  };
+  scopesById.set(featureScope.id, featureScope);
+  scopesById.set(updatedRoot.id, updatedRoot);
+  const scopePlan = {
+    root: updatedRoot,
+    stepsById: scopedStepsById,
+    hooksById: basePlan.hooksById,
+    scopesById
+  };
+  if (basePlan.worldFactory) {
+    scopePlan.worldFactory = basePlan.worldFactory;
+  }
+  if (basePlan.parameterRegistry) {
+    scopePlan.parameterRegistry = basePlan.parameterRegistry;
+  }
+  return scopePlan;
+}
+async function runFeatures(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const cacheDir = options.cacheDir ?? await resolveCliCacheDir(cwd);
+  const summaryFormatter = options.summaryFormatter ?? formatSummary;
+  const { resolved } = await loadExecutorConfig(cwd, {
+    cacheDir,
+    ...typeof options.environment === "string" && options.environment.trim().length > 0 ? { environment: options.environment } : {},
+    ...options.modules ? { modules: [...options.modules] } : {},
+    ...options.groups ? { groups: [...options.groups] } : {}
+  });
+  const executorConfig = resolved.config;
+  const mode = options.mode ?? "native";
+  if (mode !== "standalone") {
+    const orchestratorResult = await orchestrate({
+      cwd,
+      config: executorConfig,
+      ...options.patterns ? { patterns: options.patterns } : {},
+      ...options.runnerArgs ? { runnerArgs: options.runnerArgs } : {},
+      ...options.dryRun !== void 0 ? { dryRun: options.dryRun } : {},
+      ...options.watch !== void 0 ? { watch: options.watch } : {},
+      ...options.verbose !== void 0 ? { verbose: options.verbose } : {}
+    });
+    if (orchestratorResult.runner !== "default") {
+      return {
+        success: orchestratorResult.success,
+        total: 0,
+        // Native runner handles its own reporting
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        pending: 0,
+        durationMs: 0,
+        scenarios: []
+      };
+    }
+    if (options.verbose) {
+      console.log("[autometa] Using standalone runtime");
+    }
+  }
+  const hierarchicalBufferOutput = executorConfig.reporting?.hierarchical?.bufferOutput;
+  const reporterOptions = hierarchicalBufferOutput !== void 0 ? { hierarchical: { bufferOutput: hierarchicalBufferOutput } } : void 0;
+  const runtimeOptions = {
+    ...typeof options.dryRun === "boolean" ? { dryRun: options.dryRun } : {},
+    ...options.reporters ? { reporters: options.reporters } : {},
+    ...reporterOptions ? { reporter: reporterOptions } : {}
+  };
+  const { runtime, hookLogger, execute } = createCliRuntime(runtimeOptions);
+  configureHttpLogging(executorConfig.logging);
+  const hasModuleSelection = (options.groups?.length ?? 0) > 0 || (options.modules?.length ?? 0) > 0;
+  const hasExplicitPatterns = (options.patterns?.length ?? 0) > 0;
+  if (hasExplicitPatterns && hasModuleSelection) {
+    const patterns = [...options.patterns ?? []];
+    const shouldWarn = (() => {
+      const groups = executorConfig.modules?.groups;
+      if (!groups) {
+        return true;
+      }
+      if ((options.groups?.length ?? 0) > 0) {
+        const allowedGroups = new Set(options.groups);
+        const allowedRoots = Object.entries(groups).filter(([group]) => allowedGroups.has(group)).map(([, groupConfig]) => groupConfig.root);
+        if (allowedRoots.length > 0) {
+          return patterns.some(
+            (pattern) => !allowedRoots.some((root) => patternIsUnderRoot(pattern, root))
+          );
+        }
+      }
+      return true;
+    })();
+    if (shouldWarn) {
+      console.warn(
+        "[autometa] Note: when you pass explicit feature patterns, they are used as-is. Group/module filters (-g/-m) affect module/step loading, but do not automatically filter your feature patterns."
+      );
+    }
+  }
+  const patternSource = (() => {
+    if (hasExplicitPatterns) {
+      return [...options.patterns ?? []];
+    }
+    const roots = [...executorConfig.roots.features];
+    if (hasModuleSelection && executorConfig.modules?.groups) {
+      const allowedGroups = (options.groups?.length ?? 0) > 0 ? new Set(options.groups) : new Set(Object.keys(executorConfig.modules.groups));
+      const allowedRoots = Object.entries(executorConfig.modules.groups).filter(([group]) => allowedGroups.has(group)).map(([, groupConfig]) => groupConfig.root);
+      const filtered = roots.filter(
+        (pattern) => allowedRoots.some((root) => patternIsUnderRoot(pattern, root))
+      );
+      if (filtered.length > 0) {
+        return filtered;
+      }
+    }
+    return roots;
+  })();
+  const featurePatterns = buildPatterns(patternSource, FEATURE_FALLBACK_GLOB);
+  const featureFiles = (await expandFilePatterns(featurePatterns, cwd)).filter(
+    (file) => file.toLowerCase().endsWith(".feature")
+  );
+  if (featureFiles.length === 0) {
+    throw new Error(
+      `No feature files found for patterns: ${patternSource.map((pattern) => `"${pattern}"`).join(", ")}`
+    );
+  }
+  const builder = CucumberRunner.builder();
+  let stepsEnvironments = [builder.steps()];
+  const modulePlan = await createModulePlan(executorConfig, cwd);
+  const compileOptions = executorConfig.builder ? { cwd, cacheDir, builder: executorConfig.builder } : { cwd, cacheDir };
+  const compileResult = await compileModules(modulePlan.orderedFiles, compileOptions);
+  if (modulePlan.orderedFiles.length > 0) {
+    const imported = await import(pathToFileURL(compileResult.bundlePath).href);
+    const resolved2 = collectStepsEnvironments(imported);
+    if (resolved2.length > 0) {
+      stepsEnvironments = resolved2;
+    }
+  }
+  const groupIndex = buildGroupIndex(executorConfig, cwd);
+  const environmentIndex = indexStepsEnvironments(stepsEnvironments, cwd, groupIndex);
+  for (const featurePath of featureFiles) {
+    const feature = await readFeatureFile(featurePath, cwd);
+    const featureAbsPath = resolve(cwd, featurePath);
+    const selectedStepsEnvironment = resolveFeatureStepsEnvironment(
+      featureAbsPath,
+      feature,
+      environmentIndex,
+      groupIndex
+    );
+    CucumberRunner.setSteps(selectedStepsEnvironment);
+    const basePlan = selectedStepsEnvironment.getPlan();
+    const scopePlan = createFeatureScopePlan(feature, basePlan, {
+      featureAbsPath,
+      cwd,
+      config: executorConfig,
+      groupIndex
+    });
+    const coordinated = selectedStepsEnvironment.coordinateFeature({
+      feature,
+      plan: scopePlan,
+      config: executorConfig,
+      runtime,
+      hookLogger
+    });
+    coordinated.register(runtime);
+  }
+  const summary = await execute();
+  logSummary(summary, resolved.environment, summaryFormatter);
+  return summary;
+}
+function collectStepsEnvironments(imported) {
+  const candidates = collectCandidateModules(imported);
+  const environments = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const extracted = extractStepsEnvironments(candidate);
+    for (const env of extracted) {
+      environments.add(env);
+    }
+  }
+  return Array.from(environments);
+}
+function collectCandidateModules(imported) {
+  if (!imported || typeof imported !== "object") {
+    return [];
+  }
+  const record = imported;
+  const modules = /* @__PURE__ */ new Set();
+  modules.add(record);
+  const exportedModules = record.modules;
+  if (Array.isArray(exportedModules)) {
+    for (const entry of exportedModules) {
+      if (entry && typeof entry === "object") {
+        modules.add(entry);
+      }
+    }
+  }
+  const defaultExport = record.default;
+  if (Array.isArray(defaultExport)) {
+    for (const entry of defaultExport) {
+      if (entry && typeof entry === "object") {
+        modules.add(entry);
+      }
+    }
+  } else if (defaultExport && typeof defaultExport === "object") {
+    modules.add(defaultExport);
+  }
+  return Array.from(modules);
+}
+function extractStepsEnvironments(candidate) {
+  const environments = [];
+  if (isStepsEnvironment(candidate)) {
+    environments.push(candidate);
+  }
+  const steps = candidate.stepsEnvironment;
+  if (isStepsEnvironment(steps)) {
+    environments.push(steps);
+  }
+  const defaultExport = candidate.default;
+  if (isStepsEnvironment(defaultExport)) {
+    environments.push(defaultExport);
+  }
+  return environments;
+}
+function inferEnvironmentGroup(environment, cwd, groupIndex) {
+  const meta = environment[STEPS_ENVIRONMENT_META];
+  if (meta?.kind === "group" && typeof meta.group === "string" && meta.group.trim().length > 0) {
+    return { kind: "group", group: meta.group };
+  }
+  if (meta?.kind === "root") {
+    return { kind: "root" };
+  }
+  const plan = environment.getPlan();
+  const groups = /* @__PURE__ */ new Set();
+  for (const step of plan.stepsById.values()) {
+    const file = step.source?.file;
+    if (!file) {
+      continue;
+    }
+    const scope = resolveFileScope(resolve(cwd, file), groupIndex);
+    if (scope.kind === "group" || scope.kind === "module") {
+      groups.add(scope.group);
+    }
+    if (groups.size > 1) {
+      return { kind: "ambiguous" };
+    }
+  }
+  const only = Array.from(groups.values())[0];
+  return only ? { kind: "group", group: only } : { kind: "root" };
+}
+function indexStepsEnvironments(environments, cwd, groupIndex) {
+  const entries = [];
+  for (const env of environments) {
+    const inferred = inferEnvironmentGroup(env, cwd, groupIndex);
+    if (inferred.kind === "ambiguous") {
+      continue;
+    }
+    entries.push(
+      inferred.kind === "group" ? { kind: "group", group: inferred.group, environment: env } : { kind: "root", environment: env }
+    );
+  }
+  return entries;
+}
+function resolveFeatureStepsEnvironment(featureAbsPath, feature, environments, groupIndex) {
+  const featureScope = resolveFeatureScope(featureAbsPath, feature, groupIndex);
+  if (featureScope.kind === "root") {
+    const root = environments.find((entry) => entry.kind === "root");
+    return root?.environment ?? environments[0]?.environment ?? CucumberRunner.steps();
+  }
+  const group = featureScope.group;
+  const match = environments.find((entry) => entry.kind === "group" && entry.group === group);
+  if (match) {
+    return match.environment;
+  }
+  const available = environments.filter((entry) => entry.kind === "group").map((entry) => entry.group).sort();
+  throw new Error(
+    `No steps environment found for group "${group}". Available groups: ${available.length > 0 ? available.join(", ") : "<none>"}`
+  );
+}
+function isStepsEnvironment(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.coordinateFeature === "function" && typeof candidate.Given === "function" && typeof candidate.When === "function" && typeof candidate.Then === "function";
+}
+async function createModulePlan(config, cwd) {
+  const orderedFiles = [];
+  const seenFiles = /* @__PURE__ */ new Set();
+  const processed = /* @__PURE__ */ new Set(["features", "steps"]);
+  const rootsRecord = config.roots;
+  const pushFiles = (files) => {
+    for (const file of files) {
+      if (seenFiles.has(file)) {
+        continue;
+      }
+      seenFiles.add(file);
+      orderedFiles.push(file);
+    }
+  };
+  const eventFiles = await resolveRootFiles(config.events ?? [], cwd);
+  if (eventFiles.length > 0) {
+    pushFiles(eventFiles);
+  }
+  for (const key of ROOT_LOAD_ORDER) {
+    const entries = rootsRecord[key];
+    if (!entries || entries.length === 0) {
+      processed.add(key);
+      continue;
+    }
+    const files = await resolveRootFiles(entries, cwd);
+    if (files.length > 0) {
+      pushFiles(files);
+    }
+    processed.add(key);
+  }
+  for (const [key, entries] of Object.entries(rootsRecord)) {
+    if (processed.has(key)) {
+      continue;
+    }
+    if (!entries || entries.length === 0) {
+      continue;
+    }
+    const files = await resolveRootFiles(entries, cwd);
+    if (files.length > 0) {
+      pushFiles(files);
+    }
+  }
+  const stepFiles = await resolveRootFiles(config.roots.steps, cwd);
+  pushFiles(stepFiles);
+  return {
+    orderedFiles
+  };
+}
+async function resolveRootFiles(entries, cwd) {
+  const patterns = buildPatterns(entries, STEP_FALLBACK_GLOB);
+  if (patterns.length === 0) {
+    return [];
+  }
+  const matches = await expandFilePatterns(patterns, cwd);
+  return filterCodeFiles(matches);
+}
+function buildPatterns(entries, fallbackGlob) {
+  const patterns = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const normalized = entry.trim();
+    if (!normalized) {
+      continue;
+    }
+    for (const pattern of toPatterns(normalized, fallbackGlob)) {
+      patterns.add(pattern);
+    }
+  }
+  return Array.from(patterns);
+}
+function toPatterns(entry, fallbackGlob) {
+  if (hasGlobMagic(entry) || hasFileExtension(entry)) {
+    return [entry];
+  }
+  return [appendGlob(entry, fallbackGlob)];
+}
+function hasGlobMagic(input) {
+  return /[*?{}()[\]!,@+]/.test(input);
+}
+function hasFileExtension(input) {
+  const normalized = input.replace(/\\/g, "/");
+  const trimmed = normalized === "/" ? "/" : normalized.replace(/\/+$/u, "");
+  if (!trimmed || trimmed === "." || trimmed === "..") {
+    return false;
+  }
+  return Boolean(extname(trimmed));
+}
+function appendGlob(entry, glob) {
+  const normalized = entry.replace(/\\/g, "/");
+  const trimmed = normalized === "/" ? "/" : normalized.replace(/\/+$/u, "");
+  if (!trimmed || trimmed === ".") {
+    return glob;
+  }
+  if (trimmed === "/") {
+    return `/${glob}`;
+  }
+  return `${trimmed}/${glob}`;
+}
+function filterCodeFiles(files) {
+  return files.filter((file) => {
+    const lower = file.toLowerCase();
+    if (lower.endsWith(".d.ts")) {
+      return false;
+    }
+    const dotIndex = lower.lastIndexOf(".");
+    if (dotIndex === -1) {
+      return false;
+    }
+    const extension = lower.slice(dotIndex);
+    return STEP_FILE_EXTENSIONS.has(extension);
+  });
+}
+async function readFeatureFile(path3, cwd) {
+  const source = await promises.readFile(path3, "utf8");
+  const feature = parseGherkin(source);
+  if (!feature.uri) {
+    const relativePath2 = relative(cwd, path3);
+    const candidate = relativePath2.startsWith("..") ? path3 : relativePath2;
+    feature.uri = candidate.replace(/\\/g, "/");
+  }
+  return feature;
+}
+function logSummary(summary, environment, formatter) {
+  console.log(formatter(summary, { environment }));
+}
+function configureHttpLogging(logging) {
+  if (!logging?.http) {
+    return;
+  }
+  const registered = HTTP.getSharedPlugins();
+  if (registered.some((plugin) => plugin.name === "http-logging")) {
+    return;
+  }
+  HTTP.registerSharedPlugin(createLoggingPlugin(logHttpEvent));
+}
+function logHttpEvent(event) {
+  const timestamp = new Date(event.timestamp).toISOString();
+  const url = resolveRequestUrl(event.request);
+  switch (event.type) {
+    case "request": {
+      const method = event.request.method ?? "<unknown>";
+      console.log(`[HTTP ${timestamp}] \u2192 ${method} ${url}`);
+      break;
+    }
+    case "response": {
+      const status = event.response.status;
+      console.log(`[HTTP ${timestamp}] \u2190 ${status} ${url}`);
+      break;
+    }
+    case "error": {
+      const message = event.error instanceof Error ? event.error.message : String(event.error);
+      console.error(`[HTTP ${timestamp}] ! ${url} ${message}`);
+      break;
+    }
+  }
+}
+function resolveRequestUrl(request) {
+  const url = request.fullUrl;
+  if (url) {
+    return url;
+  }
+  if (request.baseUrl && request.route && request.route.length > 0) {
+    const normalizedRoute = request.route.join("/");
+    return `${request.baseUrl.replace(/\/?$/u, "")}/${normalizedRoute}`;
+  }
+  if (request.baseUrl) {
+    return request.baseUrl;
+  }
+  if (request.route && request.route.length > 0) {
+    return request.route.join("/");
+  }
+  return "<unknown>";
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+async function createCliProgram() {
+  const program = new Command();
+  program.name("autometa").description("Autometa command-line runner").version(version ?? "0.0.0");
+  registerRunCommand(program);
+  return program;
+}
+
+export { createCliProgram, runFeatures };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map