@systemfsoftware/storybook-gherkin 3.0.3 → 3.0.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @systemfsoftware/storybook-gherkin
 
+## 3.0.5
+
+### Patch Changes
+
+- Dependencies resolve to Effect 4.0.0-rc.116 and Vitest 5.
+
+## 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,312 @@
-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 { 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 = typeof screen_2;
+
+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/dist/index.mjs

@@ -3,11 +3,12 @@ import { screen } from "storybook/test";
 //#region src/Capture.ts
 const CaptureTag = { _tag: "Capture" };
 function capture(name, options) {
+	const resolved = options ?? {};
 	return {
 		...CaptureTag,
 		name,
-		schema: options?.schema,
-		default: options?.default
+		schema: resolved.schema,
+		default: resolved.default
 	};
 }
 //#endregion
@@ -67,9 +68,22 @@ var CaptureDecodeFailed = class extends Schema.TaggedError()("CaptureDecodeFaile
 }) {};
 //#endregion
 //#region src/Steps.ts
-const joinStep = (step, renderHole) => [step.parts[0] ?? "", ...step.captures.flatMap((cap, i) => [renderHole(cap), step.parts[i + 1] ?? ""])].join("");
+const emptyIfMissing = (part) => {
+	if (part === void 0) return "";
+	return part;
+};
+const joinStep = (step, renderHole) => [emptyIfMissing(step.parts[0]), ...step.captures.flatMap((cap, i) => [renderHole(cap), emptyIfMissing(step.parts[i + 1])])].join("");
 const displayPattern = (step) => joinStep(step, (cap) => `{${cap.name}}`);
-const renderStepText = (step, values) => joinStep(step, (cap) => values[cap.name] ?? cap.default ?? `{${cap.name}}`);
+const firstString = (left, right) => {
+	if (left !== void 0) return left;
+	return right;
+};
+const holeText = (cap, values) => {
+	const fromValues = values[cap.name];
+	if (fromValues !== void 0) return fromValues;
+	return firstString(cap.default, `{${cap.name}}`);
+};
+const renderStepText = (step, values) => joinStep(step, (cap) => holeText(cap, values));
 const resolveKeyword = (keyword, previous) => Match.value(keyword).pipe(Match.when("Given", () => "Given"), Match.when("When", () => "When"), Match.when("Then", () => "Then"), Match.when("And", () => previous), Match.when("But", () => previous), Match.when("Star", () => previous), Match.exhaustive);
 const resolveKeywords = (steps) => {
 	return Array$1.mapAccum(steps, "Given", (previous, s) => {
@@ -82,44 +96,63 @@ const resolveKeywords = (steps) => {
 };
 const STEP_TAG = "Step";
 const StepTag = { _tag: STEP_TAG };
+const partAt = (statics, index) => emptyIfMissing(statics[index]);
+const appendLiteral = (current, literal, trailing) => current + literal + trailing;
+const consumeNonStringHole = (current, hole, trailing, parts, captures) => {
+	if (typeof hole === "number") return appendLiteral(current, String(hole), trailing);
+	parts.push(current);
+	captures.push({
+		name: hole.name,
+		schema: hole.schema,
+		default: hole.default
+	});
+	return trailing;
+};
+const consumeHole = (current, hole, trailing, parts, captures) => {
+	if (typeof hole === "string") return appendLiteral(current, hole, trailing);
+	return consumeNonStringHole(current, hole, trailing, parts, captures);
+};
+const rememberCapture = (model, seen, cap) => {
+	if (seen.has(cap.name)) throw DuplicateCapture.make({
+		step: displayPattern(model),
+		name: cap.name
+	});
+	seen.add(cap.name);
+};
+const assertUniqueCaptures = (model, captures) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const cap of captures) rememberCapture(model, seen, cap);
+};
 const buildModel = (keyword, statics, holes) => {
 	const parts = [];
 	const captures = [];
-	let current = statics[0] ?? "";
-	for (const [i, hole] of holes.entries()) if (typeof hole === "string") current += hole + (statics[i + 1] ?? "");
-	else if (typeof hole === "number") current += String(hole) + (statics[i + 1] ?? "");
-	else {
-		parts.push(current);
-		current = statics[i + 1] ?? "";
-		captures.push({
-			name: hole.name,
-			schema: hole.schema,
-			default: hole.default
-		});
-	}
+	let current = partAt(statics, 0);
+	for (const [i, hole] of holes.entries()) current = consumeHole(current, hole, partAt(statics, i + 1), parts, captures);
 	parts.push(current);
 	const model = {
 		keyword,
 		parts,
 		captures
 	};
-	const seen = /* @__PURE__ */ new Set();
-	for (const cap of captures) {
-		if (seen.has(cap.name)) throw DuplicateCapture.make({
-			step: displayPattern(model),
-			name: cap.name
-		});
-		seen.add(cap.name);
-	}
+	assertUniqueCaptures(model, captures);
 	return model;
 };
+const captureRaw = (cap, values) => {
+	const fromValues = values[cap.name];
+	if (fromValues !== void 0) return fromValues;
+	return cap.default;
+};
+const rawOrEmpty = (raw) => {
+	if (raw === void 0) return "";
+	return raw;
+};
 const decodeCapture = (cap, values, model) => {
-	const raw = values[cap.name] ?? cap.default;
+	const raw = captureRaw(cap, values);
 	if (cap.schema === void 0) return Effect.succeed(raw);
 	return Schema.decodeEffect(cap.schema)(raw).pipe(Effect.mapError((error) => CaptureDecodeFailed.make({
 		step: displayPattern(model),
 		capture: cap.name,
-		value: raw ?? "",
+		value: rawOrEmpty(raw),
 		cause: error
 	})));
 };
@@ -146,13 +179,28 @@ const Then = makeStepCtor("Then");
 const And = makeStepCtor("And");
 const But = makeStepCtor("But");
 const Star = makeStepCtor("Star");
+const isNonNullObject = (value) => {
+	if (typeof value !== "object") return false;
+	return value !== null;
+};
+const hasModelAndRun = (value) => {
+	if (!("model" in value)) return false;
+	return "run" in value;
+};
+const hasStepFields = (value) => {
+	if (Reflect.get(value, "_tag") !== STEP_TAG) return false;
+	return hasModelAndRun(value);
+};
 const isStep = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	return Reflect.get(value, "_tag") === STEP_TAG && "model" in value && "run" in value;
+	if (!isNonNullObject(value)) return false;
+	return hasStepFields(value);
 };
 //#endregion
 //#region src/Feature.ts
