@autometa/jest-executor 0.6.3 → 1.0.0-rc.2

package/dist/index.js

@@ -1,989 +1,36 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+import { registerFeaturePlan } from '@autometa/executor';
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  default: () => src_default,
-  execute: () => execute,
-  getTimeout: () => getTimeout
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/executor.ts
-var import_test_builder = require("@autometa/test-builder");
-var import_globals = require("@jest/globals");
-var import_errors = require("@autometa/errors");
-var import_test_builder2 = require("@autometa/test-builder");
-
-// src/timeout-selector.ts
-var import_scopes = require("@autometa/scopes");
-function getTimeout(target, config) {
-  if (target && !(target instanceof import_scopes.NullTimeout)) {
-    return target;
-  }
-  return import_scopes.Timeout.from(config?.current?.test?.timeout);
-}
-function chooseTimeout(timeout1, timeout2) {
-  if (timeout2 instanceof import_scopes.Timeout && !(timeout2 instanceof import_scopes.NullTimeout)) {
-    return {
-      getTimeout: getTimeout.bind(null, timeout2)
-    };
-  }
-  if (timeout1 instanceof import_scopes.Timeout && !(timeout1 instanceof import_scopes.NullTimeout)) {
-    return {
-      getTimeout: getTimeout.bind(null, timeout1)
-    };
-  }
-  return {
-    getTimeout: getTimeout.bind(null, import_scopes.Timeout.from(0))
-  };
-}
-
-// src/executor.ts
-var import_scopes2 = require("@autometa/scopes");
-var import_injection = require("@autometa/injection");
-var import_gherkin = require("@autometa/gherkin");
-var outlineApps = /* @__PURE__ */ new Map();
-var examplesApps = /* @__PURE__ */ new Map();
-var featureApps = /* @__PURE__ */ new Map();
-var ruleApps = /* @__PURE__ */ new Map();
-function execute({ app, world }, global, bridge, events, config) {
-  const globalBridge = new import_test_builder.GlobalBridge(global);
-  const featureTitle = bridge.data.scope.title(bridge.data.gherkin);
-  const [group, modifier] = getGroupOrModifier(
-    bridge,
-    config.current.test?.tagFilter
-  );
-  const chosenTimeout = chooseTimeout(
-    new import_scopes2.NullTimeout(),
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  (0, import_globals.beforeAll)(() => {
-    events.feature.emitStart({
-      title: featureTitle,
-      path: bridge.data.scope.path,
-      modifier,
-      tags: [...bridge.data.gherkin.tags]
-    });
-  }, chosenTimeout.milliseconds);
-  group(featureTitle, () => {
-    const tags = [...bridge.data.gherkin.tags];
-    const retries = tags.find((tag) => tag.startsWith("@retries="));
-    let testContainerContext;
-    let testContainer;
-    let localApp;
-    const globalContainerContext = (0, import_injection.defineContainerContext)("global");
-    const globalContainer = new import_injection.Container(globalContainerContext);
-    globalContainer.registerCached(world);
-    const staticApp = globalContainer.get(app);
-    staticApp.world = globalContainer.get(world);
-    staticApp.di = globalContainer;
-    (0, import_globals.beforeAll)(() => {
-      if (retries) {
-        const count = parseInt(retries.split("=")[1]);
-        import_globals.jest.retryTimes(count);
-      }
-    });
-    (0, import_globals.beforeEach)(() => {
-      const name = import_globals.expect.getState().currentTestName ?? (0, import_errors.raise)("A test must have a name");
-      testContainerContext = (0, import_injection.defineContainerContext)(name);
-      testContainer = new import_injection.Container(testContainerContext);
-      testContainer.registerCached(world);
-      localApp = testContainer.get(app);
-      localApp.world = testContainer.get(world);
-      localApp.di = testContainer;
-      if (!featureApps.has(name)) {
-        featureApps.set(name, []);
-      }
-      featureApps.get(name)?.push(localApp);
-    });
-    bridge.data.scope.hooks.beforeFeatureHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        chosenTimeout,
-        hook.options.timeout
-      ).getTimeout(config).milliseconds;
-      (0, import_globals.beforeAll)(async () => {
-        const tags2 = bridge?.data?.gherkin?.tags ?? [];
-        if (!hook.canExecute(...tags2)) {
-          return;
-        }
-        events.beforeFeature.emitStart({
-          title: hook.description,
-          tags: [...tags2]
-        });
-        const report = await hook.execute(staticApp, ...tags2);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.beforeFeature.emitEnd({
-            title: hook.description,
-            tags: [...tags2],
-            status: "FAILED",
-            error: report.error
-          });
-          throw new import_errors.AutomationError(message, { cause: report.error });
-        }
-        events.beforeFeature.emitEnd({
-          title: hook.description,
-          tags: [...tags2],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    bridge.data.scope.hooks.afterFeatureHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        chosenTimeout,
-        hook.options.timeout
-      ).getTimeout(config).milliseconds;
-      (0, import_globals.afterAll)(async () => {
-        const tags2 = bridge?.data?.gherkin?.tags ?? [];
-        if (!hook.canExecute(...bridge.data.gherkin.tags)) {
-          return;
-        }
-        events.afterFeature.emitStart({
-          title: hook.description,
-          tags: [...tags2]
-        });
-        const testName = import_globals.expect.getState().currentTestName;
-        const apps = featureApps.get(testName);
-        const report = await hook.execute(staticApp, apps, ...tags2);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.afterFeature.emitEnd({
-            title: hook.description,
-            tags: [...tags2],
-            status: "FAILED",
-            error: report.error
-          });
-          throw new import_errors.AutomationError(message, { cause: report.error });
-        }
-        events.afterFeature.emitEnd({
-          title: hook.description,
-          tags: [...tags2],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    bootstrapSetupHooks(globalBridge, staticApp, events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapSetupHooks(bridge, staticApp, events, [config, chosenTimeout]);
-    bootstrapBeforeHooks(
-      bridge,
-      globalBridge,
-      () => [testContainer, localApp],
-      events,
-      [config, chosenTimeout]
-    );
-    bootstrapBeforeHooks(
-      bridge,
-      bridge,
-      () => [testContainer, localApp],
-      events,
-      [config, chosenTimeout]
-    );
-    bootstrapBackground(bridge, bridge, () => [testContainer, localApp], events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapScenarios(
-      bridge,
-      bridge,
-      () => [testContainer, localApp],
-      staticApp,
-      events,
-      [config, chosenTimeout]
-    );
-    bootstrapRules(bridge, () => [testContainer, localApp], staticApp, events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapAfterHooks(bridge, bridge, () => [testContainer, localApp], events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapAfterHooks(bridge, globalBridge, () => [testContainer, localApp], events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapTeardownHooks(globalBridge, staticApp, events, [
-      config,
-      chosenTimeout
-    ]);
-    bootstrapTeardownHooks(bridge, staticApp, events, [config, chosenTimeout]);
-    (0, import_globals.afterAll)(async () => {
-      await globalContainer.disposeGlobal(tags, import_gherkin.isTagsMatch);
-    });
-  });
-  (0, import_globals.afterAll)(async () => {
-    const failures = import_test_builder2.Query.find.failed(bridge);
-    const status = modifier === "skip" ? "SKIPPED" : failures.length === 0 ? "PASSED" : "FAILED";
-    events.feature.emitEnd({
-      title: featureTitle,
-      modifier,
-      tags: [...bridge.data.gherkin.tags],
-      status
-    });
-    const settled = await events.settleAsyncEvents();
-    const failedCount = settled.filter((e) => e.status === "rejected").length;
-    if (failedCount > 0) {
-      const count = `${failedCount}/${settled.length}`;
-      const message = `${count} asynchronous Test Events were rejected.`;
-      console.warn(message);
-    }
-    featureApps.clear();
-    outlineApps.clear();
-    examplesApps.clear();
-    ruleApps.clear();
-  });
-}
-function bootstrapBackground(root, bridge, localApp, events, [config, timeout]) {
-  const background = bridge.background;
-  if (!background)
-    return;
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config).milliseconds;
-  const tags = bridge?.data?.gherkin?.tags ?? [];
-  if (tags.has("@skip") || tags.has("@skipped"))
-    return;
-  (0, import_globals.beforeEach)(async () => {
-    const testName = import_globals.expect.getState().currentTestName;
-    if (!testName)
-      throw new import_errors.AutomationError("A Scenario must have a title");
-    const scenarioBridge = (0, import_test_builder.find)(root, testName);
-    if (!scenarioBridge) {
-      throw new import_errors.AutomationError(
-        `No matching scenario bridge was found matching the test name: ${testName}`
-      );
-    }
-    const title = background.data.scope.title(background.data.gherkin);
-    events.before.emitStart({
-      title,
-      tags: [...tags]
-    });
-    const steps = background.steps;
-    try {
-      for (const step of steps) {
-        const [_, app] = localApp();
-        const args = step.args?.(app) ?? [];
-        const title2 = step.data.scope.stepText(
-          step.data.gherkin.keyword,
-          step.data.gherkin.text
-        );
-        events.step.emitStart({
-          title: title2,
-          args,
-          expression: step.data.scope.expression.source
-        });
-        await step.data.scope.execute(step.data.gherkin, args, app);
-        events.step.emitEnd({
-          expression: step.data.scope.expression.source,
-          title: title2,
-          args
-        });
-      }
-      events.before.emitEnd({
-        title,
-        tags: [...tags],
-        status: "PASSED"
-      });
-    } catch (e) {
-      events.before.emitEnd({
-        title,
-        tags: [...tags],
-        status: "FAILED",
-        error: e
-      });
-      const message = `${title} failed to execute.
-Test: ${testName}`;
-      throw new import_errors.AutomationError(message, { cause: e });
-    }
-  }, chosenTimeout);
-}
-function bootstrapScenarios(root, bridge, localApp, staticApp, events, [config, timeout]) {
-  const { scenarios } = bridge;
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  scenarios.forEach((scenario) => {
-    if (isOutline(scenario)) {
-      bootstrapScenarioOutline(root, scenario, localApp, staticApp, events, [
-        config,
-        chosenTimeout
-      ]);
-      return;
-    }
-    bootstrapScenario(scenario, localApp, events, [config, chosenTimeout]);
-  });
-}
-function bootstrapScenario(bridge, localApp, events, [config, timeout]) {
-  const { data } = bridge;
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  const scenarioName = data.scope.title(data.gherkin);
-  const test = getTestOrModifier(bridge, config.current.test?.tagFilter);
-  test(
-    scenarioName,
-    async () => {
-      events.scenario.emitStart({
-        title: bridge.title,
-        tags: bridge.tags
-      });
-      const [container, app] = localApp();
-      try {
-        for (const step of bridge.steps) {
-          await tryRunStep(step, events, bridge, () => app);
-        }
-        bridge.report = { passed: true };
-        events.scenario.emitEnd({
-          title: bridge.title,
-          tags: bridge.tags,
-          status: "PASSED"
-        });
-      } catch (e) {
-        const error = e;
-        bridge.report = { passed: false, error: e };
-        events.scenario.emitEnd({
-          title: bridge.title,
-          tags: bridge.tags,
-          status: "FAILED",
-          error
-        });
-        const message = `${bridge.title} failed while executing a step`;
-        const meta = { cause: error };
-        throw new import_errors.AutomationError(message, meta);
-      } finally {
-        await container.disposeAll(bridge.tags, import_gherkin.isTagsMatch);
-      }
-    },
-    chosenTimeout.milliseconds
-  );
-}
-async function tryRunStep(step, events, bridge, localApp) {
-  await bootstrapStep(step, events, bridge, localApp);
-}
-async function bootstrapStep(step, events, bridge, localApp) {
-  const title = step.data.scope.stepText(
-    step.data.gherkin.keyword,
-    step.data.gherkin.text
-  );
-  let args = [];
-  try {
-    const app = localApp();
-    args = step.args?.(app) ?? [];
-    events.step.emitStart({
-      title,
-      args,
-      expression: step.expressionText
-    });
-    await step.data.scope.execute(step.data.gherkin, args, app);
-    events.step.emitEnd({
-      expression: step.expressionText,
-      title,
-      args,
-      status: "PASSED"
-    });
-  } catch (e) {
-    const error = e;
-    events.step.emitEnd({
-      expression: step.expressionText,
-      title,
-      args,
-      status: "FAILED",
-      error: e
-    });
-    const message = `${title} experienced an error`;
-    const meta = { cause: error };
-    const newError = new import_errors.AutomationError(message, meta);
-    console.error((0, import_errors.formatErrorCauses)(newError));
-    throw newError;
-  }
-}
-function isOutline(data) {
-  return data instanceof import_test_builder.ScenarioOutlineBridge;
-}
-function bootstrapScenarioOutline(root, bridge, localApp, staticApp, events, [config, timeout]) {
-  const {
-    data: { scope, gherkin },
-    examples
-  } = bridge;
-  const title = scope.title(gherkin);
-  const retry = [...gherkin.tags].find((tag) => tag.startsWith("@retries="));
-  const { beforeScenarioOutlineHooks, afterScenarioOutlineHooks } = scope.hooks;
-  const [group, modifier] = getGroupOrModifier(
-    bridge,
-    config.current.test?.tagFilter
-  );
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config).milliseconds;
-  const original = localApp;
-  localApp = () => {
-    const testName = import_globals.expect.getState().currentTestName;
-    if (!outlineApps.has(testName)) {
-      outlineApps.set(testName, []);
-    }
-    const apps = outlineApps.get(testName);
-    const [container, app] = original();
-    apps.push(app);
-    return [container, app];
-  };
-  group(title, () => {
-    beforeScenarioOutlineHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        timeout,
-        hook.options.timeout
-      ).getTimeout(config).milliseconds;
-      (0, import_globals.beforeAll)(async () => {
-        if (!hook.canExecute(...gherkin.tags)) {
-          return;
-        }
-        events.beforeScenarioOutline.emitStart({
-          title,
-          modifier,
-          tags: [...gherkin.tags]
-        });
-        const tags = gherkin.tags ?? [];
-        events.beforeScenarioOutline.emitStart({
-          title,
-          modifier,
-          tags: [...gherkin.tags]
-        });
-        const report = await hook.execute(staticApp, ...tags);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.beforeScenarioOutline.emitEnd({
-            title,
-            modifier,
-            error: report.error,
-            tags: [...gherkin.tags],
-            status: "FAILED"
-          });
-          throw new import_errors.AutomationError(message, { cause: report.error });
-        }
-        events.beforeScenarioOutline.emitEnd({
-          title,
-          modifier,
-          tags: [...gherkin.tags],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    (0, import_globals.beforeAll)(() => {
-      if (retry) {
-        const count = parseInt(retry.split("=")[1]);
-        import_globals.jest.retryTimes(count);
-      }
-      events.scenarioOutline.emitStart({
-        title,
-        modifier,
-        tags: [...gherkin.tags]
-      });
-    });
-    bootstrapSetupHooks(bridge, staticApp, events, [config, timeout]);
-    bootstrapBeforeHooks(root, bridge, localApp, events, [config, timeout]);
-    examples.forEach((example) => {
-      bootstrapExamples(root, example, localApp, staticApp, events, [
-        config,
-        timeout
-      ]);
-    });
-    bootstrapAfterHooks(root, bridge, localApp, events, [config, timeout]);
-    bootstrapTeardownHooks(bridge, staticApp, events, [config, timeout]);
-    afterScenarioOutlineHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        timeout,
-        hook.options.timeout
-      ).getTimeout(config).milliseconds;
-      (0, import_globals.afterAll)(async () => {
-        if (!hook.canExecute(...gherkin.tags)) {
-          return;
-        }
-        const testName = import_globals.expect.getState().currentTestName;
-        const tags = gherkin.tags ?? [];
-        const apps = outlineApps.get(testName);
-        events.afterScenarioOutline.emitStart({
-          title,
-          modifier,
-          tags: [...gherkin.tags]
-        });
-        const report = await hook.execute(staticApp, apps, ...tags);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.scenarioOutline.emitEnd({
-            title,
-            modifier,
-            error: report.error,
-            tags: [...gherkin.tags],
-            status: "FAILED"
-          });
-          throw new import_errors.AutomationError(message, { cause: report.error });
-        }
-        events.afterScenarioOutline.emitEnd({
-          title,
-          modifier,
-          tags: [...gherkin.tags],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    (0, import_globals.afterAll)(() => {
-      const failures = import_test_builder2.Query.find.failed(bridge);
-      const status = getStatus(modifier, failures);
-      events.scenarioOutline.emitEnd({
-        title,
-        modifier,
-        tags: [...gherkin.tags],
-        status
-      });
-      outlineApps.clear();
-      examplesApps.clear();
-    }, chosenTimeout);
-  });
-}
-function bootstrapExamples(root, example, localApp, staticApp, events, timeout) {
-  const { gherkin } = example.data;
-  const title = `${gherkin.keyword}: ${gherkin.name}`;
-  const retry = [...example.data.gherkin.tags].find(
-    (tag) => tag.startsWith("@retries=")
-  );
-  const original = localApp;
-  localApp = () => {
-    const testName = import_globals.expect.getState().currentTestName ?? "unnamed test";
-    if (!examplesApps.has(testName)) {
-      examplesApps.set(testName, []);
-    }
-    const apps = examplesApps.get(testName);
-    const [container, app] = original();
-    apps.push(app);
-    return [container, app];
-  };
-  const [group] = getGroupOrModifier(
-    example,
-    timeout[0].current.test?.tagFilter
-  );
-  group(title, () => {
-    (0, import_globals.beforeAll)(() => {
-      if (retry) {
-        const count = parseInt(retry.split("=")[1]);
-        import_globals.jest.retryTimes(count);
-      }
-    });
-    example.data.scope.hooks.beforeExamplesHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        timeout[1],
-        hook.options.timeout
-      ).getTimeout(timeout[0]).milliseconds;
-      (0, import_globals.beforeAll)(async () => {
-        if (!hook.canExecute(...example.data.gherkin.tags)) {
-          return;
-        }
-        const tags = example?.data?.gherkin?.tags ?? [];
-        events.beforeExamples.emitStart({
-          title,
-          tags: [...tags]
-        });
-        const report = await hook.execute(staticApp, ...tags);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          events.beforeExamples.emitEnd({
-            title,
-            error: report.error,
-            tags: [...tags],
-            status: "FAILED"
-          });
-          throw new import_errors.AutomationError(message, { cause: report.error });
-        }
-        events.beforeExamples.emitEnd({
-          title,
-          tags: [...tags],
-          status: "PASSED"
-        });
-      }, hookTimeout);
-    });
-    bootstrapScenarios(root, example, localApp, staticApp, events, timeout);
-    example.data.scope.hooks.afterExamplesHooks.forEach((hook) => {
-      const hookTimeout = chooseTimeout(
-        timeout[1],
-        hook.options.timeout
-      ).getTimeout(timeout[0]).milliseconds;
-      (0, import_globals.afterAll)(async () => {
-        const testName = import_globals.expect.getState().currentTestName;
-        if (!hook.canExecute(...example.data.gherkin.tags)) {
-          return;
-        }
-        const tags = example?.data?.gherkin?.tags ?? [];
-        const apps = examplesApps.get(testName);
-        const report = await hook.execute(staticApp, apps, ...tags);
-        if (report.error) {
-          const message = `${hook.name}: ${hook.description} failed to execute.`;
-          throw new import_errors.AutomationError(message, { cause: report.error });
-        }
-      }, hookTimeout);
-    });
-    (0, import_globals.afterAll)(() => {
-      const testName = import_globals.expect.getState().currentTestName;
-      examplesApps.delete(testName);
-    });
-  });
-}
-function bootstrapRules(bridge, localApp, staticApp, events, [config, timeout]) {
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  bridge.rules.forEach((rule) => {
-    const tags = [...rule.data.gherkin.tags];
-    const retry = tags.find((tag) => tag.startsWith("@retries="));
-    const ruleTimeout = chooseTimeout(
-      chosenTimeout,
-      rule.data.scope.timeout
-    ).getTimeout(config);
-    const transferTimeout = [config, ruleTimeout];
-    const { data } = rule;
-    const ruleName = data.scope.title(data.gherkin);
-    const [group, modifier] = getGroupOrModifier(
-      bridge,
-      config.current.test?.tagFilter
-    );
-    group(ruleName, () => {
-      (0, import_globals.beforeAll)(() => {
-        events.rule.emitStart({
-          title: ruleName,
-          modifier,
-          tags: [...data.gherkin.tags]
-        });
-        if (retry) {
-          const count = parseInt(retry.split("=")[1]);
-          import_globals.jest.retryTimes(count);
-        }
-        const original = localApp;
-        localApp = () => {
-          const testName = import_globals.expect.getState().currentTestName;
-          if (!ruleApps.has(testName)) {
-            ruleApps.set(testName, []);
-          }
-          const apps = ruleApps.get(testName);
-          const [container, app] = original();
-          apps.push(app);
-          return [container, app];
-        };
-      });
-      bridge.data.scope.hooks.beforeRuleHooks.forEach((hook) => {
-        const hookTimeout = chooseTimeout(
-          ruleTimeout,
-          hook.options.timeout
-        ).getTimeout(config).milliseconds;
-        (0, import_globals.beforeAll)(async () => {
-          if (!hook.canExecute(...data.gherkin.tags)) {
-            return;
-          }
-          const tags2 = data.gherkin.tags ?? [];
-          events.beforeRule.emitStart({
-            title: `${hook.name}: ${hook.description}`,
-            tags: [...tags2]
-          });
-          const report = await hook.execute(staticApp, ...tags2);
-          if (report.error) {
-            const message = `${hook.name}: ${hook.description} failed to execute.`;
-            events.beforeRule.emitEnd({
-              title: `${hook.name}: ${hook.description}`,
-              tags: [...tags2],
-              status: "FAILED",
-              error: report.error
-            });
-            throw new import_errors.AutomationError(message, { cause: report.error });
-          }
-          events.beforeRule.emitEnd({
-            title: `${hook.name}: ${hook.description}`,
-            tags: [...tags2],
-            status: "PASSED"
-          });
-        }, hookTimeout);
-      });
-      bridge.data.scope.hooks.afterRuleHooks.forEach((hook) => {
-        const hookTimeout = chooseTimeout(
-          ruleTimeout,
-          hook.options.timeout
-        ).getTimeout(config).milliseconds;
-        (0, import_globals.afterAll)(async () => {
-          const testName = import_globals.expect.getState().currentTestName;
-          if (!hook.canExecute(...data.gherkin.tags)) {
-            return;
-          }
-          const tags2 = data.gherkin.tags ?? [];
-          const apps = ruleApps.get(testName);
-          events.afterRule.emitStart({
-            title: `${hook.name}: ${hook.description}`,
-            tags: [...tags2]
-          });
-          const report = await hook.execute(staticApp, apps, ...tags2);
-          if (report.error) {
-            const message = `${hook.name}: ${hook.description} failed to execute.`;
-            events.afterRule.emitEnd({
-              title: `${hook.name}: ${hook.description}`,
-              tags: [...tags2],
-              status: "FAILED",
-              error: report.error
-            });
-            throw new import_errors.AutomationError(message, { cause: report.error });
-          }
-          events.afterRule.emitEnd({
-            title: `${hook.name}: ${hook.description}`,
-            tags: [...tags2],
-            status: "PASSED"
-          });
-        }, hookTimeout);
-      });
-      bootstrapSetupHooks(rule, staticApp, events, transferTimeout);
-      bootstrapBeforeHooks(bridge, rule, localApp, events, transferTimeout);
-      bootstrapBackground(bridge, rule, localApp, events, transferTimeout);
-      bootstrapScenarios(
-        bridge,
-        rule,
-        localApp,
-        staticApp,
-        events,
-        transferTimeout
-      );
-      bootstrapAfterHooks(bridge, rule, localApp, events, transferTimeout);
-      bootstrapTeardownHooks(rule, staticApp, events, transferTimeout);
-      (0, import_globals.afterAll)(() => {
-        const failures = import_test_builder2.Query.find.failed(rule);
-        const status = getStatus(modifier, failures);
-        events.rule.emitEnd({
-          title: ruleName,
-          modifier,
-          tags: [...data.gherkin.tags],
-          status
-        });
-        const testName = import_globals.expect.getState().currentTestName;
-        ruleApps.delete(testName);
-      }, ruleTimeout.milliseconds);
-    });
-  });
-}
-function getStatus(modifier, failures) {
-  if (modifier === "skip") {
-    return "SKIPPED";
+var runtime = {
+  suite: describe,
+  test: it,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach,
+  currentTestName: () => expect.getState().currentTestName,
+  retry: (count) => {
+    if (typeof jest?.retryTimes === "function") {
+      jest.retryTimes(count);
+    }
+  },
+  warn: (message) => {
+    console.warn(message);
+  },
+  logError: (error) => {
+    console.error(error);
   }
-  if (failures.length === 0) {
-    return "PASSED";
-  }
-  return "FAILED";
-}
-function getGroupOrModifier(bridge, tagFilter) {
-  const { data } = bridge;
-  if (data.gherkin.tags?.has("@skip") || data.gherkin.tags?.has("@skipped")) {
-    return [import_globals.describe.skip, "skip"];
-  }
-  if (data.gherkin.tags?.has("@only")) {
-    return [import_globals.describe.only, "only"];
-  }
-  if (tagFilter) {
-    const parse = require("@cucumber/tag-expressions").default;
-    const expression = parse(tagFilter).evaluate([...bridge.data.gherkin.tags]);
-    if (!expression) {
-      return [import_globals.describe.skip, "skip"];
-    }
-  }
-  return [import_globals.describe, void 0];
-}
-function getTestOrModifier({ data }, tagFilter) {
-  if (data.gherkin.tags?.has("@skip") || data.gherkin.tags?.has("@skipped")) {
-    return import_globals.it.skip;
-  }
-  if (data.gherkin.tags?.has("@only")) {
-    return import_globals.it.only;
-  }
-  if (tagFilter) {
-    const parse = require("@cucumber/tag-expressions").default;
-    const expression = parse(tagFilter).evaluate([...data.gherkin.tags]);
-    if (!expression) {
-      return import_globals.it.skip;
-    }
-  }
-  return import_globals.it;
-}
-function bootstrapBeforeHooks(root, bridge, localApp, events, [config, timeout]) {
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config);
-  bridge.data.scope.hooks.before.forEach((hook) => {
-    const hookTimeout = chooseTimeout(
-      chosenTimeout,
-      hook.options.timeout
-    ).getTimeout(config).milliseconds;
-    (0, import_globals.beforeEach)(async () => {
-      const testName = import_globals.expect.getState().currentTestName;
-      if (!testName)
-        throw new import_errors.AutomationError("A Scenario must have a title");
-      const scenarioBridge = (0, import_test_builder.find)(root, testName);
-      if (!scenarioBridge) {
-        throw new import_errors.AutomationError(
-          `No matching scenario was found matching the test name: ${testName}`
-        );
-      }
-      if (!hook.canExecute(...scenarioBridge.data.gherkin.tags)) {
-        return;
-      }
-      const tags = scenarioBridge?.data?.gherkin?.tags ?? [];
-      events.before.emitStart({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags]
-      });
-      const report = await hook.execute(localApp()[1], ...tags);
-      events.before.emitEnd({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags],
-        status: report.status,
-        error: report.error
-      });
-      if (report.error) {
-        const message = `${hook.name}: ${hook.description} experienced a failure.`;
-        throw new import_errors.AutomationError(message, { cause: report.error });
-      }
-    }, hookTimeout);
-  });
-}
-function bootstrapSetupHooks(bridge, staticApp, events, [config, timeout]) {
-  const { scope, gherkin } = bridge.data;
-  const chosenTimeout = chooseTimeout(
-    timeout,
-    bridge.data.scope.timeout
-  ).getTimeout(config).milliseconds;
-  const setups = scope.hooks.setup;
-  setups.forEach((hook) => {
-    const hookTimeout = chooseTimeout(
-      import_scopes2.Timeout.from(chosenTimeout),
-      hook.options.timeout
-    ).getTimeout(config).milliseconds;
-    const tags = gherkin.tags ?? [];
-    (0, import_globals.beforeAll)(async () => {
-      if (!hook.canExecute(...tags)) {
-        return;
-      }
-      events.setup.emitStart({
-        title: `${hook.name}: ${hook.description}`
-      });
-      const report = await hook.execute(staticApp, ...tags);
-      events.setup.emitEnd({
-        title: `${hook.name}: ${hook.description}`,
-        status: report.status,
-        error: report.error
-      });
-      if (report.error) {
-        const message = `${hook.name}: ${hook.description} failed to execute.`;
-        throw new import_errors.AutomationError(message, { cause: report.error });
-      }
-    }, hookTimeout);
-  });
-}
-function bootstrapAfterHooks(root, bridge, localApp, events, [config, timeout]) {
-  const { scope } = bridge.data;
-  const chosenTimeout = chooseTimeout(timeout, scope.timeout).getTimeout(
-    config
-  ).milliseconds;
-  scope.hooks.after.forEach((hook) => {
-    const hookTimeout = chooseTimeout(
-      import_scopes2.Timeout.from(chosenTimeout),
-      hook.options.timeout
-    ).getTimeout(config).milliseconds;
-    (0, import_globals.afterEach)(async () => {
-      const testName = import_globals.expect.getState().currentTestName;
-      if (!testName)
-        throw new import_errors.AutomationError("A Scenario must have a title");
-      const scenarioBridge = (0, import_test_builder.find)(root, testName);
-      if (!scenarioBridge) {
-        throw new import_errors.AutomationError(
-          `No scenario was found matching the test path: ${testName}`
-        );
-      }
-      if (!hook.canExecute(...scenarioBridge.data.gherkin.tags)) {
-        return;
-      }
-      const tags = scenarioBridge?.data?.gherkin?.tags ?? [];
-      events.after.emitStart({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags]
-      });
-      const report = await hook.execute(localApp()[1], ...tags);
-      events.after.emitEnd({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags],
-        status: report.status,
-        error: report.error
-      });
-      if (report.error) {
-        const message = `${hook.name}: ${hook.description} failed to execute.`;
-        throw new import_errors.AutomationError(message, { cause: report.error });
-      }
-    }, hookTimeout);
-  });
-}
-function bootstrapTeardownHooks(bridge, staticApp, event, [config, timeout]) {
-  const tags = [...bridge.data.gherkin.tags];
-  const { scope } = bridge.data;
-  const chosenTimeout = chooseTimeout(timeout, scope.timeout).getTimeout(
-    config
-  );
-  scope.hooks.teardown.forEach((hook) => {
-    const hookTimeout = chooseTimeout(
-      chosenTimeout,
-      hook.options.timeout
-    ).getTimeout(config).milliseconds;
-    (0, import_globals.afterAll)(async () => {
-      if (!hook.canExecute(...tags)) {
-        return;
-      }
-      event.teardown.emitStart({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags]
-      });
-      const report = await hook.execute(staticApp, tags);
-      event.teardown.emitEnd({
-        title: `${hook.name}: ${hook.description}`,
-        tags: [...tags],
-        status: report.status,
-        error: report.error
-      });
-      if (report.error) {
-        const message = `${hook.name}: ${hook.description} failed to execute.`;
-        throw new import_errors.AutomationError(message, { cause: report.error });
-      }
-    }, hookTimeout);
+};
+function execute(options) {
+  registerFeaturePlan({
+    plan: options.plan,
+    adapter: options.adapter,
+    config: options.config,
+    runtime
   });
 }
+var src_default = { execute };
 
-// src/index.ts
-var src_default = execute;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  execute,
-  getTimeout
-});
+export { src_default as default, execute };
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map