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

package/dist/index.cjs

@@ -0,0 +1,1133 @@
+'use strict';
+
+var cucumberExpressions$1 = require('@cucumber/cucumber-expressions');
+var cucumberExpressions = require('@autometa/cucumber-expressions');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+// 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__default.default.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);
+      }
+    }
+  }
+  return result;
+}
+function combineSteps(featureSteps, ruleSteps, scenarioSteps) {
+  return [
+    ...featureSteps ?? [],
+    ...ruleSteps ?? [],
+    ...scenarioSteps ?? []
+  ];
+}
+function cloneData(data) {
+  if (!data) {
+    return void 0;
+  }
+  return { ...data };
+}
+function mergeData(base, extra) {
+  if (!base && !extra) {
+    return void 0;
+  }
+  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;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  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;
+    }
+  }
+  listExecutables() {
+    return this.executions;
+  }
+};
+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 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()
+    };
+  }
+  markFailed(error) {
+    const startedAt = this.resultState.startedAt ?? Date.now();
+    this.resultState = {
+      status: "failed",
+      error: normalizeError(error),
+      startedAt,
+      completedAt: Date.now()
+    };
+  }
+  markSkipped(reason) {
+    const timestamp = Date.now();
+    this.resultState = {
+      status: "skipped",
+      startedAt: this.resultState.startedAt ?? timestamp,
+      completedAt: timestamp,
+      ...reason !== void 0 ? { reason } : {}
+    };
+  }
+  markPending(reason) {
+    const timestamp = Date.now();
+    this.resultState = {
+      status: "pending",
+      startedAt: this.resultState.startedAt ?? timestamp,
+      completedAt: timestamp,
+      ...reason !== void 0 ? { reason } : {}
+    };
+  }
+  reset() {
+    this.resultState = { status: "pending" };
+  }
+};
+var ScenarioNodeImpl = class extends ScenarioExecutionBase {
+  constructor(init) {
+    super("scenario", init);
+  }
+};
+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 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 examples() {
+    return this.mutableExamples;
+  }
+};
+
+// 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);
+  }
+  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}'`);
+  }
+  return `${summary.scenario.kind} '${parts.join(" ")}'`;
+}
+
+// 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;
+  }
+  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 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;
+  }
+  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.`
+  );
+}
+
+// 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?.());
+    cucumberExpressions.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);
+      }
+    }
+    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)
+      }
+    ]);
+    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);
+      }
+    }
+  }
+  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);
+      }
+    }
+  }
+  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;
+  }
+  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(", ")}`
+      );
+    }
+  }
+  getRuleScenarios(rule) {
+    const list = this.ruleScenarioMap.get(rule);
+    if (!list) {
+      throw new Error(`Rule '${rule.name}' has no associated scenario registry`);
+    }
+    return list;
+  }
+  getRuleOutlines(rule) {
+    const list = this.ruleOutlineMap.get(rule);
+    if (!list) {
+      throw new Error(`Rule '${rule.name}' has no associated scenario outline registry`);
+    }
+    return list;
+  }
+  getOutlineExamples(outline) {
+    const list = this.outlineExamplesMap.get(outline);
+    if (!list) {
+      throw new Error(
+        `Scenario outline '${outline.name}' has no associated example registry`
+      );
+    }
+    return list;
+  }
+  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;
+  }
+  matchesStepExpression(definition, text, matchers) {
+    let matcher = matchers.get(definition);
+    if (!matcher) {
+      matcher = this.createMatcher(definition.expression);
+      matchers.set(definition, matcher);
+    }
+    return matcher(text);
+  }
+  createMatcher(expression) {
+    if (expression instanceof RegExp) {
+      const regex = new RegExp(expression.source, expression.flags);
+      const evaluator = new cucumberExpressions$1.RegularExpression(regex, this.parameterRegistry);
+      return (text) => evaluator.match(text) !== null;
+    }
+    try {
+      const cucumberExpression = new cucumberExpressions$1.CucumberExpression(
+        expression,
+        this.parameterRegistry
+      );
+      return (text) => cucumberExpression.match(text) !== null;
+    } catch {
+      const literal = expression;
+      return (text) => text === literal;
+    }
+  }
+  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");
+  }
+  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(" ");
+  }
+  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";
+    }
+  }
+  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 };
+  }
+  normalizeForDistance(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+  }
+  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));
+  }
+  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");
+    }
+    return result;
+  }
+  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;
+    }
+  }
+};
+_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;
+  }
+  listFailed() {
+    return this.executions.filter((execution) => execution.result.status === "failed");
+  }
+  findById(id) {
+    return this.byId.get(id);
+  }
+  findByQualifiedName(name) {
+    return this.byQualifiedName.get(name);
+  }
+};
+function resolveParameterRegistry(parameterRegistry) {
+  if (!parameterRegistry) {
+    return new cucumberExpressions$1.ParameterTypeRegistry();
+  }
+  if (isParameterTypeRegistry(parameterRegistry)) {
+    return parameterRegistry;
+  }
+  const candidate = parameterRegistry.registry;
+  if (isParameterTypeRegistry(candidate)) {
+    return candidate;
+  }
+  return new cucumberExpressions$1.ParameterTypeRegistry();
+}
+function isParameterTypeRegistry(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof cucumberExpressions$1.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"
+};
+var FLEXIBLE_KEYWORDS = /* @__PURE__ */ new Set(["and", "but", "*"]);
+
+// 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();
+}
+function assertFeature(feature) {
+  if (!feature) {
+    throw new Error("A Gherkin feature is required to build a test plan");
+  }
+}
+function assertAdapter(adapter) {
+  if (!adapter) {
+    throw new Error("A scope execution adapter is required to build a test plan");
+  }
+}
+
+exports.buildTestPlan = buildTestPlan;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map