@autometa/executor 1.0.0-rc.0

package/dist/index.cjs

@@ -0,0 +1,2409 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+var url = require('url');
+var cucumberExpressions = require('@cucumber/cucumber-expressions');
+var events = require('@autometa/events');
+var errors = require('@autometa/errors');
+var gherkin = require('@autometa/gherkin');
+var TagExpressions = require('@cucumber/tag-expressions');
+var async_hooks = require('async_hooks');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var TagExpressions__namespace = /*#__PURE__*/_interopNamespace(TagExpressions);
+
+// src/timeouts.ts
+var UNIT_TO_MILLISECONDS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5
+};
+var normalizeSpec = (spec) => {
+  if (spec === void 0 || spec === null) {
+    return void 0;
+  }
+  if (typeof spec === "number") {
+    return spec <= 0 ? void 0 : spec;
+  }
+  if (Array.isArray(spec)) {
+    const [value2, unit2] = spec;
+    if (typeof value2 !== "number" || value2 <= 0) {
+      return void 0;
+    }
+    const multiplier2 = UNIT_TO_MILLISECONDS[unit2] ?? 1;
+    return value2 * multiplier2;
+  }
+  if (typeof spec !== "object") {
+    return void 0;
+  }
+  const value = "duration" in spec ? spec.duration : spec.value;
+  if (typeof value !== "number" || value <= 0) {
+    return void 0;
+  }
+  const unit = "duration" in spec ? spec.unit : spec.unit;
+  if (!unit) {
+    return value;
+  }
+  const multiplier = UNIT_TO_MILLISECONDS[unit] ?? 1;
+  return value * multiplier;
+};
+var resolveTimeout = (explicit, config, explicitSource = "scenario") => {
+  const explicitMs = normalizeSpec(explicit);
+  if (explicitMs !== void 0) {
+    return { milliseconds: explicitMs, source: explicitSource };
+  }
+  const configMs = normalizeSpec(config.test?.timeout);
+  if (configMs !== void 0) {
+    return { milliseconds: configMs, source: "config" };
+  }
+  return { milliseconds: void 0, source: "default" };
+};
+var chooseTimeout = (primary, secondary, config) => {
+  const secondaryResolution = resolveTimeout(secondary, config, "hook");
+  if (secondaryResolution.milliseconds !== void 0) {
+    return secondaryResolution;
+  }
+  return resolveTimeout(primary, config, "scenario");
+};
+
+// src/hooks.ts
+var EMPTY_COLLECTION = {
+  beforeFeature: [],
+  afterFeature: [],
+  beforeRule: [],
+  afterRule: [],
+  beforeScenario: [],
+  afterScenario: [],
+  beforeScenarioOutline: [],
+  afterScenarioOutline: [],
+  beforeStep: [],
+  afterStep: []
+};
+function collectScenarioHooks(adapter, execution) {
+  const scopes = buildScopeChain(adapter, execution);
+  if (scopes.length === 0) {
+    return EMPTY_COLLECTION;
+  }
+  const buckets = {
+    beforeFeature: [],
+    afterFeature: [],
+    beforeRule: [],
+    afterRule: [],
+    beforeScenario: [],
+    afterScenario: [],
+    beforeScenarioOutline: [],
+    afterScenarioOutline: [],
+    beforeStep: [],
+    afterStep: []
+  };
+  for (const scope of scopes) {
+    for (const hook of scope.hooks) {
+      addHookToBuckets(buckets, hook, scope);
+    }
+  }
+  return buckets;
+}
+function buildScopeChain(adapter, execution) {
+  const chain = [adapter.plan.root];
+  chain.push(...execution.ancestors);
+  chain.push(execution.scope);
+  return chain;
+}
+function addHookToBuckets(buckets, hook, scope) {
+  const entry = { hook, scope };
+  switch (hook.type) {
+    case "beforeFeature":
+      buckets.beforeFeature.push(entry);
+      break;
+    case "afterFeature":
+      buckets.afterFeature.push(entry);
+      break;
+    case "beforeRule":
+      buckets.beforeRule.push(entry);
+      break;
+    case "afterRule":
+      buckets.afterRule.push(entry);
+      break;
+    case "beforeScenario":
+      buckets.beforeScenario.push(entry);
+      break;
+    case "afterScenario":
+      buckets.afterScenario.push(entry);
+      break;
+    case "beforeScenarioOutline":
+      buckets.beforeScenarioOutline.push(entry);
+      break;
+    case "afterScenarioOutline":
+      buckets.afterScenarioOutline.push(entry);
+      break;
+    case "beforeStep":
+      buckets.beforeStep.push(entry);
+      break;
+    case "afterStep":
+      buckets.afterStep.push(entry);
+      break;
+  }
+}
+var DATA_TABLE_SYMBOL = Symbol.for(
+  "autometa:runner:step:data-table"
+);
+var DOCSTRING_SYMBOL = Symbol.for(
+  "autometa:runner:step:docstring"
+);
+var DOCSTRING_MEDIA_TYPE_SYMBOL = Symbol.for(
+  "autometa:runner:step:docstring:media-type"
+);
+var STEP_RUNTIME_SYMBOL = Symbol.for(
+  "autometa:runner:step:runtime"
+);
+var STEP_METADATA_SYMBOL = Symbol.for(
+  "autometa:runner:step:metadata"
+);
+var DEFAULT_CONFIG = { ...gherkin.DEFAULT_COERCE_BY_SHAPE };
+var activeConfig = { ...DEFAULT_CONFIG };
+var DEFAULT_DOCSTRING_CONFIG = { transformers: {} };
+var activeDocstringConfig = { ...DEFAULT_DOCSTRING_CONFIG };
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+function cloneTable(source) {
+  return source.map((row) => [...row]);
+}
+function withCarrier(world) {
+  if (!isObjectLike(world)) {
+    return void 0;
+  }
+  return world;
+}
+function configureStepTables(config) {
+  if (config.coercePrimitives) {
+    activeConfig = {
+      ...activeConfig,
+      ...config.coercePrimitives
+    };
+  }
+}
+function resetStepTableConfig() {
+  activeConfig = { ...DEFAULT_CONFIG };
+}
+function setStepTable(world, table) {
+  const carrier = withCarrier(world);
+  if (!carrier) {
+    return;
+  }
+  if (!table) {
+    Reflect.deleteProperty(carrier, DATA_TABLE_SYMBOL);
+    return;
+  }
+  const cloned = cloneTable(table);
+  if (Object.prototype.hasOwnProperty.call(carrier, DATA_TABLE_SYMBOL)) {
+    carrier[DATA_TABLE_SYMBOL] = cloned;
+  } else {
+    Object.defineProperty(carrier, DATA_TABLE_SYMBOL, {
+      value: cloned,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+}
+function clearStepTable(world) {
+  const carrier = withCarrier(world);
+  if (!carrier) {
+    return;
+  }
+  Reflect.deleteProperty(carrier, DATA_TABLE_SYMBOL);
+}
+function setStepDocstring(world, docstring) {
+  const carrier = withCarrier(world);
+  if (!carrier) {
+    return;
+  }
+  if (docstring === void 0) {
+    Reflect.deleteProperty(carrier, DOCSTRING_SYMBOL);
+    Reflect.deleteProperty(carrier, DOCSTRING_MEDIA_TYPE_SYMBOL);
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(carrier, DOCSTRING_SYMBOL)) {
+    carrier[DOCSTRING_SYMBOL] = docstring;
+  } else {
+    Object.defineProperty(carrier, DOCSTRING_SYMBOL, {
+      value: docstring,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  Reflect.deleteProperty(carrier, DOCSTRING_MEDIA_TYPE_SYMBOL);
+}
+function setStepDocstringInfo(world, docstring) {
+  if (docstring === void 0) {
+    setStepDocstring(world, void 0);
+    return;
+  }
+  setStepDocstring(world, docstring.content);
+  const carrier = withCarrier(world);
+  if (!carrier) {
+    return;
+  }
+  const mediaType = docstring.mediaType;
+  if (mediaType === void 0) {
+    Reflect.deleteProperty(carrier, DOCSTRING_MEDIA_TYPE_SYMBOL);
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(carrier, DOCSTRING_MEDIA_TYPE_SYMBOL)) {
+    carrier[DOCSTRING_MEDIA_TYPE_SYMBOL] = mediaType;
+  } else {
+    Object.defineProperty(carrier, DOCSTRING_MEDIA_TYPE_SYMBOL, {
+      value: mediaType,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+}
+function clearStepDocstring(world) {
+  const carrier = withCarrier(world);
+  if (!carrier) {
+    return;
+  }
+  Reflect.deleteProperty(carrier, DOCSTRING_SYMBOL);
+  Reflect.deleteProperty(carrier, DOCSTRING_MEDIA_TYPE_SYMBOL);
+}
+function setStepMetadata(world, metadata) {
+  const carrier = withCarrier(world);
+  if (!carrier) {
+    return;
+  }
+  if (!metadata) {
+    Reflect.deleteProperty(carrier, STEP_METADATA_SYMBOL);
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(carrier, STEP_METADATA_SYMBOL)) {
+    carrier[STEP_METADATA_SYMBOL] = metadata;
+  } else {
+    Object.defineProperty(carrier, STEP_METADATA_SYMBOL, {
+      value: metadata,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+}
+function clearStepMetadata(world) {
+  const carrier = withCarrier(world);
+  if (!carrier) {
+    return;
+  }
+  Reflect.deleteProperty(carrier, STEP_METADATA_SYMBOL);
+}
+function getStepMetadata(world) {
+  const carrier = withCarrier(world);
+  return carrier?.[STEP_METADATA_SYMBOL];
+}
+function getDocstring(world) {
+  const carrier = withCarrier(world);
+  return carrier?.[DOCSTRING_SYMBOL];
+}
+function getDocstringMediaType(world) {
+  const carrier = withCarrier(world);
+  return carrier?.[DOCSTRING_MEDIA_TYPE_SYMBOL];
+}
+function getDocstringInfo(world) {
+  const content = getDocstring(world);
+  if (content === void 0) {
+    return void 0;
+  }
+  const mediaType = getDocstringMediaType(world);
+  if (mediaType === void 0) {
+    return { content };
+  }
+  return { content, mediaType };
+}
+function getRawTable(world) {
+  const carrier = withCarrier(world);
+  return carrier?.[DATA_TABLE_SYMBOL];
+}
+function getStepRuntimeFromWorld(world) {
+  const carrier = withCarrier(world);
+  return carrier?.[STEP_RUNTIME_SYMBOL];
+}
+function resolveCoerceOverride(shape, coerceOverride) {
+  if (typeof coerceOverride === "boolean") {
+    return coerceOverride;
+  }
+  return activeConfig[shape];
+}
+function getTable(world, shape, options) {
+  const table = getRawTable(world);
+  if (!table) {
+    return void 0;
+  }
+  const coerce = resolveCoerceOverride(shape, options?.coerce);
+  switch (shape) {
+    case "headerless":
+      return gherkin.createTable(table, "headerless", {
+        ...options,
+        coerce
+      });
+    case "horizontal":
+      return gherkin.createTable(table, "horizontal", {
+        ...options,
+        coerce
+      });
+    case "vertical":
+      return gherkin.createTable(table, "vertical", {
+        ...options,
+        coerce
+      });
+    case "matrix":
+      return gherkin.createTable(table, "matrix", {
+        ...options,
+        coerce
+      });
+    default:
+      return void 0;
+  }
+}
+function consumeTable(world, shape, options) {
+  let instance;
+  switch (shape) {
+    case "headerless":
+      instance = getTable(world, "headerless", options);
+      break;
+    case "horizontal":
+      instance = getTable(world, "horizontal", options);
+      break;
+    case "vertical":
+      instance = getTable(world, "vertical", options);
+      break;
+    case "matrix":
+      instance = getTable(world, "matrix", options);
+      break;
+    default:
+      instance = void 0;
+  }
+  clearStepTable(world);
+  return instance;
+}
+function consumeDocstring(world) {
+  const value = getDocstring(world);
+  clearStepDocstring(world);
+  return value;
+}
+function normalizeDocstringMediaType(mediaType) {
+  if (!mediaType) {
+    return void 0;
+  }
+  const normalized = mediaType.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  const [primary] = normalized.split(";", 1);
+  return primary?.trim().toLowerCase() || void 0;
+}
+function resolveDocstringTransformer(transformers, mediaType) {
+  const normalized = normalizeDocstringMediaType(mediaType);
+  if (!normalized) {
+    return void 0;
+  }
+  if (transformers[normalized]) {
+    return transformers[normalized];
+  }
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex !== -1) {
+    const subtype = normalized.slice(slashIndex + 1);
+    if (transformers[subtype]) {
+      return transformers[subtype];
+    }
+    const plusIndex = subtype.lastIndexOf("+");
+    if (plusIndex !== -1) {
+      const suffix = subtype.slice(plusIndex + 1);
+      if (transformers[`+${suffix}`]) {
+        return transformers[`+${suffix}`];
+      }
+      if (transformers[suffix]) {
+        return transformers[suffix];
+      }
+    }
+  }
+  return void 0;
+}
+function configureStepDocstrings(config) {
+  if (config.transformers) {
+    activeDocstringConfig = {
+      ...activeDocstringConfig,
+      transformers: {
+        ...activeDocstringConfig.transformers,
+        ...config.transformers
+      }
+    };
+  }
+}
+function resetStepDocstringConfig() {
+  activeDocstringConfig = { ...DEFAULT_DOCSTRING_CONFIG };
+}
+function bindGetTable(world) {
+  function getTable2(shape, options) {
+    switch (shape) {
+      case "headerless":
+        return getTableForShape(world, "headerless", options);
+      case "horizontal":
+        return getTableForShape(world, "horizontal", options);
+      case "vertical":
+        return getTableForShape(world, "vertical", options);
+      case "matrix":
+        return getTableForShape(world, "matrix", options);
+      default:
+        return void 0;
+    }
+  }
+  return getTable2;
+}
+function getTableForShape(world, shape, options) {
+  switch (shape) {
+    case "headerless":
+      return getTable(world, "headerless", options);
+    case "horizontal":
+      return getTable(world, "horizontal", options);
+    case "vertical":
+      return getTable(world, "vertical", options);
+    case "matrix":
+      return getTable(world, "matrix", options);
+    default:
+      return void 0;
+  }
+}
+function bindConsumeTable(world) {
+  function consume(shape, options) {
+    switch (shape) {
+      case "headerless":
+        return consumeTable(world, "headerless", options);
+      case "horizontal":
+        return consumeTable(world, "horizontal", options);
+      case "vertical":
+        return consumeTable(world, "vertical", options);
+      case "matrix":
+        return consumeTable(world, "matrix", options);
+      default:
+        return void 0;
+    }
+  }
+  return consume;
+}
+function bindRequireTable(world) {
+  function require2(shape, options) {
+    switch (shape) {
+      case "headerless": {
+        const table = consumeTable(
+          world,
+          "headerless",
+          options
+        );
+        if (!table) {
+          throw new RangeError("No headerless data table is attached to the current step.");
+        }
+        return table;
+      }
+      case "horizontal": {
+        const table = consumeTable(
+          world,
+          "horizontal",
+          options
+        );
+        if (!table) {
+          throw new RangeError("No horizontal data table is attached to the current step.");
+        }
+        return table;
+      }
+      case "vertical": {
+        const table = consumeTable(
+          world,
+          "vertical",
+          options
+        );
+        if (!table) {
+          throw new RangeError("No vertical data table is attached to the current step.");
+        }
+        return table;
+      }
+      case "matrix": {
+        const table = consumeTable(
+          world,
+          "matrix",
+          options
+        );
+        if (!table) {
+          throw new RangeError("No matrix data table is attached to the current step.");
+        }
+        return table;
+      }
+      default:
+        throw new RangeError(`Unsupported table shape: ${String(shape)}`);
+    }
+  }
+  return require2;
+}
+function cacheRuntime(world, runtime) {
+  const carrier = withCarrier(world);
+  if (!carrier) {
+    return;
+  }
+  if (!Object.prototype.hasOwnProperty.call(carrier, STEP_RUNTIME_SYMBOL)) {
+    Object.defineProperty(carrier, STEP_RUNTIME_SYMBOL, {
+      value: runtime,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  } else {
+    carrier[STEP_RUNTIME_SYMBOL] = runtime;
+  }
+  if (!Object.prototype.hasOwnProperty.call(carrier, "runtime")) {
+    Object.defineProperty(carrier, "runtime", {
+      get() {
+        return carrier[STEP_RUNTIME_SYMBOL];
+      },
+      enumerable: false,
+      configurable: true
+    });
+  }
+}
+function createStepRuntime(world) {
+  const existing = getStepRuntimeFromWorld(world);
+  if (existing) {
+    return existing;
+  }
+  const getDocstringTransformed = (options) => {
+    const info = getDocstringInfo(world);
+    if (!info) {
+      return void 0;
+    }
+    const transformer = resolveDocstringTransformer(
+      activeDocstringConfig.transformers,
+      info.mediaType
+    );
+    if (!transformer) {
+      if (options?.fallback === "throw") {
+        const type = normalizeDocstringMediaType(info.mediaType) ?? "<unknown>";
+        throw new RangeError(
+          `No docstring transformer is configured for media type '${type}'.`
+        );
+      }
+      return info.content;
+    }
+    return transformer(
+      info.content,
+      info.mediaType === void 0 ? {} : { mediaType: info.mediaType }
+    );
+  };
+  const runtime = {
+    get hasTable() {
+      return getRawTable(world) !== void 0;
+    },
+    get hasDocstring() {
+      return getDocstring(world) !== void 0;
+    },
+    get currentStep() {
+      return getStepMetadata(world);
+    },
+    getTable: bindGetTable(world),
+    consumeTable: bindConsumeTable(world),
+    getRawTable() {
+      return getRawTable(world);
+    },
+    getDocstring() {
+      return getDocstring(world);
+    },
+    getDocstringMediaType() {
+      return getDocstringMediaType(world);
+    },
+    getDocstringInfo() {
+      return getDocstringInfo(world);
+    },
+    consumeDocstring() {
+      return consumeDocstring(world);
+    },
+    getDocstringTransformed,
+    consumeDocstringTransformed(options) {
+      const result = getDocstringTransformed(options);
+      clearStepDocstring(world);
+      return result;
+    },
+    getStepMetadata() {
+      return getStepMetadata(world);
+    },
+    requireTable: bindRequireTable(world)
+  };
+  cacheRuntime(world, runtime);
+  return runtime;
+}
+
+// src/pending.ts
+var PENDING_SCENARIO_SYMBOL = Symbol("autometa:scenario:pending");
+var _a;
+var ScenarioPendingError = class extends Error {
+  constructor(reason) {
+    super(reason ? `Scenario pending: ${reason}` : "Scenario pending");
+    this[_a] = true;
+    this.name = "ScenarioPendingError";
+    if (reason !== void 0 && reason !== null) {
+      const trimmed = String(reason).trim();
+      if (trimmed.length > 0) {
+        this.reason = trimmed;
+      }
+    }
+  }
+};
+_a = PENDING_SCENARIO_SYMBOL;
+function isScenarioPendingError(error) {
+  return typeof error === "object" && error !== null && error[PENDING_SCENARIO_SYMBOL] === true;
+}
+function createPendingError(reason) {
+  return new ScenarioPendingError(reason);
+}
+function Pending(reason) {
+  return function pendingStepHandler(world, ..._args) {
+    throw createPendingError(reason);
+  };
+}
+var ToDo = Pending;
+function markScenarioPending(reason) {
+  throw createPendingError(reason);
+}
+function createFeatureRef(feature) {
+  return {
+    id: feature.id,
+    name: feature.name,
+    location: feature.location ?? { line: 1, column: 1 },
+    tags: feature.tags,
+    comments: feature.comments?.map((comment) => comment.text)
+  };
+}
+function createRuleRef(rule) {
+  return {
+    id: rule.id,
+    name: rule.name,
+    location: rule.location ?? { line: 1, column: 1 },
+    tags: rule.tags
+  };
+}
+function requirePickle(feature, scenarioId) {
+  const pickle = gherkin.generatePickleById(feature, scenarioId);
+  if (!pickle) {
+    throw new Error(
+      `Unable to generate pickle for scenario "${scenarioId}". Ensure the feature contains compiled scenarios and stable ids.`
+    );
+  }
+  return pickle;
+}
+function findPickleStep(pickle, stepId) {
+  return pickle.steps.find((step) => step.id === stepId || step.astNodeIds?.includes(stepId));
+}
+
+// src/scenario-runner.ts
+var matcherCache = /* @__PURE__ */ new WeakMap();
+async function runScenarioExecution(execution, context) {
+  execution.reset();
+  const eventEmitter = context.events ? events.getEventEmitter() : void 0;
+  const pickle = context.events?.pickle;
+  const { world, beforeStepHooks, afterStepHooks, invokeHooks } = context;
+  const parameterRegistry = resolveParameterRegistry(context.parameterRegistry);
+  const stepSummaries = [];
+  try {
+    const { steps, gherkinSteps } = execution;
+    for (let index = 0; index < steps.length; index++) {
+      const step = steps[index];
+      if (!step) {
+        continue;
+      }
+      const gherkinStep = gherkinSteps[index];
+      const metadata = buildStepMetadata(execution, index);
+      const stepDetails = {
+        index,
+        definition: step,
+        ...gherkinStep ? { gherkin: gherkinStep } : {}
+      };
+      const beforeOptions = {
+        direction: "asc",
+        step: stepDetails
+      };
+      await invokeHooks(beforeStepHooks, beforeOptions);
+      const pickleStep = pickle && gherkinStep?.id ? findPickleStep(pickle, gherkinStep.id) : void 0;
+      if (eventEmitter && pickle && pickleStep) {
+        await eventEmitter.stepStarted({
+          feature: pickle.feature,
+          scenario: pickle.scenario,
+          step: pickleStep,
+          pickle,
+          ...pickle.rule ? { rule: pickle.rule } : {},
+          metadata: { index }
+        });
+      }
+      setStepMetadata(world, metadata);
+      setStepTable(world, gherkinStep?.dataTable);
+      if (!gherkinStep?.docString) {
+        setStepDocstringInfo(world, void 0);
+      } else if (gherkinStep.docString.mediaType === void 0) {
+        setStepDocstringInfo(world, { content: gherkinStep.docString.content });
+      } else {
+        setStepDocstringInfo(world, {
+          content: gherkinStep.docString.content,
+          mediaType: gherkinStep.docString.mediaType
+        });
+      }
+      let status = "passed";
+      try {
+        const args = resolveStepArguments(
+          step,
+          gherkinStep,
+          parameterRegistry,
+          world
+        );
+        await step.handler(world, ...args);
+        stepSummaries.push(createStepSummary(metadata, gherkinStep, "passed"));
+      } catch (error) {
+        if (isScenarioPendingError(error)) {
+          status = "skipped";
+          throw error;
+        }
+        status = "failed";
+        if (eventEmitter && pickle && pickleStep) {
+          await eventEmitter.errorRaised({
+            error,
+            phase: "step",
+            feature: pickle.feature,
+            scenario: pickle.scenario,
+            ...pickle.rule ? { rule: pickle.rule } : {},
+            pickle,
+            metadata: { index, stepId: pickleStep.id }
+          });
+        }
+        stepSummaries.push(createStepSummary(metadata, gherkinStep, "failed"));
+        for (let remaining = index + 1; remaining < gherkinSteps.length; remaining++) {
+          const remainingMetadata = buildStepMetadata(execution, remaining);
+          const remainingStep = gherkinSteps[remaining];
+          stepSummaries.push(
+            createStepSummary(remainingMetadata, remainingStep, "skipped")
+          );
+        }
+        throw enrichStepError(error, metadata, stepSummaries);
+      } finally {
+        const afterStepDetails = {
+          ...stepDetails,
+          status
+        };
+        const afterOptions = {
+          direction: "desc",
+          step: afterStepDetails
+        };
+        await invokeHooks(afterStepHooks, afterOptions);
+        if (eventEmitter && pickle && pickleStep) {
+          await eventEmitter.stepCompleted({
+            feature: pickle.feature,
+            scenario: pickle.scenario,
+            step: pickleStep,
+            pickle,
+            ...pickle.rule ? { rule: pickle.rule } : {},
+            metadata: { index, status }
+          });
+        }
+        clearStepTable(world);
+        clearStepDocstring(world);
+        clearStepMetadata(world);
+      }
+    }
+    execution.markPassed();
+  } catch (error) {
+    if (isScenarioPendingError(error)) {
+      execution.markPending(error.reason);
+      return;
+    }
+    execution.markFailed(error);
+    throw error;
+  }
+}
+function resolveStepArguments(definition, gherkinStep, registry, world) {
+  if (!gherkinStep) {
+    return [];
+  }
+  const matcher = getStepArgumentMatcher(definition, registry);
+  return matcher(gherkinStep.text, world);
+}
+function getStepArgumentMatcher(definition, registry) {
+  const cached = matcherCache.get(definition);
+  if (cached) {
+    return cached;
+  }
+  const matcher = createStepArgumentMatcher(
+    definition.expression,
+    registry
+  );
+  matcherCache.set(
+    definition,
+    matcher
+  );
+  return matcher;
+}
+function createStepArgumentMatcher(expression, registry) {
+  if (expression instanceof RegExp) {
+    const evaluator2 = new cucumberExpressions.RegularExpression(expression, registry);
+    return (text, world) => collectArguments(evaluator2.match(text), world, text, expression);
+  }
+  const evaluator = new cucumberExpressions.CucumberExpression(expression, registry);
+  return (text, world) => collectArguments(evaluator.match(text), world, text, expression);
+}
+function collectArguments(match, world, text, expression) {
+  if (!match) {
+    throw new Error(
+      `Step '${text}' did not match expression ${String(expression)}`
+    );
+  }
+  return match.map((argument) => argument.getValue(world));
+}
+function resolveParameterRegistry(source) {
+  if (isParameterTypeRegistry(source)) {
+    return source;
+  }
+  const carrier = source;
+  const registry = carrier?.registry;
+  if (isParameterTypeRegistry(registry)) {
+    return registry;
+  }
+  return new cucumberExpressions.ParameterTypeRegistry();
+}
+function isParameterTypeRegistry(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof cucumberExpressions.ParameterTypeRegistry) {
+    return true;
+  }
+  const registry = value;
+  return typeof registry.lookupByTypeName === "function" && typeof registry.defineParameterType === "function" && typeof registry.lookupByRegexp === "function";
+}
+function buildStepMetadata(execution, index) {
+  const stepDefinition = execution.steps[index];
+  const gherkinStep = execution.gherkinSteps[index];
+  const featureNode = execution.feature;
+  const feature = featureNode.feature;
+  const featureSource = combineSourceRef(
+    featureNode.scope.source,
+    feature.uri,
+    feature.location
+  );
+  const featureMeta = {
+    name: featureNode.name,
+    keyword: featureNode.keyword,
+    uri: feature.uri,
+    ...featureSource ? { source: featureSource } : {}
+  };
+  const scenarioSource = combineSourceRef(
+    execution.scope.source,
+    feature.uri,
+    extractScenarioLocation(execution)
+  );
+  const scenarioMeta = {
+    name: execution.name,
+    keyword: execution.keyword,
+    ...scenarioSource ? { source: scenarioSource } : {}
+  };
+  const outlineMeta = execution.outline ? (() => {
+    const outlineSource = combineSourceRef(
+      execution.outline?.scope.source,
+      feature.uri,
+      execution.outline.outline.location
+    );
+    return {
+      name: execution.outline.name,
+      keyword: execution.outline.keyword,
+      ...outlineSource ? { source: outlineSource } : {}
+    };
+  })() : void 0;
+  const exampleMeta = isScenarioOutlineExample(execution) ? (() => {
+    const group = execution.exampleGroup;
+    const exampleSource = combineSourceRef(
+      void 0,
+      feature.uri,
+      group.location
+    );
+    return {
+      name: group.name,
+      index: execution.exampleIndex,
+      values: buildExampleValues(group, execution.exampleIndex),
+      ...exampleSource ? { source: exampleSource } : {}
+    };
+  })() : void 0;
+  const stepMeta = gherkinStep ? (() => {
+    const stepSource = combineSourceRef(
+      void 0,
+      feature.uri,
+      gherkinStep.location
+    );
+    return {
+      keyword: gherkinStep.keyword,
+      text: gherkinStep.text,
+      ...stepSource ? { source: stepSource } : {}
+    };
+  })() : void 0;
+  const definitionMeta = stepDefinition ? (() => {
+    const definitionSource = normalizeDefinitionSource(stepDefinition.source);
+    return {
+      keyword: stepDefinition.keyword,
+      expression: stepDefinition.expression,
+      ...definitionSource ? { source: definitionSource } : {}
+    };
+  })() : void 0;
+  const metadata = {
+    ...featureMeta ? { feature: featureMeta } : {},
+    ...scenarioMeta ? { scenario: scenarioMeta } : {},
+    ...outlineMeta ? { outline: outlineMeta } : {},
+    ...exampleMeta ? { example: exampleMeta } : {},
+    ...stepMeta ? { step: stepMeta } : {},
+    ...definitionMeta ? { definition: definitionMeta } : {}
+  };
+  return hasMetadata(metadata) ? metadata : void 0;
+}
+function combineSourceRef(source, uri, location) {
+  const file = source?.file ?? uri;
+  const line = source?.line ?? location?.line;
+  const column = source?.column ?? location?.column;
+  if (file === void 0 && line === void 0 && column === void 0) {
+    return void 0;
+  }
+  return {
+    ...file !== void 0 ? { file } : {},
+    ...line !== void 0 ? { line } : {},
+    ...column !== void 0 ? { column } : {}
+  };
+}
+function normalizeDefinitionSource(source) {
+  if (!source) {
+    return void 0;
+  }
+  return {
+    ...source.file !== void 0 ? { file: source.file } : {},
+    ...source.line !== void 0 ? { line: source.line } : {},
+    ...source.column !== void 0 ? { column: source.column } : {}
+  };
+}
+function extractScenarioLocation(execution) {
+  if (execution.type === "example") {
+    return execution.outline?.outline.location;
+  }
+  const scenario = execution.gherkin;
+  return scenario.location;
+}
+function isScenarioOutlineExample(execution) {
+  return execution.type === "example";
+}
+function buildExampleValues(group, index) {
+  const values = {};
+  const headers = group.tableHeader;
+  const row = group.tableBody[index] ?? [];
+  for (let i = 0; i < headers.length; i++) {
+    const header = headers[i];
+    if (header === void 0 || header.length === 0) {
+      continue;
+    }
+    values[header] = row[i] ?? "";
+  }
+  return Object.freeze(values);
+}
+function hasMetadata(metadata) {
+  return Boolean(
+    metadata.feature || metadata.scenario || metadata.outline || metadata.example || metadata.step || metadata.definition
+  );
+}
+function enrichStepError(error, metadata, steps) {
+  const base = error instanceof Error ? error : new Error(String(error));
+  if (errors.isGherkinStepError(base)) {
+    return base;
+  }
+  const wrapped = new errors.GherkinStepError(base.message, {
+    cause: base,
+    context: buildGherkinErrorContext(metadata, base, steps) ?? {}
+  });
+  if (base.stack) {
+    Object.defineProperty(wrapped, "stack", {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: base.stack
+    });
+  }
+  return wrapped;
+}
+function buildGherkinErrorContext(metadata, error, steps) {
+  if (!metadata) {
+    return void 0;
+  }
+  const gherkinLocation = toSourceLocation(metadata.step?.source);
+  const definitionLocation = toSourceLocation(metadata.definition?.source);
+  const errorLocation = extractErrorLocation(error);
+  const pathSegments = buildGherkinPath(metadata);
+  const gherkinSegment = gherkinLocation ? {
+    location: gherkinLocation,
+    ...metadata.feature?.name !== void 0 ? { featureName: metadata.feature.name } : {},
+    ...metadata.step?.keyword !== void 0 ? { stepKeyword: metadata.step.keyword } : {},
+    ...metadata.step?.text !== void 0 ? { stepText: metadata.step.text } : {}
+  } : void 0;
+  const expression = metadata.definition?.expression;
+  const functionName = typeof expression === "string" ? expression : expression !== void 0 ? String(expression) : void 0;
+  const codeLocation = errorLocation ?? definitionLocation;
+  const codeSegment = codeLocation ? {
+    location: codeLocation,
+    ...functionName !== void 0 ? { functionName } : {}
+  } : void 0;
+  const hasSteps = Boolean(steps && steps.length > 0);
+  if (!gherkinSegment && !codeSegment && !pathSegments && !hasSteps) {
+    return void 0;
+  }
+  return {
+    ...gherkinSegment ? { gherkin: gherkinSegment } : {},
+    ...codeSegment ? { code: codeSegment } : {},
+    ...pathSegments ? { path: pathSegments } : {},
+    ...hasSteps && steps ? { steps } : {}
+  };
+}
+function createStepSummary(metadata, gherkinStep, status) {
+  const keyword = metadata?.step?.keyword ?? gherkinStep?.keyword;
+  const text = metadata?.step?.text ?? gherkinStep?.text;
+  const location = metadata?.step?.source ? toSourceLocation(metadata.step.source) : void 0;
+  return {
+    status,
+    ...keyword !== void 0 ? { keyword } : {},
+    ...text !== void 0 ? { text } : {},
+    ...location ? { location } : {}
+  };
+}
+function buildGherkinPath(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  const segments = [];
+  const featureLocation = toSourceLocation(metadata.feature?.source);
+  if (featureLocation) {
+    segments.push({
+      role: "feature",
+      location: featureLocation,
+      ...metadata.feature?.keyword !== void 0 ? { keyword: metadata.feature.keyword } : {},
+      ...metadata.feature?.name !== void 0 ? { name: metadata.feature.name } : {}
+    });
+  }
+  const outlineLocation = toSourceLocation(metadata.outline?.source);
+  if (outlineLocation) {
+    segments.push({
+      role: "outline",
+      location: outlineLocation,
+      ...metadata.outline?.keyword !== void 0 ? { keyword: metadata.outline.keyword } : {},
+      ...metadata.outline?.name !== void 0 ? { name: metadata.outline.name } : {}
+    });
+  }
+  const scenarioLocation = toSourceLocation(metadata.scenario?.source);
+  if (scenarioLocation) {
+    segments.push({
+      role: "scenario",
+      location: scenarioLocation,
+      ...metadata.scenario?.keyword !== void 0 ? { keyword: metadata.scenario.keyword } : {},
+      ...metadata.scenario?.name !== void 0 ? { name: metadata.scenario.name } : {}
+    });
+  }
+  const exampleLocation = toSourceLocation(metadata.example?.source);
+  if (exampleLocation) {
+    segments.push({
+      role: "example",
+      keyword: "Example",
+      location: exampleLocation,
+      ...metadata.example?.name !== void 0 ? { name: metadata.example.name } : {},
+      ...metadata.example?.index !== void 0 ? { index: metadata.example.index } : {}
+    });
+  }
+  const stepLocation = toSourceLocation(metadata.step?.source);
+  if (stepLocation) {
+    segments.push({
+      role: "step",
+      location: stepLocation,
+      ...metadata.step?.keyword !== void 0 ? { keyword: metadata.step.keyword } : {},
+      ...metadata.step?.text !== void 0 ? { text: metadata.step.text } : {}
+    });
+  }
+  return segments.length ? segments : void 0;
+}
+var STACK_FRAME_IGNORE_PATTERNS = [
+  /^node:/,
+  /node:internal\//,
+  /internal\/(?:modules|process)/,
+  /node_modules\/@autometa\//,
+  /packages\/(?:runner|executor|errors|cli|assertions)\//,
+  /\/\.autometa-cli\/cache\//,
+  /\/\.autometa\/cache\//,
+  /\/node_modules\/\.cache\/autometa\//
+];
+function extractErrorLocation(error) {
+  if (!error?.stack) {
+    return void 0;
+  }
+  const lines = error.stack.split("\n").slice(1);
+  for (const raw of lines) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("at ")) {
+      continue;
+    }
+    const parsed = parseStackFrame(trimmed);
+    if (!parsed) {
+      continue;
+    }
+    if (isFrameworkStackFile(parsed.file)) {
+      continue;
+    }
+    const filePath = normalizeFilePath(parsed.file);
+    return {
+      filePath,
+      start: {
+        line: parsed.line,
+        column: parsed.column
+      }
+    };
+  }
+  return void 0;
+}
+function parseStackFrame(line) {
+  const match = line.match(/at (?:.+?\()?((?:[a-zA-Z]:)?[^():]+):(\d+):(\d+)\)?$/);
+  if (!match) {
+    return void 0;
+  }
+  const [, file = "", lineText = "", columnText = ""] = match;
+  if (!file || !lineText) {
+    return void 0;
+  }
+  const lineNumber = Number.parseInt(lineText, 10);
+  if (Number.isNaN(lineNumber)) {
+    return void 0;
+  }
+  const columnNumber = Number.parseInt(columnText, 10);
+  return {
+    file,
+    line: lineNumber,
+    column: Number.isNaN(columnNumber) ? 1 : columnNumber
+  };
+}
+function isFrameworkStackFile(file) {
+  const normalized = file.replace(/\\/g, "/");
+  return STACK_FRAME_IGNORE_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function toSourceLocation(source) {
+  if (!source?.file) {
+    return void 0;
+  }
+  const filePath = normalizeFilePath(source.file);
+  const line = source.line ?? 1;
+  const column = source.column ?? 1;
+  return {
+    filePath,
+    start: {
+      line,
+      column
+    }
+  };
+}
+function normalizeFilePath(file) {
+  if (file.startsWith("file://")) {
+    try {
+      return url.fileURLToPath(file);
+    } catch {
+      return file;
+    }
+  }
+  return path__default.default.isAbsolute(file) ? file : path__default.default.resolve(file);
+}
+var ALWAYS_TRUE = {
+  evaluate: () => true
+};
+var resolveParser = () => {
+  const namespace = TagExpressions__namespace;
+  if (typeof namespace.parse === "function") {
+    return namespace.parse;
+  }
+  if (typeof namespace.default === "function") {
+    return namespace.default;
+  }
+  throw new Error("Unable to resolve @cucumber/tag-expressions parser export");
+};
+var parseExpression = resolveParser();
+var createTagFilter = (expression) => {
+  if (!expression || expression.trim().length === 0) {
+    return ALWAYS_TRUE;
+  }
+  const parsed = parseExpression(expression);
+  return {
+    evaluate(tags) {
+      return parsed.evaluate(tags.map((tag) => tag.trim()));
+    }
+  };
+};
+
+// src/modes.ts
+var MODE_TAG_ALIASES = {
+  concurrent: "concurrent",
+  sequential: "sequential",
+  failing: "failing",
+  fails: "failing"
+};
+function normalizeTagValue(tag) {
+  return tag.replace(/^@/, "").trim().toLowerCase();
+}
+function wrapFailingTest(test) {
+  const failing = (title, handler, timeout) => {
+    const wrapped = async () => {
+      let threw = false;
+      try {
+        await handler();
+      } catch (_error) {
+        threw = true;
+        return;
+      }
+      if (!threw) {
+        throw new Error("Expected scenario to fail, but it passed");
+      }
+    };
+    test(title, wrapped, timeout);
+  };
+  failing.skip = test.skip;
+  failing.only = test.only;
+  if (typeof test.concurrent === "function") {
+    failing.concurrent = test.concurrent;
+  }
+  failing.failing = failing;
+  failing.fails = failing;
+  return failing;
+}
+function selectFailingTest(test) {
+  if (typeof test.failing === "function") {
+    return test.failing;
+  }
+  if (typeof test.fails === "function") {
+    return test.fails;
+  }
+  return wrapFailingTest(test);
+}
+var selectSuiteByMode = (suite, mode) => {
+  switch (mode) {
+    case "skip":
+      return suite.skip;
+    case "only":
+      return suite.only;
+    case "concurrent":
+      return typeof suite.concurrent === "function" ? suite.concurrent : suite;
+    case "sequential":
+      return typeof suite.sequential === "function" ? suite.sequential : suite;
+    default:
+      return suite;
+  }
+};
+var selectTestByMode = (test, mode) => {
+  switch (mode) {
+    case "skip":
+      return test.skip;
+    case "only":
+      return test.only;
+    case "concurrent":
+      return typeof test.concurrent === "function" ? test.concurrent : test;
+    case "sequential":
+      return typeof test.sequential === "function" ? test.sequential : test;
+    case "failing":
+      return selectFailingTest(test);
+    default:
+      return test;
+  }
+};
+var resolveModeFromTags = (currentMode, tags) => {
+  if (currentMode !== "default") {
+    return currentMode;
+  }
+  if (!tags || tags.length === 0) {
+    return currentMode;
+  }
+  for (const tag of tags) {
+    const normalized = normalizeTagValue(tag);
+    const derived = MODE_TAG_ALIASES[normalized];
+    if (derived) {
+      return derived;
+    }
+  }
+  return currentMode;
+};
+var WORLD_CONTEXT_KEY = "__AUTOMETA_EXECUTOR_WORLD_CONTEXT__";
+var globalTarget = globalThis;
+var getOrCreateWorldContext = () => {
+  const existing = globalTarget[WORLD_CONTEXT_KEY];
+  if (existing) {
+    return existing;
+  }
+  const created = new async_hooks.AsyncLocalStorage();
+  globalTarget[WORLD_CONTEXT_KEY] = created;
+  return created;
+};
+var WorldContext = getOrCreateWorldContext();
+function getWorld() {
+  const store = WorldContext.getStore();
+  if (store === void 0) {
+    throw new Error(
+      "World context is not available. Are you running inside a scenario?"
+    );
+  }
+  return store;
+}
+function tryGetWorld() {
+  return WorldContext.getStore();
+}
+
+// src/scope-lifecycle.ts
+var PERSISTENT_SCOPE_KINDS = /* @__PURE__ */ new Set([
+  "feature",
+  "rule",
+  "scenarioOutline"
+]);
+var BEFORE_HOOK_TYPES = {
+  root: void 0,
+  feature: "beforeFeature",
+  rule: "beforeRule",
+  scenario: "beforeScenario",
+  scenarioOutline: "beforeScenarioOutline"
+};
+var AFTER_HOOK_TYPES = {
+  root: void 0,
+  feature: "afterFeature",
+  rule: "afterRule",
+  scenario: "afterScenario",
+  scenarioOutline: "afterScenarioOutline"
+};
+function formatSourceRef(source) {
+  if (!source?.file) {
+    return void 0;
+  }
+  const line = source.line ? `:${source.line}` : "";
+  const column = source.column ? `:${source.column}` : "";
+  return `${source.file}${line}${column}`;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+var ScopeLifecycle = class {
+  constructor(adapter, options = {}) {
+    this.adapter = adapter;
+    this.states = /* @__PURE__ */ new Map();
+    this.depthMap = /* @__PURE__ */ new Map();
+    this.root = adapter.plan.root;
+    this.buildDepthMap(this.root, 0);
+    if (options.hookLogger) {
+      this.hookLogger = options.hookLogger;
+    }
+    this.featureLanguage = options.featureLanguage;
+    this.scopeKeywords = options.scopeKeywords ?? /* @__PURE__ */ new Map();
+  }
+  configurePersistentScope(scope, runtime) {
+    if (!this.isPersistentScope(scope)) {
+      return;
+    }
+    if (!this.shouldMaterializePersistentScope(scope)) {
+      return;
+    }
+    runtime.beforeAll(async () => {
+      await this.ensureState(scope);
+    });
+    runtime.afterAll(async () => {
+      await this.teardownState(scope);
+    });
+  }
+  collectScenarioHooks(execution) {
+    return collectScenarioHooks(this.adapter, execution);
+  }
+  async runScenario(execution, hooks, runner, options = {}) {
+    const parentWorld = await this.resolveParentWorldForScenario(execution);
+    const world = await this.adapter.createWorld(execution.scope, parentWorld);
+    const disposeWorld = createWorldDisposer(world);
+    const invokeHooks = this.createHookInvoker(execution, world, options.events);
+    const scenarioContext = {
+      world,
+      parameterRegistry: this.adapter.getParameterRegistry(),
+      beforeStepHooks: hooks.beforeStep,
+      afterStepHooks: hooks.afterStep,
+      ...options.events ? { events: options.events } : {},
+      invokeHooks
+    };
+    const errors = [];
+    try {
+      await WorldContext.run(world, async () => {
+        await this.invokeHooks(hooks.beforeScenario, {
+          world,
+          scope: execution.scope,
+          scenario: execution,
+          ...options.events ? { events: options.events } : {},
+          direction: "asc"
+        });
+        await runner(world, scenarioContext);
+      });
+    } catch (error) {
+      errors.push(error);
+    } finally {
+      try {
+        await this.invokeHooks(hooks.afterScenario, {
+          world,
+          scope: execution.scope,
+          scenario: execution,
+          ...options.events ? { events: options.events } : {},
+          direction: "desc",
+          metadata: { result: execution.result }
+        });
+      } catch (error) {
+        errors.push(error);
+      }
+      try {
+        await disposeWorld();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length === 1) {
+      throw toError(errors[0], "Scenario execution failed");
+    }
+    if (errors.length > 1) {
+      throw combineErrors(errors, "Multiple errors occurred during scenario execution");
+    }
+  }
+  async ensureState(scope) {
+    let state = this.states.get(scope.id);
+    if (state) {
+      if (!state.beforeExecuted) {
+        await this.runScopeHooks(scope, "before", state.world);
+        state.beforeExecuted = true;
+      }
+      return state;
+    }
+    await this.ensureAncestorStates(scope);
+    const parentWorld = await this.resolveParentWorld(scope);
+    const world = await this.adapter.createWorld(scope, parentWorld);
+    const dispose = createWorldDisposer(world);
+    state = {
+      scope,
+      world,
+      dispose,
+      beforeExecuted: false,
+      afterExecuted: false
+    };
+    this.states.set(scope.id, state);
+    await this.runScopeHooks(scope, "before", world);
+    state.beforeExecuted = true;
+    return state;
+  }
+  async teardownState(scope) {
+    const state = this.states.get(scope.id);
+    if (!state) {
+      return;
+    }
+    if (!state.afterExecuted) {
+      await this.runScopeHooks(scope, "after", state.world);
+      state.afterExecuted = true;
+    }
+    await state.dispose();
+    this.states.delete(scope.id);
+  }
+  async ensureAncestorStates(scope) {
+    const parent = this.getParentScope(scope);
+    if (!parent) {
+      return;
+    }
+    if (!this.isPersistentScope(parent)) {
+      return;
+    }
+    if (!this.shouldMaterializePersistentScope(parent)) {
+      return;
+    }
+    await this.ensureState(parent);
+  }
+  async resolveParentWorld(scope) {
+    const parent = this.getParentScope(scope);
+    if (!parent || !this.isPersistentScope(parent)) {
+      return void 0;
+    }
+    if (!this.shouldMaterializePersistentScope(parent)) {
+      return void 0;
+    }
+    const parentState = this.states.get(parent.id) ?? await this.ensureState(parent);
+    return parentState.world;
+  }
+  async resolveParentWorldForScenario(execution) {
+    const scope = execution.scope;
+    const ownState = this.states.get(scope.id);
+    if (ownState) {
+      return ownState.world;
+    }
+    const ancestors = this.adapter.getAncestors(scope.id);
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+      const candidate = ancestors[index];
+      if (!candidate || !this.isPersistentScope(candidate)) {
+        continue;
+      }
+      if (!this.shouldMaterializePersistentScope(candidate)) {
+        continue;
+      }
+      const state = this.states.get(candidate.id) ?? await this.ensureState(candidate);
+      if (state) {
+        return state.world;
+      }
+    }
+    return void 0;
+  }
+  getParentScope(scope) {
+    const ancestors = this.adapter.getAncestors(scope.id);
+    if (ancestors.length === 0) {
+      return void 0;
+    }
+    return ancestors[ancestors.length - 1];
+  }
+  isPersistentScope(scope) {
+    return PERSISTENT_SCOPE_KINDS.has(scope.kind);
+  }
+  shouldMaterializePersistentScope(scope) {
+    const beforeType = BEFORE_HOOK_TYPES[scope.kind];
+    const afterType = AFTER_HOOK_TYPES[scope.kind];
+    if (beforeType) {
+      const hooks = this.collectHooksForScope(scope, beforeType);
+      if (hooks.length > 0) {
+        return true;
+      }
+    }
+    if (afterType) {
+      const hooks = this.collectHooksForScope(scope, afterType);
+      if (hooks.length > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async runScopeHooks(scope, phase, world) {
+    const hookType = phase === "before" ? BEFORE_HOOK_TYPES[scope.kind] : AFTER_HOOK_TYPES[scope.kind];
+    if (!hookType) {
+      return;
+    }
+    const hooks = this.collectHooksForScope(scope, hookType);
+    if (!hooks.length) {
+      return;
+    }
+    await this.invokeHooks(hooks, {
+      world,
+      scope,
+      direction: phase === "before" ? "asc" : "desc"
+    });
+  }
+  createHookInvoker(execution, world, events) {
+    return async (hooks, options) => {
+      const params = {
+        world,
+        scope: execution.scope,
+        scenario: execution,
+        ...events ? { events } : {},
+        ...options.direction ? { direction: options.direction } : {},
+        ...options.step ? { step: options.step } : {},
+        ...options.metadata ? { metadata: options.metadata } : {}
+      };
+      await this.invokeHooks(hooks, params);
+    };
+  }
+  async invokeHooks(hooks, params) {
+    if (hooks.length === 0) {
+      return;
+    }
+    const sorted = this.sortHooks(hooks, params.direction ?? "asc");
+    const eventEmitter = events.getEventEmitter();
+    const pickle = params.events?.pickle;
+    for (const entry of sorted) {
+      const source = formatSourceRef(entry.hook.source ?? entry.scope.source);
+      const hookMetadata = isRecord(entry.hook.options.data) ? entry.hook.options.data : void 0;
+      const pickleStep = pickle && params.step?.gherkin?.id ? findPickleStep(pickle, params.step.gherkin.id) : void 0;
+      const hookDescriptor = {
+        kind: entry.hook.type,
+        ...entry.hook.description ? { name: entry.hook.description } : {},
+        ...source ? { source } : {},
+        ...pickle ? { feature: pickle.feature } : {},
+        ...pickle?.rule ? { rule: pickle.rule } : {},
+        ...pickle ? { scenario: pickle.scenario } : {},
+        ...pickleStep ? { step: pickleStep } : {},
+        ...pickle ? { pickle } : {},
+        ...hookMetadata ? { metadata: hookMetadata } : {}
+      };
+      await eventEmitter.hookStarted({
+        hook: hookDescriptor,
+        metadata: { hookId: entry.hook.id }
+      });
+      const metadata = this.buildHookMetadata(entry, params);
+      const log = this.createContextLogger(entry, params);
+      const context = {
+        world: params.world,
+        scope: entry.scope,
+        ...metadata ? { metadata } : {},
+        ...log ? { log } : {}
+      };
+      try {
+        await entry.hook.handler(context);
+      } catch (error) {
+        await eventEmitter.errorRaised({
+          error,
+          phase: "hook",
+          ...pickle ? { feature: pickle.feature } : {},
+          ...pickle?.rule ? { rule: pickle.rule } : {},
+          ...pickle ? { scenario: pickle.scenario } : {},
+          ...pickle ? { pickle } : {},
+          metadata: { hook: hookDescriptor, hookId: entry.hook.id }
+        });
+        throw error;
+      } finally {
+        await eventEmitter.hookCompleted({
+          hook: hookDescriptor,
+          metadata: { hookId: entry.hook.id }
+        });
+      }
+    }
+  }
+  buildHookMetadata(entry, params) {
+    const metadata = {};
+    if (params.metadata) {
+      Object.assign(metadata, params.metadata);
+    }
+    if (entry.hook.options.data !== void 0) {
+      metadata.hook = entry.hook.options.data;
+    }
+    metadata.targetScope = {
+      id: params.scope.id,
+      kind: params.scope.kind,
+      name: params.scope.name
+    };
+    if (params.scenario) {
+      metadata.scenario = {
+        id: params.scenario.id,
+        name: params.scenario.name,
+        type: params.scenario.type,
+        tags: params.scenario.tags,
+        qualifiedName: params.scenario.qualifiedName
+      };
+    }
+    if (params.step) {
+      const { step } = params;
+      metadata.step = {
+        index: step.index,
+        status: step.status,
+        keyword: step.gherkin?.keyword ?? step.definition?.keyword,
+        text: step.gherkin?.text
+      };
+    }
+    return Object.keys(metadata).length > 0 ? metadata : void 0;
+  }
+  collectHooksForScope(scope, type) {
+    const chain = this.buildChain(scope);
+    const collected = [];
+    for (const candidate of chain) {
+      for (const hook of candidate.hooks) {
+        if (hook.type === type) {
+          collected.push({ hook, scope: candidate });
+        }
+      }
+    }
+    return collected;
+  }
+  buildChain(scope) {
+    const ancestors = this.adapter.getAncestors(scope.id);
+    return [this.root, ...ancestors, scope];
+  }
+  createContextLogger(entry, params) {
+    if (!this.hookLogger) {
+      return void 0;
+    }
+    const emit = this.hookLogger;
+    return (rawMessage) => {
+      if (rawMessage === void 0 || rawMessage === null) {
+        return;
+      }
+      const message = String(rawMessage);
+      if (message.length === 0) {
+        return;
+      }
+      try {
+        emit(this.buildHookLogEvent(entry, params, message));
+      } catch (error) {
+        if (typeof console !== "undefined" && typeof console.error === "function") {
+          console.error(error);
+        }
+      }
+    };
+  }
+  buildHookLogEvent(entry, params, message) {
+    const ancestors = this.adapter.getAncestors(params.scope.id);
+    const path2 = ancestors.map((node) => this.toPathSegment(node));
+    const targetSegment = this.toPathSegment(params.scope);
+    path2.push(targetSegment);
+    const direction = params.direction ?? "asc";
+    const phase = direction === "desc" ? "after" : "before";
+    const scenarioIndex = this.findScenarioSegmentIndex(path2);
+    const scenarioDetails = this.buildScenarioDetails(path2, scenarioIndex, params);
+    const language = this.resolveLanguage(params, scenarioDetails);
+    const targetKeyword = this.scopeKeywords.get(params.scope.id);
+    if (params.step) {
+      path2.push(this.toStepSegment(params.scope, params.step));
+    }
+    return {
+      message,
+      hookId: entry.hook.id,
+      hookType: entry.hook.type,
+      ...entry.hook.description ? { hookDescription: entry.hook.description } : {},
+      phase,
+      path: path2,
+      ...scenarioDetails ? { scenario: scenarioDetails } : {},
+      ...params.step ? { step: this.toStepDetails(params.step) } : {},
+      ...targetKeyword ? { targetKeyword } : {},
+      ...language ? { language } : {}
+    };
+  }
+  toPathSegment(scope) {
+    const keyword = this.scopeKeywords.get(scope.id);
+    return {
+      id: scope.id,
+      kind: scope.kind,
+      name: scope.name,
+      ...keyword ? { keyword } : {}
+    };
+  }
+  toStepSegment(scope, step) {
+    const keyword = step.gherkin?.keyword ?? step.definition?.keyword;
+    return {
+      id: `${scope.id}:step:${step.index}`,
+      kind: "step",
+      name: this.describeStep(step),
+      ...keyword ? { keyword: keyword.trim() } : {}
+    };
+  }
+  toStepDetails(step) {
+    return {
+      index: step.index,
+      ...step.gherkin?.keyword ? { keyword: step.gherkin.keyword } : {},
+      ...step.gherkin?.text ? { text: step.gherkin.text } : {},
+      ...step.status ? { status: step.status } : {}
+    };
+  }
+  describeStep(step) {
+    const keyword = step.gherkin?.keyword ?? step.definition?.keyword;
+    const text = step.gherkin?.text ?? this.describeStepExpression(step.definition);
+    if (keyword) {
+      const trimmedKeyword = keyword.trim();
+      if (text && text.length > 0) {
+        const needsSpace = text.startsWith(" ");
+        return `${trimmedKeyword}${needsSpace ? "" : " "}${text}`;
+      }
+      return trimmedKeyword;
+    }
+    if (text && text.length > 0) {
+      return text;
+    }
+    return `Step #${step.index + 1}`;
+  }
+  describeStepExpression(definition) {
+    if (!definition) {
+      return void 0;
+    }
+    const expression = definition.expression;
+    if (typeof expression === "string") {
+      return expression;
+    }
+    return expression.toString();
+  }
+  findScenarioSegmentIndex(path2) {
+    for (let index = path2.length - 1; index >= 0; index -= 1) {
+      const segment = path2[index];
+      if (!segment) {
+        continue;
+      }
+      if (segment.kind === "scenario") {
+        return index;
+      }
+      if (segment.kind === "scenarioOutline") {
+        return index;
+      }
+    }
+    return -1;
+  }
+  buildScenarioDetails(path2, scenarioIndex, params) {
+    if (scenarioIndex < 0) {
+      return void 0;
+    }
+    const scenarioSegment = path2[scenarioIndex];
+    if (!scenarioSegment) {
+      return void 0;
+    }
+    const segments = path2.slice(0, scenarioIndex + 1).map((segment) => segment.name);
+    const fullName = segments.join(" \u203A ");
+    const scenario = params.scenario;
+    const keyword = scenario?.keyword ?? scenarioSegment.keyword;
+    const language = scenario?.feature.feature.language ?? this.featureLanguage;
+    if (scenario) {
+      return {
+        id: scenario.id,
+        name: scenario.name,
+        fullName,
+        ...keyword ? { keyword } : {},
+        ...language ? { language } : {}
+      };
+    }
+    return {
+      id: scenarioSegment.id,
+      name: scenarioSegment.name,
+      fullName,
+      ...keyword ? { keyword } : {},
+      ...language ? { language } : {}
+    };
+  }
+  resolveLanguage(params, scenarioDetails) {
+    if (params.scenario) {
+      const scenarioLanguage = params.scenario.feature.feature.language;
+      if (scenarioLanguage) {
+        return scenarioLanguage;
+      }
+    }
+    if (scenarioDetails?.language) {
+      return scenarioDetails.language;
+    }
+    return this.featureLanguage;
+  }
+  sortHooks(hooks, direction) {
+    return hooks.slice().sort((a, b) => this.compareHooks(a, b, direction));
+  }
+  compareHooks(a, b, direction) {
+    const orderA = a.hook.options.order ?? 5;
+    const orderB = b.hook.options.order ?? 5;
+    if (orderA !== orderB) {
+      return direction === "asc" ? orderA - orderB : orderB - orderA;
+    }
+    const depthA = this.depthMap.get(a.scope.id) ?? 0;
+    const depthB = this.depthMap.get(b.scope.id) ?? 0;
+    if (depthA !== depthB) {
+      return direction === "asc" ? depthB - depthA : depthA - depthB;
+    }
+    return a.hook.id.localeCompare(b.hook.id);
+  }
+  buildDepthMap(node, depth) {
+    this.depthMap.set(node.id, depth);
+    for (const child of node.children) {
+      this.buildDepthMap(child, depth + 1);
+    }
+  }
+};
+function normalizeError(value, fallbackMessage) {
+  if (value instanceof Error) {
+    return value;
+  }
+  const error = new Error(fallbackMessage);
+  Object.defineProperty(error, "cause", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value
+  });
+  return error;
+}
+function toError(value, fallbackMessage) {
+  return normalizeError(value, fallbackMessage);
+}
+function combineErrors(values, message) {
+  const normalized = values.map(
+    (value, index) => normalizeError(value, `${message} (${index + 1})`)
+  );
+  const aggregate = new Error(message);
+  Object.defineProperty(aggregate, "cause", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: normalized
+  });
+  return aggregate;
+}
+function createWorldDisposer(world) {
+  const disposers = [];
+  if (world && typeof world === "object") {
+    const record = world;
+    const app = record.app;
+    if (isDisposable(app)) {
+      disposers.push(async () => {
+        await app.dispose();
+      });
+    }
+    const container = record.di ?? record.container;
+    if (isDisposable(container)) {
+      disposers.push(async () => {
+        await container.dispose();
+      });
+    }
+  }
+  return async () => {
+    if (disposers.length === 0) {
+      return;
+    }
+    const errors = [];
+    for (const dispose of disposers) {
+      try {
+        await dispose();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length === 1) {
+      throw toError(errors[0], "World disposal failed");
+    }
+    if (errors.length > 1) {
+      throw combineErrors(errors, "Multiple errors occurred while disposing world resources");
+    }
+  };
+}
+function isDisposable(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  const dispose = candidate.dispose;
+  return typeof dispose === "function";
+}
+
+// src/execute-plan.ts
+function runSuiteWithMetadata(suite, metadata, title, handler, timeout) {
+  const target = suite;
+  if (typeof target.__withMetadata === "function") {
+    target.__withMetadata(metadata, () => {
+      suite(title, handler, timeout);
+    });
+    return;
+  }
+  suite(title, handler, timeout);
+}
+function isScenarioOutlineExample2(execution) {
+  return execution.type === "example";
+}
+function shouldDisplayExamplesGroup(group, totalGroups) {
+  if (totalGroups > 1) {
+    return true;
+  }
+  const name = group.name?.trim();
+  return Boolean(name && name.length > 0);
+}
+function formatExamplesGroupTitle(group, index) {
+  const trimmed = group.name?.trim();
+  if (trimmed && trimmed.length > 0) {
+    return trimmed;
+  }
+  return `Table #${index + 1}`;
+}
+function registerFeaturePlan(options) {
+  const { plan, runtime, adapter, config, hookLogger } = options;
+  const feature = plan.feature;
+  const tagFilter = createTagFilter(config.test?.tagFilter);
+  const scopeKeywords = collectScopeKeywords(feature);
+  const eventEmitter = events.getEventEmitter();
+  const featureRef = createFeatureRef(feature.feature);
+  const lifecycle = new ScopeLifecycle(adapter, {
+    ...hookLogger ? { hookLogger } : {},
+    featureLanguage: feature.feature.language,
+    scopeKeywords
+  });
+  const featureTags = [
+    ...feature.feature.tags ?? [],
+    ...feature.scope.tags ?? []
+  ];
+  const featureMode = resolveModeFromTags(feature.scope.mode, featureTags);
+  const featureTimeout = resolveTimeout(feature.scope.timeout, config);
+  const featureSuite = selectSuiteByMode(runtime.suite, featureMode);
+  runSuiteWithMetadata(
+    featureSuite,
+    { kind: "feature", keyword: feature.keyword },
+    feature.name,
+    () => {
+      runtime.beforeAll(async () => {
+        await eventEmitter.featureStarted({ feature: featureRef });
+      });
+      runtime.afterAll(async () => {
+        await eventEmitter.featureCompleted({ feature: featureRef });
+      });
+      lifecycle.configurePersistentScope(feature.scope, runtime);
+      registerScenarios(feature.scenarios, runtime, config, tagFilter, lifecycle, feature.feature);
+      registerScenarioOutlines(feature.scenarioOutlines, runtime, config, tagFilter, lifecycle, feature.feature, featureRef);
+      registerRules(feature.rules, runtime, config, tagFilter, lifecycle, feature.feature, featureRef);
+    },
+    featureTimeout.milliseconds
+  );
+}
+function collectScopeKeywords(feature) {
+  const entries = [];
+  entries.push([feature.scope.id, feature.keyword]);
+  for (const scenario of feature.scenarios) {
+    entries.push([scenario.scope.id, scenario.keyword]);
+  }
+  for (const outline of feature.scenarioOutlines) {
+    entries.push([outline.scope.id, outline.keyword]);
+    for (const example of outline.examples) {
+      entries.push([example.scope.id, example.keyword]);
+    }
+  }
+  for (const rule of feature.rules) {
+    entries.push([rule.scope.id, rule.keyword]);
+    for (const scenario of rule.scenarios) {
+      entries.push([scenario.scope.id, scenario.keyword]);
+    }
+    for (const outline of rule.scenarioOutlines) {
+      entries.push([outline.scope.id, outline.keyword]);
+      for (const example of outline.examples) {
+        entries.push([example.scope.id, example.keyword]);
+      }
+    }
+  }
+  return new Map(entries);
+}
+function registerRules(rules, runtime, config, tagFilter, lifecycle, feature, featureRef) {
+  const eventEmitter = events.getEventEmitter();
+  for (const rule of rules) {
+    const ruleRef = createRuleRef(rule.rule);
+    const ruleTags = [
+      ...rule.rule.tags ?? [],
+      ...rule.scope.tags ?? []
+    ];
+    const ruleMode = resolveModeFromTags(rule.scope.mode, ruleTags);
+    const suite = selectSuiteByMode(runtime.suite, ruleMode);
+    const timeout = resolveTimeout(rule.scope.timeout, config);
+    runSuiteWithMetadata(
+      suite,
+      { kind: "rule", keyword: rule.keyword },
+      rule.name,
+      () => {
+        runtime.beforeAll(async () => {
+          await eventEmitter.ruleStarted({ feature: featureRef, rule: ruleRef });
+        });
+        runtime.afterAll(async () => {
+          await eventEmitter.ruleCompleted({ feature: featureRef, rule: ruleRef });
+        });
+        lifecycle.configurePersistentScope(rule.scope, runtime);
+        registerScenarios(rule.scenarios, runtime, config, tagFilter, lifecycle, feature);
+        registerScenarioOutlines(rule.scenarioOutlines, runtime, config, tagFilter, lifecycle, feature, featureRef);
+      },
+      timeout.milliseconds
+    );
+  }
+}
+function registerScenarioOutlines(outlines, runtime, config, tagFilter, lifecycle, feature, featureRef) {
+  const eventEmitter = events.getEventEmitter();
+  for (const outline of outlines) {
+    const outlineMode = resolveModeFromTags(outline.mode, outline.tags);
+    const suite = selectSuiteByMode(runtime.suite, outlineMode);
+    const timeout = resolveTimeout(outline.timeout, config);
+    runSuiteWithMetadata(
+      suite,
+      { kind: "scenarioOutline", keyword: outline.keyword },
+      outline.name,
+      () => {
+        const firstRule = outline.examples[0]?.rule?.rule;
+        runtime.beforeAll(async () => {
+          await eventEmitter.scenarioOutlineStarted({
+            feature: featureRef,
+            scenarioOutline: outline.outline,
+            ...firstRule ? { rule: createRuleRef(firstRule) } : {}
+          });
+        });
+        runtime.afterAll(async () => {
+          await eventEmitter.scenarioOutlineCompleted({
+            feature: featureRef,
+            scenarioOutline: outline.outline,
+            ...firstRule ? { rule: createRuleRef(firstRule) } : {}
+          });
+        });
+        lifecycle.configurePersistentScope(outline.scope, runtime);
+        registerScenarioExecutions(outline.examples, runtime, config, tagFilter, lifecycle, feature);
+      },
+      timeout.milliseconds
+    );
+  }
+}
+function registerScenarios(scenarios, runtime, config, tagFilter, lifecycle, feature) {
+  registerScenarioExecutions(scenarios, runtime, config, tagFilter, lifecycle, feature);
+}
+function registerScenarioExecutions(executions, runtime, config, tagFilter, lifecycle, feature) {
+  const standaloneExecutions = [];
+  const outlineExamples = /* @__PURE__ */ new Map();
+  for (const execution of executions) {
+    if (isScenarioOutlineExample2(execution)) {
+      const outlineId = execution.outline.scope.id;
+      let collection = outlineExamples.get(outlineId);
+      if (!collection) {
+        collection = {
+          outline: execution.outline,
+          order: [],
+          groups: /* @__PURE__ */ new Map()
+        };
+        outlineExamples.set(outlineId, collection);
+      }
+      const groupId = execution.exampleGroup.id;
+      let groupInfo = collection.groups.get(groupId);
+      if (!groupInfo) {
+        groupInfo = {
+          group: execution.exampleGroup,
+          examples: []
+        };
+        collection.groups.set(groupId, groupInfo);
+        collection.order.push(groupId);
+      }
+      groupInfo.examples.push(execution);
+      continue;
+    }
+    standaloneExecutions.push(execution);
+  }
+  for (const execution of standaloneExecutions) {
+    scheduleScenario(execution, runtime, config, tagFilter, lifecycle, feature);
+  }
+  for (const collection of outlineExamples.values()) {
+    const orderedGroups = collection.order.map((id) => collection.groups.get(id)).filter((info) => Boolean(info));
+    if (orderedGroups.length === 0) {
+      continue;
+    }
+    if (orderedGroups.length === 1) {
+      const [singleGroup] = orderedGroups;
+      if (singleGroup && !shouldDisplayExamplesGroup(singleGroup.group, orderedGroups.length)) {
+        for (const example of singleGroup.examples) {
+          scheduleScenario(example, runtime, config, tagFilter, lifecycle, feature);
+        }
+        continue;
+      }
+    }
+    orderedGroups.forEach((info, index) => {
+      const title = formatExamplesGroupTitle(info.group, index);
+      const keyword = (info.group.keyword ?? "Examples").trim() || "Examples";
+      runSuiteWithMetadata(
+        runtime.suite,
+        { kind: "examples", keyword },
+        title,
+        () => {
+          for (const example of info.examples) {
+            scheduleScenario(example, runtime, config, tagFilter, lifecycle, feature);
+          }
+        }
+      );
+    });
+  }
+}
+function scheduleScenario(execution, runtime, config, tagFilter, lifecycle, feature) {
+  const title = buildScenarioTitle(execution);
+  const eventEmitter = events.getEventEmitter();
+  if (!tagFilter.evaluate(execution.tags)) {
+    runtime.test.skip(title, () => void 0);
+    return;
+  }
+  if (execution.pending) {
+    execution.markPending(execution.pendingReason);
+    registerPendingScenarioTest(execution, runtime, title);
+    return;
+  }
+  const effectiveMode = resolveModeFromTags(execution.mode, execution.tags);
+  const testFn = selectTestByMode(runtime.test, effectiveMode);
+  const scenarioTimeout = resolveTimeout(execution.timeout, config);
+  testFn(title, async () => {
+    const hooks = lifecycle.collectScenarioHooks(execution);
+    const pickle = requirePickle(feature, execution.gherkin.id);
+    const scenarioScope = pickle.scenario;
+    const isExample = isScenarioOutlineExample2(execution);
+    if (isExample) {
+      await eventEmitter.exampleStarted({
+        feature: pickle.feature,
+        scenarioOutline: execution.outline.outline,
+        example: execution.exampleGroup,
+        pickle,
+        ...pickle.rule ? { rule: pickle.rule } : {}
+      });
+    }
+    await eventEmitter.scenarioStarted({
+      feature: pickle.feature,
+      scenario: scenarioScope,
+      pickle,
+      ...pickle.rule ? { rule: pickle.rule } : {}
+    });
+    let status;
+    try {
+      await lifecycle.runScenario(
+        execution,
+        hooks,
+        async (_world, context) => {
+          await runScenarioExecution(execution, context);
+        },
+        { events: { pickle } }
+      );
+      status = execution.result.status === "passed" ? events.TestStatus.PASSED : execution.result.status === "failed" ? events.TestStatus.FAILED : execution.result.status === "skipped" ? events.TestStatus.SKIPPED : execution.result.status === "pending" ? events.TestStatus.SKIPPED : void 0;
+    } catch (error) {
+      status = events.TestStatus.FAILED;
+      if (!errors.isGherkinStepError(error)) {
+        await eventEmitter.errorRaised({
+          error,
+          phase: "scenario",
+          feature: pickle.feature,
+          scenario: pickle.scenario,
+          ...pickle.rule ? { rule: pickle.rule } : {},
+          pickle
+        });
+      }
+      throw error;
+    } finally {
+      if (status) {
+        await eventEmitter.statusChanged({
+          status,
+          feature: pickle.feature,
+          scenario: pickle.scenario,
+          ...pickle.rule ? { rule: pickle.rule } : {},
+          pickle,
+          metadata: { result: execution.result }
+        });
+      }
+      await eventEmitter.scenarioCompleted({
+        feature: pickle.feature,
+        scenario: scenarioScope,
+        pickle,
+        ...pickle.rule ? { rule: pickle.rule } : {},
+        metadata: { result: execution.result }
+      });
+      if (isExample) {
+        await eventEmitter.exampleCompleted({
+          feature: pickle.feature,
+          scenarioOutline: execution.outline.outline,
+          example: execution.exampleGroup,
+          pickle,
+          ...pickle.rule ? { rule: pickle.rule } : {},
+          metadata: { result: execution.result }
+        });
+      }
+    }
+  }, scenarioTimeout.milliseconds);
+}
+function registerPendingScenarioTest(execution, runtime, title) {
+  const reason = execution.pendingReason;
+  const { test } = runtime;
+  if (typeof test.todo === "function") {
+    test.todo(title, reason);
+    return;
+  }
+  if (typeof test.pending === "function") {
+    test.pending(title, reason);
+    return;
+  }
+  if (typeof test.skip === "function") {
+    test.skip(title, () => void 0);
+    return;
+  }
+  test(title, () => void 0);
+}
+function buildScenarioTitle(execution) {
+  if (!isScenarioOutlineExample2(execution)) {
+    return execution.name;
+  }
+  const descriptor = formatExampleDescriptor(execution);
+  if (!descriptor) {
+    return `${execution.name} [Example ${execution.exampleIndex + 1}]`;
+  }
+  return `${execution.name} [${descriptor}]`;
+}
+function formatExampleDescriptor(example) {
+  const segments = [];
+  segments.push(`Example ${example.exampleIndex + 1}`);
+  const groupName = example.exampleGroup.name?.trim();
+  if (groupName) {
+    segments.push(groupName);
+  }
+  const valueSummary = formatExampleValues(example.exampleGroup, example.exampleIndex);
+  if (valueSummary) {
+    segments.push(valueSummary);
+  }
+  return segments.length > 0 ? segments.join(" \xB7 ") : void 0;
+}
+function formatExampleValues(group, index) {
+  const headers = group.tableHeader ?? [];
+  const rows = group.tableBody ?? [];
+  const row = rows[index];
+  if (!row || headers.length === 0) {
+    return void 0;
+  }
+  const pairs = [];
+  headers.forEach((header, headerIndex) => {
+    const key = header?.trim();
+    if (!key) {
+      return;
+    }
+    const value = row[headerIndex] ?? "";
+    pairs.push(`${key}=${String(value).trim()}`);
+  });
+  return pairs.length > 0 ? pairs.join(", ") : void 0;
+}
+
+// src/index.ts
+var src_default = {};
+
+exports.Pending = Pending;
+exports.ScenarioPendingError = ScenarioPendingError;
+exports.ScopeLifecycle = ScopeLifecycle;
+exports.ToDo = ToDo;
+exports.chooseTimeout = chooseTimeout;
+exports.clearStepDocstring = clearStepDocstring;
+exports.clearStepMetadata = clearStepMetadata;
+exports.clearStepTable = clearStepTable;
+exports.collectScenarioHooks = collectScenarioHooks;
+exports.configureStepDocstrings = configureStepDocstrings;
+exports.configureStepTables = configureStepTables;
+exports.consumeDocstring = consumeDocstring;
+exports.consumeTable = consumeTable;
+exports.createStepRuntime = createStepRuntime;
+exports.createTagFilter = createTagFilter;
+exports.default = src_default;
+exports.getDocstring = getDocstring;
+exports.getDocstringInfo = getDocstringInfo;
+exports.getDocstringMediaType = getDocstringMediaType;
+exports.getRawTable = getRawTable;
+exports.getStepMetadata = getStepMetadata;
+exports.getTable = getTable;
+exports.getWorld = getWorld;
+exports.isScenarioPendingError = isScenarioPendingError;
+exports.markScenarioPending = markScenarioPending;
+exports.registerFeaturePlan = registerFeaturePlan;
+exports.resetStepDocstringConfig = resetStepDocstringConfig;
+exports.resetStepTableConfig = resetStepTableConfig;
+exports.resolveModeFromTags = resolveModeFromTags;
+exports.resolveTimeout = resolveTimeout;
+exports.runScenarioExecution = runScenarioExecution;
+exports.selectSuiteByMode = selectSuiteByMode;
+exports.selectTestByMode = selectTestByMode;
+exports.setStepDocstring = setStepDocstring;
+exports.setStepDocstringInfo = setStepDocstringInfo;
+exports.setStepMetadata = setStepMetadata;
+exports.setStepTable = setStepTable;
+exports.tryGetWorld = tryGetWorld;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map