@step-forge/step-forge 0.0.17 → 0.0.20

package/dist/step-forge.d.ts

@@ -1,82 +1,223 @@
+import { C as numberParser, S as intParser, _ as StepDefinitionMeta, b as Parser, d as AnalysisRule, f as AnalyzerConfig, g as ParsedStep, h as ParsedScenario, i as PlainHookFn, m as MatchedStep, o as ScenarioHookFn, p as Diagnostic, s as ScenarioInfo, v as BasicWorld, w as stringParser, x as booleanParser, y as MergeableWorld } from "./hooks-Dar49TtT.js";
+
 //#region src/builderTypeUtils.d.ts
-type EmptyObject = Record<string, never>;
+type StepType = "given" | "when" | "then";
+/** A dependency declaration: each key of a phase's state marked required/optional. */
 type RequiredOrOptional<T> = { [K in keyof T]?: "required" | "optional" };
-type GetFunctionArgs<T> = T extends ((...args: infer A) => any) ? A : never;
-type EmptyDependencies = {
-  given: EmptyObject;
-  when: EmptyObject;
-  then: EmptyObject;
+/** The dependency map for a single phase, keyed by state property name. */
+type DepMap = Record<string, "required" | "optional">;
+/** The fully-resolved dependency declaration passed to `addStep` at runtime. */
+type FullDependencies = {
+  given: DepMap;
+  when: DepMap;
+  then: DepMap;
 };
-//#endregion
-//#region src/parsers.d.ts
 /**
- * A Parser maps a Cucumber expression placeholder to a typed value.
- *
- * `gherkin` is the Cucumber Expression placeholder used when registering the
- * step (e.g. `{int}`). `parse` converts the raw value Cucumber captures into
- * the desired TypeScript type.
- *
- * Note: Cucumber Expressions already transform `{int}`/`{float}` captures into
- * JS numbers before the step function runs, so `parse` receives an `unknown`
- * and must tolerate both the pre-transformed value and a raw string.
+ * Narrows a phase's full state to only the keys named in a dependency map.
+ * Optional dependencies widen to `| undefined`; keys not present in the state
+ * are dropped. This is the shape a step function sees for `given`/`when`/`then`.
  */
-type Parser<T> = {
-  parse: (value: unknown) => T;
-  gherkin: string;
-};
-/** Matches a quoted string (`{string}`) and passes the unquoted contents through. */
-declare const stringParser: Parser<string>;
-/** Matches an unquoted integer (`{int}`). */
-declare const intParser: Parser<number>;
-/** Matches an unquoted floating point number (`{float}`). */
-declare const numberParser: Parser<number>;
-/** Matches an unquoted `true`/`false` word (`{word}`) and parses it to a boolean. */
-declare const booleanParser: Parser<boolean>;
+type Restrict<State, Deps extends RequiredOrOptional<State>> = { [K in keyof State as K extends keyof Deps ? K : never]: Deps[K] extends "optional" ? State[K] | undefined : State[K] };
+type GetFunctionArgs<T> = T extends ((...args: infer A) => any) ? A : never;
 //#endregion
 //#region src/given.d.ts
+type GivenInput<Variables, Given> = {
+  variables: Variables;
+  given: Given;
+  when: never;
+  then: never;
+};
+type GivenOutput<GivenState> = Partial<GivenState> | Promise<Partial<GivenState>>;
 declare const givenBuilder: <GivenState>() => {
   statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
+    dependencies: <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
+      given: GivenDeps;
+    }) => {
+      step: (stepFunction: (input: GivenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>>) => GivenOutput<GivenState>) => {
+        statement: (...args: any[]) => string;
+        expression: string;
+        dependencies: FullDependencies;
+        stepType: StepType;
+        stepFunction: (input: GivenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>>) => GivenOutput<GivenState>;
+      };
+    };
+    parsers: <Parsers extends ((Statement extends string ? [] : GetFunctionArgs<Statement>) extends infer T ? { [K in keyof T]: Parser<(Statement extends string ? [] : GetFunctionArgs<Statement>)[K]> } : never)>(parsers: Parsers) => {
+      dependencies: <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
+        given: GivenDeps;
+      }) => {
+        step: (stepFunction: (input: GivenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>>) => GivenOutput<GivenState>) => {
+          statement: (...args: any[]) => string;
+          expression: string;
+          dependencies: FullDependencies;
+          stepType: StepType;
+          stepFunction: (input: GivenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>>) => GivenOutput<GivenState>;
+        };
+      };
+      step: (stepFunction: (input: GivenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never>) => GivenOutput<GivenState>) => {
+        statement: (...args: any[]) => string;
+        expression: string;
+        dependencies: FullDependencies;
+        stepType: StepType;
+        stepFunction: (input: GivenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never>) => GivenOutput<GivenState>;
+      };
+    };
+    step: (stepFunction: (input: GivenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never>) => GivenOutput<GivenState>) => {
+      statement: (...args: any[]) => string;
+      expression: string;
+      dependencies: FullDependencies;
+      stepType: StepType;
+      stepFunction: (input: GivenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never>) => GivenOutput<GivenState>;
+    };
+  };
+};
+//#endregion
+//#region src/when.d.ts
+type WhenInput<Variables, Given, When> = {
+  variables: Variables;
+  given: Given;
+  when: When;
+  then: never;
+};
+type WhenOutput<WhenState> = Partial<WhenState> | Promise<Partial<WhenState>>;
+declare const whenBuilder: <GivenState, WhenState>() => {
+  statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
+    dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>>(dependencies: {
+      given?: GivenDeps | undefined;
+      when?: WhenDeps | undefined;
+    }) => {
+      step: (stepFunction: (input: WhenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>, Restrict<WhenState, WhenDeps>>) => WhenOutput<WhenState>) => {
+        statement: (...args: any[]) => string;
+        expression: string;
+        dependencies: FullDependencies;
+        stepType: StepType;
+        stepFunction: (input: WhenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>, Restrict<WhenState, WhenDeps>>) => WhenOutput<WhenState>;
+      };
+    };
+    parsers: <Parsers extends ((Statement extends string ? [] : GetFunctionArgs<Statement>) extends infer T ? { [K in keyof T]: Parser<(Statement extends string ? [] : GetFunctionArgs<Statement>)[K]> } : never)>(parsers: Parsers) => {
+      dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>>(dependencies: {
+        given?: GivenDeps | undefined;
+        when?: WhenDeps | undefined;
+      }) => {
+        step: (stepFunction: (input: WhenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>, Restrict<WhenState, WhenDeps>>) => WhenOutput<WhenState>) => {
+          statement: (...args: any[]) => string;
+          expression: string;
+          dependencies: FullDependencies;
+          stepType: StepType;
+          stepFunction: (input: WhenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>, Restrict<WhenState, WhenDeps>>) => WhenOutput<WhenState>;
+        };
+      };
+      step: (stepFunction: (input: WhenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never, never>) => WhenOutput<WhenState>) => {
+        statement: (...args: any[]) => string;
+        expression: string;
+        dependencies: FullDependencies;
+        stepType: StepType;
+        stepFunction: (input: WhenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never, never>) => WhenOutput<WhenState>;
+      };
+    };
+    step: (stepFunction: (input: WhenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never, never>) => WhenOutput<WhenState>) => {
+      statement: (...args: any[]) => string;
+      expression: string;
+      dependencies: FullDependencies;
+      stepType: StepType;
+      stepFunction: (input: WhenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never, never>) => WhenOutput<WhenState>;
+    };
+  };
+};
+//#endregion
+//#region src/then.d.ts
+type ThenInput<Variables, Given, When, Then> = {
+  variables: Variables;
+  given: Given;
+  when: When;
+  then: Then;
+};
+type ThenOutput<ThenState> = Partial<ThenState> | Promise<Partial<ThenState>> | void | Promise<void>;
+declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
+  statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
+    dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
+      given?: GivenDeps | undefined;
+      when?: WhenDeps | undefined;
+      then?: ThenDeps | undefined;
+    }) => {
+      step: (stepFunction: (input: ThenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>, Restrict<WhenState, WhenDeps>, Restrict<ThenState, ThenDeps>>) => ThenOutput<ThenState>) => {
+        statement: (...args: any[]) => string;
+        expression: string;
+        dependencies: FullDependencies;
+        stepType: StepType;
+        stepFunction: (input: ThenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>, Restrict<WhenState, WhenDeps>, Restrict<ThenState, ThenDeps>>) => ThenOutput<ThenState>;
+      };
+    };
+    parsers: <Parsers extends ((Statement extends string ? [] : GetFunctionArgs<Statement>) extends infer T ? { [K in keyof T]: Parser<(Statement extends string ? [] : GetFunctionArgs<Statement>)[K]> } : never)>(parsers: Parsers) => {
+      dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
+        given?: GivenDeps | undefined;
+        when?: WhenDeps | undefined;
+        then?: ThenDeps | undefined;
+      }) => {
+        step: (stepFunction: (input: ThenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>, Restrict<WhenState, WhenDeps>, Restrict<ThenState, ThenDeps>>) => ThenOutput<ThenState>) => {
+          statement: (...args: any[]) => string;
+          expression: string;
+          dependencies: FullDependencies;
+          stepType: StepType;
+          stepFunction: (input: ThenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, Restrict<GivenState, GivenDeps>, Restrict<WhenState, WhenDeps>, Restrict<ThenState, ThenDeps>>) => ThenOutput<ThenState>;
+        };
+      };
+      step: (stepFunction: (input: ThenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never, never, never>) => ThenOutput<ThenState>) => {
+        statement: (...args: any[]) => string;
+        expression: string;
+        dependencies: FullDependencies;
+        stepType: StepType;
+        stepFunction: (input: ThenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never, never, never>) => ThenOutput<ThenState>;
+      };
+    };
+    step: (stepFunction: (input: ThenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never, never, never>) => ThenOutput<ThenState>) => {
+      statement: (...args: any[]) => string;
+      expression: string;
+      dependencies: FullDependencies;
+      stepType: StepType;
+      stepFunction: (input: ThenInput<Statement extends string ? [] : GetFunctionArgs<Statement>, never, never, never>) => ThenOutput<ThenState>;
+    };
+  };
+};
+//#endregion
+//#region src/analyzer/stepExtractor.d.ts
+declare function extractStepDefinitions(filePaths: string[], tsConfigPath?: string): StepDefinitionMeta[];
+//#endregion
+//#region src/analyzer/gherkinParser.d.ts
+declare function parseFeatureFiles(filePaths: string[]): ParsedScenario[];
+declare function parseFeatureContent(content: string, filePath: string): ParsedScenario[];
+//#endregion
+//#region src/analyzer/stepMatcher.d.ts
+declare function matchScenarioSteps(scenario: ParsedScenario, definitions: StepDefinitionMeta[]): MatchedStep[];
+declare function findMatchingDefinitions(text: string, effectiveKeyword: "Given" | "When" | "Then", definitions: StepDefinitionMeta[]): StepDefinitionMeta[];
+//#endregion
+//#region src/analyzer/index.d.ts
+interface AnalyzeOptions {
+  rules?: AnalysisRule[];
+}
+declare function analyze(config: AnalyzerConfig, options?: AnalyzeOptions): Promise<Diagnostic[]>;
+//#endregion
+//#region src/init.d.ts
+declare const createBuilders: <GivenState, WhenState, ThenState>() => {
+  Given: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
     dependencies: <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
       given: GivenDeps;
     }) => {
       step: (stepFunction: (input: {
         variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
+        given: Restrict<GivenState, GivenDeps>;
         when: never;
         then: never;
       }) => Partial<GivenState> | Promise<Partial<GivenState>>) => {
-        statement: Statement extends string ? () => string : Statement;
+        statement: (...args: any[]) => string;
         expression: string;
-        dependencies: {
-          given: GivenDeps;
-        } & {
-          when: EmptyObject;
-          then: EmptyObject;
-        };
-        stepType: "given";
+        dependencies: FullDependencies;
+        stepType: StepType;
         stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
+          given: Restrict<GivenState, GivenDeps>;
           when: never;
           then: never;
         }) => Partial<GivenState> | Promise<Partial<GivenState>>;
