@autometa/test-builder 0.4.2 → 1.0.0-rc.1

package/dist/index.js

@@ -1,729 +1,1127 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
+import { RegularExpression, CucumberExpression, ParameterTypeRegistry } from '@cucumber/cucumber-expressions';
+import { createDefaultParameterTypes } from '@autometa/cucumber-expressions';
+import path from 'node:path';
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  BackgroundBridge: () => BackgroundBridge,
-  ExampleBridge: () => ExampleBridge,
-  ExamplesBridge: () => ExamplesBridge,
-  FeatureBridge: () => FeatureBridge,
-  GherkinCodeBridge: () => GherkinCodeBridge,
-  GherkinWalker: () => GherkinWalker,
-  GlobalBridge: () => GlobalBridge,
-  Query: () => Query,
-  RuleBridge: () => RuleBridge,
-  ScenarioBridge: () => ScenarioBridge,
-  ScenarioOutlineBridge: () => ScenarioOutlineBridge,
-  StepBridge: () => StepBridge,
-  TestBuilder: () => TestBuilder,
-  find: () => find,
-  findExamplesOrChild: () => findExamplesOrChild,
-  findRuleOrChild: () => findRuleOrChild,
-  findRuleTypes: () => findRuleTypes,
-  findScenario: () => findScenario,
-  findScenarioOutlineOrChild: () => findScenarioOutlineOrChild,
-  findTestTypes: () => findTestTypes,
-  scope: () => scope
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/bridges/bridge.ts
-var import_gherkin = require("@autometa/gherkin");
-var GherkinCodeBridge = class {
-};
-var GlobalBridge = class extends GherkinCodeBridge {
-  constructor(scope2) {
-    super();
-    const nullNode = class extends import_gherkin.GherkinNode {
-      constructor() {
-        super(...arguments);
-        this.keyword = "none";
+// src/internal/test-plan-builder.ts
+function normalizeName(value) {
+  return value.trim();
+}
+function normalizeKeyword(keyword) {
+  return keyword.trim();
+}
+function normalizeUri(uri) {
+  const cleaned = uri.replace(/^file:/, "");
+  const normalized = path.normalize(cleaned);
+  return normalized.replace(/[\\/]+/g, "/");
+}
+function buildScopeSuffix(id) {
+  return ` [${id}]`;
+}
+function buildExampleSuffix(exampleId, index) {
+  return ` [${exampleId}#${index + 1}]`;
+}
+function buildQualifiedName(segments) {
+  return segments.map((segment) => {
+    const keyword = segment.keyword.trim();
+    const name = segment.name?.trim();
+    const suffix = segment.suffix ?? "";
+    if (!name || name.length === 0) {
+      return `${keyword}${suffix}`;
+    }
+    return `${keyword}: ${name}${suffix}`;
+  }).join(" > ");
+}
+function collectTags(...sources) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    if (!source) {
+      continue;
+    }
+    for (const tag of source) {
+      if (!seen.has(tag)) {
+        seen.add(tag);
+        result.push(tag);
       }
-    };
-    this.data = {
-      scope: scope2,
-      gherkin: new nullNode()
-    };
-  }
-};
-var FeatureBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.scenarios = [];
-    this.rules = [];
-    this.steps = [];
-  }
-  accumulateTags() {
-    const scenarioTags = this.scenarios.map((scenario) => scenario.accumulateTags()).flat();
-    const ruleTags = this.rules.map((rule) => rule.accumulateTags()).flat();
-    const allTags = [...this.data.gherkin.tags, ...scenarioTags, ...ruleTags];
-    return [...new Set(allTags)];
-  }
-};
-var BackgroundBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.steps = [];
+    }
   }
