@systemfsoftware/storybook-gherkin 3.0.3 → 3.0.4

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @systemfsoftware/storybook-gherkin
 
+## 3.0.4
+
+### Patch Changes
+
+- Type declarations for `@systemfsoftware/npm-package` and `@systemfsoftware/storybook-gherkin` are now flattened: every exported type is declared inline, so no published type refers to a declaration file you would have to resolve yourself.
+
+  The declarations of `@systemfsoftware/effect-atom` and `@systemfsoftware/effect-atom-react` are unchanged.
+
 ## 3.0.3
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,248 +1,313 @@
-import { Context, Effect, Schema } from "effect";
-import { UserEventObject, screen, within } from "storybook/test";
-import { Simplify, UnionToIntersection } from "type-fest";
-//#region src/Capture.d.ts
-declare const CaptureTag: {
-  readonly _tag: 'Capture';
-};
-type CaptureTag = typeof CaptureTag;
-interface Capture<Name extends string = string, _A = unknown> extends CaptureTag {
-  readonly name: Name;
-  readonly schema: Schema.ConstraintDecoder<unknown> | undefined;
-  readonly default: string | undefined;
-}
-declare function capture<Name extends string, A>(name: Name, options: {
-  readonly schema: Schema.Codec<A, string>;
-  readonly default?: string;
-}): Capture<Name, A>;
-declare function capture<Name extends string>(name: Name, options?: {
-  readonly default?: string;
-}): Capture<Name, string>;
-//#endregion
-//#region src/Errors.schema.d.ts
-declare const EmptyScenario_base: Schema.Class<EmptyScenario, Schema.TaggedStruct<"EmptyScenario", {
-  readonly scenario: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/**
- * Two channels:
- * - Declaration time: every violation except `CaptureDecodeFailed` is thrown
- *   during module evaluation of the story file, so a malformed spec fails the
- *   Storybook import before any story runs.
- * - Run time: `CaptureDecodeFailed` travels the typed error channel of
- *   `Step.run` and surfaces when the play edge interprets the scenario.
- */
-declare class EmptyScenario extends EmptyScenario_base {}
-declare const MissingThen_base: Schema.Class<MissingThen, Schema.TaggedStruct<"MissingThen", {
-  readonly scenario: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/** Without a Then-phase step nothing is asserted — the scenario is not a spec. */
-declare class MissingThen extends MissingThen_base {}
-declare const BackgroundNotGiven_base: Schema.Class<BackgroundNotGiven, Schema.TaggedStruct<"BackgroundNotGiven", {
-  readonly step: Schema.String;
-  readonly resolved: Schema.Literals<readonly ["Given", "When", "Then"]>;
-}>, import("effect/Cause").YieldableError>;
-declare class BackgroundNotGiven extends BackgroundNotGiven_base {}
-declare const DuplicateCapture_base: Schema.Class<DuplicateCapture, Schema.TaggedStruct<"DuplicateCapture", {
-  readonly step: Schema.String;
-  readonly name: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class DuplicateCapture extends DuplicateCapture_base {}
-declare const UnresolvedCapture_base: Schema.Class<UnresolvedCapture, Schema.TaggedStruct<"UnresolvedCapture", {
-  readonly scenario: Schema.String;
-  readonly step: Schema.String;
-  readonly capture: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/** Capture values come from a literal hole, `with`, or an outline row — none matched. */
-declare class UnresolvedCapture extends UnresolvedCapture_base {}
-declare const OutlineEmpty_base: Schema.Class<OutlineEmpty, Schema.TaggedStruct<"OutlineEmpty", {
-  readonly outline: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class OutlineEmpty extends OutlineEmpty_base {}
-declare const OutlineInconsistentKeys_base: Schema.Class<OutlineInconsistentKeys, Schema.TaggedStruct<"OutlineInconsistentKeys", {
-  readonly outline: Schema.String;
-  readonly row: Schema.String;
-  readonly expected: Schema.$Array<Schema.String>;
-  readonly actual: Schema.$Array<Schema.String>;
-}>, import("effect/Cause").YieldableError>;
-declare class OutlineInconsistentKeys extends OutlineInconsistentKeys_base {}
-declare const OutlineDuplicateRowName_base: Schema.Class<OutlineDuplicateRowName, Schema.TaggedStruct<"OutlineDuplicateRowName", {
-  readonly outline: Schema.String;
-  readonly name: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/** Row names become the exported story names, so duplicates would collide. */
-declare class OutlineDuplicateRowName extends OutlineDuplicateRowName_base {}
-declare const OutlineMissingCapture_base: Schema.Class<OutlineMissingCapture, Schema.TaggedStruct<"OutlineMissingCapture", {
-  readonly outline: Schema.String;
-  readonly row: Schema.String;
-  readonly capture: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-declare class OutlineMissingCapture extends OutlineMissingCapture_base {}
-declare const CaptureDecodeFailed_base: Schema.Class<CaptureDecodeFailed, Schema.TaggedStruct<"CaptureDecodeFailed", {
-  readonly step: Schema.String;
-  readonly capture: Schema.String;
-  readonly value: Schema.String;
-  readonly cause: Schema.Unknown;
-}>, import("effect/Cause").YieldableError>;
-declare class CaptureDecodeFailed extends CaptureDecodeFailed_base {}
-//#endregion
-//#region src/Steps.d.ts
-type Keyword = 'Given' | 'When' | 'Then' | 'And' | 'But' | 'Star';
-type ConcreteKeyword = 'Given' | 'When' | 'Then';
-interface CaptureModel {
-  readonly name: string;
-  /** Service-free decode view — the v4 counterpart of the removed no-context alias. */
-  readonly schema: Schema.ConstraintDecoder<unknown> | undefined;
-  readonly default: string | undefined;
-}
-interface StepModel {
-  readonly keyword: Keyword;
-  /** Static segments around the holes — length is always captures.length + 1. */
-  readonly parts: readonly string[];
-  readonly captures: readonly CaptureModel[];
-}
-type ExampleRow = {
-  readonly name: string;
-} & Readonly<Record<string, string>>;
-type Canvas = ReturnType<typeof within>;
-type StepFn = (label: string, fn: () => Promise<void>) => Promise<void> | void;
-interface Report {
-  readonly type: string;
-  readonly version?: number;
-  readonly result: unknown;
-  readonly status: 'failed' | 'passed' | 'warning';
-}
-interface ReportingAPI {
-  readonly reports: Report[];
-  readonly addReport: (report: Report) => void;
-}
-interface PlayContext<TArgs = unknown> {
-  readonly canvas: Canvas;
-  readonly canvasElement: HTMLElement;
-  readonly step: StepFn;
-  readonly userEvent: UserEventObject;
-  readonly args: TArgs;
-  readonly globals: Record<string, unknown>;
-  readonly parameters: Record<string, unknown>;
-  readonly loaded: Record<string, unknown>;
-  readonly abortSignal: AbortSignal;
-  readonly reporting: ReportingAPI;
-}
-interface StepContext<TArgs = unknown> {
-  readonly canvas: Canvas;
-  readonly screen: typeof screen;
-  readonly userEvent: UserEventObject;
-  readonly step: StepFn;
-  readonly args: TArgs;
-  readonly globals: Record<string, unknown>;
-  readonly parameters: Record<string, unknown>;
-  readonly loaded: Record<string, unknown>;
-  readonly canvasElement: HTMLElement;
-  /**
-   * Fires on story teardown (remount, navigation, HMR). Since the 2026-08-09
-   * Effect-composition refactor, the play edge interrupts the in-flight step
-   * on abort — steps no longer run to completion after teardown. The step
-   * handler's own promise is abandoned, not cancelled: observe this signal
-   * for cleanup or to race long-running work.
-   */
-  readonly abortSignal: AbortSignal;
-  readonly reporting: ReportingAPI;
-  readonly context: PlayContext<TArgs>;
-}
-type Hole = Capture | string | number;
-type CapsOf<THoles extends readonly Hole[]> = THoles extends readonly [] ? {} : Simplify<UnionToIntersection<{ [K in keyof THoles]: THoles[K] extends Capture<infer N, infer A> ? { [P in N]: A; } : {}; }[number]>>;
-type StepHandler<TCaps, TArgs = unknown> = (ctx: StepContext<TArgs>, caps: TCaps) => void | Promise<void>;
-declare const StepTag: {
-  readonly _tag: "Step";
-};
-type StepTag = typeof StepTag;
-interface Step<TArgs = unknown> extends StepTag {
-  readonly model: StepModel;
-  readonly run: (values: Readonly<Record<string, string>>, ctx: StepContext<TArgs>) => Effect.Effect<void, CaptureDecodeFailed>;
-}
-interface StepBuilder<THoles extends readonly Hole[], TArgs = unknown> {
-  (handler: StepHandler<CapsOf<THoles>, TArgs>): Step<TArgs>;
-}
-type StepCtor = {
-  <const THoles extends readonly Hole[]>(statics: TemplateStringsArray, ...holes: THoles): StepBuilder<THoles>;
-  <TArgs, const THoles extends readonly Hole[] = readonly Hole[]>(statics: TemplateStringsArray, ...holes: THoles): StepBuilder<THoles, TArgs>;
-};
-declare const Given: StepCtor;
-declare const When: StepCtor;
-declare const Then: StepCtor;
-declare const And: StepCtor;
-declare const But: StepCtor;
-declare const Star: StepCtor;
-//#endregion
-//#region src/Feature.d.ts
-interface StorySpec<TArgs = unknown> {
-  readonly name: string;
-  readonly play: (context: PlayContext<TArgs>) => Promise<void>;
-}
-interface ScenarioOptions {
-  /** Capture values for a plain (non-outline) scenario, keyed by capture name. */
-  readonly with?: Readonly<Record<string, string>>;
-}
-interface FeatureOptions {
-  /**
-   * Context that interprets a scenario's step program at the play edge,
-   * defaulting to `Context.empty()`. Supply a context carrying services
-   * or a custom scheduler to make them available to the run.
-   */
-  readonly context?: Context.Context<never>;
-}
-/**
- * Anything positional after the scenario name: a step, a step group from
- * `Steps(...)` / `From(...)`, or — in first position only — an options object.
- */
-type StepArg<TArgs> = Step<TArgs> | readonly Step<TArgs>[];
-/**
- * A scenario title names a concrete situation in natural-language prose. Two
- * shape checks keep DAMP `Should_[Behavior]_When_[Condition]` unit-test names —
- * and every concatenated-token title shaped like one — out of the call site:
- *  1. the literal must not start with `Should`;
- *  2. the literal must contain at least one ASCII space (a single-word title is
- *     a test name, not prose).
- * Either check failing maps to `ScenarioTitleRejected`, so the call fails to
- * type-check with the rule in the diagnostic. Non-literal titles (widened
- * `string`) pass through untouched — a runtime guard would catch those, but
- * the brand is the contract this skill ships.
- */
-type ScenarioTitleRejected<T extends string> = `Scenario titles are natural-language prose of a concrete situation, not DAMP Should_[Behavior]_When_[Condition] unit-test names. Got: ${T}` | `Scenario title must be natural-language prose (at least one space separates words); got: ${T}`;
-type ScenarioTitle<T extends string> = T extends `Should${string}` ? ScenarioTitleRejected<T> : T extends `${string} ${string}` ? T : ScenarioTitleRejected<T>;
-interface ScenarioFn<TArgs> {
-  <TName extends string>(name: ScenarioTitle<TName>, ...steps: readonly StepArg<TArgs>[]): StorySpec<TArgs>;
-  <TName extends string>(name: ScenarioTitle<TName>, options: ScenarioOptions, ...steps: readonly StepArg<TArgs>[]): StorySpec<TArgs>;
-}
-interface OutlineBuilder<TArgs> {
-  readonly examples: (rows: readonly ExampleRow[]) => Record<string, StorySpec<TArgs>>;
-}
-interface OutlineFn<TArgs> {
-  <TName extends string>(name: ScenarioTitle<TName>, ...steps: readonly StepArg<TArgs>[]): OutlineBuilder<TArgs>;
-  <TName extends string>(name: ScenarioTitle<TName>, options: ScenarioOptions, ...steps: readonly StepArg<TArgs>[]): OutlineBuilder<TArgs>;
-}
-interface RuleScope<TArgs> {
-  readonly scenario: ScenarioFn<TArgs>;
-  readonly scenarioOutline: OutlineFn<TArgs>;
-}
-interface Feature<M, TArgs = unknown> {
-  readonly meta: M;
-  readonly type: <TNext>() => Feature<M, TNext>;
-  readonly background: (...steps: readonly Step<TArgs>[]) => void;
-  readonly scenario: ScenarioFn<TArgs>;
-  readonly scenarioOutline: OutlineFn<TArgs>;
-  readonly rule: (name: string) => RuleScope<TArgs>;
-}
-/**
- * Declare a feature: a story set whose scenarios execute as CSF `play`
- * functions. `options.context` (default `Context.empty()`) is the Effect
- * context interpreting each scenario's composed step program exactly once,
- * at the play edge.
- */
-declare const feature: <M>(meta: M, options?: FeatureOptions) => Feature<M>;
-declare const Steps: <TArgs>(...steps: readonly Step<TArgs>[]) => Step<TArgs>[];
-interface StoryWithPlay<TArgs> {
-  readonly play?: (context: PlayContext<TArgs>) => Promise<void> | void;
-}
-declare const From: <TArgs>(story: StoryWithPlay<TArgs>) => Step<TArgs>[];
-//#endregion
-export { And, BackgroundNotGiven, But, type Canvas, type CapsOf, type Capture, CaptureDecodeFailed, type CaptureModel, type ConcreteKeyword, DuplicateCapture, EmptyScenario, type ExampleRow, type Feature, type FeatureOptions, From, Given, type Hole, type Keyword, MissingThen, type OutlineBuilder, OutlineDuplicateRowName, OutlineEmpty, type OutlineFn, OutlineInconsistentKeys, OutlineMissingCapture, type PlayContext, type Report, type ReportingAPI, type RuleScope, type ScenarioFn, type ScenarioOptions, Star, type Step, type StepArg, type StepBuilder, type StepContext, type StepCtor, type StepFn, type StepHandler, type StepModel, Steps, type StorySpec, Then, UnresolvedCapture, When, capture, feature };
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { screen as screen_2 } from 'storybook/test';
+import { Simplify } from 'type-fest';
+import { UnionToIntersection } from 'type-fest';
+import { UserEventObject } from 'storybook/test';
+import { within } from 'storybook/test';
+import { YieldableError } from 'effect/Cause';
+
+export declare const And: StepCtor;
+
+export declare class BackgroundNotGiven extends BackgroundNotGiven_base {}
+
+declare const BackgroundNotGiven_base: Schema.Class<BackgroundNotGiven, Schema.TaggedStruct<"BackgroundNotGiven", {
+    readonly step: Schema.String;
+    readonly resolved: Schema.Literals<readonly ["Given", "When", "Then"]>;
+}>, YieldableError>;
+
+export declare const But: StepCtor;
+
+export declare type Canvas = ReturnType<typeof within>;
+
+export declare type CapsOf<THoles extends readonly Hole[]> = THoles extends readonly [] ? {} : Simplify<UnionToIntersection<{ [K in keyof THoles]: THoles[K] extends Capture<infer N, infer A> ? { [P in N]: A; } : {}; }[number]>>;
+
+export declare interface Capture<Name extends string = string, _A = unknown> extends CaptureTag {
+    readonly name: Name;
+    readonly schema: Schema.ConstraintDecoder<unknown> | undefined;
+    readonly default: string | undefined;
+}
+
+export declare function capture<Name extends string, A>(name: Name, options: {
+    readonly schema: Schema.Codec<A, string>;
+    readonly default?: string;
+}): Capture<Name, A>;
+
+export declare function capture<Name extends string>(name: Name, options?: {
+    readonly default?: string;
+}): Capture<Name, string>;
+
+export declare class CaptureDecodeFailed extends CaptureDecodeFailed_base {}
+
+declare const CaptureDecodeFailed_base: Schema.Class<CaptureDecodeFailed, Schema.TaggedStruct<"CaptureDecodeFailed", {
+    readonly step: Schema.String;
+    readonly capture: Schema.String;
+    readonly value: Schema.String;
+    readonly cause: Schema.Unknown;
+}>, YieldableError>;
+
+export declare interface CaptureModel {
+    readonly name: string;
+    /** Service-free decode view — the v4 counterpart of the removed no-context alias. */
+    readonly schema: Schema.ConstraintDecoder<unknown> | undefined;
+    readonly default: string | undefined;
+}
+
+declare const CaptureTag: {
+    readonly _tag: 'Capture';
+};
+
+declare type CaptureTag = typeof CaptureTag;
+
+export declare type ConcreteKeyword = 'Given' | 'When' | 'Then';
+
+export declare class DuplicateCapture extends DuplicateCapture_base {}
+
+declare const DuplicateCapture_base: Schema.Class<DuplicateCapture, Schema.TaggedStruct<"DuplicateCapture", {
+    readonly step: Schema.String;
+    readonly name: Schema.String;
+}>, YieldableError>;
+
+/**
+ * Two channels:
+ * - Declaration time: every violation except `CaptureDecodeFailed` is thrown
+ *   during module evaluation of the story file, so a malformed spec fails the
+ *   Storybook import before any story runs.
+ * - Run time: `CaptureDecodeFailed` travels the typed error channel of
+ *   `Step.run` and surfaces when the play edge interprets the scenario.
+ */
+export declare class EmptyScenario extends EmptyScenario_base {}
+
+declare const EmptyScenario_base: Schema.Class<EmptyScenario, Schema.TaggedStruct<"EmptyScenario", {
+    readonly scenario: Schema.String;
+}>, YieldableError>;
+
+export declare type ExampleRow = {
+    readonly name: string;
+} & Readonly<Record<string, string>>;
+
+export declare interface Feature<M, TArgs = unknown> {
+    readonly meta: M;
+    readonly type: <TNext>() => Feature<M, TNext>;
+    readonly background: (...steps: readonly Step<TArgs>[]) => void;
+    readonly scenario: ScenarioFn<TArgs>;
+    readonly scenarioOutline: OutlineFn<TArgs>;
+    readonly rule: (name: string) => RuleScope<TArgs>;
+}
+
+/**
+ * Declare a feature: a story set whose scenarios execute as CSF `play`
+ * functions. `options.context` (default `Context.empty()`) is the Effect
+ * context interpreting each scenario's composed step program exactly once,
+ * at the play edge.
+ */
+export declare const feature: <M>(meta: M, options?: FeatureOptions) => Feature<M>;
+
+export declare interface FeatureOptions {
+    /**
+     * Context that interprets a scenario's step program at the play edge,
+     * defaulting to `Context.empty()`. Supply a context carrying services
+     * or a custom scheduler to make them available to the run.
+     */
+    readonly context?: Context.Context<never>;
+}
+
+export declare const From: <TArgs>(story: StoryWithPlay<TArgs>) => Step<TArgs>[];
+
+export declare const Given: StepCtor;
+
+export declare type Hole = Capture | string | number;
+
+export declare type Keyword = 'Given' | 'When' | 'Then' | 'And' | 'But' | 'Star';
+
+/** Without a Then-phase step nothing is asserted — the scenario is not a spec. */
+export declare class MissingThen extends MissingThen_base {}
+
+declare const MissingThen_base: Schema.Class<MissingThen, Schema.TaggedStruct<"MissingThen", {
+    readonly scenario: Schema.String;
+}>, YieldableError>;
+
+export declare interface OutlineBuilder<TArgs> {
+    readonly examples: (rows: readonly ExampleRow[]) => Record<string, StorySpec<TArgs>>;
+}
+
+/** Row names become the exported story names, so duplicates would collide. */
+export declare class OutlineDuplicateRowName extends OutlineDuplicateRowName_base {}
+
+declare const OutlineDuplicateRowName_base: Schema.Class<OutlineDuplicateRowName, Schema.TaggedStruct<"OutlineDuplicateRowName", {
+    readonly outline: Schema.String;
+    readonly name: Schema.String;
+}>, YieldableError>;
+
+export declare class OutlineEmpty extends OutlineEmpty_base {}
+
+declare const OutlineEmpty_base: Schema.Class<OutlineEmpty, Schema.TaggedStruct<"OutlineEmpty", {
+    readonly outline: Schema.String;
+}>, YieldableError>;
+
+export declare interface OutlineFn<TArgs> {
+    <TName extends string>(name: ScenarioTitle<TName>, ...steps: readonly StepArg<TArgs>[]): OutlineBuilder<TArgs>;
+    <TName extends string>(name: ScenarioTitle<TName>, options: ScenarioOptions, ...steps: readonly StepArg<TArgs>[]): OutlineBuilder<TArgs>;
+}
+
+export declare class OutlineInconsistentKeys extends OutlineInconsistentKeys_base {}
+
+declare const OutlineInconsistentKeys_base: Schema.Class<OutlineInconsistentKeys, Schema.TaggedStruct<"OutlineInconsistentKeys", {
+    readonly outline: Schema.String;
+    readonly row: Schema.String;
+    readonly expected: Schema.$Array<Schema.String>;
+    readonly actual: Schema.$Array<Schema.String>;
+}>, YieldableError>;
+
+export declare class OutlineMissingCapture extends OutlineMissingCapture_base {}
+
+declare const OutlineMissingCapture_base: Schema.Class<OutlineMissingCapture, Schema.TaggedStruct<"OutlineMissingCapture", {
+    readonly outline: Schema.String;
+    readonly row: Schema.String;
+    readonly capture: Schema.String;
+}>, YieldableError>;
+
+export declare interface PlayContext<TArgs = unknown> {
+    readonly canvas: Canvas;
+    readonly canvasElement: HTMLElement;
+    readonly step: StepFn;
+    readonly userEvent: UserEventObject;
+    readonly args: TArgs;
+    readonly globals: Record<string, unknown>;
+    readonly parameters: Record<string, unknown>;
+    readonly loaded: Record<string, unknown>;
+    readonly abortSignal: AbortSignal;
+    readonly reporting: ReportingAPI;
+}
+
+declare interface Report_2 {
+    readonly type: string;
+    readonly version?: number;
+    readonly result: unknown;
+    readonly status: 'failed' | 'passed' | 'warning';
+}
+export { Report_2 as Report }
+
+export declare interface ReportingAPI {
+    readonly reports: Report_2[];
+    readonly addReport: (report: Report_2) => void;
+}
+
+export declare interface RuleScope<TArgs> {
+    readonly scenario: ScenarioFn<TArgs>;
+    readonly scenarioOutline: OutlineFn<TArgs>;
+}
+
+export declare interface ScenarioFn<TArgs> {
+    <TName extends string>(name: ScenarioTitle<TName>, ...steps: readonly StepArg<TArgs>[]): StorySpec<TArgs>;
+    <TName extends string>(name: ScenarioTitle<TName>, options: ScenarioOptions, ...steps: readonly StepArg<TArgs>[]): StorySpec<TArgs>;
+}
+
+export declare interface ScenarioOptions {
+    /** Capture values for a plain (non-outline) scenario, keyed by capture name. */
+    readonly with?: Readonly<Record<string, string>>;
+}
+
+declare type ScenarioTitle<T extends string> = T extends `Should${string}` ? ScenarioTitleRejected<T> : T extends `${string} ${string}` ? T : ScenarioTitleRejected<T>;
+
+/**
+ * A scenario title names a concrete situation in natural-language prose. Two
+ * shape checks keep DAMP `Should_[Behavior]_When_[Condition]` unit-test names —
+ * and every concatenated-token title shaped like one — out of the call site:
+ *  1. the literal must not start with `Should`;
+ *  2. the literal must contain at least one ASCII space (a single-word title is
+ *     a test name, not prose).
+ * Either check failing maps to `ScenarioTitleRejected`, so the call fails to
+ * type-check with the rule in the diagnostic. Non-literal titles (widened
+ * `string`) pass through untouched — a runtime guard would catch those, but
+ * the brand is the contract this skill ships.
+ */
+declare type ScenarioTitleRejected<T extends string> = `Scenario titles are natural-language prose of a concrete situation, not DAMP Should_[Behavior]_When_[Condition] unit-test names. Got: ${T}` | `Scenario title must be natural-language prose (at least one space separates words); got: ${T}`;
+
+export declare const Star: StepCtor;
+
+export declare interface Step<TArgs = unknown> extends StepTag {
+    readonly model: StepModel;
+    readonly run: (values: Readonly<Record<string, string>>, ctx: StepContext<TArgs>) => Effect.Effect<void, CaptureDecodeFailed>;
+}
+
+/**
+ * Anything positional after the scenario name: a step, a step group from
+ * `Steps(...)` / `From(...)`, or — in first position only — an options object.
+ */
+export declare type StepArg<TArgs> = Step<TArgs> | readonly Step<TArgs>[];
+
+export declare interface StepBuilder<THoles extends readonly Hole[], TArgs = unknown> {
+    (handler: StepHandler<CapsOf<THoles>, TArgs>): Step<TArgs>;
+}
+
+export declare interface StepContext<TArgs = unknown> {
+    readonly canvas: Canvas;
+    readonly screen: typeof screen_2;
+    readonly userEvent: UserEventObject;
+    readonly step: StepFn;
+    readonly args: TArgs;
+    readonly globals: Record<string, unknown>;
+    readonly parameters: Record<string, unknown>;
+    readonly loaded: Record<string, unknown>;
+    readonly canvasElement: HTMLElement;
+    /**
+     * Fires on story teardown (remount, navigation, HMR). Since the 2026-08-09
+     * Effect-composition refactor, the play edge interrupts the in-flight step
+     * on abort — steps no longer run to completion after teardown. The step
+     * handler's own promise is abandoned, not cancelled: observe this signal
+     * for cleanup or to race long-running work.
+     */
+    readonly abortSignal: AbortSignal;
+    readonly reporting: ReportingAPI;
+    readonly context: PlayContext<TArgs>;
+}
+
+export declare type StepCtor = {
+    <const THoles extends readonly Hole[]>(statics: TemplateStringsArray, ...holes: THoles): StepBuilder<THoles>;
+    <TArgs, const THoles extends readonly Hole[] = readonly Hole[]>(statics: TemplateStringsArray, ...holes: THoles): StepBuilder<THoles, TArgs>;
+};
+
+export declare type StepFn = (label: string, fn: () => Promise<void>) => Promise<void> | void;
+
+export declare type StepHandler<TCaps, TArgs = unknown> = (ctx: StepContext<TArgs>, caps: TCaps) => void | Promise<void>;
+
+export declare interface StepModel {
+    readonly keyword: Keyword;
+    /** Static segments around the holes — length is always captures.length + 1. */
+    readonly parts: readonly string[];
+    readonly captures: readonly CaptureModel[];
+}
+
+export declare const Steps: <TArgs>(...steps: readonly Step<TArgs>[]) => Step<TArgs>[];
+
+declare const StepTag: {
+    readonly _tag: "Step";
+};
+
+declare type StepTag = typeof StepTag;
+
+export declare interface StorySpec<TArgs = unknown> {
+    readonly name: string;
+    readonly play: (context: PlayContext<TArgs>) => Promise<void>;
+}
+
+declare interface StoryWithPlay<TArgs> {
+    readonly play?: (context: PlayContext<TArgs>) => Promise<void> | void;
+}
+
+export declare const Then: StepCtor;
+
+/** Capture values come from a literal hole, `with`, or an outline row — none matched. */
+export declare class UnresolvedCapture extends UnresolvedCapture_base {}
+
+declare const UnresolvedCapture_base: Schema.Class<UnresolvedCapture, Schema.TaggedStruct<"UnresolvedCapture", {
+    readonly scenario: Schema.String;
+    readonly step: Schema.String;
+    readonly capture: Schema.String;
+}>, YieldableError>;
+
+export declare const When: StepCtor;
+
+export { }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/storybook-gherkin",
   "license": "Apache-2.0",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -43,6 +43,7 @@
     "storybook": ">=10.0.0"
   },
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.58.7",
     "@storybook/addon-vitest": "^10.5.0",
     "@storybook/react-vite": "^10.5.0",
     "@systemfsoftware/arethetypeswrong-cli": "^4.1.0",
@@ -70,13 +71,15 @@
   },
   "scripts": {
     "clean": "rimraf dist",
-    "build": "tsdown && pnpm dts:check",
+    "build": "tsdown && pnpm dts:check && pnpm api:check",
     "typecheck": "tsc --noEmit --incremental",
     "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --config oxlint.config.ts --format=${f:-default}",
     "lint:tsgo": "effect-tsgo diagnostics --project tsconfig.json --format ${TSGO_FORMAT:-text}",
     "attw": "attw --pack .",
     "dts:check": "node scripts/check-dts.mjs",
     "storybook": "storybook dev -p 6006 --no-open",
-    "test:browser": "pnpm build && vitest run"
+    "test:browser": "pnpm build && vitest run",
+    "api:check": "tsdown && api-extractor run",
+    "api:update": "api-extractor run --local"
   }
 }