-        register: () => {
-          stepType: "given";
-          expression: string;
-          dependencies: {
-            given: GivenDeps;
-          } & {
-            when: EmptyObject;
-            then: EmptyObject;
-          };
-          statement: Statement extends string ? () => string : Statement;
-          stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
-            when: never;
-            then: never;
-          }) => Partial<GivenState> | Promise<Partial<GivenState>>;
-        };
       };
     };
     parsers: <Parsers extends ((Statement extends string ? [] : GetFunctionArgs<Statement>) extends infer T ? { [K in keyof T]: Parser<(Statement extends string ? [] : GetFunctionArgs<Statement>)[K]> } : never)>(parsers: Parsers) => {
@@ -85,42 +226,20 @@ declare const givenBuilder: <GivenState>() => {
       }) => {
         step: (stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
+          given: Restrict<GivenState, GivenDeps>;
           when: never;
           then: never;
         }) => Partial<GivenState> | Promise<Partial<GivenState>>) => {
-          statement: Statement extends string ? () => string : Statement;
+          statement: (...args: any[]) => string;
           expression: string;
-          dependencies: {
-            given: GivenDeps;
-          } & {
-            when: EmptyObject;
-            then: EmptyObject;
-          };
-          stepType: "given";
+          dependencies: FullDependencies;
+          stepType: StepType;
           stepFunction: (input: {
             variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
+            given: Restrict<GivenState, GivenDeps>;
             when: never;
             then: never;
           }) => Partial<GivenState> | Promise<Partial<GivenState>>;
-          register: () => {
-            stepType: "given";
-            expression: string;
-            dependencies: {
-              given: GivenDeps;
-            } & {
-              when: EmptyObject;
-              then: EmptyObject;
-            };
-            statement: Statement extends string ? () => string : Statement;
-            stepFunction: (input: {
-              variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-              given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
-              when: never;
-              then: never;
-            }) => Partial<GivenState> | Promise<Partial<GivenState>>;
-          };
         };
       };
       step: (stepFunction: (input: {
@@ -129,28 +248,16 @@ declare const givenBuilder: <GivenState>() => {
         when: never;
         then: never;
       }) => Partial<GivenState> | Promise<Partial<GivenState>>) => {
-        statement: Statement extends string ? () => string : Statement;
+        statement: (...args: any[]) => string;
         expression: string;
-        dependencies: EmptyDependencies;
-        stepType: "given";
+        dependencies: FullDependencies;
+        stepType: StepType;
         stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
           given: never;
           when: never;
           then: never;
         }) => Partial<GivenState> | Promise<Partial<GivenState>>;