-const displayKeyword = (model) => model.keyword === "Star" ? "*" : model.keyword;
+const displayKeyword = (model) => {
+	if (model.keyword === "Star") return "*";
+	return model.keyword;
+};
 const buildStepContext = (ctx) => ({
 	canvas: ctx.canvas,
 	screen,
@@ -167,12 +215,6 @@ const buildStepContext = (ctx) => ({
 	reporting: ctx.reporting,
 	context: ctx
 });
-/**
-* Total classification of an interpreted program's `Exit`, shared by the play
-* edge and the step bridge: interruption resolves silently, success returns
-* the value, and any other cause is rethrown as the original error instance
-* (`Cause.squash`) so Storybook's panel keeps the matcher diff.
-*/
 const squashExit = (exit) => Exit.match(exit, {
 	onSuccess: (value) => value,
 	onFailure: (cause) => {
@@ -180,17 +222,6 @@ const squashExit = (exit) => Exit.match(exit, {
 		throw Cause.squash(cause);
 	}
 });
-/**
-* One scenario step, composed as an Effect. Storybook's instrumented `step`
-* expects a promise whose settlement tracks the step's work, so the body runs
-* in a child fiber that settles a deferred; the bridge promise given to
-* `stepCtx.step` awaits that deferred and rejects with the step's original error.
-* The bridge interprets only this pure signalling effect; user code runs in
-* the single play-edge interpretation. The `ensuring` finalizer interrupts
-* the child on every parent exit — success (no-op on a joined fiber),
-* failure, and interruption — so an independently failed `stepCtx.step` never
-* orphans a running step body.
-*/
 const runStep = (step, values, stepCtx) => {
 	const label = `${displayKeyword(step.model)} ${renderStepText(step.model, values)}`;
 	return Deferred.make().pipe(Effect.flatMap((done) => {
@@ -202,7 +233,6 @@ const executeSteps = (ordered, values, ctx) => {
 	const stepCtx = buildStepContext(ctx);
 	return Effect.forEach(ordered, (s) => runStep(s, values, stepCtx), { discard: true });
 };
-/** The single interpretation edge of the package. */
 const interpretPlay = (context, program, ctx) => Effect.runPromiseExitWith(context)(program, { signal: ctx.abortSignal }).then(squashExit);
 const rowValuesFor = (row) => Object.fromEntries(Object.entries(row).filter(([k]) => k !== "name"));
 const sortKeys = (keys) => {
@@ -210,41 +240,95 @@ const sortKeys = (keys) => {
 	sorted.sort();
 	return sorted;
 };
-const validateScenarioSteps = (fullName, models, withRecord) => {
+const assertNonEmptyScenario = (fullName, models) => {
 	if (models.length === 0) throw EmptyScenario.make({ scenario: fullName });
-	if (!resolveKeywords(models).some((r) => r.resolved === "Then")) throw MissingThen.make({ scenario: fullName });
-	for (const stepModel of models) for (const cap of stepModel.captures) {
-		const hasDefault = cap.default !== void 0;
-		const hasWith = Object.prototype.hasOwnProperty.call(withRecord, cap.name);
-		if (!hasDefault && !hasWith) throw UnresolvedCapture.make({
-			scenario: fullName,
-			step: displayPattern(stepModel),
-			capture: cap.name
-		});
-	}
+};
+const isThen = (r) => r.resolved === "Then";
+const assertHasThen = (fullName, models) => {
+	if (!resolveKeywords(models).some(isThen)) throw MissingThen.make({ scenario: fullName });
+};
+const captureIsBound = (cap, withRecord) => {
+	if (cap.default !== void 0) return true;
+	return Object.prototype.hasOwnProperty.call(withRecord, cap.name);
+};
+const assertCaptureBound = (fullName, stepModel, cap, withRecord) => {
+	if (captureIsBound(cap, withRecord)) return;
+	throw UnresolvedCapture.make({
+		scenario: fullName,
+		step: displayPattern(stepModel),
+		capture: cap.name
+	});
+};
+const assertCapturesBound = (fullName, stepModel, withRecord) => {
+	for (const cap of stepModel.captures) assertCaptureBound(fullName, stepModel, cap, withRecord);
+};
+const validateScenarioSteps = (fullName, models, withRecord) => {
+	assertNonEmptyScenario(fullName, models);
+	assertHasThen(fullName, models);
+	for (const stepModel of models) assertCapturesBound(fullName, stepModel, withRecord);
 };
 const isScenarioOptions = (value) => !isStep(value) && !Array.isArray(value);
-const parseScenarioArgs = (rest) => {
+const optionsIfPresent = (firstArg) => {
+	if (!isScenarioOptions(firstArg)) return void 0;
+	return firstArg;
+};
+const readOptions = (rest) => {
 	const firstArg = rest[0];
-	const options = firstArg !== void 0 && isScenarioOptions(firstArg) ? firstArg : void 0;
-	const body = options === void 0 ? rest : rest.slice(1);
-	const steps = [];
-	for (const item of body) if (isStep(item)) steps.push(item);
-	else if (Array.isArray(item)) for (const inner of item) {
-		if (!isStep(inner)) throw new TypeError(`Steps group contains a non-step value of type ${typeof inner}`);
-		steps.push(inner);
+	if (firstArg === void 0) return void 0;
+	return optionsIfPresent(firstArg);
+};
+const bodyAfterOptions = (rest, options) => {
+	if (options === void 0) return rest;
+	return rest.slice(1);
+};
+const pushInnerStep = (steps, inner) => {
+	if (!isStep(inner)) throw new TypeError(`Steps group contains a non-step value of type ${typeof inner}`);
+	steps.push(inner);
+};
+const pushStepGroup = (steps, item) => {
+	for (const inner of item) pushInnerStep(steps, inner);
+};
+const pushIfGroup = (steps, item) => {
+	if (Array.isArray(item)) {
+		pushStepGroup(steps, item);
+		return;
+	}
+	throw new TypeError(`Scenario arguments must be steps or step groups; got type ${typeof item}`);
+};
+const pushScenarioItem = (steps, item) => {
+	if (isStep(item)) {
+		steps.push(item);
+		return;
 	}
-	else throw new TypeError(`Scenario arguments must be steps or step groups; got type ${typeof item}`);
+	pushIfGroup(steps, item);
+};
+const parseScenarioArgs = (rest) => {
+	const options = readOptions(rest);
+	const body = bodyAfterOptions(rest, options);
+	const steps = [];
+	for (const item of body) pushScenarioItem(steps, item);
 	return {
 		options,
 		steps
 	};
 };
+const qualifyName = (prefix, name) => {
+	if (prefix === "") return name;
+	return `${prefix}: ${name}`;
+};
+const recordOrEmpty = (value) => {
+	if (value === void 0) return {};
+	return value;
+};
+const withRecordOf = (options) => {
+	if (options === void 0) return {};
+	return recordOrEmpty(options.with);
+};
 const makeScenario = (background, prefix, context) => {
 	function scenario(name, ...rest) {
 		const { options, steps } = parseScenarioArgs(rest);
-		const fullName = prefix === "" ? name : `${prefix}: ${name}`;
-		const withRecord = options?.with ?? {};
+		const fullName = qualifyName(prefix, name);
+		const withRecord = withRecordOf(options);
 		validateScenarioSteps(fullName, steps.map((s) => s.model), withRecord);
 		return {
 			name: fullName,
@@ -253,40 +337,77 @@ const makeScenario = (background, prefix, context) => {
 	}
 	return scenario;
 };
-const validateOutlineRows = (rows, captureNames, fullName) => {
+const assertOutlineNonEmpty = (rows, fullName) => {
 	if (rows.length === 0) throw OutlineEmpty.make({ outline: fullName });
+};
+const isNotName = (k) => k !== "name";
+const keysExceptName = (row) => sortKeys(Object.keys(row).filter(isNotName));
+const firstRowKeys = (rows) => {
+	const first = rows[0];
+	if (first === void 0) return [];
+	return keysExceptName(first);
+};
+const rememberRowName = (seen, row, fullName) => {
+	if (seen.has(row.name)) throw OutlineDuplicateRowName.make({
+		outline: fullName,
+		name: row.name
+	});
+	seen.add(row.name);
+};
+const keyAtMatches = (actual, expected, i) => actual[i] === expected[i];
+const keysMatch = (actual, expected) => {
+	if (actual.length !== expected.length) return false;
+	return actual.every((_, i) => keyAtMatches(actual, expected, i));
+};
+const assertKeysConsistent = (row, firstKeys, fullName) => {
+	const actual = keysExceptName(row);
+	if (keysMatch(actual, firstKeys)) return;
+	throw OutlineInconsistentKeys.make({
+		outline: fullName,
+		row: row.name,
+		expected: [...firstKeys],
+		actual: [...actual]
+	});
+};
+const assertRowHasCapture = (row, cap, fullName) => {
+	if (Object.prototype.hasOwnProperty.call(row, cap)) return;
+	throw OutlineMissingCapture.make({
+		outline: fullName,
+		row: row.name,
+		capture: cap
+	});
+};
+const assertRowCaptures = (row, captureNames, fullName) => {
+	for (const cap of captureNames) assertRowHasCapture(row, cap, fullName);
+};
+const validateOneRow = (seenRowNames, row, firstKeys, captureNames, fullName) => {
+	rememberRowName(seenRowNames, row, fullName);
+	assertKeysConsistent(row, firstKeys, fullName);
+	assertRowCaptures(row, captureNames, fullName);
+};
+const validateOutlineRows = (rows, captureNames, fullName) => {
+	assertOutlineNonEmpty(rows, fullName);
 	const seenRowNames = /* @__PURE__ */ new Set();
-	const firstKeys = sortKeys(Object.keys(rows[0] ?? {}).filter((k) => k !== "name"));
-	for (const row of rows) {
-		if (seenRowNames.has(row.name)) throw OutlineDuplicateRowName.make({
-			outline: fullName,
-			name: row.name
-		});
-		seenRowNames.add(row.name);
-		const actual = sortKeys(Object.keys(row).filter((k) => k !== "name"));
-		if (actual.length !== firstKeys.length || actual.some((k, i) => k !== firstKeys[i])) throw OutlineInconsistentKeys.make({
-			outline: fullName,
-			row: row.name,
-			expected: [...firstKeys],
-			actual: [...actual]
-		});
-		for (const cap of captureNames) if (!Object.prototype.hasOwnProperty.call(row, cap)) throw OutlineMissingCapture.make({
-			outline: fullName,
-			row: row.name,
-			capture: cap
-		});
-	}
+	const firstKeys = firstRowKeys(rows);
+	for (const row of rows) validateOneRow(seenRowNames, row, firstKeys, captureNames, fullName);
+};
+const addModelCaptures = (captureNames, m) => {
+	for (const c of m.captures) captureNames.add(c.name);
+};
+const collectCaptureNames = (models) => {
+	const captureNames = /* @__PURE__ */ new Set();
+	for (const m of models) addModelCaptures(captureNames, m);
+	return captureNames;
 };
 const makeOutline = (background, prefix, context) => {
 	function outline(name, ...rest) {
 		const { options, steps } = parseScenarioArgs(rest);
-		const fullName = prefix === "" ? name : `${prefix}: ${name}`;
-		const withRecord = options?.with ?? {};
+		const fullName = qualifyName(prefix, name);
+		const withRecord = withRecordOf(options);
 		const models = steps.map((s) => s.model);
-		if (models.length === 0) throw EmptyScenario.make({ scenario: fullName });
-		if (!resolveKeywords(models).some((r) => r.resolved === "Then")) throw MissingThen.make({ scenario: fullName });
-		const captureNames = /* @__PURE__ */ new Set();
-		for (const m of models) for (const c of m.captures) captureNames.add(c.name);
+		assertNonEmptyScenario(fullName, models);
+		assertHasThen(fullName, models);
+		const captureNames = collectCaptureNames(models);
 		const buildRowSpec = (row) => {
 			const values = {
 				...withRecord,
@@ -307,17 +428,24 @@ const makeOutline = (background, prefix, context) => {
 	}
 	return outline;
 };
+const assertResolvedGiven = (step, resolved) => {
+	if (resolved === "Given") return;
+	throw BackgroundNotGiven.make({
+		step: displayPattern(step.model),
+		resolved
+	});
+};
+const assertBackgroundResolved = (step, resolvedEntry) => {
+	if (resolvedEntry === void 0) return;
+	assertResolvedGiven(step, resolvedEntry.resolved);
+};
+const assertBackgroundStep = (step, resolvedEntry) => {
+	if (step === void 0) return;
+	assertBackgroundResolved(step, resolvedEntry);
+};
 const makeBackground = (background) => (...steps) => {
 	const resolvedKeywords = resolveKeywords(steps.map((s) => s.model));
-	for (let i = 0; i < steps.length; i++) {
-		const step = steps[i];
-		const resolvedEntry = resolvedKeywords[i];
-		if (step === void 0 || resolvedEntry === void 0) continue;
-		if (resolvedEntry.resolved !== "Given") throw BackgroundNotGiven.make({
-			step: displayPattern(step.model),
-			resolved: resolvedEntry.resolved
-		});
-	}
+	for (let i = 0; i < steps.length; i++) assertBackgroundStep(steps[i], resolvedKeywords[i]);
 	background.push(...steps);
 };
 const makeFeature = (meta, context) => {
@@ -334,13 +462,17 @@ const makeFeature = (meta, context) => {
 		})
 	};
 };
+const contextOf = (options) => {
+	if (options.context === void 0) return Context.empty();
+	return options.context;
+};
 /**
 * 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.
 */
-const feature = (meta, options = {}) => makeFeature(meta, options.context ?? Context.empty());
+const feature = (meta, options = {}) => makeFeature(meta, contextOf(options));
 const Steps = (...steps) => [...steps];
 const From = (story) => {
 	const play = story.play;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/storybook-gherkin",
   "license": "Apache-2.0",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -36,47 +36,51 @@
     "dist"
   ],
   "dependencies": {
-    "type-fest": "^5.8.0"
+    "type-fest": "^5.10.0"
   },
   "peerDependencies": {
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.116",
     "storybook": ">=10.0.0"
   },
   "devDependencies": {
-    "@storybook/addon-vitest": "^10.5.0",
-    "@storybook/react-vite": "^10.5.0",
-    "@systemfsoftware/arethetypeswrong-cli": "^4.1.0",
-    "@types/node": "^24",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.4",
-    "@vitest/browser": "^4",
-    "@vitest/browser-playwright": "^4",
-    "effect": "4.0.0-rc.112",
-    "oxlint": "^1.77.0",
+    "@microsoft/api-extractor": "^7.59.1",
+    "@storybook/addon-vitest": "^10.6.0",
+    "@storybook/react-vite": "^10.6.0",
+    "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
+    "@types/node": "^26",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitest/browser": "^5",
+    "@vitest/browser-playwright": "^5",
+    "effect": "4.0.0-rc.116",
+    "oxlint": "~1.82.0",
     "playwright": "^1",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "rimraf": "^6.1.3",
-    "storybook": "^10.5.0",
-    "tsdown": "^0.22.14",
+    "storybook": "^10.6.0",
+    "tsdown": "^0.23.0",
     "typescript": "^7",
     "vite": "^8",
-    "vitest": "^4",
-    "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.4"
+    "vitest": "^5",
+    "@systemfsoftware/all": "^2.1.1",
+    "@systemfsoftware/tsconfig": "^1.3.5",
+    "@systemfsoftware/oxlint-config": "^0.1.0"
   },
   "publishConfig": {
     "provenance": true
   },
   "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"
   }
 }