@autometa/runner 0.6.4 → 1.0.0-rc.1

package/dist/index.cjs

@@ -0,0 +1,2212 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var executor = require('@autometa/executor');
+var cucumberExpressions$1 = require('@autometa/cucumber-expressions');
+var scopes = require('@autometa/scopes');
+var cucumberExpressions = require('@cucumber/cucumber-expressions');
+var assertions = require('@autometa/assertions');
+var injection = require('@autometa/injection');
+var coordinator = require('@autometa/coordinator');
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _registry;
+var ParameterRegistryAdapter = class {
+  constructor(options = {}) {
+    __privateAdd(this, _registry, void 0);
+    __privateSet(this, _registry, options.registry ?? new cucumberExpressions.ParameterTypeRegistry());
+  }
+  get registry() {
+    return __privateGet(this, _registry);
+  }
+  get parameterTypes() {
+    return __privateGet(this, _registry).parameterTypes;
+  }
+  lookupByTypeName(name) {
+    return __privateGet(this, _registry).lookupByTypeName(name);
+  }
+  lookupByRegexp(parameterTypeRegexp, expressionRegexp, text) {
+    return __privateGet(this, _registry).lookupByRegexp(parameterTypeRegexp, expressionRegexp, text);
+  }
+  defineParameterType(definition) {
+    const parameter = definition;
+    __privateGet(this, _registry).defineParameterType(parameter);
+    return parameter;
+  }
+};
+_registry = new WeakMap();
+function createParameterRegistryAdapter(options) {
+  return new ParameterRegistryAdapter(options);
+}
+
+// src/core/runner-context.ts
+var RunnerContext = class _RunnerContext {
+  constructor(options = {}) {
+    this.registryAdapter = options.parameterRegistry ? createParameterRegistryAdapter({ registry: options.parameterRegistry }) : createParameterRegistryAdapter();
+    this.defineParameterTypeFn = cucumberExpressions$1.createParameterTypes(
+      options.parameterTypesOptions
+    );
+    this.registerDefaultParameterTypesFn = cucumberExpressions$1.createDefaultParameterTypes(
+      options.parameterTypesOptions
+    );
+    const scopeOptions = _RunnerContext.extractScopeOptions(options);
+    this.scopesInternal = scopes.createScopes({
+      ...scopeOptions,
+      parameterRegistry: this.registryAdapter
+    });
+    if (options.registerDefaultParameterTypes !== false) {
+      this.registerDefaultParameterTypes();
+    }
+    if (options.parameterTypes && options.parameterTypes.length > 0) {
+      this.defineParameterTypes(...options.parameterTypes);
+    }
+  }
+  get scopes() {
+    return this.scopesInternal;
+  }
+  get parameterRegistry() {
+    return this.registryAdapter.registry;
+  }
+  get parameterRegistryAdapter() {
+    return this.registryAdapter;
+  }
+  get plan() {
+    return this.scopesInternal.plan();
+  }
+  defineParameterType(definition) {
+    return this.defineParameterTypeFn(this.parameterRegistry, definition);
+  }
+  defineParameterTypes(...definitions) {
+    this.defineParameterTypeFn.many(this.parameterRegistry, ...definitions);
+    return this.parameterRegistry;
+  }
+  registerDefaultParameterTypes() {
+    return this.registerDefaultParameterTypesFn(this.parameterRegistry);
+  }
+  lookupParameterType(name) {
+    return this.parameterRegistry.lookupByTypeName(name);
+  }
+  static extractScopeOptions(options) {
+    const {
+      parameterRegistry: _parameterRegistry,
+      parameterTypes: _parameterTypes,
+      parameterTypesOptions: _parameterTypesOptions,
+      registerDefaultParameterTypes: _registerDefaultParameterTypes,
+      ...scopeOptions
+    } = options;
+    return scopeOptions;
+  }
+};
+
+// src/dsl/create-runner.ts
+var hookWrapperCache = /* @__PURE__ */ new WeakMap();
+function wrapHook(hook) {
+  if (typeof hook !== "function") {
+    throw new TypeError("Hook DSL must be a function");
+  }
+  const cached = hookWrapperCache.get(hook);
+  if (cached) {
+    return cached;
+  }
+  const callable = (first, second, third) => {
+    if (typeof first === "string") {
+      return hook(first, second, third);
+    }
+    return hook(first, second);
+  };
+  hookWrapperCache.set(hook, callable);
+  const assignVariant = (variant, source) => {
+    if (typeof source === "function") {
+      callable[variant] = wrapHook(
+        source
+      );
+    }
+  };
+  assignVariant("skip", hook.skip);
+  assignVariant("only", hook.only);
+  assignVariant("failing", hook.failing);
+  assignVariant("concurrent", hook.concurrent);
+  return callable;
+}
+function wrapStepHandler(handler) {
+  return (world, ...args) => {
+    const runtime = executor.createStepRuntime(world);
+    const withRuntime = handler;
+    const withoutRuntime = handler;
+    const paramLength = typeof handler === "function" ? handler.length : 0;
+    const expectsRuntime = paramLength > args.length + 1;
+    const invocationArgs = expectsRuntime ? [...args, runtime, world] : [...args, world];
+    const callable = expectsRuntime ? withRuntime : withoutRuntime;
+    return Reflect.apply(callable, world, invocationArgs);
+  };
+}
+function enhanceStepDsl(dsl) {
+  const cache = /* @__PURE__ */ new Map();
+  const convert = (source) => {
+    const existing = cache.get(source);
+    if (existing) {
+      return existing;
+    }
+    const invoke = (expression, handler, options) => source(
+      expression,
+      wrapStepHandler(handler),
+      options
+    );
+    cache.set(source, invoke);
+    invoke.skip = convert(source.skip);
+    invoke.only = convert(source.only);
+    invoke.failing = convert(source.failing);
+    invoke.concurrent = convert(source.concurrent);
+    invoke.tags = (...inputs) => convert(source.tags(...inputs));
+    return invoke;
+  };
+  return convert(dsl);
+}
+function createRunner(options = {}) {
+  const context = new RunnerContext(options);
+  const scopes = context.scopes;
+  const given = enhanceStepDsl(scopes.given);
+  const when = enhanceStepDsl(scopes.when);
+  const then = enhanceStepDsl(scopes.then);
+  const and = enhanceStepDsl(scopes.and);
+  const but = enhanceStepDsl(scopes.but);
+  const defineParameterTypesFromList = (definitions) => context.defineParameterTypes(...definitions);
+  const beforeFeatureHook = wrapHook(scopes.beforeFeature);
+  const afterFeatureHook = wrapHook(scopes.afterFeature);
+  const beforeRuleHook = wrapHook(scopes.beforeRule);
+  const afterRuleHook = wrapHook(scopes.afterRule);
+  const beforeScenarioHook = wrapHook(scopes.beforeScenario);
+  const afterScenarioHook = wrapHook(scopes.afterScenario);
+  const beforeScenarioOutlineHook = wrapHook(scopes.beforeScenarioOutline);
+  const afterScenarioOutlineHook = wrapHook(scopes.afterScenarioOutline);
+  const beforeStepHook = wrapHook(scopes.beforeStep);
+  const afterStepHook = wrapHook(scopes.afterStep);
+  const environment = {
+    context,
+    parameterRegistry: context.parameterRegistry,
+    getPlan: () => context.plan,
+    defineParameterType: (definition) => context.defineParameterType(definition),
+    defineParameterTypes: (...definitions) => context.defineParameterTypes(...definitions),
+    defineParameterTypesFromList,
+    registerDefaultParameterTypes: () => context.registerDefaultParameterTypes(),
+    lookupParameterType: (name) => context.lookupParameterType(name),
+    feature: scopes.feature,
+    rule: scopes.rule,
+    scenario: scopes.scenario,
+    scenarioOutline: scopes.scenarioOutline,
+    given,
+    when,
+    then,
+    and,
+    but,
+    beforeFeature: beforeFeatureHook,
+    afterFeature: afterFeatureHook,
+    beforeRule: beforeRuleHook,
+    afterRule: afterRuleHook,
+    beforeScenario: beforeScenarioHook,
+    afterScenario: afterScenarioHook,
+    beforeScenarioOutline: beforeScenarioOutlineHook,
+    afterScenarioOutline: afterScenarioOutlineHook,
+    beforeStep: beforeStepHook,
+    afterStep: afterStepHook,
+    Given: given,
+    When: when,
+    Then: then,
+    And: and,
+    But: but,
+    plan: scopes.plan,
+    BeforeFeature: beforeFeatureHook,
+    AfterFeature: afterFeatureHook,
+    BeforeRule: beforeRuleHook,
+    AfterRule: afterRuleHook,
+    BeforeScenario: beforeScenarioHook,
+    AfterScenario: afterScenarioHook,
+    BeforeScenarioOutline: beforeScenarioOutlineHook,
+    AfterScenarioOutline: afterScenarioOutlineHook,
+    BeforeStep: beforeStepHook,
+    AfterStep: afterStepHook
+  };
+  return environment;
+}
+
+// src/dsl/create-global-runner.ts
+function createGlobalRunner(initialOptions) {
+  let lastOptions = initialOptions;
+  function instantiate(options) {
+    if (options) {
+      lastOptions = options;
+      return createRunner(options);
+    }
+    if (lastOptions) {
+      return createRunner(lastOptions);
+    }
+    return createRunner();
+  }
+  let current = instantiate(initialOptions);
+  const target = {
+    reset(options) {
+      current = instantiate(options);
+      return current;
+    },
+    useEnvironment(environment) {
+      current = environment;
+      return current;
+    },
+    getEnvironment() {
+      return current;
+    }
+  };
+  const forwardedKeys = /* @__PURE__ */ new Set([
+    "reset",
+    "useEnvironment",
+    "getEnvironment"
+  ]);
+  return new Proxy(target, {
+    get(obj, prop, receiver) {
+      if (forwardedKeys.has(prop)) {
+        return Reflect.get(obj, prop, receiver);
+      }
+      const value = current[prop];
+      if (typeof value === "function") {
+        return value.bind(current);
+      }
+      return value;
+    },
+    has(_, prop) {
+      if (forwardedKeys.has(prop)) {
+        return true;
+      }
+      return prop in current;
+    },
+    ownKeys() {
+      const forwardable = Array.from(forwardedKeys).filter(
+        (key) => typeof key === "string" || typeof key === "symbol"
+      );
+      const keys = /* @__PURE__ */ new Set([
+        ...Reflect.ownKeys(current),
+        ...forwardable
+      ]);
+      return Array.from(keys);
+    },
+    getOwnPropertyDescriptor(obj, prop) {
+      if (forwardedKeys.has(prop)) {
+        return {
+          configurable: true,
+          enumerable: false,
+          value: Reflect.get(obj, prop)
+        };
+      }
+      return Object.getOwnPropertyDescriptor(current, prop);
+    }
+  });
+}
+function createDecoratorRunner(options = {}) {
+  const context = new RunnerContext(options);
+  const registry = new scopes.DecoratorScopeRegistry();
+  const scopeOptions = RunnerContext.extractScopeOptions(options);
+  return {
+    feature(token, descriptor) {
+      registry.registerFeature(token, descriptor);
+    },
+    rule(featureToken, token, descriptor) {
+      registry.registerRule(featureToken, token, descriptor);
+    },
+    scenario(token, descriptor, scenarioContext) {
+      registry.registerScenario(token, descriptor, scenarioContext);
+    },
+    step(scenarioToken, keyword, expression, handler, options2) {
+      registry.registerStep(scenarioToken, {
+        keyword,
+        expression,
+        handler,
+        ...options2 ? { options: options2 } : {}
+      });
+    },
+    hook(scopeToken, type, handler, description, options2) {
+      registry.registerHook(scopeToken, {
+        type,
+        handler,
+        ...description ? { description } : {},
+        ...options2 ? { options: options2 } : {}
+      });
+    },
+    context,
+    buildPlan() {
+      return registry.build(
+        createScopeOptions(scopeOptions, context.parameterRegistryAdapter)
+      );
+    }
+  };
+}
+function createScopeOptions(opts, parameterRegistry) {
+  return {
+    ...opts,
+    parameterRegistry
+  };
+}
+
+// src/decorators/create-runner-decorators.ts
+function createRunnerDecorators(environment) {
+  const stepMetadata = /* @__PURE__ */ new WeakMap();
+  const hookMetadata = /* @__PURE__ */ new WeakMap();
+  const scenarioRecords = /* @__PURE__ */ new WeakMap();
+  const pendingScenarioData = /* @__PURE__ */ new WeakMap();
+  const ruleRecords = /* @__PURE__ */ new WeakMap();
+  const pendingRuleData = /* @__PURE__ */ new WeakMap();
+  const featureHooks = /* @__PURE__ */ new WeakMap();
+  function getOrCreateRecordMap(constructor) {
+    let records = scenarioRecords.get(constructor);
+    if (!records) {
+      records = /* @__PURE__ */ new Map();
+      scenarioRecords.set(constructor, records);
+    }
+    return records;
+  }
+  function getOrCreatePending(constructor) {
+    let pending = pendingScenarioData.get(constructor);
+    if (!pending) {
+      pending = /* @__PURE__ */ new Map();
+      pendingScenarioData.set(constructor, pending);
+    }
+    return pending;
+  }
+  function getOrCreateRuleRecordMap(constructor) {
+    let records = ruleRecords.get(constructor);
+    if (!records) {
+      records = /* @__PURE__ */ new Map();
+      ruleRecords.set(constructor, records);
+    }
+    return records;
+  }
+  function getOrCreateRulePending(constructor) {
+    let pending = pendingRuleData.get(constructor);
+    if (!pending) {
+      pending = /* @__PURE__ */ new Map();
+      pendingRuleData.set(constructor, pending);
+    }
+    return pending;
+  }
+  function addStepAssociation(constructor, scenarioKey, stepKey) {
+    const records = scenarioRecords.get(constructor);
+    const record = records?.get(scenarioKey);
+    if (record) {
+      record.steps.add(stepKey);
+      return;
+    }
+    const pending = getOrCreatePending(constructor);
+    let entry = pending.get(scenarioKey);
+    if (!entry) {
+      entry = { steps: /* @__PURE__ */ new Set(), hooks: [] };
+      pending.set(scenarioKey, entry);
+    }
+    entry.steps.add(stepKey);
+  }
+  function addHookAssociation(constructor, scenarioKey, hook) {
+    const records = scenarioRecords.get(constructor);
+    const record = records?.get(scenarioKey);
+    if (record) {
+      record.hooks.push(hook);
+      return;
+    }
+    const pending = getOrCreatePending(constructor);
+    let entry = pending.get(scenarioKey);
+    if (!entry) {
+      entry = { steps: /* @__PURE__ */ new Set(), hooks: [] };
+      pending.set(scenarioKey, entry);
+    }
+    entry.hooks.push(hook);
+  }
+  function addRuleScenarioAssociation(constructor, ruleKey, scenarioKey) {
+    const records = ruleRecords.get(constructor);
+    const record = records?.get(ruleKey);
+    if (record) {
+      record.scenarios.add(scenarioKey);
+      return record.token;
+    }
+    const pending = getOrCreateRulePending(constructor);
+    let entry = pending.get(ruleKey);
+    if (!entry) {
+      entry = { scenarios: /* @__PURE__ */ new Set(), hooks: [] };
+      pending.set(ruleKey, entry);
+    }
+    entry.scenarios.add(scenarioKey);
+    return void 0;
+  }
+  function addRuleHookAssociation(constructor, ruleKey, hook) {
+    const records = ruleRecords.get(constructor);
+    const record = records?.get(ruleKey);
+    if (record) {
+      record.hooks.push(hook);
+      return;
+    }
+    const pending = getOrCreateRulePending(constructor);
+    let entry = pending.get(ruleKey);
+    if (!entry) {
+      entry = { scenarios: /* @__PURE__ */ new Set(), hooks: [] };
+      pending.set(ruleKey, entry);
+    }
+    entry.hooks.push(hook);
+  }
+  function recordFeatureHook(constructor, hook) {
+    const hooks = featureHooks.get(constructor);
+    if (hooks) {
+      hooks.push(hook);
+      return;
+    }
+    featureHooks.set(constructor, [hook]);
+  }
+  function recordStepMetadata(target, propertyKey, metadata) {
+    let map = stepMetadata.get(target);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      stepMetadata.set(target, map);
+    }
+    map.set(propertyKey, metadata);
+  }
+  function recordHookMetadata(target, propertyKey, metadata) {
+    let map = hookMetadata.get(target);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      hookMetadata.set(target, map);
+    }
+    map.set(propertyKey, metadata);
+  }
+  function getStepMetadata(target, propertyKey) {
+    return stepMetadata.get(target)?.get(propertyKey);
+  }
+  function getHookMetadata(target, propertyKey) {
+    return hookMetadata.get(target)?.get(propertyKey);
+  }
+  function normalizeSteps(value) {
+    return value ? new Set(value) : /* @__PURE__ */ new Set();
+  }
+  function isReadonlyArray(value) {
+    return Array.isArray(value);
+  }
+  function toArray(input) {
+    return isReadonlyArray(input) ? input : [input];
+  }
+  function buildStepOptions(options) {
+    const candidate = {};
+    if (options.tags) {
+      candidate.tags = [...options.tags];
+    }
+    if (options.timeout !== void 0) {
+      candidate.timeout = options.timeout;
+    }
+    if (options.mode) {
+      candidate.mode = options.mode;
+    }
+    if (options.data) {
+      candidate.data = { ...options.data };
+    }
+    return Object.keys(candidate).length > 0 ? candidate : void 0;
+  }
+  function buildHookOptions(options) {
+    const candidate = {};
+    if (options.tags) {
+      candidate.tags = [...options.tags];
+    }
+    if (options.timeout !== void 0) {
+      candidate.timeout = options.timeout;
+    }
+    if (options.order !== void 0) {
+      candidate.order = options.order;
+    }
+    if (options.mode) {
+      candidate.mode = options.mode;
+    }
+    if (options.data) {
+      candidate.data = { ...options.data };
+    }
+    return Object.keys(candidate).length > 0 ? candidate : void 0;
+  }
+  function normalizeTagInputs(inputs) {
+    if (inputs.length === 0) {
+      return [];
+    }
+    const tags = [];
+    for (const input of inputs) {
+      if (typeof input === "string") {
+        if (input.length > 0) {
+          tags.push(input);
+        }
+        continue;
+      }
+      if (Array.isArray(input)) {
+        for (const tag of input) {
+          if (typeof tag === "string" && tag.length > 0) {
+            tags.push(tag);
+          }
+        }
+      }
+    }
+    return tags.length > 0 ? Array.from(new Set(tags)) : [];
+  }
+  function mergeStepOptions(base, extras) {
+    if (!base && !extras) {
+      return void 0;
+    }
+    const mergedTags = [
+      ...base?.tags ?? [],
+      ...extras?.tags ?? []
+    ];
+    const timeout = extras?.timeout ?? base?.timeout;
+    const mode = extras?.mode ?? base?.mode;
+    const data = {
+      ...base?.data ?? {},
+      ...extras?.data ?? {}
+    };
+    const tagsResult = mergedTags.length > 0 ? Array.from(new Set(mergedTags)) : void 0;
+    const hasData = Object.keys(data).length > 0;
+    if (!tagsResult && timeout === void 0 && mode === void 0 && !hasData) {
+      return void 0;
+    }
+    return {
+      ...tagsResult ? { tags: tagsResult } : {},
+      ...timeout !== void 0 ? { timeout } : {},
+      ...mode !== void 0 ? { mode } : {},
+      ...hasData ? { data } : {}
+    };
+  }
+  function applyExecutionModeToStepOptions(mode, options) {
+    if (!options) {
+      return mode === "default" ? void 0 : { mode };
+    }
+    return mode !== "default" ? { ...options, mode } : { ...options };
+  }
+  function clonePendingOption(pending) {
+    if (typeof pending === "boolean" || typeof pending === "string") {
+      return pending;
+    }
+    const reason = pending.reason;
+    return reason !== void 0 ? { reason } : {};
+  }
+  function cloneScopeOptions(options) {
+    const {
+      tags,
+      description,
+      timeout,
+      mode,
+      source,
+      data,
+      examples,
+      pending
+    } = options;
+    const cloned = {
+      ...tags ? { tags: [...tags] } : {},
+      ...description !== void 0 ? { description } : {},
+      ...timeout !== void 0 ? {
+        timeout: typeof timeout === "number" ? timeout : { ...timeout }
+      } : {},
+      ...mode !== void 0 ? { mode } : {},
+      ...source ? { source: { ...source } } : {},
+      ...data ? { data: { ...data } } : {},
+      ...examples ? {
+        examples: examples.map((example) => ({
+          ...example,
+          ...example.tags ? { tags: [...example.tags] } : {},
+          table: example.table.map((row) => [...row])
+        }))
+      } : {}
+    };
+    if (pending !== void 0) {
+      cloned.pending = clonePendingOption(pending);
+    }
+    return cloned;
+  }
+  function Feature(options = {}) {
+    return (target) => {
+      const constructor = target;
+      const descriptor = {
+        name: options.name ?? constructor.name ?? "Feature",
+        ...cloneScopeOptions(options)
+      };
+      environment.feature(constructor, descriptor);
+      const featureHookRefs = featureHooks.get(constructor);
+      if (featureHookRefs) {
+        for (const hook of featureHookRefs) {
+          const metadata = getHookMetadata(constructor.prototype, hook.propertyKey) ?? getHookMetadata(constructor, hook.propertyKey);
+          if (!metadata) {
+            throw new Error(
+              `Hook metadata missing for ${String(hook.propertyKey)} on feature ${descriptor.name}`
+            );
+          }
+          environment.hook(
+            constructor,
+            hook.type,
+            metadata.handler,
+            hook.description,
+            hook.options ?? metadata.options
+          );
+        }
+        featureHooks.delete(constructor);
+      }
+      const rules = ruleRecords.get(constructor);
+      if (rules) {
+        for (const [ruleKey, ruleRecord] of rules.entries()) {
+          environment.rule(constructor, ruleRecord.token, ruleRecord.descriptor);
+          const hooks = ruleRecord.hooks;
+          for (const hook of hooks) {
+            const metadata = getHookMetadata(constructor.prototype, hook.propertyKey) ?? getHookMetadata(constructor, hook.propertyKey);
+            if (!metadata) {
+              throw new Error(
+                `Hook metadata missing for ${String(hook.propertyKey)} on rule ${String(ruleKey)} of feature ${descriptor.name}`
+              );
+            }
+            environment.hook(
+              ruleRecord.token,
+              hook.type,
+              metadata.handler,
+              hook.description,
+              hook.options ?? metadata.options
+            );
+          }
+        }
+      }
+      const records = scenarioRecords.get(constructor);
+      if (records) {
+        for (const [scenarioKey, record] of records.entries()) {
+          if (record.ruleKey) {
+            const ruleRecord = rules?.get(record.ruleKey);
+            if (!ruleRecord) {
+              throw new Error(
+                `Scenario ${record.descriptor.name} references unknown rule ${String(record.ruleKey)}`
+              );
+            }
+            record.ruleToken = record.ruleToken ?? ruleRecord.token;
+            ruleRecord.scenarios.add(scenarioKey);
+          }
+          environment.scenario(record.token, record.descriptor, {
+            feature: constructor,
+            ...record.ruleToken ? { rule: record.ruleToken } : {}
+          });
+          for (const stepKey of record.steps) {
+            const metadata = getStepMetadata(constructor.prototype, stepKey) ?? getStepMetadata(constructor, stepKey);
+            if (!metadata) {
+              throw new Error(
+                `Step metadata missing for ${String(stepKey)} on feature ${descriptor.name}`
+              );
+            }
+            environment.step(
+              record.token,
+              metadata.keyword,
+              metadata.expression,
+              metadata.handler,
+              metadata.options
+            );
+          }
+          for (const hook of record.hooks) {
+            const metadata = getHookMetadata(constructor.prototype, hook.propertyKey) ?? getHookMetadata(constructor, hook.propertyKey);
+            if (!metadata) {
+              throw new Error(
+                `Hook metadata missing for ${String(hook.propertyKey)} on feature ${descriptor.name}`
+              );
+            }
+            environment.hook(
+              record.token,
+              hook.type,
+              metadata.handler,
+              hook.description,
+              hook.options ?? metadata.options
+            );
+          }
+        }
+        scenarioRecords.delete(constructor);
+      }
+      ruleRecords.delete(constructor);
+      pendingRuleData.delete(constructor);
+      pendingScenarioData.delete(constructor);
+    };
+  }
+  function Rule(options) {
+    return (target, propertyKey) => {
+      const constructor = resolveConstructor(target);
+      const descriptor = {
+        name: options.name,
+        ...cloneScopeOptions(options)
+      };
+      const records = getOrCreateRuleRecordMap(constructor);
+      if (records.has(propertyKey)) {
+        throw new Error(`Rule ${String(propertyKey)} already registered on feature ${constructor.name}`);
+      }
+      const token = Symbol(`rule:${String(propertyKey)}`);
+      const record = {
+        token,
+        descriptor,
+        hooks: [],
+        scenarios: /* @__PURE__ */ new Set()
+      };
+      const pending = pendingRuleData.get(constructor)?.get(propertyKey);
+      if (pending) {
+        for (const scenarioKey of pending.scenarios) {
+          record.scenarios.add(scenarioKey);
+        }
+        record.hooks.push(...pending.hooks);
+        pendingRuleData.get(constructor)?.delete(propertyKey);
+      }
+      records.set(propertyKey, record);
+      const scenarios = scenarioRecords.get(constructor);
+      if (scenarios) {
+        for (const scenarioKey of record.scenarios) {
+          const scenarioRecord = scenarios.get(scenarioKey);
+          if (scenarioRecord) {
+            scenarioRecord.ruleToken = token;
+          }
+        }
+      }
+    };
+  }
+  function Scenario(options) {
+    return (target, propertyKey) => {
+      const constructor = resolveConstructor(target);
+      const records = getOrCreateRecordMap(constructor);
+      const descriptor = {
+        name: options.name,
+        kind: options.kind ?? "scenario",
+        ...cloneScopeOptions(options)
+      };
+      const token = Symbol(`scenario:${String(propertyKey)}`);
+      const steps = normalizeSteps(options.steps);
+      const hooks = [];
+      const ruleKey = options.rule;
+      let ruleToken;
+      if (ruleKey !== void 0) {
+        ruleToken = addRuleScenarioAssociation(constructor, ruleKey, propertyKey);
+      }
+      const pending = pendingScenarioData.get(constructor)?.get(propertyKey);
+      if (pending) {
+        for (const stepKey of pending.steps) {
+          steps.add(stepKey);
+        }
+        hooks.push(...pending.hooks);
+        pendingScenarioData.get(constructor)?.delete(propertyKey);
+      }
+      const record = {
+        token,
+        descriptor,
+        steps,
+        hooks,
+        ...ruleKey !== void 0 ? { ruleKey } : {},
+        ...ruleToken ? { ruleToken } : {}
+      };
+      records.set(propertyKey, record);
+    };
+  }
+  function createStepDecorator(keyword) {
+    const factoryCache = /* @__PURE__ */ new Map();
+    const getCachedFactory = (mode, inheritedOptions) => {
+      const cacheForOptions = factoryCache.get(inheritedOptions);
+      return cacheForOptions?.get(mode);
+    };
+    const storeFactory = (mode, inheritedOptions, factory) => {
+      let cacheForOptions = factoryCache.get(inheritedOptions);
+      if (!cacheForOptions) {
+        cacheForOptions = /* @__PURE__ */ new Map();
+        factoryCache.set(inheritedOptions, cacheForOptions);
+      }
+      cacheForOptions.set(mode, factory);
+    };
+    const buildFactory = (mode, inheritedOptions) => {
+      const cached = getCachedFactory(mode, inheritedOptions);
+      if (cached) {
+        return cached;
+      }
+      const decorator = (expression, options) => {
+        if (!options || !options.scenario) {
+          throw new Error("Step decorator requires a scenario property key");
+        }
+        const scenarioRefs = toArray(options.scenario);
+        const explicitOptions = buildStepOptions(options);
+        const baseWithMode = mergeStepOptions(
+          inheritedOptions,
+          applyExecutionModeToStepOptions(mode)
+        );
+        const mergedOptions = mergeStepOptions(baseWithMode, explicitOptions);
+        const finalOptions = applyExecutionModeToStepOptions(mode, mergedOptions);
+        return (target, propertyKey, descriptor) => {
+          const handler = descriptor?.value;
+          if (typeof handler !== "function") {
+            throw new Error(
+              `Step decorator can only be applied to methods. ${String(propertyKey)} is not a function.`
+            );
+          }
+          recordStepMetadata(target, propertyKey, {
+            keyword,
+            expression,
+            handler,
+            ...finalOptions ? { options: finalOptions } : {}
+          });
+          const constructor = resolveConstructor(target);
+          for (const scenarioKey of scenarioRefs) {
+            addStepAssociation(constructor, scenarioKey, propertyKey);
+          }
+        };
+      };
+      storeFactory(mode, inheritedOptions, decorator);
+      decorator.tags = (...inputs) => {
+        const normalizedTags = normalizeTagInputs(inputs);
+        if (normalizedTags.length === 0) {
+          return decorator;
+        }
+        const tagOptions = {
+          tags: normalizedTags
+        };
+        const merged = mergeStepOptions(inheritedOptions, tagOptions);
+        return buildFactory(mode, merged);
+      };
+      decorator.skip = mode === "skip" ? decorator : buildFactory("skip", inheritedOptions);
+      decorator.only = mode === "only" ? decorator : buildFactory("only", inheritedOptions);
+      decorator.failing = mode === "failing" ? decorator : buildFactory("failing", inheritedOptions);
+      decorator.concurrent = mode === "concurrent" ? decorator : buildFactory("concurrent", inheritedOptions);
+      return decorator;
+    };
+    return buildFactory("default");
+  }
+  function createScenarioHookDecorator(type) {
+    return (options) => {
+      if (!options || !options.scenario) {
+        throw new Error("Hook decorator requires a scenario property key");
+      }
+      const scenarioRefs = toArray(options.scenario);
+      const hookOptions = buildHookOptions(options);
+      const description = options.description;
+      return (target, propertyKey, descriptor) => {
+        const handler = descriptor?.value;
+        if (typeof handler !== "function") {
+          throw new Error(
+            `Hook decorator can only be applied to methods. ${String(propertyKey)} is not a function.`
+          );
+        }
+        recordHookMetadata(target, propertyKey, {
+          handler,
+          ...hookOptions ? { options: hookOptions } : {}
+        });
+        const constructor = resolveConstructor(target);
+        const hookRef = {
+          propertyKey,
+          type,
+          ...description ? { description } : {},
+          ...hookOptions ? { options: hookOptions } : {}
+        };
+        for (const scenarioKey of scenarioRefs) {
+          addHookAssociation(constructor, scenarioKey, hookRef);
+        }
+      };
+    };
+  }
+  function createRuleHookDecorator(type) {
+    return (options) => {
+      if (!options || !options.rule) {
+        throw new Error("Rule hook decorator requires a rule property key");
+      }
+      const ruleRefs = toArray(options.rule);
+      const hookOptions = buildHookOptions(options);
+      const description = options.description;
+      return (target, propertyKey, descriptor) => {
+        const handler = descriptor?.value;
+        if (typeof handler !== "function") {
+          throw new Error(
+            `Hook decorator can only be applied to methods. ${String(propertyKey)} is not a function.`
+          );
+        }
+        recordHookMetadata(target, propertyKey, {
+          handler,
+          ...hookOptions ? { options: hookOptions } : {}
+        });
+        const constructor = resolveConstructor(target);
+        const hookRef = {
+          propertyKey,
+          type,
+          ...description ? { description } : {},
+          ...hookOptions ? { options: hookOptions } : {}
+        };
+        for (const ruleKey of ruleRefs) {
+          addRuleHookAssociation(constructor, ruleKey, hookRef);
+        }
+      };
+    };
+  }
+  function createFeatureHookDecorator(type) {
+    return (options = {}) => {
+      const hookOptions = buildHookOptions(options);
+      const description = options.description;
+      return (target, propertyKey, descriptor) => {
+        const handler = descriptor?.value;
+        if (typeof handler !== "function") {
+          throw new Error(
+            `Hook decorator can only be applied to methods. ${String(propertyKey)} is not a function.`
+          );
+        }
+        recordHookMetadata(target, propertyKey, {
+          handler,
+          ...hookOptions ? { options: hookOptions } : {}
+        });
+        const constructor = resolveConstructor(target);
+        const hookRef = {
+          propertyKey,
+          type,
+          ...description ? { description } : {},
+          ...hookOptions ? { options: hookOptions } : {}
+        };
+        recordFeatureHook(constructor, hookRef);
+      };
+    };
+  }
+  function resolveConstructor(target) {
+    const ctor = target.constructor;
+    if (typeof ctor !== "function") {
+      throw new Error("Decorated target does not expose a constructor");
+    }
+    return ctor;
+  }
+  return {
+    Feature,
+    Rule,
+    Scenario,
+    Given: createStepDecorator("Given"),
+    When: createStepDecorator("When"),
+    Then: createStepDecorator("Then"),
+    And: createStepDecorator("And"),
+    But: createStepDecorator("But"),
+    BeforeFeature: createFeatureHookDecorator("beforeFeature"),
+    AfterFeature: createFeatureHookDecorator("afterFeature"),
+    BeforeRule: createRuleHookDecorator("beforeRule"),
+    AfterRule: createRuleHookDecorator("afterRule"),
+    BeforeScenario: createScenarioHookDecorator("beforeScenario"),
+    AfterScenario: createScenarioHookDecorator("afterScenario"),
+    BeforeScenarioOutline: createScenarioHookDecorator("beforeScenarioOutline"),
+    AfterScenarioOutline: createScenarioHookDecorator("afterScenarioOutline")
+  };
+}
+var WORLD_TOKEN = injection.createToken(
+  "@autometa/runner/world"
+);
+
+// src/bindings/create-bindings-ts.ts
+var BINDING_METADATA_KEY = Symbol("autometa:binding");
+var INJECT_PARAM_KEY = "autometa:inject_param";
+function createBindingsTS(stepsEnvironment) {
+  if (typeof Reflect === "undefined" || typeof Reflect.getMetadata !== "function") {
+    throw new Error(
+      "bindingsTS() requires reflect-metadata. Add `import 'reflect-metadata'` at the top of your step-definitions file."
+    );
+  }
+  const globalContainer = injection.createContainer();
+  const { Inject, LazyInject } = injection.createDecorators(globalContainer);
+  const { Given: GivenFn, When: WhenFn, Then: ThenFn, And: AndFn, But: BothFn } = stepsEnvironment;
+  const instanceCache = /* @__PURE__ */ new WeakMap();
+  const containerCache = /* @__PURE__ */ new WeakMap();
+  function getScenarioContainer(world) {
+    const worldObj = world;
+    let container = containerCache.get(worldObj);
+    if (!container) {
+      container = globalContainer.createChild();
+      container.registerValue(WORLD_TOKEN, world);
+      containerCache.set(worldObj, container);
+    }
+    return container;
+  }
+  function getStepInstance(BindingClass, world) {
+    const worldObj = world;
+    let cache = instanceCache.get(worldObj);
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      instanceCache.set(worldObj, cache);
+    }
+    let instance = cache.get(BindingClass);
+    if (instance) {
+      return instance;
+    }
+    const container = getScenarioContainer(world);
+    instance = container.resolve(BindingClass);
+    cache.set(BindingClass, instance);
+    return instance;
+  }
+  function getBindingMetadata(target) {
+    let metadata = Reflect.getMetadata(BINDING_METADATA_KEY, target);
+    if (!metadata) {
+      metadata = { steps: [] };
+      Reflect.defineMetadata(BINDING_METADATA_KEY, metadata, target);
+    }
+    return metadata;
+  }
+  function getBindingSteps(target) {
+    const proto = target.prototype;
+    return Reflect.getMetadata(BINDING_METADATA_KEY, target) ?? (proto ? Reflect.getMetadata(BINDING_METADATA_KEY, proto) : void 0);
+  }
+  function registerBindingClass(BindingClass) {
+    const metadata = getBindingSteps(BindingClass);
+    if (!metadata) {
+      return;
+    }
+    for (const step of metadata.steps) {
+      const handler = (...args) => {
+        const world = args[args.length - 1];
+        const stepArgs = args.slice(0, -1);
+        const instance = getStepInstance(BindingClass, world);
+        const method = instance[step.propertyKey];
+        if (typeof method !== "function") {
+          throw new Error(`Step method ${String(step.propertyKey)} is not a function`);
+        }
+        return method.apply(instance, stepArgs);
+      };
+      switch (step.keyword) {
+        case "Given":
+          GivenFn(step.expression, handler);
+          break;
+        case "When":
+          WhenFn(step.expression, handler);
+          break;
+        case "Then":
+          ThenFn(step.expression, handler);
+          break;
+        case "And":
+          AndFn(step.expression, handler);
+          break;
+        case "But":
+          BothFn(step.expression, handler);
+          break;
+      }
+    }
+  }
+  function Binding() {
+    return (target) => {
+      const existing = Reflect.getMetadata(BINDING_METADATA_KEY, target.prototype);
+      if (existing) {
+        Reflect.defineMetadata(BINDING_METADATA_KEY, existing, target);
+      }
+      const paramTokens = Reflect.getMetadata(INJECT_PARAM_KEY, target);
+      const deps = [];
+      if (paramTokens) {
+        const maxIndex = Math.max(...paramTokens.keys());
+        for (let i = 0; i <= maxIndex; i++) {
+          const token = paramTokens.get(i);
+          if (token) {
+            deps[i] = token;
+          }
+        }
+      }
+      globalContainer.registerClass(target, {
+        scope: injection.Scope.TRANSIENT,
+        deps
+      });
+      registerBindingClass(target);
+    };
+  }
+  function createStepDecorator(keyword) {
+    return (expression) => {
+      return (target, propertyKey, _descriptor) => {
+        const metadata = getBindingMetadata(target);
+        metadata.steps.push({
+          propertyKey,
+          keyword,
+          expression
+        });
+      };
+    };
+  }
+  function Injectable(options) {
+    return (target) => {
+      globalContainer.registerClass(target, {
+        scope: options?.scope ?? injection.Scope.TRANSIENT
+      });
+    };
+  }
+  return {
+    Binding,
+    Given: createStepDecorator("Given"),
+    When: createStepDecorator("When"),
+    Then: createStepDecorator("Then"),
+    And: createStepDecorator("And"),
+    But: createStepDecorator("But"),
+    Injectable,
+    Inject,
+    LazyInject,
+    container: globalContainer
+  };
+}
+function coordinateRunnerFeature(options) {
+  const {
+    environment,
+    feature,
+    config,
+    runtime,
+    plan,
+    adapterFactory,
+    planBuilder,
+    registerPlan,
+    featureScope,
+    hookLogger
+  } = options;
+  const scopePlan = plan ?? environment.getPlan();
+  return coordinator.coordinateFeature({
+    feature,
+    scopePlan,
+    config,
+    ...runtime ? { runtime } : {},
+    ...adapterFactory ? { adapterFactory } : {},
+    ...planBuilder ? { planBuilder } : {},
+    ...registerPlan ? { registerPlan } : {},
+    ...featureScope ? { featureScope } : {},
+    ...hookLogger ? { hookLogger } : {}
+  });
+}
+
+// src/builder/create-runner-builder.ts
+function normalizeWorldFactory(factory) {
+  const callable = factory;
+  if (callable.length >= 1) {
+    return factory;
+  }
+  return async (_context) => await callable();
+}
+var WORLD_INHERIT_KEYS = Symbol("autometa.runner.world.inherit");
+var STEPS_ENVIRONMENT_META = Symbol.for(
+  "autometa.runner.steps.environment.meta"
+);
+var App = {
+  compositionRoot(ctor, options) {
+    return async (context) => {
+      const { setup, ...registration } = options ?? {};
+      if (setup) {
+        await setup(context);
+      }
+      const registered = context.getRegisteredApp?.();
+      if (registered !== void 0) {
+        return registered;
+      }
+      const container = context.container;
+      if (typeof container.isRegistered === "function" && container.isRegistered(ctor)) {
+        return context.resolve(ctor);
+      }
+      return context.registerApp(
+        ctor,
+        registration
+      );
+    };
+  }
+};
+function createRunnerBuilder(initial) {
+  const state = initializeState(initial);
+  return new RunnerBuilderImpl(state);
+}
+var RunnerBuilderImpl = class _RunnerBuilderImpl {
+  constructor(state) {
+    this.state = state;
+  }
+  fork() {
+    const next = cloneBuilderState(this.state);
+    return new _RunnerBuilderImpl(next);
+  }
+  derivable() {
+    if (!this.state.derivedBuilders) {
+      this.state.derivedBuilders = /* @__PURE__ */ new Map();
+    }
+    return this;
+  }
+  group(key) {
+    const trimmed = key.trim();
+    if (!trimmed) {
+      throw new Error("group key must be a non-empty string");
+    }
+    if (!this.state.derivedBuilders) {
+      this.state.derivedBuilders = /* @__PURE__ */ new Map();
+    }
+    const existing = this.state.derivedBuilders.get(trimmed);
+    if (existing) {
+      return new _RunnerBuilderImpl(existing);
+    }
+    const derived = cloneBuilderState(this.state);
+    derived.stepsEnvironmentMeta = { kind: "group", group: trimmed };
+    this.state.derivedBuilders.set(trimmed, derived);
+    return new _RunnerBuilderImpl(derived);
+  }
+  extendWorld(value) {
+    const baseFactory = this.state.worldFactory;
+    const extensionFactory = typeof value === "function" ? normalizeWorldFactory(
+      value
+    ) : value ? createDefaultsWorldFactory(ensureWorldDefaults(value)) : async () => ({});
+    const baseInheritance = getWorldInheritance(baseFactory);
+    const extensionInheritance = getWorldInheritance(extensionFactory);
+    const inheritance = baseInheritance || extensionInheritance ? /* @__PURE__ */ new Set([
+      ...baseInheritance ? Array.from(baseInheritance) : [],
+      ...extensionInheritance ? Array.from(extensionInheritance) : []
+    ]) : void 0;
+    const merged = async (context) => {
+      const base = baseFactory ? await baseFactory(context) : {};
+      const extension = await extensionFactory(
+        context
+      );
+      const baseObj = ensureWorldObject(base);
+      const extObj = ensureWorldObject(extension);
+      return { ...baseObj, ...extObj };
+    };
+    if (inheritance && inheritance.size > 0) {
+      Object.defineProperty(merged, WORLD_INHERIT_KEYS, {
+        value: inheritance,
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+    }
+    this.state.worldFactory = merged;
+    delete this.state.ensureFactory;
+    invalidateCaches(this.state);
+    return new _RunnerBuilderImpl(this.state);
+  }
+  extendApp(app) {
+    const next = normalizeAppFactory(app);
+    const previous = this.state.appFactory;
+    const chained = async (context) => {
+      let currentApp;
+      const readRegisteredApp = () => {
+        const anyContext = context;
+        return typeof anyContext.getRegisteredApp === "function" ? anyContext.getRegisteredApp() : void 0;
+      };
+      const updateWorldApp = (value) => {
+        if (!value) {
+          return;
+        }
+        const world = context.world;
+        if (world && typeof world === "object") {
+          world.app = value;
+        }
+      };
+      if (previous) {
+        const result = await previous(context);
+        currentApp = result ?? readRegisteredApp();
+        updateWorldApp(currentApp);
+      }
+      const nextResult = await next(context);
+      const nextApp = nextResult ?? readRegisteredApp();
+      if (nextApp !== void 0) {
+        currentApp = nextApp;
+        updateWorldApp(currentApp);
+      }
+      return currentApp;
+    };
+    this.state.appFactory = chained;
+    delete this.state.ensureFactory;
+    invalidateCaches(this.state);
+    return new _RunnerBuilderImpl(this.state);
+  }
+  configure(update) {
+    if (typeof update === "function") {
+      const current = collectCurrentOptions(this.state);
+      const merged = update(current);
+      applyOptions(this.state, merged);
+      return new _RunnerBuilderImpl(
+        this.state
+      );
+    }
+    applyOptions(this.state, update);
+    return new _RunnerBuilderImpl(
+      this.state
+    );
+  }
+  expressionMap() {
+    return new _RunnerBuilderImpl(
+      this.state
+    );
+  }
+  withWorld(value) {
+    if (typeof value === "function") {
+      this.state.worldFactory = normalizeWorldFactory(
+        value
+      );
+    } else if (value) {
+      const validated = ensureWorldDefaults(value);
+      this.state.worldFactory = createDefaultsWorldFactory(validated);
+    } else {
+      this.state.worldFactory = async (_context) => ({});
+    }
+    delete this.state.ensureFactory;
+    invalidateCaches(this.state);
+    return new _RunnerBuilderImpl(this.state);
+  }
+  app(app) {
+    this.state.appFactory = normalizeAppFactory(app);
+    delete this.state.ensureFactory;
+    invalidateCaches(this.state);
+    return new _RunnerBuilderImpl(this.state);
+  }
+  assertions(setup) {
+    this.state.ensureFactory = setup(assertions.ensure);
+    invalidateCaches(this.state);
+    return new _RunnerBuilderImpl(
+      this.state
+    );
+  }
+  assertionPlugins(plugins) {
+    return this.assertions(
+      (ensureInvoke) => {
+        const factory = assertions.createEnsureFactory(
+          ensureInvoke,
+          plugins
+        );
+        return createImplicitEnsureProxy(factory);
+      }
+    );
+  }
+  parameterTypes(definitions) {
+    const current = this.state.options.parameterTypes ?? [];
+    this.state.options.parameterTypes = [
+      ...current,
+      ...definitions
+    ];
+    invalidateCaches(this.state);
+    return new _RunnerBuilderImpl(this.state);
+  }
+  steps() {
+    return ensureSteps(this.state);
+  }
+  decorators() {
+    return ensureDecorators(this.state);
+  }
+  bindingsTS() {
+    return ensureBindingsTS(this.state);
+  }
+};
+function initializeState(initial) {
+  if (!initial) {
+    return {
+      options: {},
+      stepsEnvironmentMeta: { kind: "root" }
+    };
+  }
+  const { worldFactory, ...rest } = initial;
+  const state = {
+    options: { ...rest },
+    stepsEnvironmentMeta: { kind: "root" }
+  };
+  if (worldFactory) {
+    state.worldFactory = normalizeWorldFactory(
+      worldFactory
+    );
+  }
+  return state;
+}
+function cloneBuilderState(source) {
+  const next = {
+    options: cloneWithFallback(source.options)
+  };
+  if (source.stepsEnvironmentMeta) {
+    next.stepsEnvironmentMeta = source.stepsEnvironmentMeta;
+  }
+  if (source.worldFactory) {
+    next.worldFactory = source.worldFactory;
+  }
+  if (source.appFactory) {
+    next.appFactory = source.appFactory;
+  }
+  if (source.ensureFactory) {
+    next.ensureFactory = source.ensureFactory;
+  }
+  return next;
+}
+function collectCurrentOptions(state) {
+  const options = {
+    ...state.options
+  };
+  if (state.worldFactory) {
+    options.worldFactory = state.worldFactory;
+  }
+  return options;
+}
+function applyOptions(state, options) {
+  const { worldFactory, ...rest } = options;
+  state.options = {
+    ...state.options,
+    ...rest
+  };
+  if ("worldFactory" in options) {
+    if (worldFactory) {
+      state.worldFactory = normalizeWorldFactory(
+        worldFactory
+      );
+    } else {
+      delete state.worldFactory;
+    }
+    delete state.ensureFactory;
+  }
+  invalidateCaches(state);
+}
+function normalizeAppFactory(app) {
+  if (typeof app === "function") {
+    if (app.length > 0) {
+      return async (context) => await app(
+        context
+      );
+    }
+    return async () => await app();
+  }
+  return async () => app;
+}
+function createDefaultsWorldFactory(defaults) {
+  const inheritance = extractWorldInheritance(defaults);
+  const snapshot = cloneDefaults(defaults);
+  const factory = async () => cloneDefaults(snapshot);
+  if (inheritance.size > 0) {
+    Object.defineProperty(factory, WORLD_INHERIT_KEYS, {
+      value: inheritance,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  return factory;
+}
+function ensureWorldDefaults(value) {
+  if (!value || typeof value !== "object") {
+    throw new TypeError(
+      "withWorld defaults must be a non-null object"
+    );
+  }
+  return value;
+}
+function cloneDefaults(defaults) {
+  const structuredCloneFn = globalThis.structuredClone;
+  if (structuredCloneFn) {
+    try {
+      return structuredCloneFn(defaults);
+    } catch {
+    }
+  }
+  return cloneWithFallback(defaults);
+}
+function extractWorldInheritance(defaults) {
+  const inherit = defaults[WORLD_INHERIT_KEYS];
+  if (!inherit || inherit.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const inheritance = new Set(inherit);
+  return inheritance;
+}
+function getWorldInheritance(factory) {
+  if (!factory) {
+    return void 0;
+  }
+  const withMetadata = factory;
+  return withMetadata[WORLD_INHERIT_KEYS];
+}
+function cloneWithFallback(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneWithFallback(item));
+  }
+  if (value instanceof Map) {
+    return new Map(
+      Array.from(value.entries(), ([key, entry]) => [key, cloneWithFallback(entry)])
+    );
+  }
+  if (value instanceof Set) {
+    return new Set(Array.from(value.values(), (entry) => cloneWithFallback(entry)));
+  }
+  if (value && typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === Object.prototype || prototype === null) {
+      const result = {};
+      for (const [key, entry] of Object.entries(value)) {
+        result[key] = cloneWithFallback(entry);
+      }
+      return result;
+    }
+  }
+  return value;
+}
+function invalidateCaches(state) {
+  delete state.stepsCache;
+  delete state.decoratorsCache;
+  delete state.bindingsTSCache;
+}
+function ensureSteps(state) {
+  let cache = state.stepsCache;
+  if (!cache) {
+    const options = buildRunnerOptions(state, { includeParameterTypes: true });
+    const environment = createRunner(options);
+    const globals = createGlobalRunner();
+    globals.useEnvironment(environment);
+    const ensureFactory = resolveEnsureFactory(state);
+    const surface = attachStepsHelpers(
+      state,
+      environment,
+      globals,
+      ensureFactory
+    );
+    try {
+      Object.defineProperty(surface, STEPS_ENVIRONMENT_META, {
+        value: state.stepsEnvironmentMeta ?? { kind: "root" },
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+    } catch {
+    }
+    cache = {
+      environment,
+      globals,
+      surface,
+      ensureFactory
+    };
+    state.stepsCache = cache;
+  }
+  return cache.surface;
+}
+function ensureDecorators(state) {
+  let cache = state.decoratorsCache;
+  if (!cache) {
+    const steps = ensureSteps(state);
+    const options = buildRunnerOptions(state, {
+      includeParameterTypes: false
+    });
+    const decoratorOptions = {
+      ...options,
+      parameterRegistry: steps.parameterRegistry,
+      registerDefaultParameterTypes: false
+    };
+    const environment = createDecoratorRunner(decoratorOptions);
+    const decorators = createRunnerDecorators(environment);
+    const surface = attachDecoratorEnvironment(decorators, environment);
+    cache = {
+      environment,
+      surface
+    };
+    state.decoratorsCache = cache;
+  }
+  return cache.surface;
+}
+function ensureBindingsTS(state) {
+  let cache = state.bindingsTSCache;
+  if (!cache) {
+    const stepsEnv = ensureSteps(state);
+    const surface = createBindingsTS(stepsEnv);
+    cache = {
+      surface
+    };
+    state.bindingsTSCache = cache;
+  }
+  return cache.surface;
+}
+function buildRunnerOptions(state, options) {
+  const includeParameterTypes = options?.includeParameterTypes ?? true;
+  const base = {
+    ...state.options
+  };
+  if (!includeParameterTypes && "parameterTypes" in base) {
+    delete base.parameterTypes;
+  }
+  const featureRegistry = ensureFeatureRegistry(state);
+  const worldFactory = composeWorldFactory(
+    state.worldFactory,
+    state.appFactory,
+    featureRegistry
+  );
+  if (worldFactory) {
+    base.worldFactory = worldFactory;
+  } else if ("worldFactory" in base) {
+    delete base.worldFactory;
+  }
+  return base;
+}
+function composeWorldFactory(baseFactory, appFactory, featureRegistry) {
+  if (!baseFactory && !appFactory && !featureRegistry) {
+    return void 0;
+  }
+  const factory = baseFactory ?? (async (_context) => ({}));
+  const inheritance = getWorldInheritance(baseFactory);
+  return async (context) => {
+    const container = injection.createContainer();
+    const world = await factory(context);
+    const asObject = ensureWorldObject(world);
+    const parentObject = context.parent !== void 0 ? ensureWorldObject(context.parent) : void 0;
+    const mergedWorld = parentObject !== void 0 ? mergeWorldWithParent(asObject, parentObject, inheritance) : asObject;
+    attachWorldAncestors(mergedWorld, parentObject);
+    attachFeatureRegistry(mergedWorld, featureRegistry);
+    attachContainer(mergedWorld, container);
+    attachRuntime(mergedWorld);
+    attachWorldToJson(mergedWorld);
+    container.registerValue(WORLD_TOKEN, mergedWorld, {
+      scope: injection.Scope.SCENARIO
+    });
+    if (appFactory) {
+      const resolvedAppFactory = appFactory;
+      const composer = createAppFactoryContext(container, mergedWorld);
+      const appResult = await resolvedAppFactory(composer);
+      const app = appResult ?? composer.getRegisteredApp();
+      if (app === void 0) {
+        throw new Error(
+          "App factory did not return an application instance. Use return or registerApp to provide one."
+        );
+      }
+      mergedWorld.app = app;
+    }
+    return mergedWorld;
+  };
+}
+function attachStepsHelpers(state, environment, globals, ensureFactory) {
+  if (!("globals" in environment)) {
+    Object.defineProperty(environment, "globals", {
+      value: globals,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  if (!("coordinateFeature" in environment)) {
+    Object.defineProperty(environment, "coordinateFeature", {
+      value: (options) => {
+        const registry = ensureFeatureRegistry(state);
+        if (options.feature) {
+          registry.remember(options.feature);
+        }
+        return coordinateRunnerFeature({
+          environment,
+          ...options
+        });
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  if (!("ensure" in environment)) {
+    Object.defineProperty(environment, "ensure", {
+      value: ensureFactory,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return environment;
+}
+function resolveEnsureFactory(state) {
+  if (state.ensureFactory) {
+    return state.ensureFactory;
+  }
+  const factory = assertions.createDefaultEnsureFactory();
+  const proxy = createImplicitEnsureProxy(factory);
+  state.ensureFactory = proxy;
+  return proxy;
+}
+function attachDecoratorEnvironment(decorators, environment) {
+  if (!("environment" in decorators)) {
+    Object.defineProperty(decorators, "environment", {
+      value: environment,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return decorators;
+}
+function ensureWorldObject(world) {
+  if (world && typeof world === "object") {
+    return world;
+  }
+  return {};
+}
+function attachContainer(world, container) {
+  const descriptor = {
+    value: container,
+    configurable: true,
+    enumerable: false,
+    writable: false
+  };
+  if (!Reflect.has(world, "di")) {
+    Object.defineProperty(world, "di", descriptor);
+  }
+  if (!Reflect.has(world, "container")) {
+    Object.defineProperty(world, "container", descriptor);
+  }
+}
+function createAppFactoryContext(container, world) {
+  let registeredApp;
+  function withScenarioScope(options) {
+    return {
+      scope: options?.scope ?? injection.Scope.SCENARIO,
+      ...options?.tags ? { tags: [...options.tags] } : {},
+      ...options?.deps ? { deps: [...options.deps] } : {},
+      ...options?.props ? { props: options.props } : {}
+    };
+  }
+  const context = {
+    container,
+    world,
+    getRegisteredApp() {
+      return registeredApp;
+    },
+    registerClass(target, options) {
+      const { scope, tags, deps, inject } = options ?? {};
+      let propsMap;
+      if (inject) {
+        const keys = Reflect.ownKeys(inject);
+        if (keys.length > 0) {
+          const entries = [];
+          for (const key of keys) {
+            const descriptor = inject[key];
+            if (!descriptor) {
+              continue;
+            }
+            entries.push([key, descriptor]);
+          }
+          if (entries.length > 0) {
+            propsMap = Object.fromEntries(entries.map(([key, descriptor]) => {
+              if (typeof descriptor === "object" && "token" in descriptor) {
+                return [key, {
+                  token: descriptor.token,
+                  ...descriptor.lazy ? { lazy: descriptor.lazy } : {}
+                }];
+              }
+              return [key, descriptor];
+            }));
+          }
+        }
+      }
+      const registration = {
+        scope: scope ?? injection.Scope.SCENARIO,
+        ...tags ? { tags: [...tags] } : {},
+        ...deps ? { deps: [...deps] } : {},
+        ...propsMap ? { props: propsMap } : {}
+      };
+      container.registerClass(target, registration);
+      return context;
+    },
+    registerValue(identifier, value, options) {
+      container.registerValue(identifier, value, withScenarioScope(options));
+      return context;
+    },
+    registerFactory(identifier, factory, options) {
+      container.registerFactory(identifier, factory, withScenarioScope(options));
+      return context;
+    },
+    registerToken(token, target, options) {
+      container.registerToken(token, target, withScenarioScope(options));
+      return context;
+    },
+    async registerApp(target, options) {
+      context.registerClass(target, options);
+      const instance = container.resolve(target);
+      registeredApp = instance;
+      if (options?.configure) {
+        await options.configure(instance, context);
+      }
+      return instance;
+    },
+    resolve(identifier) {
+      return container.resolve(identifier);
+    }
+  };
+  return context;
+}
+function attachRuntime(world) {
+  if (Reflect.has(world, "runtime")) {
+    return;
+  }
+  Object.defineProperty(world, "runtime", {
+    get() {
+      return executor.createStepRuntime(this);
+    },
+    enumerable: false,
+    configurable: true
+  });
+}
+var WORLD_JSON_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
+  "app",
+  "di",
+  "container",
+  "runtime",
+  "ancestors"
+]);
+function attachWorldToJson(world) {
+  if (Reflect.has(world, "toJSON")) {
+    return;
+  }
+  Object.defineProperty(world, "toJSON", {
+    value: () => {
+      const stack = /* @__PURE__ */ new WeakSet();
+      return toJsonSafeValue(world, 8, stack);
+    },
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+}
+function toJsonSafeValue(value, depth, stack) {
+  if (value === null) {
+    return null;
+  }
+  switch (typeof value) {
+    case "boolean":
+    case "number":
+    case "string":
+      return value;
+    case "bigint":
+      return value.toString();
+    case "undefined":
+      return "[undefined]";
+    case "symbol":
+      return value.toString();
+    case "function":
+      return "[Function]";
+    case "object":
+      break;
+    default:
+      return String(value);
+  }
+  if (depth <= 0) {
+    return "[MaxDepth]";
+  }
+  const obj = value;
+  if (stack.has(obj)) {
+    return "[Circular]";
+  }
+  if (Array.isArray(obj)) {
+    stack.add(obj);
+    try {
+      return obj.map((entry) => toJsonSafeValue(entry, depth - 1, stack));
+    } finally {
+      stack.delete(obj);
+    }
+  }
+  if (obj instanceof Date) {
+    return obj.toISOString();
+  }
+  if (obj instanceof Error) {
+    return {
+      name: obj.name,
+      message: obj.message,
+      stack: obj.stack ?? ""
+    };
+  }
+  if (obj instanceof Map) {
+    stack.add(obj);
+    try {
+      return {
+        "[Map]": Array.from(obj.entries()).map(([key, entry]) => ({
+          key: toJsonSafeValue(key, depth - 1, stack),
+          value: toJsonSafeValue(entry, depth - 1, stack)
+        }))
+      };
+    } finally {
+      stack.delete(obj);
+    }
+  }
+  if (obj instanceof Set) {
+    stack.add(obj);
+    try {
+      return { "[Set]": Array.from(obj.values()).map((entry) => toJsonSafeValue(entry, depth - 1, stack)) };
+    } finally {
+      stack.delete(obj);
+    }
+  }
+  stack.add(obj);
+  try {
+    const record = obj;
+    const result = {};
+    for (const [key, entry] of Object.entries(record)) {
+      if (WORLD_JSON_EXCLUDE_KEYS.has(key)) {
+        continue;
+      }
+      result[key] = toJsonSafeValue(entry, depth - 1, stack);
+    }
+    return result;
+  } finally {
+    stack.delete(obj);
+  }
+}
+function attachFeatureRegistry(world, featureRegistry) {
+  if (!featureRegistry) {
+    return;
+  }
+  world.features = featureRegistry.snapshot();
+}
+var PARENT_WORLD_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
+  "di",
+  "container",
+  "runtime",
+  "app",
+  "ancestors"
+]);
+function mergeWorldWithParent(child, parent, inheritance) {
+  if (!parent || !inheritance || inheritance.size === 0) {
+    return child;
+  }
+  for (const key of inheritance) {
+    if (PARENT_WORLD_EXCLUDE_KEYS.has(key)) {
+      continue;
+    }
+    if (!Reflect.has(parent, key)) {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(parent, key);
+    if (descriptor) {
+      Object.defineProperty(child, key, descriptor);
+    }
+  }
+  return child;
+}
+function attachWorldAncestors(world, parent) {
+  const parentAncestors = parent && Reflect.has(parent, "ancestors") ? parent.ancestors : void 0;
+  const lineage = parent ? [
+    parent,
+    ...Array.isArray(parentAncestors) ? parentAncestors : []
+  ] : [];
+  Object.defineProperty(world, "ancestors", {
+    value: lineage,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+}
+function ensureFeatureRegistry(state) {
+  if (!state.featureRegistry) {
+    state.featureRegistry = createFeatureRegistry();
+  }
+  return state.featureRegistry;
+}
+function createFeatureRegistry() {
+  const byId = /* @__PURE__ */ new Map();
+  return {
+    remember(feature) {
+      const id = feature.uri ?? feature.name;
+      if (!id || byId.has(id)) {
+        return;
+      }
+      byId.set(id, feature);
+    },
+    snapshot() {
+      return Array.from(byId.values());
+    }
+  };
+}
+function createImplicitEnsureProxy(factory) {
+  return new Proxy(factory, {
+    get(target, prop, receiver) {
+      if (prop === "world") {
+        return executor.tryGetWorld();
+      }
+      const world = executor.tryGetWorld();
+      if (world) {
+        const facade = factory(world);
+        return Reflect.get(facade, prop, receiver);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    apply(target, _thisArg, args) {
+      const [arg, options] = args;
+      const world = executor.tryGetWorld();
+      if (world) {
+        if (arg === world) {
+          return factory(world);
+        }
+        const facade = factory(world);
+        return facade(arg, options);
+      }
+      return factory(arg);
+    }
+  });
+}
+
+// src/current.ts
+var stepsErrorMessage = "Runner steps surface has not been configured. Call setCurrentRunnerSteps() before accessing the shared runner surface.";
+var currentSteps;
+function setCurrentRunnerSteps(steps) {
+  currentSteps = steps;
+}
+function getCurrentRunnerSteps() {
+  if (!currentSteps) {
+    throw new Error(stepsErrorMessage);
+  }
+  return currentSteps;
+}
+function clearCurrentRunnerSteps() {
+  currentSteps = void 0;
+}
+
+// src/global.ts
+var runnerInstance;
+function instantiateRunner(options) {
+  return createGlobalRunner(options);
+}
+function requireConfigured(action) {
+  if (!runnerInstance) {
+    throw new Error(
+      `Global runner has not been configured. ${action}`
+    );
+  }
+  return runnerInstance;
+}
+function getGlobalRunner(options) {
+  if (!runnerInstance) {
+    runnerInstance = instantiateRunner(options);
+  }
+  return runnerInstance;
+}
+function configureGlobalRunner(options) {
+  runnerInstance = instantiateRunner(options);
+  return runnerInstance;
+}
+function resetGlobalRunner(options) {
+  runnerInstance = instantiateRunner(options);
+  return runnerInstance;
+}
+function disposeGlobalRunner() {
+  runnerInstance = void 0;
+}
+function useGlobalRunnerEnvironment(environment) {
+  const runner = requireConfigured(
+    "Call configureGlobalRunner() before injecting environments."
+  );
+  return runner.useEnvironment(environment);
+}
+function getGlobalRunnerEnvironment() {
+  const runner = requireConfigured(
+    "Call configureGlobalRunner() before reading environments."
+  );
+  return runner.getEnvironment();
+}
+function getConfiguredGlobalRunner() {
+  return requireConfigured(
+    "Call configureGlobalRunner() before accessing runner APIs."
+  );
+}
+
+// src/cucumber-runner.ts
+var CucumberRunner = class {
+  static builder(initial) {
+    return createRunnerBuilder(initial);
+  }
+  static setSteps(steps) {
+    setCurrentRunnerSteps(steps);
+  }
+  static steps() {
+    return getCurrentRunnerSteps();
+  }
+  static clearSteps() {
+    clearCurrentRunnerSteps();
+  }
+};
+
+Object.defineProperty(exports, 'Pending', {
+  enumerable: true,
+  get: function () { return executor.Pending; }
+});
+Object.defineProperty(exports, 'ScenarioPendingError', {
+  enumerable: true,
+  get: function () { return executor.ScenarioPendingError; }
+});
+Object.defineProperty(exports, 'ToDo', {
+  enumerable: true,
+  get: function () { return executor.ToDo; }
+});
+Object.defineProperty(exports, 'clearStepDocstring', {
+  enumerable: true,
+  get: function () { return executor.clearStepDocstring; }
+});
+Object.defineProperty(exports, 'clearStepTable', {
+  enumerable: true,
+  get: function () { return executor.clearStepTable; }
+});
+Object.defineProperty(exports, 'configureStepDocstrings', {
+  enumerable: true,
+  get: function () { return executor.configureStepDocstrings; }
+});
+Object.defineProperty(exports, 'configureStepTables', {
+  enumerable: true,
+  get: function () { return executor.configureStepTables; }
+});
+Object.defineProperty(exports, 'consumeDocstring', {
+  enumerable: true,
+  get: function () { return executor.consumeDocstring; }
+});
+Object.defineProperty(exports, 'consumeTable', {
+  enumerable: true,
+  get: function () { return executor.consumeTable; }
+});
+Object.defineProperty(exports, 'getDocstring', {
+  enumerable: true,
+  get: function () { return executor.getDocstring; }
+});
+Object.defineProperty(exports, 'getDocstringInfo', {
+  enumerable: true,
+  get: function () { return executor.getDocstringInfo; }
+});
+Object.defineProperty(exports, 'getDocstringMediaType', {
+  enumerable: true,
+  get: function () { return executor.getDocstringMediaType; }
+});
+Object.defineProperty(exports, 'getRawTable', {
+  enumerable: true,
+  get: function () { return executor.getRawTable; }
+});
+Object.defineProperty(exports, 'getTable', {
+  enumerable: true,
+  get: function () { return executor.getTable; }
+});
+Object.defineProperty(exports, 'isScenarioPendingError', {
+  enumerable: true,
+  get: function () { return executor.isScenarioPendingError; }
+});
+Object.defineProperty(exports, 'markScenarioPending', {
+  enumerable: true,
+  get: function () { return executor.markScenarioPending; }
+});
+Object.defineProperty(exports, 'resetStepDocstringConfig', {
+  enumerable: true,
+  get: function () { return executor.resetStepDocstringConfig; }
+});
+Object.defineProperty(exports, 'resetStepTableConfig', {
+  enumerable: true,
+  get: function () { return executor.resetStepTableConfig; }
+});
+Object.defineProperty(exports, 'setStepDocstring', {
+  enumerable: true,
+  get: function () { return executor.setStepDocstring; }
+});
+Object.defineProperty(exports, 'setStepDocstringInfo', {
+  enumerable: true,
+  get: function () { return executor.setStepDocstringInfo; }
+});
+Object.defineProperty(exports, 'setStepTable', {
+  enumerable: true,
+  get: function () { return executor.setStepTable; }
+});
+exports.App = App;
+exports.CucumberRunner = CucumberRunner;
+exports.ParameterRegistryAdapter = ParameterRegistryAdapter;
+exports.RunnerContext = RunnerContext;
+exports.STEPS_ENVIRONMENT_META = STEPS_ENVIRONMENT_META;
+exports.WORLD_INHERIT_KEYS = WORLD_INHERIT_KEYS;
+exports.WORLD_TOKEN = WORLD_TOKEN;
+exports.clearCurrentRunnerSteps = clearCurrentRunnerSteps;
+exports.configureGlobalRunner = configureGlobalRunner;
+exports.coordinateRunnerFeature = coordinateRunnerFeature;
+exports.createDecoratorRunner = createDecoratorRunner;
+exports.createGlobalRunner = createGlobalRunner;
+exports.createParameterRegistryAdapter = createParameterRegistryAdapter;
+exports.createRunner = createRunner;
+exports.default = createRunner;
+exports.disposeGlobalRunner = disposeGlobalRunner;
+exports.getConfiguredGlobalRunner = getConfiguredGlobalRunner;
+exports.getCurrentRunnerSteps = getCurrentRunnerSteps;
+exports.getGlobalRunner = getGlobalRunner;
+exports.getGlobalRunnerEnvironment = getGlobalRunnerEnvironment;
+exports.resetGlobalRunner = resetGlobalRunner;
+exports.setCurrentRunnerSteps = setCurrentRunnerSteps;
+exports.useGlobalRunnerEnvironment = useGlobalRunnerEnvironment;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map