-        register: () => {
-          stepType: "given";
-          expression: string;
-          dependencies: EmptyDependencies;
-          statement: Statement extends string ? () => string : Statement;
-          stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: never;
-            when: never;
-            then: never;
-          }) => Partial<GivenState> | Promise<Partial<GivenState>>;
-        };
       };
     };
     step: (stepFunction: (input: {
@@ -159,75 +266,39 @@ declare const givenBuilder: <GivenState>() => {
       when: never;
       then: never;
     }) => Partial<GivenState> | Promise<Partial<GivenState>>) => {
-      statement: Statement extends string ? () => string : Statement;
+      statement: (...args: any[]) => string;
       expression: string;
-      dependencies: EmptyDependencies;
-      stepType: "given";
+      dependencies: FullDependencies;
+      stepType: StepType;
       stepFunction: (input: {
         variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
         given: never;
         when: never;
         then: never;
       }) => Partial<GivenState> | Promise<Partial<GivenState>>;
-      register: () => {
-        stepType: "given";
-        expression: string;
-        dependencies: EmptyDependencies;
-        statement: Statement extends string ? () => string : Statement;
-        stepFunction: (input: {
-          variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: never;
-          when: never;
-          then: never;
-        }) => Partial<GivenState> | Promise<Partial<GivenState>>;
-      };
     };
   };