-};
-var RuleBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.scenarios = [];
-    this.steps = [];
+  return result;
+}
+function combineSteps(featureSteps, ruleSteps, scenarioSteps) {
+  return [
+    ...featureSteps ?? [],
+    ...ruleSteps ?? [],
+    ...scenarioSteps ?? []
+  ];
+}
+function cloneData(data) {
+  if (!data) {
+    return void 0;
   }
-  accumulateTags() {
-    const scenarioTags = this.scenarios.map((scenario) => scenario.accumulateTags()).flat();
-    const allTags = [...this.data.gherkin.tags, ...scenarioTags];
-    return [...new Set(allTags)];
+  return { ...data };
+}
+function mergeData(base, extra) {
+  if (!base && !extra) {
+    return void 0;
   }
-};
-var ScenarioBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.steps = [];
-    this.report = {};
+  return {
+    ...base ?? {},
+    ...extra ?? {}
+  };
+}
+function createExampleData(group, compiled) {
+  const headers = group.tableHeader ?? [];
+  const rows = group.tableBody ?? [];
+  const row = rows[compiled.exampleIndex];
+  if (!row) {
+    return void 0;
+  }
+  const values = {};
+  headers.forEach((header, index) => {
+    const key = header.trim();
+    if (key.length === 0) {
+      return;
+    }
+    values[key] = row[index] ?? "";
+  });
+  return {
+    example: {
+      group: {
+        id: group.id,
+        name: group.name,
+        tags: [...group.tags]
+      },
+      index: compiled.exampleIndex,
+      values
+    }
+  };
+}
+function normalizeError(error) {
+  if (error instanceof Error) {
+    return error;
   }
-  get title() {
-    return this.data.scope.title(this.data.gherkin);
+  if (typeof error === "string") {
+    return new Error(error);
   }
-  get tags() {
-    return [...this.data.gherkin.tags];
+  return new Error(JSON.stringify(error));
+}
+function groupCompiledScenarios(compiled) {
+  const map = /* @__PURE__ */ new Map();
+  for (const scenario of compiled ?? []) {
+    const list = map.get(scenario.exampleGroupId) ?? [];
+    list.push(scenario);
+    map.set(scenario.exampleGroupId, list);
+  }
+  return map;
+}
+function isRule(element) {
+  return "elements" in element && Array.isArray(element.elements);
+}
+function isScenarioOutline(element) {
+  return "exampleGroups" in element;
+}
+function isScenario(element) {
+  return "steps" in element && !("exampleGroups" in element) && !("elements" in element);
+}
+
+// src/internal/nodes.ts
+function createFeatureNode(init) {
+  return new FeatureNodeImpl(init);
+}
+function createRuleNode(init) {
+  return new RuleNodeImpl(init);
+}
+function createScenarioNode(init) {
+  return new ScenarioNodeImpl(init);
+}
+function createScenarioOutlineNode(init) {
+  return new ScenarioOutlineNodeImpl(init);
+}
+function createScenarioOutlineExample(init) {
+  return new ScenarioOutlineExampleImpl(init);
+}
+var FeatureNodeImpl = class {
+  constructor(init) {
+    this.type = "feature";
+    this.feature = init.feature;
+    this.scope = init.scope;
+    this.executions = init.executions;
+    this.scenarios = init.scenarios;
+    this.scenarioOutlines = init.outlines;
+    this.rules = init.rules;
+    this.name = init.feature.name;
+    this.keyword = normalizeKeyword(init.feature.keyword ?? "Feature");
+    if (init.feature.background) {
+      this.background = init.feature.background;
+    }
   }
-  accumulateTags() {
-    return this.tags;
+  listExecutables() {
+    return this.executions;
   }
 };
-var ExampleBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.steps = [];
-    this.report = {};
-  }
-  get title() {
-    return this.data.scope.title(this.data.gherkin);
-  }
-  get tags() {
-    return [...this.data.gherkin.tags];
-  }
-  accumulateTags() {
-    return this.tags;
+var RuleNodeImpl = class {
+  constructor(init) {
+    this.type = "rule";
+    this.rule = init.rule;
+    this.scope = init.scope;
+    this.qualifiedName = init.qualifiedName;
+    this.name = init.rule.name;
+    this.keyword = normalizeKeyword(init.rule.keyword ?? "Rule");
+    if (init.rule.background) {
+      this.background = init.rule.background;
+    }
+    this.scenarios = init.scenarios;
+    this.scenarioOutlines = init.outlines;
   }
 };
-var ScenarioOutlineBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.examples = [];
-    this.steps = [];
-  }
-  get title() {
-    return this.data.scope.title(this.data.gherkin);
+var ScenarioExecutionBase = class {
+  constructor(type, init) {
+    this.resultState = { status: "pending" };
+    this.type = type;
+    this.id = init.id;
+    this.name = init.name;
+    this.keyword = normalizeKeyword(init.keyword);
+    this.qualifiedName = init.qualifiedName;
+    this.tags = [...init.tags];
+    this.mode = init.mode;
+    this.pending = init.pending;
+    if (init.pendingReason !== void 0) {
+      this.pendingReason = init.pendingReason;
+    }
+    if (init.timeout !== void 0) {
+      this.timeout = init.timeout;
+    }
+    const data = cloneData(init.data);
+    if (data !== void 0) {
+      this.data = data;
+    }
+    this.feature = init.feature;
+    if (init.rule) {
+      this.rule = init.rule;
+    }
+    if (init.outline) {
+      this.outline = init.outline;
+    }
+    this.scope = init.scope;
+    this.summary = init.summary;
+    this.gherkin = init.gherkin;
+    this.gherkinSteps = [...init.gherkinSteps];
+    this.steps = [...init.steps];
+    this.ancestors = [...init.ancestors];
+  }
+  get result() {
+    return this.resultState;
+  }
+  markPassed() {
+    const startedAt = this.resultState.startedAt ?? Date.now();
+    this.resultState = {
+      status: "passed",
+      startedAt,
+      completedAt: Date.now()
+    };
   }
-  get tags() {
-    return [...this.data.gherkin.tags];
+  markFailed(error) {
+    const startedAt = this.resultState.startedAt ?? Date.now();
+    this.resultState = {
+      status: "failed",
+      error: normalizeError(error),
+      startedAt,
+      completedAt: Date.now()
+    };
   }
-  accumulateTags() {
-    const exampleTags = this.examples.map((example) => example.tags).flat();
-    const allTags = [...this.data.gherkin.tags, ...exampleTags];
-    return [...new Set(allTags)];
+  markSkipped(reason) {
+    const timestamp = Date.now();
+    this.resultState = {
+      status: "skipped",
+      startedAt: this.resultState.startedAt ?? timestamp,
+      completedAt: timestamp,
+      ...reason !== void 0 ? { reason } : {}
+    };
   }
-};
-var ExamplesBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.scenarios = [];
-    this.steps = [];
+  markPending(reason) {
+    const timestamp = Date.now();
+    this.resultState = {
+      status: "pending",
+      startedAt: this.resultState.startedAt ?? timestamp,
+      completedAt: timestamp,
+      ...reason !== void 0 ? { reason } : {}
+    };
   }
-  get title() {
-    return this.data.scope.title(this.data.gherkin);
+  reset() {
+    this.resultState = { status: "pending" };
   }
-  get tags() {
-    return [...this.data.gherkin.tags];
+};
+var ScenarioNodeImpl = class extends ScenarioExecutionBase {
+  constructor(init) {
+    super("scenario", init);
   }
-  accumulateTags() {
-    const scenarioTags = this.scenarios.map((scenario) => scenario.accumulateTags()).flat();
-    const allTags = [...this.data.gherkin.tags, ...scenarioTags];
-    return [...new Set(allTags)];
+};
+var ScenarioOutlineExampleImpl = class extends ScenarioExecutionBase {
+  constructor(init) {
+    super("example", init);
+    this.outline = init.outline;
+    this.exampleGroup = init.exampleGroup;
+    this.compiled = init.gherkin;
+    this.exampleIndex = init.exampleIndex;
   }
 };
-var StepBridge = class extends GherkinCodeBridge {
-  get args() {
-    return this.data.args;
+var ScenarioOutlineNodeImpl = class {
+  constructor(init) {
+    this.type = "scenarioOutline";
+    this.outline = init.outline;
+    this.summary = init.summary;
+    this.scope = init.scope;
+    this.keyword = normalizeKeyword(init.keyword);
+    this.name = init.name;
+    this.qualifiedName = init.qualifiedName;
+    this.tags = [...init.tags];
+    this.mode = init.mode;
+    this.pending = init.pending;
+    if (init.pendingReason !== void 0) {
+      this.pendingReason = init.pendingReason;
+    }
+    if (init.timeout !== void 0) {
+      this.timeout = init.timeout;
+    }
+    const data = cloneData(init.data);
+    if (data !== void 0) {
+      this.data = data;
+    }
+    this.ancestors = [...init.ancestors];
+    if (init.rule) {
+      this.rule = init.rule;
+    }
+    this.feature = init.feature;
+    this.mutableExamples = init.examples;
   }
-  get expressionText() {
-    return this.data.scope.expression.source;
+  get examples() {
+    return this.mutableExamples;
   }
 };
 
-// src/bridges/bridge-search.ts
-var import_errors = require("@autometa/errors");
-function find(bridge, testName) {
-  if (bridge instanceof FeatureBridge) {
-    return findByFeature(bridge, testName);
-  }
-  if (bridge instanceof RuleBridge) {
-    return findByRule(bridge, testName);
+// src/internal/summaries.ts
+function bucketScenarioSummaries(summaries) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    const key = createSummaryKey(
+      summary.scenario.kind,
+      summary.scenario.name,
+      summary.rule?.id
+    );
+    const existing = buckets.get(key) ?? [];
+    existing.push(summary);
+    buckets.set(key, existing);
   }
-  if (bridge instanceof ScenarioOutlineBridge) {
-    return findScenarioOutlineOrChild(bridge, testName);
+  return buckets;
+}
+function createSummaryKey(kind, scenarioName, parentScopeId) {
+  return [
+    kind,
+    normalizeName(scenarioName),
+    parentScopeId ?? "root"
+  ].join("::");
+}
+function describeSummary(summary) {
+  const parts = [summary.scenario.name];
+  if (summary.rule) {
+    parts.push(`in rule '${summary.rule.name}'`);
   }
-  throw new import_errors.AutomationError(`Could not find test matching ${testName}`);
+  return `${summary.scenario.kind} '${parts.join(" ")}'`;
 }
-function findByFeature(feature, testName) {
-  const title = feature.data.scope.title(feature.data.gherkin);
-  const byScenario = findTestTypes(feature.scenarios, testName, title);
-  if (byScenario) {
-    return byScenario;
+
+// src/internal/scope-resolution.ts
+function resolveFeatureScope(adapter, feature) {
+  const normalizedName = normalizeName(feature.name);
+  const featureUri = feature.uri ? normalizeUri(feature.uri) : void 0;
+  const matches = adapter.features.filter((scope) => {
+    if (scope.kind !== "feature") {
+      return false;
+    }
+    const scopeName = normalizeName(scope.name);
+    if (scopeName !== normalizedName) {
+      return false;
+    }
+    if (!featureUri) {
+      return true;
+    }
+    const scopeFile = typeof scope.data?.file === "string" ? normalizeUri(scope.data.file) : void 0;
+    return scopeFile ? scopeFile === featureUri : true;
+  });
+  if (matches.length === 1) {
+    const [match] = matches;
+    if (!match) {
+      throw new Error("Unexpected empty feature scope match");
+    }
+    return match;
   }
-  const byRule = findRuleTypes(feature.rules, testName, title);
-  if (byRule) {
-    return byRule;
+  if (matches.length === 0) {
+    throw new Error(
+      `No feature scope registered for feature '${feature.name}'. Provide featureScope explicitly to resolve the association.`
+    );
   }
+  throw new Error(
+    `Multiple feature scopes match feature '${feature.name}'. Provide featureScope explicitly to disambiguate.`
+  );
 }
-function findByRule(rule, testName) {
-  const title = rule.data.scope.title(rule.data.gherkin);
-  const byScenario = findTestTypes(rule.scenarios, testName, title);
-  if (byScenario) {
-    return byScenario;
+function findChildScope(parent, kind, name) {
+  const normalizedName = normalizeName(name);
+  const matches = parent.children.filter(
+    (child) => child.kind === kind && normalizeName(child.name) === normalizedName
+  );
+  if (matches.length === 1) {
+    const [match] = matches;
+    if (!match) {
+      throw new Error("Unexpected empty child scope match");
+    }
+    return match;
   }
-  const byRule = findRuleOrChild(rule, testName, title);
-  if (byRule) {
-    return byRule;
+  if (matches.length === 0) {
+    throw new Error(
+      `Could not find ${kind} scope named '${name}' beneath '${parent.name}'`
+    );
   }
+  throw new Error(
+    `Multiple ${kind} scopes named '${name}' were found beneath '${parent.name}'. Names must be unique within the same parent scope.`
+  );
 }
-function findTestTypes(scenarios, testName, from) {
-  for (const scenario of scenarios) {
-    if (scenario instanceof ScenarioOutlineBridge) {
-      const found = findScenarioOutlineOrChild(scenario, testName, from);
-      if (found) {
-        return found;
+
+// src/internal/test-plan-builder.ts
+var FEATURE_SEGMENT_KEY = "feature";
+var RULE_SEGMENT_KEY = "rule";
+var EXAMPLE_SEGMENT_KEY = "Example";
+var _TestPlanBuilder = class _TestPlanBuilder {
+  constructor(feature, featureScope, adapter) {
+    this.feature = feature;
+    this.featureScope = featureScope;
+    this.adapter = adapter;
+    this.executions = [];
+    this.byId = /* @__PURE__ */ new Map();
+    this.byQualifiedName = /* @__PURE__ */ new Map();
+    this.featureScenarios = [];
+    this.featureScenarioOutlines = [];
+    this.featureRules = [];
+    this.ruleScenarioMap = /* @__PURE__ */ new Map();
+    this.ruleOutlineMap = /* @__PURE__ */ new Map();
+    this.outlineExamplesMap = /* @__PURE__ */ new Map();
+    const summaries = adapter.listScenarios().filter((summary) => summary.feature.id === featureScope.id);
+    this.summaryBuckets = bucketScenarioSummaries(summaries);
+    this.featureSegment = {
+      keyword: normalizeKeyword(feature.keyword ?? FEATURE_SEGMENT_KEY),
+      name: feature.name,
+      suffix: buildScopeSuffix(featureScope.id)
+    };
+    this.parameterRegistry = resolveParameterRegistry(adapter.getParameterRegistry?.());
+    createDefaultParameterTypes()(this.parameterRegistry);
+  }
+  build() {
+    this.featureNode = createFeatureNode({
+      feature: this.feature,
+      scope: this.featureScope,
+      executions: this.executions,
+      scenarios: this.featureScenarios,
+      outlines: this.featureScenarioOutlines,
+      rules: this.featureRules
+    });
+    for (const element of this.feature.elements ?? []) {
+      if (isRule(element)) {
+        this.processRule(element);
+      } else if (isScenarioOutline(element)) {
+        this.processScenarioOutline(element, void 0);
+      } else if (isScenario(element)) {
+        this.processScenario(element, void 0);
       }
     }
-    if (scenario instanceof ExamplesBridge) {
-      const found = findExamplesOrChild(scenario, testName, from);
-      if (found) {
-        return found;
+    this.ensureAllSummariesConsumed();
+    return new TestPlanImpl(
+      this.featureNode,
+      this.executions,
+      this.byId,
+      this.byQualifiedName
+    );
+  }
+  processRule(rule) {
+    const ruleScope = findChildScope(this.featureScope, "rule", rule.name);
+    const qualifiedName = buildQualifiedName([
+      this.featureSegment,
+      {
+        keyword: normalizeKeyword(rule.keyword ?? RULE_SEGMENT_KEY),
+        name: rule.name,
+        suffix: buildScopeSuffix(ruleScope.id)
       }
-    }
-    if (scenario instanceof ScenarioBridge) {
-      const found = findScenario(scenario, testName, from);
-      if (found) {
-        return found;
+    ]);
+    const ruleScenarios = [];
+    const ruleOutlines = [];
+    const ruleNode = createRuleNode({
+      rule,
+      scope: ruleScope,
+      qualifiedName,
+      scenarios: ruleScenarios,
+      outlines: ruleOutlines
+    });
+    this.ruleScenarioMap.set(ruleNode, ruleScenarios);
+    this.ruleOutlineMap.set(ruleNode, ruleOutlines);
+    this.featureRules.push(ruleNode);
+    for (const element of rule.elements ?? []) {
+      if (isScenarioOutline(element)) {
+        this.processScenarioOutline(element, ruleNode);
+      } else if (isScenario(element)) {
+        this.processScenario(element, ruleNode);
       }
     }
   }
-}
-function findRuleTypes(rules, testName, from) {
-  for (const rule of rules) {
-    const found = findRuleOrChild(rule, testName, from);
-    if (found) {
-      return found;
+  processScenario(gherkinScenario, ruleNode) {
+    const ruleScope = ruleNode?.scope;
+    const summary = this.consumeSummary(
+      "scenario",
+      gherkinScenario.name,
+      ruleScope
+    );
+    if (summary.scenario.kind !== "scenario") {
+      throw new Error(
+        `Scope mismatch: expected scenario kind 'scenario' but received '${summary.scenario.kind}' for '${gherkinScenario.name}'`
+      );
+    }
+    const qualifiedName = buildQualifiedName([
+      this.featureSegment,
+      ...ruleNode ? [
+        {
+          keyword: normalizeKeyword(ruleNode.keyword),
+          name: ruleNode.name,
+          suffix: buildScopeSuffix(ruleNode.scope.id)
+        }
+      ] : [],
+      {
+        keyword: normalizeKeyword(gherkinScenario.keyword ?? "Scenario"),
+        name: gherkinScenario.name,
+        suffix: buildScopeSuffix(summary.scenario.id)
+      }
+    ]);
+    const gherkinSteps = combineSteps(
+      this.feature.background?.steps,
+      ruleNode?.background?.steps,
+      gherkinScenario.steps
+    );
+    const resolvedSteps = this.resolveStepDefinitions(summary, gherkinSteps, {
+      scenario: gherkinScenario.name,
+      ...ruleNode ? { rule: ruleNode.name } : {}
+    });
+    const scenarioData = cloneData(summary.scenario.data);
+    const scenarioNode = createScenarioNode({
+      id: summary.id,
+      feature: this.featureNode,
+      name: gherkinScenario.name,
+      keyword: gherkinScenario.keyword ?? "Scenario",
+      qualifiedName,
+      tags: collectTags(
+        this.feature.tags,
+        ruleNode?.rule.tags,
+        gherkinScenario.tags,
+        summary.feature.tags,
+        summary.scenario.tags
+      ),
+      mode: summary.scenario.mode,
+      pending: summary.scenario.pending,
+      ...summary.scenario.pendingReason ? { pendingReason: summary.scenario.pendingReason } : {},
+      scope: summary.scenario,
+      summary,
+      gherkin: gherkinScenario,
+      gherkinSteps,
+      steps: resolvedSteps,
+      ancestors: summary.ancestors,
+      ...ruleNode ? { rule: ruleNode } : {},
+      ...summary.scenario.timeout !== void 0 ? { timeout: summary.scenario.timeout } : {},
+      ...scenarioData ? { data: scenarioData } : {}
+    });
+    if (ruleNode) {
+      this.getRuleScenarios(ruleNode).push(scenarioNode);
+    } else {
+      this.featureScenarios.push(scenarioNode);
+    }
+    this.registerExecution(scenarioNode);
+  }
+  processScenarioOutline(outline, ruleNode) {
+    const ruleScope = ruleNode?.scope;
+    const summary = this.consumeSummary(
+      "scenarioOutline",
+      outline.name,
+      ruleScope
+    );
+    if (summary.scenario.kind !== "scenarioOutline") {
+      throw new Error(
+        `Scope mismatch: expected scenario kind 'scenarioOutline' but received '${summary.scenario.kind}' for '${outline.name}'`
+      );
+    }
+    const outlineQualifiedName = buildQualifiedName([
+      this.featureSegment,
+      ...ruleNode ? [
+        {
+          keyword: normalizeKeyword(ruleNode.keyword),
+          name: ruleNode.name,
+          suffix: buildScopeSuffix(ruleNode.scope.id)
+        }
+      ] : [],
+      {
+        keyword: normalizeKeyword(outline.keyword ?? "Scenario Outline"),
+        name: outline.name,
+        suffix: buildScopeSuffix(summary.scenario.id)
+      }
+    ]);
+    const outlineData = cloneData(summary.scenario.data);
+    const outlineExamples = [];
+    const outlineNode = createScenarioOutlineNode({
+      outline,
+      summary,
+      scope: summary.scenario,
+      keyword: outline.keyword ?? "Scenario Outline",
+      name: outline.name,
+      qualifiedName: outlineQualifiedName,
+      tags: collectTags(
+        this.feature.tags,
+        ruleNode?.rule.tags,
+        outline.tags,
+        summary.feature.tags,
+        summary.scenario.tags
+      ),
+      mode: summary.scenario.mode,
+      pending: summary.scenario.pending,
+      ...summary.scenario.pendingReason ? { pendingReason: summary.scenario.pendingReason } : {},
+      ancestors: summary.ancestors,
+      feature: this.featureNode,
+      ...summary.scenario.timeout !== void 0 ? { timeout: summary.scenario.timeout } : {},
+      ...outlineData ? { data: outlineData } : {},
+      ...ruleNode ? { rule: ruleNode } : {},
+      examples: outlineExamples
+    });
+    this.outlineExamplesMap.set(outlineNode, outlineExamples);
+    if (ruleNode) {
+      this.getRuleOutlines(ruleNode).push(outlineNode);
+    } else {
+      this.featureScenarioOutlines.push(outlineNode);
+    }
+    const compiledByGroup = groupCompiledScenarios(outline.compiledScenarios);
+    for (const group of outline.exampleGroups ?? []) {
+      const compiledForGroup = compiledByGroup.get(group.id) ?? [];
+      compiledForGroup.sort((a, b) => a.exampleIndex - b.exampleIndex);
+      for (const compiled of compiledForGroup) {
+        const qualifiedName = buildQualifiedName([
+          this.featureSegment,
+          ...ruleNode ? [
+            {
+              keyword: normalizeKeyword(ruleNode.keyword),
+              name: ruleNode.name,
+              suffix: buildScopeSuffix(ruleNode.scope.id)
+            }
+          ] : [],
+          {
+            keyword: normalizeKeyword(outline.keyword ?? "Scenario Outline"),
+            name: outline.name,
+            suffix: buildScopeSuffix(summary.scenario.id)
+          },
+          {
+            keyword: EXAMPLE_SEGMENT_KEY,
+            name: compiled.name,
+            suffix: buildExampleSuffix(compiled.id, compiled.exampleIndex)
+          }
+        ]);
+        const gherkinSteps = combineSteps(
+          this.feature.background?.steps,
+          ruleNode?.background?.steps,
+          compiled.steps
+        );
+        const resolvedSteps = this.resolveStepDefinitions(summary, gherkinSteps, {
+          scenario: compiled.name,
+          outline: outline.name,
+          ...ruleNode ? { rule: ruleNode.name } : {}
+        });
+        const exampleData = mergeData(
+          cloneData(summary.scenario.data),
+          createExampleData(group, compiled)
+        );
+        const exampleExecution = createScenarioOutlineExample({
+          id: compiled.id,
+          feature: this.featureNode,
+          outline: outlineNode,
+          name: compiled.name,
+          keyword: compiled.keyword ?? outline.keyword ?? "Scenario Outline",
+          qualifiedName,
+          tags: collectTags(
+            this.feature.tags,
+            ruleNode?.rule.tags,
+            outline.tags,
+            group.tags,
+            compiled.tags,
+            summary.feature.tags,
+            summary.scenario.tags
+          ),
+          mode: summary.scenario.mode,
+          pending: summary.scenario.pending,
+          ...summary.scenario.pendingReason ? { pendingReason: summary.scenario.pendingReason } : {},
+          scope: summary.scenario,
+          summary,
+          gherkin: compiled,
+          gherkinSteps,
+          steps: resolvedSteps,
+          ancestors: summary.ancestors,
+          exampleGroup: group,
+          exampleIndex: compiled.exampleIndex,
+          ...ruleNode ? { rule: ruleNode } : {},
+          ...summary.scenario.timeout !== void 0 ? { timeout: summary.scenario.timeout } : {},
+          ...exampleData ? { data: exampleData } : {}
+        });
+        this.getOutlineExamples(outlineNode).push(exampleExecution);
+        this.registerExecution(exampleExecution);
+      }
     }
   }
-}
-function findRuleOrChild(rule, testName, from) {
-  const {
-    data: { scope: scope2, gherkin }
-  } = rule;
-  const title = scope2.title(gherkin);
-  if (testName === title) {
-    return rule;
+  consumeSummary(kind, scenarioName, parentScope) {
+    const key = createSummaryKey(kind, scenarioName, parentScope?.id);
+    const bucket = this.summaryBuckets.get(key);
+    if (!bucket || bucket.length === 0) {
+      throw new Error(
+        `Could not find a registered ${kind} scope for '${scenarioName}'${parentScope ? ` within '${parentScope.name}'` : ""}`
+      );
+    }
+    const summary = bucket.shift();
+    if (bucket.length === 0) {
+      this.summaryBuckets.delete(key);
+    }
+    return summary;
   }
-  if (from) {
-    const fullTitle = `${from} ${title}`;
-    if (fullTitle === testName) {
-      return rule;
+  registerExecution(execution) {
+    if (this.byId.has(execution.id)) {
+      throw new Error(
+        `Duplicate scenario identifier detected: '${execution.id}' for '${execution.qualifiedName}'`
+      );
+    }
+    if (this.byQualifiedName.has(execution.qualifiedName)) {
+      throw new Error(
+        `Duplicate qualified scenario name detected: '${execution.qualifiedName}'`
+      );
+    }
+    this.executions.push(execution);
+    this.byId.set(execution.id, execution);
+    this.byQualifiedName.set(execution.qualifiedName, execution);
+  }
+  ensureAllSummariesConsumed() {
+    const leftovers = [];
+    for (const bucket of this.summaryBuckets.values()) {
+      for (const summary of bucket) {
+        leftovers.push(describeSummary(summary));
+      }
+    }
+    if (leftovers.length > 0) {
+      throw new Error(
+        `The following scope scenarios were not matched to Gherkin nodes for feature '${this.feature.name}': ${leftovers.join(", ")}`
+      );
     }
   }
-  const newFrom = appendPath(from, title);
-  return findTestTypes(rule.scenarios, testName, newFrom);
-}
-function findScenarioOutlineOrChild(outline, testName, from) {
-  const {
-    data: { scope: scope2, gherkin }
-  } = outline;
-  const title = scope2.title(gherkin);
-  if (testName === title) {
-    return outline;
+  getRuleScenarios(rule) {
+    const list = this.ruleScenarioMap.get(rule);
+    if (!list) {
+      throw new Error(`Rule '${rule.name}' has no associated scenario registry`);
+    }
+    return list;
   }
-  if (from) {
-    const fullTitle = `${from} ${title}`;
-    if (fullTitle === testName) {
-      return outline;
+  getRuleOutlines(rule) {
+    const list = this.ruleOutlineMap.get(rule);
+    if (!list) {
+      throw new Error(`Rule '${rule.name}' has no associated scenario outline registry`);
     }
+    return list;
   }
-  for (const example of outline.examples) {
-    const newFrom = appendPath(from, title);
-    const found = findExamplesOrChild(example, testName, newFrom);
-    if (found) {
-      return found;
+  getOutlineExamples(outline) {
+    const list = this.outlineExamplesMap.get(outline);
+    if (!list) {
+      throw new Error(
+        `Scenario outline '${outline.name}' has no associated example registry`
+      );
     }
+    return list;
   }
-}
-function appendPath(from, title) {
-  return from ? `${from} ${title}` : title;
-}
-function findExamplesOrChild(example, testName, from) {
-  const {
-    data: { gherkin }
-  } = example;
-  const title = `${gherkin.keyword}: ${gherkin.name}`;
-  if (testName === title) {
-    return example;
+  resolveStepDefinitions(summary, gherkinSteps, context) {
+    if (summary.steps.length === 0) {
+      if (gherkinSteps.length === 0) {
+        return [];
+      }
+      return gherkinSteps.map(
+        (step, index) => this.createMissingStepDefinition(summary, context, step, index)
+      );
+    }
+    const remaining = new Set(summary.steps);
+    const ordered = [];
+    const matchers = /* @__PURE__ */ new Map();
+    let encounteredMissing = false;
+    for (const step of gherkinSteps) {
+      const matched = this.findMatchingStepDefinition(
+        step,
+        summary.steps,
+        remaining,
+        matchers
+      );
+      if (!matched) {
+        ordered.push(
+          this.createMissingStepDefinition(
+            summary,
+            context,
+            step,
+            ordered.length
+          )
+        );
+        encounteredMissing = true;
+        continue;
+      }
+      ordered.push(matched);
+      remaining.delete(matched);
+    }
+    if (encounteredMissing) {
+      return ordered;
+    }
+    return ordered;
+  }
+  findMatchingStepDefinition(step, definitions, remaining, matchers) {
+    const rawKeyword = normalizeKeyword(step.keyword ?? "");
+    const wildcard = isFlexibleKeyword(rawKeyword);
+    const keyword = wildcard ? void 0 : normalizeGherkinStepKeyword(rawKeyword);
+    const candidates = definitions.filter((definition) => {
+      if (!remaining.has(definition)) {
+        return false;
+      }
+      if (wildcard) {
+        return true;
+      }
+      return keyword ? definition.keyword === keyword : false;
+    });
+    for (const definition of candidates) {
+      if (this.matchesStepExpression(definition, step.text, matchers)) {
+        return definition;
+      }
+    }
+    return void 0;
   }
-  if (from) {
-    const fullTitle = `${from} ${title}`;
-    if (fullTitle === testName) {
-      return example;
+  matchesStepExpression(definition, text, matchers) {
+    let matcher = matchers.get(definition);
+    if (!matcher) {
+      matcher = this.createMatcher(definition.expression);
+      matchers.set(definition, matcher);
     }
+    return matcher(text);
   }
-  for (const scenario of example.scenarios) {
-    const newFrom = appendPath(from, title);
-    const found = findScenario(scenario, testName, newFrom);
-    if (found) {
-      return found;
+  createMatcher(expression) {
+    if (expression instanceof RegExp) {
+      const regex = new RegExp(expression.source, expression.flags);
+      const evaluator = new RegularExpression(regex, this.parameterRegistry);
+      return (text) => evaluator.match(text) !== null;
+    }
+    try {
+      const cucumberExpression = new CucumberExpression(
+        expression,
+        this.parameterRegistry
+      );
+      return (text) => cucumberExpression.match(text) !== null;
+    } catch {
+      const literal = expression;
+      return (text) => text === literal;
     }
   }
-}
-function findScenario(scenario, testName, from) {
-  const {
-    data: { scope: scope2, gherkin }
-  } = scenario;
-  const title = scope2.title(gherkin);
-  if (testName === title) {
-    return scenario;
+  buildMissingStepDefinitionMessage(context, step, definitions) {
+    const keyword = (step.keyword ?? "").trim();
+    const display = keyword.length > 0 ? `${keyword} ${step.text}` : step.text;
+    const lines = [
+      "No step definition matched:",
+      "",
+      `'${display}'`,
+      "",
+      this.buildMissingStepContextLine(context)
+    ];
+    const suggestions = this.resolveClosestStepDefinitionSuggestions(step, definitions);
+    if (suggestions.sameType.length === 0 && suggestions.differentType.length === 0) {
+      return lines.join("\n");
+    }
+    lines.push("", "Some close matches were found:");
+    if (suggestions.sameType.length > 0) {
+      lines.push("  Close matches with the same step type:");
+      for (const suggestion of suggestions.sameType) {
+        lines.push(`  - ${suggestion}`);
+      }
+    }
+    if (suggestions.differentType.length > 0) {
+      lines.push("  Close matches with different step type:");
+      for (const suggestion of suggestions.differentType) {
+        lines.push(`  - ${suggestion}`);
+      }
+    }
+    return lines.join("\n");
   }
-  if (from) {
-    const fullTitle = `${from} ${title}`;
-    if (fullTitle === testName) {
-      return scenario;
+  buildMissingStepContextLine(context) {
+    const parts = [`in scenario '${context.scenario}'`];
+    if (context.outline) {
+      parts.push(`of outline '${context.outline}'`);
+    }
+    if (context.rule) {
+      parts.push(`within rule '${context.rule}'`);
     }
+    parts.push(`for feature '${this.feature.name}'.`);
+    return parts.join(" ");
+  }
+  buildUnusedStepDefinitionsMessage(context, extras) {
+    const segments = [
+      `The following step definitions were not matched to Gherkin steps in scenario '${context.scenario}'`
+    ];
+    if (context.outline) {
+      segments.push(`of outline '${context.outline}'`);
+    }
+    if (context.rule) {
+      segments.push(`within rule '${context.rule}'`);
+    }
+    segments.push(`for feature '${this.feature.name}': ${extras.join(", ")}`);
+    return segments.join(" ");
   }
-}
-
-// src/bridges/bridge-query.ts
-var import_gherkin2 = require("@autometa/gherkin");
-function failed(bridge) {
-  const accumulator = [];
-  if (bridge instanceof ScenarioOutlineBridge) {
-    return failedOutline(bridge);
-  }
-  for (const scenario of bridge.scenarios) {
-    if (scenario instanceof ScenarioOutlineBridge) {
-      accumulator.push(...failedOutline(scenario));
-    } else if (scenario.report.error !== void 0) {
-      accumulator.push(scenario);
-    }
-  }
-  if (bridge instanceof FeatureBridge) {
-    accumulator.push(...failedRule(bridge));
-  }
-  return accumulator;
-}
-function failedOutline(bridge) {
-  const accumulator = [];
-  for (const example of bridge.examples) {
-    for (const scenario of example.scenarios) {
-      if (scenario.report.error) {
-        accumulator.push(scenario);
-      }
+  describeStepDefinition(definition) {
+    return `${definition.keyword} ${formatExpression(definition.expression)}`;
+  }
+  createMissingStepDefinition(summary, context, step, index) {
+    const message = this.buildMissingStepDefinitionMessage(
+      context,
+      step,
+      summary.steps
+    );
+    return {
+      id: `${summary.id}:missing-step:${index}`,
+      keyword: this.resolveStepKeyword(step),
+      expression: step.text,
+      handler: () => {
+        throw new Error(message);
+      },
+      options: this.createFallbackStepOptions(summary.scenario.mode)
+    };
+  }
+  resolveStepKeyword(step) {
+    const raw = normalizeKeyword(step.keyword ?? "");
+    if (isFlexibleKeyword(raw)) {
+      return "And";
+    }
+    try {
+      return normalizeGherkinStepKeyword(raw);
+    } catch {
+      return "Given";
     }
   }
-  return accumulator;
-}
-function failedRule(bridge) {
-  const accumulator = [];
-  for (const rule of bridge.rules) {
-    for (const scenario of rule.scenarios) {
-      if (scenario instanceof ScenarioOutlineBridge) {
-        accumulator.push(...failedOutline(scenario));
-      } else if (scenario.report.error) {
-        accumulator.push(scenario);
+  createFallbackStepOptions(mode) {
+    return {
+      tags: [],
+      mode
+    };
+  }
+  resolveClosestStepDefinitionSuggestions(step, definitions) {
+    if (definitions.length === 0) {
+      return { sameType: [], differentType: [] };
+    }
+    const desiredKeyword = this.tryNormalizeKeyword(step.keyword);
+    const target = this.normalizeForDistance(step.text);
+    const candidates = definitions.map((definition) => {
+      const candidateText = this.normalizeForDistance(
+        formatExpression(definition.expression)
+      );
+      const distance = this.computeEditDistance(target, candidateText);
+      const similarity = this.computeSimilarity(target, candidateText, distance);
+      return {
+        definition,
+        description: this.describeStepDefinition(definition),
+        distance,
+        similarity
+      };
+    });
+    candidates.sort((a, b) => a.distance - b.distance);
+    const sameType = [];
+    const differentType = [];
+    for (const candidate of candidates) {
+      const isSameType = !desiredKeyword || candidate.definition.keyword === desiredKeyword;
+      if (isSameType) {
+        if (candidate.similarity < _TestPlanBuilder.SUGGESTION_MIN_SIMILARITY_SAME_TYPE) {
+          continue;
+        }
+        if (sameType.length < _TestPlanBuilder.SUGGESTION_LIMIT_PER_GROUP) {
+          sameType.push(candidate.description);
+        }
+        continue;
+      }
+      if (candidate.similarity < _TestPlanBuilder.SUGGESTION_MIN_SIMILARITY_DIFFERENT_TYPE) {
+        continue;
+      }
+      if (differentType.length < _TestPlanBuilder.SUGGESTION_LIMIT_PER_GROUP) {
+        differentType.push(candidate.description);
+      }
+      if (sameType.length >= _TestPlanBuilder.SUGGESTION_LIMIT_PER_GROUP && differentType.length >= _TestPlanBuilder.SUGGESTION_LIMIT_PER_GROUP) {
+        break;
       }
     }
+    return { sameType, differentType };
   }
-  return accumulator;
-}
-function gherkinToTestNames(node, path = "", accumulator = []) {
-  if (!("name" in node) || node instanceof import_gherkin2.Background) {
-    return;
+  normalizeForDistance(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
   }
-  const title = `${node.keyword}: ${node.name}`;
-  const fullPath = path ? `${path} ${title}` : title;
-  accumulator.push(fullPath);
-  if (!node.children) {
-    return;
+  computeSimilarity(a, b, distance) {
+    const maxLen = Math.max(a.length, b.length);
+    if (maxLen === 0) {
+      return 1;
+    }
+    const normalized = 1 - distance / maxLen;
+    return Math.max(0, Math.min(1, normalized));
   }
-  for (const child of node.children) {
-    if (!("name" in child) || child instanceof import_gherkin2.Background) {
-      continue;
+  computeEditDistance(a, b) {
+    if (a === b) {
+      return 0;
+    }
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const matrix = Array.from({ length: rows }, () => Array(cols).fill(0));
+    for (let i = 0; i < rows; i++) {
+      const row = matrix[i];
+      if (!row) {
+        throw new Error("Internal error: matrix row missing");
+      }
+      row[0] = i;
+    }
+    const row0 = matrix[0];
+    if (!row0) {
+      throw new Error("Internal error: matrix[0] missing");
+    }
+    for (let j = 0; j < cols; j++) {
+      row0[j] = j;
+    }
+    for (let i = 1; i < rows; i++) {
+      const row = matrix[i];
+      const prevRow = matrix[i - 1];
+      if (!row || !prevRow) {
+        throw new Error("Internal error: matrix row missing");
+      }
+      for (let j = 1; j < cols; j++) {
+        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+        const deletion = (prevRow[j] ?? 0) + 1;
+        const insertion = (row[j - 1] ?? 0) + 1;
+        const substitution = (prevRow[j - 1] ?? 0) + cost;
+        row[j] = Math.min(deletion, insertion, substitution);
+      }
+    }
+    const lastRow = matrix[rows - 1];
+    if (!lastRow) {
+      throw new Error("Internal error: last matrix row missing");
+    }
+    const result = lastRow[cols - 1];
+    if (result === void 0) {
+      throw new Error("Internal error: matrix result missing");
     }
-    gherkinToTestNames(child, fullPath, accumulator);
+    return result;
   }
-  return accumulator;
-}
-var Query = {
-  find: {
-    failed
-  },
-  testNames: gherkinToTestNames
-};
-
-// src/gherkin-walker.ts
-var import_gherkin3 = require("@autometa/gherkin");
-var import_errors2 = require("@autometa/errors");
-var import_gherkin4 = require("@autometa/gherkin");
-var _walkNode, walkNode_fn, _walkChildren, walkChildren_fn;
-var GherkinWalker = class {
-  static walk(walkFunction, childNode, accumulator, parentNode) {
-    if (accumulator === void 0) {
-      throw new import_errors2.AutomationError(
-        `An accumulator must be defined to continue the walker from ${childNode.constructor.name}${JSON.stringify(childNode)}`
-      );
+  tryNormalizeKeyword(keyword) {
+    if (!keyword) {
+      return void 0;
+    }
+    const raw = normalizeKeyword(keyword);
+    if (isFlexibleKeyword(raw)) {
+      return void 0;
+    }
+    try {
+      return normalizeGherkinStepKeyword(raw);
+    } catch {
+      return void 0;
     }
-    __privateMethod(this, _walkNode, walkNode_fn).call(this, childNode, accumulator, walkFunction, parentNode);
-    return accumulator;
   }
 };
-_walkNode = new WeakSet();
-walkNode_fn = function(child, accumulator, walkFunction, lastNode) {
-  if (child instanceof import_gherkin3.Feature && walkFunction.onFeature) {
-    const acc = walkFunction.onFeature(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof import_gherkin3.Rule && walkFunction.onRule) {
-    const acc = walkFunction.onRule(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof import_gherkin3.Examples) {
-    const acc = walkFunction.onExamples?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof import_gherkin4.Example) {
-    const acc = walkFunction.onExample?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof import_gherkin3.Scenario) {
-    const acc = walkFunction.onScenario?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof import_gherkin3.ScenarioOutline) {
-    const acc = walkFunction.onScenarioOutline?.(
-      child,
-      accumulator,
-      lastNode
-    );
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+_TestPlanBuilder.SUGGESTION_LIMIT_PER_GROUP = 3;
+/**
+ * Similarity threshold in [0, 1].
+ * 1.0 = identical, 0.0 = completely different.
+ */
+_TestPlanBuilder.SUGGESTION_MIN_SIMILARITY_SAME_TYPE = 0.6;
+_TestPlanBuilder.SUGGESTION_MIN_SIMILARITY_DIFFERENT_TYPE = 0.85;
+var TestPlanBuilder = _TestPlanBuilder;
+var TestPlanImpl = class {
+  constructor(feature, executions, byId, byQualifiedName) {
+    this.feature = feature;
+    this.executions = executions;
+    this.byId = byId;
+    this.byQualifiedName = byQualifiedName;
+  }
+  listExecutables() {
+    return this.executions;
   }
-  if (child instanceof import_gherkin3.Background) {
-    const acc = walkFunction?.onBackground?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  listFailed() {
+    return this.executions.filter((execution) => execution.result.status === "failed");
   }
-  if (child instanceof import_gherkin3.Step) {
-    const acc = walkFunction.onStep?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  findById(id) {
+    return this.byId.get(id);
+  }
+  findByQualifiedName(name) {
+    return this.byQualifiedName.get(name);
   }
 };
-_walkChildren = new WeakSet();
-walkChildren_fn = function(child, accumulator, walkFunction) {
-  for (const node of child.children) {
-    this.walk(walkFunction, node, accumulator, child);
+function resolveParameterRegistry(parameterRegistry) {
+  if (!parameterRegistry) {
+    return new ParameterTypeRegistry();
+  }
+  if (isParameterTypeRegistry(parameterRegistry)) {
+    return parameterRegistry;
+  }
+  const candidate = parameterRegistry.registry;
+  if (isParameterTypeRegistry(candidate)) {
+    return candidate;
+  }
+  return new ParameterTypeRegistry();
+}
+function isParameterTypeRegistry(value) {
+  if (!value || typeof value !== "object") {
+    return false;
   }
+  if (value instanceof ParameterTypeRegistry) {
+    return true;
+  }
+  const registry = value;
+  return typeof registry.lookupByTypeName === "function" && typeof registry.defineParameterType === "function";
+}
+function normalizeGherkinStepKeyword(keyword) {
+  const trimmed = normalizeKeyword(keyword).replace(/:$/, "");
+  const mapped = STEP_KEYWORD_MAP[trimmed.toLowerCase()];
+  if (!mapped) {
+    throw new Error(`Unsupported Gherkin step keyword '${keyword}'`);
+  }
+  return mapped;
+}
+function isFlexibleKeyword(keyword) {
+  const normalized = normalizeKeyword(keyword).replace(/:$/, "").toLowerCase();
+  return FLEXIBLE_KEYWORDS.has(normalized);
+}
+function formatExpression(expression) {
+  return typeof expression === "string" ? expression : expression.toString();
+}
+var STEP_KEYWORD_MAP = {
+  given: "Given",
+  when: "When",
+  then: "Then",
+  and: "And",
+  but: "But"
 };
-__privateAdd(GherkinWalker, _walkNode);
-__privateAdd(GherkinWalker, _walkChildren);
+var FLEXIBLE_KEYWORDS = /* @__PURE__ */ new Set(["and", "but", "*"]);
 
-// src/scope-search.ts
-var import_errors3 = require("@autometa/errors");
-var import_scopes = require("@autometa/scopes");
-var import_scopes2 = require("@autometa/scopes");
-function scope(value) {
-  return {
-    findRule: (name) => {
-      const found = value.closedScopes.find((child) => {
-        return child instanceof import_scopes.RuleScope && child.name === name;
-      });
-      if (!found) {
-        const rule = new import_scopes.RuleScope(
-          name,
-          import_scopes2.Empty_Function,
-          void 0,
-          value.hooks,
-          value.steps
-        );
-        value.attach(rule);
-        return rule;
-      }
-      return found;
-    },
-    findScenario: (name) => {
-      const found = value.closedScopes.find((child) => {
-        return child instanceof import_scopes.ScenarioScope && child.name === name && !(child instanceof import_scopes.ScenarioOutlineScope);
-      });
-      if (!found) {
-        const scenario = new import_scopes.ScenarioScope(
-          name,
-          import_scopes2.Empty_Function,
-          void 0,
-          value.hooks,
-          value.steps
-        );
-        value.attach(scenario);
-        return scenario;
-      }
-      return found;
-    },
-    findBackground: ({ name }) => {
-      const found = value.closedScopes.find((child) => {
-        return child instanceof import_scopes.BackgroundScope;
-      });
-      if (found && found.name !== name) {
-        throw new import_errors3.AutomationError(
-          `Could not find background matching ${name} but found ${found?.name}`
-        );
-      }
-      if (found) {
-        return found;
-      }
-      const bgScope = new import_scopes.BackgroundScope(
-        name,
-        import_scopes2.Empty_Function,
-        value.hooks,
-        value.steps
-      );
-      value.attach(bgScope);
-      return bgScope;
-    },
-    findScenarioOutline: (name) => {
-      const found = value.closedScopes.find((child) => {
-        return child instanceof import_scopes.ScenarioOutlineScope && child.name === name;
-      });
-      if (!found) {
-        const scenarioOutline = new import_scopes.ScenarioOutlineScope(
-          name,
-          import_scopes2.Empty_Function,
-          void 0,
-          value.hooks,
-          value.steps
-        );
-        value.attach(scenarioOutline);
-        return scenarioOutline;
-      }
-      return found;
-    },
-    findExample(name) {
-      const found = value.closedScopes.find((child) => {
-        if (!(child instanceof import_scopes.ScenarioScope)) {
-          return false;
-        }
-        return child.name === name;
-      });
-      if (!found) {
-        const scenario = new import_scopes.ScenarioScope(
-          name,
-          import_scopes2.Empty_Function,
-          void 0,
-          value.hooks,
-          value.steps
-        );
-        value.attach(scenario);
-        return scenario;
-      }
-      return found;
-    },
-    findStep: (keywordType, keyword, name) => {
-      return value.steps.find(keywordType, keyword, name);
-    }
-  };
+// src/build-test-plan.ts
+function buildTestPlan(options) {
+  const { feature, adapter } = options;
+  assertFeature(feature);
+  assertAdapter(adapter);
+  const featureScope = options.featureScope ?? resolveFeatureScope(adapter, feature);
+  return new TestPlanBuilder(feature, featureScope, adapter).build();
 }
-
-// src/test-builder.ts
-var import_bind_decorator = require("@autometa/bind-decorator");
-var import_errors4 = require("@autometa/errors");
-var TestBuilder = class {
-  constructor(feature) {
-    this.feature = feature;
+function assertFeature(feature) {
+  if (!feature) {
+    throw new Error("A Gherkin feature is required to build a test plan");
   }
-  onFeatureExecuted(featureScope) {
-    const bridge = new FeatureBridge();
-    GherkinWalker.walk(
-      {
-        onFeature: (feature, accumulator) => {
-          accumulator.data = { gherkin: feature, scope: featureScope };
-          return accumulator;
-        },
-        onRule: (rule, accumulator) => {
-          const ruleScope = scope(featureScope).findRule(
-            rule.name
-          );
-          const bridge2 = new RuleBridge();
-          bridge2.data = { gherkin: rule, scope: ruleScope };
-          accumulator.rules.push(bridge2);
-          return bridge2;
-        },
-        onScenario: (gherkin, accumulator) => {
-          const scenarioScope = scope(accumulator.data.scope).findScenario(
-            gherkin.name
-          );
-          const bridge2 = new ScenarioBridge();
-          bridge2.data = { gherkin, scope: scenarioScope };
-          accumulator.scenarios.push(bridge2);
-          return bridge2;
-        },
-        onScenarioOutline: (gherkin, accumulator) => {
-          const outlineScope = scope(
-            accumulator.data.scope
-          ).findScenarioOutline(gherkin.name);
-          const bridge2 = new ScenarioOutlineBridge();
-          bridge2.data = { gherkin, scope: outlineScope };
-          accumulator.scenarios.push(bridge2);
-          return bridge2;
-        },
-        onExamples: (gherkin, accumulator) => {
-          const outlineScope = accumulator.data.scope;
-          const bridge2 = new ExamplesBridge();
-          bridge2.data = { gherkin, scope: outlineScope };
-          accumulator.examples.push(bridge2);
-          return bridge2;
-        },
-        onExample(gherkin, accumulator) {
-          if (gherkin.table === void 0) {
-            (0, import_errors4.raise)(
-              `Example ${gherkin.name} has no Example Table data. A Row of data is required.`
-            );
-          }
-          const title = gherkin.name;
-          const exampleScope = scope(accumulator.data.scope).findExample(title);
-          const bridge2 = new ExampleBridge();
-          bridge2.data = { gherkin, scope: exampleScope };
-          const acc = accumulator;
-          acc.scenarios.push(bridge2);
-          return bridge2;
-        },
-        onBackground(gherkin, accumulator) {
-          const backgroundScope = scope(accumulator.data.scope).findBackground({
-            name: gherkin.name
-          });
-          const bridge2 = new BackgroundBridge();
-          bridge2.data = { gherkin, scope: backgroundScope };
-          const acc = accumulator;
-          acc.background = bridge2;
-          return bridge2;
-        },
-        onStep: (step, accumulator) => {
-          const {
-            data: { scope: parentScope, gherkin }
-          } = accumulator;
-          const { keyword, keywordType, text } = step;
-          const cache = parentScope.steps;
-          const existing = getStep(
-            accumulator,
-            gherkin,
-            cache,
-            keywordType,
-            keyword,
-            text
-          );
-          const bridge2 = new StepBridge();
-          const acc = accumulator;
-          if (existing) {
-            bridge2.data = {
-              gherkin: step,
-              scope: existing.step,
-              args: existing.args
-            };
-          } else {
-            (0, import_errors4.raise)(`No step definition matching ${step.keyword} ${step.text}`);
-          }
-          acc.steps.push(bridge2);
-          return accumulator;
-        }
-      },
-      this.feature,
-      bridge
-    );
-    return bridge;
+}
+function assertAdapter(adapter) {
+  if (!adapter) {
+    throw new Error("A scope execution adapter is required to build a test plan");
   }
-};
-__decorateClass([
-  import_bind_decorator.Bind
-], TestBuilder.prototype, "onFeatureExecuted", 1);
-function getStep(accumulator, gherkin, cache, keywordType, keyword, text) {
-  try {
-    if (accumulator instanceof ExampleBridge) {
-      const scenario = gherkin;
-      if (scenario.table) {
-        return cache.findByExample(keywordType, keyword, text, scenario.table);
-      }
-    }
-    return cache.find(keywordType, keyword, text);
-  } catch (e) {
-    const cause = e;
-    const { title } = gherkin;
-    (0, import_errors4.raise)(`'${title}' could not find a step definition`, { cause });
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BackgroundBridge,
-  ExampleBridge,
-  ExamplesBridge,
-  FeatureBridge,
-  GherkinCodeBridge,
-  GherkinWalker,
-  GlobalBridge,
-  Query,
-  RuleBridge,
-  ScenarioBridge,
-  ScenarioOutlineBridge,
-  StepBridge,
-  TestBuilder,
-  find,
-  findExamplesOrChild,
-  findRuleOrChild,
-  findRuleTypes,
-  findScenario,
-  findScenarioOutlineOrChild,
-  findTestTypes,
-  scope
-});
+}
+
+export { buildTestPlan };
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map