@autometa/runner 0.6.3 → 1.0.0-rc.0

package/README.md

@@ -1,122 +1,3 @@
-# Autometa
+# Introduction
 
-[Full Docs](https://bendat.github.io/autometa/docs/cucumber/test_runner/intro/)
-
-# NOTICE
-
-Autometa is under construction. It is currently unstable, poorly documented and not production ready for most cases.
-
-Check back soon.
-
-The following libraries may be considered relatively stable, but may contain bugs or unclear errors
-
-- [Overloaded](libraries/overloaded/) - Function and method overloads that are as pleasant to make as they are to use
-- [Bind Decorator](libraries/bind-decorator/) - Binds the `this` keyword on a class method. Respectfully a fork of [bind-decorator](https://www.npmjs.com/package/autobind-decorator)
-- [Status Codes](libraries/status-codes/) - Object containing HTTP status
-  codes and status messages, visible in the editor via `as const`
-
-# Autometa
-
-_Autometa_ is an early-development automation framework toolkit, which provides libraries to help automate the automation process on node with libraries to
-help bootstrap your node automation framework, for API or E2E testing.
-
-[Full Docs](https://bendat.github.io/autometa/docs/cucumber/test_runner/intro/)
-
-## Cucumber Runner
-
-The Cucumber Runner lets you build and execute Cucumber style tests with alternative test runners. Currently supported are `jest`.
-
-Initially inspired by [jest-cucumber](github.com/bencompton/jest-cucumber) provides a customizable hybrid approach between cucumbers flat global steps
-and jest-cucumbers nested spec-like tests.
-
-Dependency injection is supported to make initializing client classes needed to interface with your service or website simple and logic-free, with unique copies
-provided to each executing tests.
-
-```ts title='Cucumber like'
-import { Feature, Given, When, Then, Before } from "@autometa/runner";
-import { App } from "./my-app";
-import * as seedData from "./seed-data";
-
-Before("Seed the database", async ({ dbClient }: App) => {
-  await dbClient.seed(seedData);
-});
-Given("a user who wants to log in", () => {});
-When("a user submits their credentials", () => {});
-Then("a user sees their", () => {});
-
-// tests assembled automatically
-Feature("./my-feature.feature");
-```
-
-Steps can also be nested or groups to override higher level
-steps.
-
-```ts title='Jest-Cucumber like'
-import {
-  Feature,
-  Given,
-  When,
-  Then,
-  Before,
-  ScenarioOutline,
-  Scenario,
-  Rule,
-} from "@autometa/runner";
-import { App } from "./my-app";
-import * as seedData from "./seed-data";
-
-Before("Seed the database", async ({ dbClient }: App) => {
-  await dbClient.seed(seedData);
-});
-Given("a user who wants to log in", () => {});
-When("a user submits their credentials", () => {});
-
-Feature(() => {
-  Scenario("a user logs in successfully", () => {
-    Then("a user sees their profile", () => {});
-  });
-
-  Scenario("a user cannot log in without a password", () => {
-    Then(
-      "a user is informed they cannot log in",
-      (expectedError: string) => {}
-    );
-  });
-  Rule("a rule", () => {
-    ScenarioOutline("some outline", () => {
-      // define steps unique to `some outline`
-    });
-  });
-}, "./my-feature.feature");
-```
-
-## Dto Builder
-
-Implementation of the Builder pattern that allows automatically generating
-builder classes from a DTO class prototype, with type-safe builder methods in
-place of DTO properties.
-
-```ts
-import { dto, Builder } from '@autometa/dto-builder'
-export class UserDto {
-    id: number
-    username: string,
-    // default values, factories, dtos
-    @DTO.dto(AddressDto)
-    address: AddressDto
-    @DTO.date()
-    createdAt: Date
-}
-// or
-// avoid duplicating interface properties
-export class UserDto extends DTO<IUser> {}
-
-const UserDtoBuilder = Builder(UserDto);
-
-const user = new UserDtoBuilder().id(1).name('bob').build()
-
-// compilation error, 'first argument of "id" must be a number"
- new UserDtoBuilder().id('1').name('bob').build()
- // force it to pass a string
- new UserDtoBuilder().id('1' as unknown as number).name('bob').build()
-```
+There's nothing here yet

package/dist/bindings/create-bindings-ts.d.ts

@@ -0,0 +1,46 @@
+import type { StepExpression } from "@autometa/scopes";
+import { Scope, type IContainer, type Identifier } from "@autometa/injection";
+import type { RunnerEnvironment } from "../dsl/create-runner";
+type StepDecorator = (expression: StepExpression) => MethodDecorator;
+/**
+ * Surface returned by `runner.bindingsTS()` for TypeScript experimental decorators.
+ * Provides class-based step definitions with dependency injection support.
+ */
+export interface RunnerBindingsSurface<_World> {
+    /**
+     * Class decorator that marks a class as containing step definitions.
+     * The class will be registered with the DI container and its step methods
+     * will be automatically registered with the runner.
+     */
+    readonly Binding: () => ClassDecorator;
+    /**
+     * Step method decorators - use on methods within a @Binding class.
+     */
+    readonly Given: StepDecorator;
+    readonly When: StepDecorator;
+    readonly Then: StepDecorator;
+    readonly And: StepDecorator;
+    readonly But: StepDecorator;
+    /**
+     * DI decorators for registering and injecting dependencies.
+     */
+    readonly Injectable: (options?: {
+        scope?: Scope;
+    }) => ClassDecorator;
+    readonly Inject: (token: Identifier) => ParameterDecorator & PropertyDecorator;
+    readonly LazyInject: (token: Identifier) => PropertyDecorator;
+    /**
+     * The global container used for registrations.
+     * Can be used for advanced scenarios like manual registration.
+     */
+    readonly container: IContainer;
+}
+/**
+ * Creates the bindings surface for TypeScript experimental decorators.
+ * This provides class-based step definitions with full DI support.
+ *
+ * Note: This function requires reflect-metadata to be imported by the user.
+ * The import is done lazily to avoid breaking projects that don't use bindings.
+ */
+export declare function createBindingsTS<World>(stepsEnvironment: RunnerEnvironment<World, Record<string, unknown>>): RunnerBindingsSurface<World>;
+export {};

package/dist/bindings/index.d.ts

@@ -0,0 +1 @@
+export { createBindingsTS, type RunnerBindingsSurface, } from "./create-bindings-ts";

package/dist/builder/create-runner-builder.d.ts

@@ -0,0 +1,149 @@
+import { type AssertionPlugin, type EnsureFacade, type EnsureInvoke, type EnsurePluginFacets, type EnsureOptions, type EnsureChain } from "@autometa/assertions";
+import type { CoordinateFeatureResult } from "@autometa/coordinator";
+import { Scope, type Constructor, type IContainer, type Identifier, type RegistrationOptions, type Token } from "@autometa/injection";
+import type { CucumberExpressionTypeMap, DefaultCucumberExpressionTypes, WorldFactory } from "@autometa/scopes";
+import type { ParameterTypeDefinitions } from "@autometa/cucumber-expressions";
+import type { RunnerContextOptions } from "../core/runner-context";
+import { type RunnerEnvironment } from "../dsl/create-runner";
+import { type GlobalRunner } from "../dsl/create-global-runner";
+import { type DecoratorRunnerEnvironment } from "../dsl/create-decorator-runner";
+import { type RunnerDecorators } from "../decorators/create-runner-decorators";
+import { type RunnerBindingsSurface } from "../bindings/create-bindings-ts";
+import { type CoordinateRunnerFeatureOptions } from "../runtime/coordinate-runner-feature";
+export type DefaultEnsureFacets = Record<string, never>;
+export type RunnerEnsureFactory<World, Facets extends Record<string, unknown>> = Facets & {
+    (world: World): EnsureFacade<World, Facets>;
+    <T>(value: T, options?: EnsureOptions): EnsureChain<T>;
+    readonly world: World;
+    readonly not: Facets;
+};
+export type AssertionSetup<World, Facets extends Record<string, unknown>> = (ensure: EnsureInvoke) => RunnerEnsureFactory<World, Facets>;
+export declare const WORLD_INHERIT_KEYS: unique symbol;
+export type StepsEnvironmentMeta = {
+    readonly kind: "root";
+} | {
+    readonly kind: "group";
+    readonly group: string;
+};
+export declare const STEPS_ENVIRONMENT_META: symbol;
+type AppPropertyInjection = Identifier | {
+    readonly token: Identifier;
+    readonly lazy?: boolean;
+};
+export interface AppClassRegistrationOptions {
+    readonly scope?: Scope;
+    readonly tags?: readonly string[];
+    readonly deps?: readonly Identifier[];
+    readonly inject?: Record<PropertyKey, AppPropertyInjection>;
+}
+export interface AppRegistrationOptions<App, World> extends AppClassRegistrationOptions {
+    readonly configure?: (instance: App, context: AppFactoryContext<World>) => void | Promise<void>;
+}
+export interface AppCompositionOptions<App, World> extends AppRegistrationOptions<App, World> {
+    readonly setup?: (context: AppFactoryContext<World>) => void | Promise<void>;
+}
+export interface AppFactoryContext<World> {
+    readonly container: IContainer;
+    readonly world: World;
+    registerClass<T>(target: Constructor<T>, options?: AppClassRegistrationOptions): AppFactoryContext<World>;
+    registerValue<T>(identifier: Identifier<T>, value: T, options?: RegistrationOptions): AppFactoryContext<World>;
+    registerFactory<T>(identifier: Identifier<T>, factory: (container: IContainer) => T, options?: RegistrationOptions): AppFactoryContext<World>;
+    registerToken<T>(token: Token<T>, target: Constructor<T> | ((container: IContainer) => T), options?: RegistrationOptions): AppFactoryContext<World>;
+    registerApp<T>(target: Constructor<T>, options?: AppRegistrationOptions<T, World>): Promise<T>;
+    getRegisteredApp(): unknown;
+    resolve<T>(identifier: Identifier<T>): T;
+}
+export declare const App: {
+    compositionRoot<Ctor extends Constructor<unknown>, World = unknown>(ctor: Ctor, options?: AppCompositionOptions<InstanceType<Ctor>, World> | undefined): AppFactoryInput<World, InstanceType<Ctor>>;
+};
+type AppFactoryInput<World, App> = App | (() => App | Promise<App>) | ((context: AppFactoryContext<World>) => App | Promise<App>);
+export type WorldWithApp<World, App> = World extends {
+    app: infer _Existing;
+} ? Omit<World, "app"> & {
+    readonly app: App;
+} : World & {
+    readonly app: App;
+};
+export interface RunnerStepsSurface<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes, Facets extends Record<string, unknown> = DefaultEnsureFacets> extends RunnerEnvironment<World, ExpressionTypes> {
+    readonly globals: GlobalRunner<World, ExpressionTypes>;
+    coordinateFeature(options: RunnerCoordinateFeatureOptions<World>): CoordinateFeatureResult<World>;
+    readonly ensure: RunnerEnsureFactory<World, Facets>;
+}
+export interface RunnerDecoratorsSurface<World> extends RunnerDecorators<World> {
+    readonly environment: DecoratorRunnerEnvironment<World>;
+}
+export interface RunnerBuilder<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes, Facets extends Record<string, unknown> = DefaultEnsureFacets> {
+    /**
+     * Creates an isolated copy of this builder.
+     *
+     * This is the foundation for per-group/per-domain runner environments.
+     *
+     * Notes:
+     * - Caches are cleared on the fork.
+     * - Factories (world/app) are copied by reference.
+     */
+    fork(): DerivableRunnerBuilder<World, ExpressionTypes, Facets>;
+    /**
+     * Enables group-based derivation on this builder.
+     *
+     * This is primarily a typing affordance; it does not change runtime behavior.
+     */
+    derivable(): DerivableRunnerBuilder<World, ExpressionTypes, Facets>;
+    /**
+     * Returns (and caches) a derived builder for a given group/domain key.
+     *
+     * The derived builder is a fork taken at first access.
+     */
+    group(key: string): DerivableRunnerBuilder<World, ExpressionTypes, Facets>;
+    /**
+     * Composes a world factory on top of the current world.
+     *
+     * The resulting world is a shallow merge of (baseWorld, extensionWorld), with
+     * extension keys taking precedence.
+     */
+    extendWorld<ExtensionWorld = Record<string, unknown>>(value?: Partial<ExtensionWorld> | WorldFactory<ExtensionWorld>): RunnerBuilder<World & ExtensionWorld, ExpressionTypes, DefaultEnsureFacets>;
+    /**
+     * Extends application configuration while preserving the existing app factory.
+     *
+     * App factories are executed in sequence; later factories may override the
+     * application instance by returning/registering a different app.
+     */
+    extendApp<App>(app: AppFactoryInput<World, App>): RunnerBuilder<WorldWithApp<World, App>, ExpressionTypes, DefaultEnsureFacets>;
+    configure(update: Partial<RunnerContextOptions<World>> | ((current: RunnerContextOptions<World>) => RunnerContextOptions<World>)): RunnerBuilder<World, ExpressionTypes, Facets>;
+    expressionMap<NextExpressionTypes extends CucumberExpressionTypeMap>(): RunnerBuilder<World, NextExpressionTypes, Facets>;
+    withWorld<NextWorld = World>(value?: Partial<NextWorld> | WorldFactory<NextWorld>): RunnerBuilder<NextWorld, ExpressionTypes, DefaultEnsureFacets>;
+    app<App>(app: AppFactoryInput<World, App>): RunnerBuilder<WorldWithApp<World, App>, ExpressionTypes, DefaultEnsureFacets>;
+    assertions<NextFacets extends Record<string, unknown>>(setup: AssertionSetup<World, NextFacets>): RunnerBuilder<World, ExpressionTypes, NextFacets>;
+    assertionPlugins<NextPlugins extends Record<string, AssertionPlugin<World, unknown>>>(plugins: NextPlugins): RunnerBuilder<World, ExpressionTypes, EnsurePluginFacets<World, NextPlugins>>;
+    parameterTypes(definitions: ParameterTypeDefinitions<World>): RunnerBuilder<World, ExpressionTypes, Facets>;
+    steps(): RunnerStepsSurface<World, ExpressionTypes, Facets>;
+    decorators(): RunnerDecoratorsSurface<World>;
+    /**
+     * Returns binding decorators for TypeScript experimental decorators.
+     * Use this for class-based step definitions with dependency injection.
+     *
+     * @example
+     * ```typescript
+     * const { Binding, Given, When, Then, Injectable, Inject } = runner.bindingsTS();
+     *
+     * @Injectable()
+     * class MyService { ... }
+     *
+     * @Binding()
+     * class MySteps {
+     *   constructor(
+     *     @Inject(WORLD_TOKEN) private world: MyWorld,
+     *     @Inject(MyService) private service: MyService
+     *   ) {}
+     *
+     *   @Given("some step")
+     *   myStep() { ... }
+     * }
+     * ```
+     */
+    bindingsTS(): RunnerBindingsSurface<World>;
+}
+export type DerivableRunnerBuilder<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes, Facets extends Record<string, unknown> = DefaultEnsureFacets> = RunnerBuilder<World, ExpressionTypes, Facets>;
+export type RunnerCoordinateFeatureOptions<World> = Omit<CoordinateRunnerFeatureOptions<World>, "environment">;
+export declare function createRunnerBuilder<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes>(initial?: Partial<RunnerContextOptions<World>>): RunnerBuilder<World, ExpressionTypes, DefaultEnsureFacets>;
+export {};

package/dist/core/parameter-registry.d.ts

@@ -0,0 +1,16 @@
+import type { ParameterType } from "@cucumber/cucumber-expressions";
+import { ParameterTypeRegistry } from "@cucumber/cucumber-expressions";
+import type { ParameterRegistryLike } from "@autometa/scopes";
+export interface ParameterRegistryAdapterOptions {
+    readonly registry?: ParameterTypeRegistry;
+}
+export declare class ParameterRegistryAdapter implements ParameterRegistryLike {
+    #private;
+    constructor(options?: ParameterRegistryAdapterOptions);
+    get registry(): ParameterTypeRegistry;
+    get parameterTypes(): Iterable<ParameterType<unknown>>;
+    lookupByTypeName(name: string): ParameterType<unknown> | undefined;
+    lookupByRegexp(parameterTypeRegexp: string, expressionRegexp: RegExp, text: string): ParameterType<unknown> | undefined;
+    defineParameterType(definition: unknown): ParameterType<unknown>;
+}
+export declare function createParameterRegistryAdapter(options?: ParameterRegistryAdapterOptions): ParameterRegistryAdapter;

package/dist/core/runner-context.d.ts

@@ -0,0 +1,27 @@
+import { type CreateParameterTypesOptions, type ParameterTypeDefinition, type ParameterTypeDefinitions } from "@autometa/cucumber-expressions";
+import type { CreateScopesOptions, CucumberExpressionTypeMap, ScopePlan, ScopesDsl, WithDefaultCucumberExpressionTypes, DefaultCucumberExpressionTypes } from "@autometa/scopes";
+import type { ParameterType, ParameterTypeRegistry } from "@cucumber/cucumber-expressions";
+import { ParameterRegistryAdapter } from "./parameter-registry";
+export type RunnerScopeOptions<World> = Omit<CreateScopesOptions<World>, "parameterRegistry">;
+export interface RunnerContextOptions<World> extends RunnerScopeOptions<World> {
+    readonly parameterRegistry?: ParameterTypeRegistry;
+    readonly parameterTypes?: ParameterTypeDefinitions<World>;
+    readonly parameterTypesOptions?: CreateParameterTypesOptions;
+    readonly registerDefaultParameterTypes?: boolean;
+}
+export declare class RunnerContext<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes> {
+    private readonly scopesInternal;
+    private readonly registryAdapter;
+    private readonly defineParameterTypeFn;
+    private readonly registerDefaultParameterTypesFn;
+    constructor(options?: RunnerContextOptions<World>);
+    get scopes(): ScopesDsl<World, WithDefaultCucumberExpressionTypes<ExpressionTypes>>;
+    get parameterRegistry(): ParameterTypeRegistry;
+    get parameterRegistryAdapter(): ParameterRegistryAdapter;
+    get plan(): ScopePlan<World>;
+    defineParameterType(definition: ParameterTypeDefinition<World>): ParameterType<unknown>;
+    defineParameterTypes(...definitions: ParameterTypeDefinition<World>[]): ParameterTypeRegistry;
+    registerDefaultParameterTypes(): ParameterTypeRegistry;
+    lookupParameterType(name: string): ParameterType<unknown> | undefined;
+    static extractScopeOptions<World>(options: RunnerContextOptions<World>): RunnerScopeOptions<World>;
+}

package/dist/cucumber-runner.d.ts

@@ -0,0 +1,9 @@
+import type { CucumberExpressionTypeMap, DefaultCucumberExpressionTypes } from "@autometa/scopes";
+import { type RunnerBuilder, type RunnerStepsSurface } from "./builder/create-runner-builder";
+import type { RunnerContextOptions } from "./core/runner-context";
+export declare class CucumberRunner {
+    static builder<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes>(initial?: Partial<RunnerContextOptions<World>>): RunnerBuilder<World, ExpressionTypes>;
+    static setSteps<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes>(steps: RunnerStepsSurface<World, ExpressionTypes>): void;
+    static steps<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes>(): RunnerStepsSurface<World, ExpressionTypes>;
+    static clearSteps(): void;
+}

package/dist/current.d.ts

@@ -0,0 +1,5 @@
+import type { RunnerStepsSurface } from "./builder/create-runner-builder";
+import type { CucumberExpressionTypeMap, DefaultCucumberExpressionTypes } from "@autometa/scopes";
+export declare function setCurrentRunnerSteps<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes>(steps: RunnerStepsSurface<World, ExpressionTypes>): void;
+export declare function getCurrentRunnerSteps<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes>(): RunnerStepsSurface<World, ExpressionTypes>;
+export declare function clearCurrentRunnerSteps(): void;

package/dist/decorators/create-runner-decorators.d.ts

@@ -0,0 +1,55 @@
+import type { DecoratorFeatureDescriptor, DecoratorRuleDescriptor, DecoratorScenarioDescriptor, HookOptions, StepExpression, StepOptions, StepTagInput } from "@autometa/scopes";
+import type { DecoratorRegistrationApi } from "../dsl/decorator-shared";
+interface FeatureDecoratorOptions extends Partial<Omit<DecoratorFeatureDescriptor, "name">> {
+    readonly name?: string;
+}
+interface RuleDecoratorOptions extends Partial<Omit<DecoratorRuleDescriptor, "name">> {
+    readonly name: string;
+}
+interface ScenarioDecoratorOptions extends Partial<Omit<DecoratorScenarioDescriptor, "name">> {
+    readonly name: string;
+    readonly steps?: readonly PropertyKey[];
+    readonly rule?: PropertyKey;
+}
+interface StepDecoratorOptions extends StepOptions {
+    readonly scenario: PropertyKey | readonly PropertyKey[];
+}
+interface ScenarioHookDecoratorOptions extends HookOptions {
+    readonly scenario: PropertyKey | readonly PropertyKey[];
+    readonly description?: string;
+}
+interface FeatureHookDecoratorOptions extends HookOptions {
+    readonly description?: string;
+}
+interface RuleHookDecoratorOptions extends HookOptions {
+    readonly rule: PropertyKey | readonly PropertyKey[];
+    readonly description?: string;
+}
+type StepDecoratorFactory<World> = {
+    (expression: StepExpression, options: StepDecoratorOptions): MethodDecorator;
+    skip: StepDecoratorFactory<World>;
+    only: StepDecoratorFactory<World>;
+    failing: StepDecoratorFactory<World>;
+    concurrent: StepDecoratorFactory<World>;
+    tags: (...tags: readonly StepTagInput[]) => StepDecoratorFactory<World>;
+};
+export interface RunnerDecorators<_World> {
+    Feature(options?: FeatureDecoratorOptions): ClassDecorator;
+    Rule(options: RuleDecoratorOptions): MethodDecorator;
+    Scenario(options: ScenarioDecoratorOptions): MethodDecorator;
+    Given: StepDecoratorFactory<_World>;
+    When: StepDecoratorFactory<_World>;
+    Then: StepDecoratorFactory<_World>;
+    And: StepDecoratorFactory<_World>;
+    But: StepDecoratorFactory<_World>;
+    BeforeFeature(options?: FeatureHookDecoratorOptions): MethodDecorator;
+    AfterFeature(options?: FeatureHookDecoratorOptions): MethodDecorator;
+    BeforeRule(options: RuleHookDecoratorOptions): MethodDecorator;
+    AfterRule(options: RuleHookDecoratorOptions): MethodDecorator;
+    BeforeScenario(options: ScenarioHookDecoratorOptions): MethodDecorator;
+    AfterScenario(options: ScenarioHookDecoratorOptions): MethodDecorator;
+    BeforeScenarioOutline(options: ScenarioHookDecoratorOptions): MethodDecorator;
+    AfterScenarioOutline(options: ScenarioHookDecoratorOptions): MethodDecorator;
+}
+export declare function createRunnerDecorators<World>(environment: DecoratorRegistrationApi<World>): RunnerDecorators<World>;
+export {};

package/dist/dsl/create-decorator-runner.d.ts

@@ -0,0 +1,19 @@
+import { type DecoratorFeatureDescriptor, type DecoratorRuleDescriptor, type DecoratorScenarioDescriptor, type HookHandler, type HookOptions, type HookType, type ScopePlan, type StepExpression, type StepHandler, type StepKeyword, type StepOptions } from "@autometa/scopes";
+import { RunnerContext, type RunnerContextOptions } from "../core/runner-context";
+interface ScenarioContext {
+    readonly feature: unknown;
+    readonly rule?: unknown;
+}
+export interface DecoratorRegistrationApi<World> {
+    feature(token: unknown, descriptor: DecoratorFeatureDescriptor): void;
+    rule(featureToken: unknown, token: unknown, descriptor: DecoratorRuleDescriptor): void;
+    scenario(token: unknown, descriptor: DecoratorScenarioDescriptor, context: ScenarioContext): void;
+    step(scenarioToken: unknown, keyword: StepKeyword, expression: StepExpression, handler: StepHandler<World>, options?: StepOptions): void;
+    hook(scopeToken: unknown, type: HookType, handler: HookHandler<World>, description?: string, options?: HookOptions): void;
+}
+export interface DecoratorRunnerEnvironment<World> extends DecoratorRegistrationApi<World> {
+    readonly context: RunnerContext<World>;
+    buildPlan(): ScopePlan<World>;
+}
+export declare function createDecoratorRunner<World>(options?: RunnerContextOptions<World>): DecoratorRunnerEnvironment<World>;
+export {};

package/dist/dsl/create-global-runner.d.ts

@@ -0,0 +1,9 @@
+import { type RunnerEnvironment } from "./create-runner";
+import type { RunnerContextOptions } from "../core/runner-context";
+import type { CucumberExpressionTypeMap, DefaultCucumberExpressionTypes } from "@autometa/scopes";
+export interface GlobalRunner<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes> extends RunnerEnvironment<World, ExpressionTypes> {
+    reset(options?: RunnerContextOptions<World>): RunnerEnvironment<World, ExpressionTypes>;
+    useEnvironment(environment: RunnerEnvironment<World, ExpressionTypes>): RunnerEnvironment<World, ExpressionTypes>;
+    getEnvironment(): RunnerEnvironment<World, ExpressionTypes>;
+}
+export declare function createGlobalRunner<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes>(initialOptions?: RunnerContextOptions<World>): GlobalRunner<World, ExpressionTypes>;

package/dist/dsl/create-runner.d.ts

@@ -0,0 +1,82 @@
+import type { HookHandler, HookRegistration, ScopePlan, ScopesDsl, StepArgumentsForExpression, StepDefinition, StepExpression, StepOptions, StepTagInput, HookOptions, CucumberExpressionTypeMap, DefaultCucumberExpressionTypes, WithDefaultCucumberExpressionTypes } from "@autometa/scopes";
+import type { ParameterTypeDefinition, ParameterTypeDefinitions } from "@autometa/cucumber-expressions";
+import type { ParameterType, ParameterTypeRegistry } from "@cucumber/cucumber-expressions";
+import { type StepRuntimeHelpers } from "@autometa/executor";
+import { RunnerContext, type RunnerContextOptions } from "../core/runner-context";
+type StepHandlerWithOptionalThis<World, TArgs extends unknown[]> = ((this: World, ...args: TArgs) => unknown | Promise<unknown>) | ((...args: TArgs) => unknown | Promise<unknown>);
+export type RuntimeAwareStepHandler<World, TArgs extends unknown[] = unknown[]> = StepHandlerWithOptionalThis<World, [
+    ...TArgs,
+    StepRuntimeHelpers,
+    World
+]>;
+export type RunnerStepHandler<World, TArgs extends unknown[] = unknown[]> = StepHandlerWithOptionalThis<World, [...TArgs, World]> | RuntimeAwareStepHandler<World, TArgs>;
+type StepExpressionArguments<Expression extends StepExpression, ExpressionTypes extends CucumberExpressionTypeMap> = StepArgumentsForExpression<Expression, WithDefaultCucumberExpressionTypes<ExpressionTypes>>;
+export interface RunnerStepDsl<World, ExpressionTypes extends CucumberExpressionTypeMap> {
+    <Expression extends StepExpression>(expression: Expression, handler: StepHandlerWithOptionalThis<World, [
+        ...StepExpressionArguments<Expression, ExpressionTypes>,
+        World
+    ]>, options?: StepOptions): StepDefinition<World>;
+    <Expression extends StepExpression>(expression: Expression, handler: StepHandlerWithOptionalThis<World, [
+        ...StepExpressionArguments<Expression, ExpressionTypes>,
+        StepRuntimeHelpers,
+        World
+    ]>, options?: StepOptions): StepDefinition<World>;
+    skip: RunnerStepDsl<World, ExpressionTypes>;
+    only: RunnerStepDsl<World, ExpressionTypes>;
+    failing: RunnerStepDsl<World, ExpressionTypes>;
+    concurrent: RunnerStepDsl<World, ExpressionTypes>;
+    tags: (...tags: readonly StepTagInput[]) => RunnerStepDsl<World, ExpressionTypes>;
+}
+export interface RunnerHookDsl<World> {
+    (handler: HookHandler<World>, options?: HookOptions): HookRegistration<World>;
+    (description: string, handler: HookHandler<World>, options?: HookOptions): HookRegistration<World>;
+    skip: RunnerHookDsl<World>;
+    only: RunnerHookDsl<World>;
+    failing: RunnerHookDsl<World>;
+    concurrent: RunnerHookDsl<World>;
+}
+type BaseScopesDsl<World, ExpressionTypes extends CucumberExpressionTypeMap> = Omit<ScopesDsl<World, ExpressionTypes>, "given" | "when" | "then" | "and" | "but" | "Given" | "When" | "Then" | "And" | "But" | "beforeFeature" | "afterFeature" | "beforeRule" | "afterRule" | "beforeScenario" | "afterScenario" | "beforeScenarioOutline" | "afterScenarioOutline" | "beforeStep" | "afterStep">;
+export interface RunnerDsl<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes> extends BaseScopesDsl<World, WithDefaultCucumberExpressionTypes<ExpressionTypes>> {
+    readonly given: RunnerStepDsl<World, ExpressionTypes>;
+    readonly when: RunnerStepDsl<World, ExpressionTypes>;
+    readonly then: RunnerStepDsl<World, ExpressionTypes>;
+    readonly and: RunnerStepDsl<World, ExpressionTypes>;
+    readonly but: RunnerStepDsl<World, ExpressionTypes>;
+    readonly Given: RunnerStepDsl<World, ExpressionTypes>;
+    readonly When: RunnerStepDsl<World, ExpressionTypes>;
+    readonly Then: RunnerStepDsl<World, ExpressionTypes>;
+    readonly And: RunnerStepDsl<World, ExpressionTypes>;
+    readonly But: RunnerStepDsl<World, ExpressionTypes>;
+    readonly beforeFeature: RunnerHookDsl<World>;
+    readonly afterFeature: RunnerHookDsl<World>;
+    readonly beforeRule: RunnerHookDsl<World>;
+    readonly afterRule: RunnerHookDsl<World>;
+    readonly beforeScenario: RunnerHookDsl<World>;
+    readonly afterScenario: RunnerHookDsl<World>;
+    readonly beforeScenarioOutline: RunnerHookDsl<World>;
+    readonly afterScenarioOutline: RunnerHookDsl<World>;
+    readonly beforeStep: RunnerHookDsl<World>;
+    readonly afterStep: RunnerHookDsl<World>;
+    readonly BeforeFeature: RunnerHookDsl<World>;
+    readonly AfterFeature: RunnerHookDsl<World>;
+    readonly BeforeRule: RunnerHookDsl<World>;
+    readonly AfterRule: RunnerHookDsl<World>;
+    readonly BeforeScenario: RunnerHookDsl<World>;
+    readonly AfterScenario: RunnerHookDsl<World>;
+    readonly BeforeScenarioOutline: RunnerHookDsl<World>;
+    readonly AfterScenarioOutline: RunnerHookDsl<World>;
+    readonly BeforeStep: RunnerHookDsl<World>;
+    readonly AfterStep: RunnerHookDsl<World>;
+}
+export interface RunnerEnvironment<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes> extends RunnerDsl<World, ExpressionTypes> {
+    readonly context: RunnerContext<World, ExpressionTypes>;
+    readonly parameterRegistry: ParameterTypeRegistry;
+    readonly getPlan: () => ScopePlan<World>;
+    readonly defineParameterType: (definition: ParameterTypeDefinition<World>) => ParameterType<unknown>;
+    readonly defineParameterTypes: (...definitions: ParameterTypeDefinition<World>[]) => ParameterTypeRegistry;
+    readonly defineParameterTypesFromList: (definitions: ParameterTypeDefinitions<World>) => ParameterTypeRegistry;
+    readonly registerDefaultParameterTypes: () => ParameterTypeRegistry;
+    readonly lookupParameterType: (name: string) => ParameterType<unknown> | undefined;
+}
+export declare function createRunner<World, ExpressionTypes extends CucumberExpressionTypeMap = DefaultCucumberExpressionTypes>(options?: RunnerContextOptions<World>): RunnerEnvironment<World, ExpressionTypes>;
+export {};

package/dist/dsl/decorator-shared.d.ts

@@ -0,0 +1,12 @@
+import type { DecoratorFeatureDescriptor, DecoratorRuleDescriptor, DecoratorScenarioDescriptor, HookHandler, HookOptions, HookType, StepExpression, StepHandler, StepKeyword, StepOptions } from "@autometa/scopes";
+export interface ScenarioContext {
+    readonly feature: unknown;
+    readonly rule?: unknown;
+}
+export interface DecoratorRegistrationApi<World> {
+    feature(token: unknown, descriptor: DecoratorFeatureDescriptor): void;
+    rule(featureToken: unknown, token: unknown, descriptor: DecoratorRuleDescriptor): void;
+    scenario(token: unknown, descriptor: DecoratorScenarioDescriptor, context: ScenarioContext): void;
+    step(scenarioToken: unknown, keyword: StepKeyword, expression: StepExpression, handler: StepHandler<World>, options?: StepOptions): void;
+    hook(scopeToken: unknown, type: HookType, handler: HookHandler<World>, description?: string, options?: HookOptions): void;
+}

package/dist/global.d.ts

@@ -0,0 +1,14 @@
+import type { RunnerEnvironment } from "./dsl/create-runner";
+import type { RunnerContextOptions } from "./core/runner-context";
+import { type GlobalRunner } from "./dsl/create-global-runner";
+export interface GlobalWorld {
+    [key: string]: unknown;
+}
+export type GlobalRunnerOptions = RunnerContextOptions<GlobalWorld>;
+export declare function getGlobalRunner(options?: GlobalRunnerOptions): GlobalRunner<GlobalWorld, import("@autometa/scopes").DefaultCucumberExpressionTypes>;
+export declare function configureGlobalRunner(options?: GlobalRunnerOptions): GlobalRunner<GlobalWorld, import("@autometa/scopes").DefaultCucumberExpressionTypes>;
+export declare function resetGlobalRunner(options?: GlobalRunnerOptions): GlobalRunner<GlobalWorld, import("@autometa/scopes").DefaultCucumberExpressionTypes>;
+export declare function disposeGlobalRunner(): void;
+export declare function useGlobalRunnerEnvironment(environment: RunnerEnvironment<GlobalWorld>): RunnerEnvironment<GlobalWorld, import("@autometa/scopes").DefaultCucumberExpressionTypes>;
+export declare function getGlobalRunnerEnvironment(): RunnerEnvironment<GlobalWorld, import("@autometa/scopes").DefaultCucumberExpressionTypes>;
+export declare function getConfiguredGlobalRunner(): GlobalRunner<GlobalWorld, import("@autometa/scopes").DefaultCucumberExpressionTypes>;