-};
-//#endregion
-//#region src/when.d.ts
-declare const whenBuilder: <GivenState, WhenState>() => {
-  statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
+  When: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
     dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>>(dependencies: {
       given?: GivenDeps | undefined;
       when?: WhenDeps | undefined;
     }) => {
       step: (stepFunction: (input: {
         variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
-        when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
+        given: Restrict<GivenState, GivenDeps>;
+        when: Restrict<WhenState, WhenDeps>;
         then: never;
       }) => Partial<WhenState> | Promise<Partial<WhenState>>) => {
-        statement: Statement extends string ? () => string : Statement;
+        statement: (...args: any[]) => string;
         expression: string;
-        dependencies: {
-          given: GivenDeps;
-          when: WhenDeps;
-          then: EmptyObject;
-        };
-        stepType: "when";
+        dependencies: FullDependencies;
+        stepType: StepType;
         stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
-          when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
+          given: Restrict<GivenState, GivenDeps>;
+          when: Restrict<WhenState, WhenDeps>;
           then: never;
         }) => Partial<WhenState> | Promise<Partial<WhenState>>;
-        register: () => {
-          stepType: "when";
-          expression: string;
-          dependencies: {
-            given: GivenDeps;
-            when: WhenDeps;
-            then: EmptyObject;
-          };
-          statement: Statement extends string ? () => string : Statement;
-          stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
-            when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
-            then: never;
-          }) => Partial<WhenState> | Promise<Partial<WhenState>>;
-        };
       };
     };
     parsers: <Parsers extends ((Statement extends string ? [] : GetFunctionArgs<Statement>) extends infer T ? { [K in keyof T]: Parser<(Statement extends string ? [] : GetFunctionArgs<Statement>)[K]> } : never)>(parsers: Parsers) => {
@@ -237,40 +308,20 @@ declare const whenBuilder: <GivenState, WhenState>() => {
       }) => {
         step: (stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
-          when: { [K_2 in keyof WhenState as K_2 extends keyof WhenDeps ? K_2 : never]: WhenDeps[K_2] extends "optional" ? WhenState[K_2] | undefined : WhenState[K_2] };
+          given: Restrict<GivenState, GivenDeps>;
+          when: Restrict<WhenState, WhenDeps>;
           then: never;
         }) => Partial<WhenState> | Promise<Partial<WhenState>>) => {
-          statement: Statement extends string ? () => string : Statement;
+          statement: (...args: any[]) => string;
           expression: string;
-          dependencies: {
-            given: GivenDeps;
-            when: WhenDeps;
-            then: EmptyObject;
-          };
-          stepType: "when";
+          dependencies: FullDependencies;
+          stepType: StepType;
           stepFunction: (input: {
             variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
-            when: { [K_2 in keyof WhenState as K_2 extends keyof WhenDeps ? K_2 : never]: WhenDeps[K_2] extends "optional" ? WhenState[K_2] | undefined : WhenState[K_2] };
+            given: Restrict<GivenState, GivenDeps>;
+            when: Restrict<WhenState, WhenDeps>;
             then: never;
           }) => Partial<WhenState> | Promise<Partial<WhenState>>;
-          register: () => {
-            stepType: "when";
-            expression: string;
-            dependencies: {
-              given: GivenDeps;
-              when: WhenDeps;
-              then: EmptyObject;
-            };
-            statement: Statement extends string ? () => string : Statement;
-            stepFunction: (input: {
-              variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-              given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
-              when: { [K_2 in keyof WhenState as K_2 extends keyof WhenDeps ? K_2 : never]: WhenDeps[K_2] extends "optional" ? WhenState[K_2] | undefined : WhenState[K_2] };
-              then: never;
-            }) => Partial<WhenState> | Promise<Partial<WhenState>>;
-          };
         };
       };
       step: (stepFunction: (input: {
@@ -279,28 +330,16 @@ declare const whenBuilder: <GivenState, WhenState>() => {
         when: never;
         then: never;
       }) => Partial<WhenState> | Promise<Partial<WhenState>>) => {
-        statement: Statement extends string ? () => string : Statement;
+        statement: (...args: any[]) => string;
         expression: string;
-        dependencies: EmptyDependencies;
-        stepType: "when";
+        dependencies: FullDependencies;
+        stepType: StepType;
         stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
           given: never;
           when: never;
           then: never;
         }) => Partial<WhenState> | Promise<Partial<WhenState>>;
-        register: () => {
-          stepType: "when";
-          expression: string;
-          dependencies: EmptyDependencies;
-          statement: Statement extends string ? () => string : Statement;
-          stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: never;
-            when: never;
-            then: never;
-          }) => Partial<WhenState> | Promise<Partial<WhenState>>;
-        };
       };
     };
     step: (stepFunction: (input: {
@@ -309,120 +348,64 @@ declare const whenBuilder: <GivenState, WhenState>() => {
       when: never;
       then: never;
     }) => Partial<WhenState> | Promise<Partial<WhenState>>) => {
-      statement: Statement extends string ? () => string : Statement;
+      statement: (...args: any[]) => string;
       expression: string;
-      dependencies: EmptyDependencies;
-      stepType: "when";
+      dependencies: FullDependencies;
+      stepType: StepType;
       stepFunction: (input: {
         variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
         given: never;
         when: never;
         then: never;
       }) => Partial<WhenState> | Promise<Partial<WhenState>>;
-      register: () => {
-        stepType: "when";
-        expression: string;
-        dependencies: EmptyDependencies;
-        statement: Statement extends string ? () => string : Statement;
-        stepFunction: (input: {
-          variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: never;
-          when: never;
-          then: never;
-        }) => Partial<WhenState> | Promise<Partial<WhenState>>;
-      };
     };
   };
-};
-//#endregion
-//#region src/then.d.ts
-declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
-  statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
-    dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
+  Then: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
+    dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps_1 extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
       given?: GivenDeps | undefined;
-      when?: WhenDeps | undefined;
+      when?: WhenDeps_1 | undefined;
       then?: ThenDeps | undefined;
     }) => {
       step: (stepFunction: (input: {
         variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-        given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
-        when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
-        then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2] };
+        given: Restrict<GivenState, GivenDeps>;
+        when: Restrict<WhenState, WhenDeps_1>;
+        then: Restrict<ThenState, ThenDeps>;
       }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>) => {
-        statement: Statement extends string ? () => string : Statement;
+        statement: (...args: any[]) => string;
         expression: string;
-        dependencies: {
-          given: GivenDeps;
-          when: WhenDeps;
-          then: ThenDeps;
-        };
-        stepType: "then";
+        dependencies: FullDependencies;
+        stepType: StepType;
         stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
-          when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
-          then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2] };
+          given: Restrict<GivenState, GivenDeps>;
+          when: Restrict<WhenState, WhenDeps_1>;
+          then: Restrict<ThenState, ThenDeps>;
         }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>;
-        register: () => {
-          stepType: "then";
-          expression: string;
-          dependencies: {
-            given: GivenDeps;
-            when: WhenDeps;
-            then: ThenDeps;
-          };
-          statement: Statement extends string ? () => string : Statement;
-          stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
-            when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
-            then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2] };
-          }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>;
-        };
       };
     };
     parsers: <Parsers extends ((Statement extends string ? [] : GetFunctionArgs<Statement>) extends infer T ? { [K in keyof T]: Parser<(Statement extends string ? [] : GetFunctionArgs<Statement>)[K]> } : never)>(parsers: Parsers) => {
-      dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
+      dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps_1 extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
         given?: GivenDeps | undefined;
-        when?: WhenDeps | undefined;
+        when?: WhenDeps_1 | undefined;
         then?: ThenDeps | undefined;
       }) => {
         step: (stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
-          when: { [K_2 in keyof WhenState as K_2 extends keyof WhenDeps ? K_2 : never]: WhenDeps[K_2] extends "optional" ? WhenState[K_2] | undefined : WhenState[K_2] };
-          then: { [K_3 in keyof ThenState as K_3 extends keyof ThenDeps ? K_3 : never]: ThenDeps[K_3] extends "optional" ? ThenState[K_3] | undefined : ThenState[K_3] };
+          given: Restrict<GivenState, GivenDeps>;
+          when: Restrict<WhenState, WhenDeps_1>;
+          then: Restrict<ThenState, ThenDeps>;
         }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>) => {
-          statement: Statement extends string ? () => string : Statement;
+          statement: (...args: any[]) => string;
           expression: string;
-          dependencies: {
-            given: GivenDeps;
-            when: WhenDeps;
-            then: ThenDeps;
-          };
-          stepType: "then";
+          dependencies: FullDependencies;
+          stepType: StepType;
           stepFunction: (input: {
             variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
-            when: { [K_2 in keyof WhenState as K_2 extends keyof WhenDeps ? K_2 : never]: WhenDeps[K_2] extends "optional" ? WhenState[K_2] | undefined : WhenState[K_2] };
-            then: { [K_3 in keyof ThenState as K_3 extends keyof ThenDeps ? K_3 : never]: ThenDeps[K_3] extends "optional" ? ThenState[K_3] | undefined : ThenState[K_3] };
+            given: Restrict<GivenState, GivenDeps>;
+            when: Restrict<WhenState, WhenDeps_1>;
+            then: Restrict<ThenState, ThenDeps>;
           }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>;
-          register: () => {
-            stepType: "then";
-            expression: string;
-            dependencies: {
-              given: GivenDeps;
-              when: WhenDeps;
-              then: ThenDeps;
-            };
-            statement: Statement extends string ? () => string : Statement;
-            stepFunction: (input: {
-              variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-              given: { [K_1 in keyof GivenState as K_1 extends keyof GivenDeps ? K_1 : never]: GivenDeps[K_1] extends "optional" ? GivenState[K_1] | undefined : GivenState[K_1] };
-              when: { [K_2 in keyof WhenState as K_2 extends keyof WhenDeps ? K_2 : never]: WhenDeps[K_2] extends "optional" ? WhenState[K_2] | undefined : WhenState[K_2] };
-              then: { [K_3 in keyof ThenState as K_3 extends keyof ThenDeps ? K_3 : never]: ThenDeps[K_3] extends "optional" ? ThenState[K_3] | undefined : ThenState[K_3] };
-            }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>;
-          };
         };
       };
       step: (stepFunction: (input: {
@@ -431,28 +414,16 @@ declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
         when: never;
         then: never;
       }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>) => {
-        statement: Statement extends string ? () => string : Statement;
+        statement: (...args: any[]) => string;
         expression: string;
-        dependencies: EmptyDependencies;
-        stepType: "then";
+        dependencies: FullDependencies;
+        stepType: StepType;
         stepFunction: (input: {
           variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
           given: never;
           when: never;
           then: never;
         }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>;
-        register: () => {
-          stepType: "then";
-          expression: string;
-          dependencies: EmptyDependencies;
-          statement: Statement extends string ? () => string : Statement;
-          stepFunction: (input: {
-            variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-            given: never;
-            when: never;
-            then: never;
-          }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>;
-        };
       };
     };
     step: (stepFunction: (input: {
@@ -461,113 +432,48 @@ declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
       when: never;
       then: never;
     }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>) => {
-      statement: Statement extends string ? () => string : Statement;
+      statement: (...args: any[]) => string;
       expression: string;
-      dependencies: EmptyDependencies;
-      stepType: "then";
+      dependencies: FullDependencies;
+      stepType: StepType;
       stepFunction: (input: {
         variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
         given: never;
         when: never;
         then: never;
       }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>;
-      register: () => {
-        stepType: "then";
-        expression: string;
-        dependencies: EmptyDependencies;
-        statement: Statement extends string ? () => string : Statement;
-        stepFunction: (input: {
-          variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
-          given: never;
-          when: never;
-          then: never;
-        }) => void | Promise<void> | Partial<ThenState> | Promise<Partial<ThenState>>;
-      };
     };
   };
 };
 //#endregion
-//#region src/world.d.ts
-type WorldState<State> = { readonly [K in keyof State]?: State[K] };
-type MergeableWorldState<T> = WorldState<T> & {
-  merge: (newState: Partial<T>) => void;
-};
-declare class BasicWorld<Given, When, Then> {
-  private givenState;
-  private whenState;
-  private thenState;
-  get given(): MergeableWorldState<Given>;
-  get when(): MergeableWorldState<When>;
-  get then(): MergeableWorldState<Then>;
-}
-//#endregion
-//#region src/analyzer/types.d.ts
-interface StepDefinitionMeta {
-  stepType: "given" | "when" | "then";
-  expression: string;
-  dependencies: {
-    given: Record<string, "required" | "optional">;
-    when: Record<string, "required" | "optional">;
-    then: Record<string, "required" | "optional">;
-  };
-  produces: string[];
-  sourceFile: string;
-  line: number;
-}
-interface ParsedScenario {
-  name: string;
-  file: string;
-  steps: ParsedStep[];
-}
-interface ParsedStep {
-  keyword: "Given" | "When" | "Then" | "And" | "But";
-  effectiveKeyword: "Given" | "When" | "Then";
-  text: string;
-  line: number;
-  column: number;
-}
-interface MatchedStep extends ParsedStep {
-  definitions: StepDefinitionMeta[];
-}
-interface Diagnostic {
-  file: string;
-  range: {
-    startLine: number;
-    startColumn: number;
-    endLine: number;
-    endColumn: number;
-  };
-  severity: "error" | "warning" | "info";
-  message: string;
-  rule: string;
-  source: "step-forge";
-}
-interface AnalysisRule {
-  name: string;
-  check(scenario: ParsedScenario, matchedSteps: MatchedStep[]): Diagnostic[];
-}
-interface AnalyzerConfig {
-  stepFiles: string[];
-  featureFiles: string[];
-  tsConfigPath?: string;
-}
-//#endregion
-//#region src/analyzer/stepExtractor.d.ts
-declare function extractStepDefinitions(filePaths: string[], tsConfigPath?: string): StepDefinitionMeta[];
-//#endregion
-//#region src/analyzer/gherkinParser.d.ts
-declare function parseFeatureFiles(filePaths: string[]): ParsedScenario[];
-declare function parseFeatureContent(content: string, filePath: string): ParsedScenario[];
-//#endregion
-//#region src/analyzer/stepMatcher.d.ts
-declare function matchScenarioSteps(scenario: ParsedScenario, definitions: StepDefinitionMeta[]): MatchedStep[];
-declare function findMatchingDefinitions(text: string, effectiveKeyword: "Given" | "When" | "Then", definitions: StepDefinitionMeta[]): StepDefinitionMeta[];
-//#endregion
-//#region src/analyzer/index.d.ts
-interface AnalyzeOptions {
-  rules?: AnalysisRule[];
-}
-declare function analyze(config: AnalyzerConfig, options?: AnalyzeOptions): Promise<Diagnostic[]>;
+//#region src/hooks.d.ts
+/**
+ * Run before every scenario, with access to that scenario's fresh world. For
+ * side effects only (reset a mock, seed an external system) — return values are
+ * ignored; seed test *state* with given steps so the dependency graph stays the
+ * single source of truth.
+ */
+declare function beforeScenario<World extends MergeableWorld<any, any, any> = MergeableWorld<any, any, any>>(fn: (context: {
+  world: World;
+  scenario: ScenarioInfo;
+}) => void | Promise<void>): void;
+/**
+ * Run after every scenario (even when a step failed), with access to that
+ * scenario's world. Runs in reverse registration order so teardown unwinds
+ * setup. For cleanup side effects only.
+ */
+declare function afterScenario<World extends MergeableWorld<any, any, any> = MergeableWorld<any, any, any>>(fn: (context: {
+  world: World;
+  scenario: ScenarioInfo;
+}) => void | Promise<void>): void;
+/** Run once at the start of each feature file. No world exists at this boundary. */
+declare function beforeFeature(fn: PlainHookFn): void;
+/** Run once at the end of each feature file (reverse registration order). */
+declare function afterFeature(fn: PlainHookFn): void;
+/** Run once before the entire test run, across all feature files. */
+declare function beforeAll(fn: PlainHookFn): void;
+/** Run once after the entire test run (reverse registration order). */
+declare function afterAll(fn: PlainHookFn): void;
 //#endregion
 //#region src/typeHelpers.d.ts
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
@@ -595,5 +501,5 @@ declare const analyzer: {
   defaultRules: AnalysisRule[];
 };
 //#endregion
-export { type AnalysisRule, type AnalyzeOptions, type AnalyzerConfig, BasicWorld, type Diagnostic, type MatchedStep, type ParsedScenario, type ParsedStep, type Parser, type StateFromDependencies, type StepDefinitionMeta, analyzer, booleanParser, givenBuilder, intParser, numberParser, stringParser, thenBuilder, whenBuilder };
+export { type AnalysisRule, type AnalyzeOptions, type AnalyzerConfig, BasicWorld, type Diagnostic, type MatchedStep, type ParsedScenario, type ParsedStep, type Parser, type PlainHookFn, type ScenarioHookFn, type ScenarioInfo, type StateFromDependencies, type StepDefinitionMeta, afterAll, afterFeature, afterScenario, analyzer, beforeAll, beforeFeature, beforeScenario, booleanParser, createBuilders, givenBuilder, intParser, numberParser, stringParser, thenBuilder, whenBuilder };
 //# sourceMappingURL=step-forge.d.ts.map