@typeonce/effect-machine 0.14.1 → 0.16.0

package/src/Machine.ts

@@ -53,7 +53,6 @@ declare const MachineTypeId: unique symbol
 declare const EventConstructionTypeId: unique symbol
 declare const EmittedEventConstructionTypeId: unique symbol
 declare const EventProtocolTypeId: unique symbol
-declare const TransitionCaseTypeId: unique symbol
 
 const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId = internal.ChildMachineLogicTypeId
 
@@ -96,7 +95,7 @@ export const isInitialEvent = (u: unknown): u is InitialEvent => hasProperty(u,
 type IsAny<A> = 0 extends (1 & A) ? true : false
 
 /**
- * A schema-first machine definition.
+ * A schema-first machine implementation.
  *
  * **Details**
  *
@@ -222,12 +221,68 @@ export interface Machine<
   readonly handlers: Machine.StateConfigs<States, Events, Emits, UnhandledStates, Machine.TagOf<Events[number]>, E, R>
 
   /**
-   * Adds typed state handlers and returns the refined machine definition.
-   * Successive calls implement the remaining unhandled states while retaining
-   * accumulated errors, services, final states, and output evidence.
-   * Event dispatch maps and transition descriptors are captured by value, so
-   * later mutation of the objects supplied to this call cannot alter the
-   * resulting machine.
+   * Machine-bound equivalent of {@link invoke}. Both forms preserve this
+   * machine's public input and parent protocols in invocation callbacks;
+   * `Machine.invoke(...)` inside `handle(...)` is the canonical inline form.
+   *
+   * @since 0.11.0
+   */
+  readonly invoke: Invoker<States, Events, Emits, InputEvents, ParentEvents>
+
+  /** @internal */
+  readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
+  /** @internal */
+  readonly initialDefinition: Machine.InitialDefinition
+}
+
+/**
+ * A schema-first machine definition that can produce independent
+ * implementations.
+ *
+ * **Details**
+ *
+ * Call `handle` once for each implementation. The returned {@link Machine}
+ * does not expose `handle`, so handler configuration cannot be accumulated or
+ * replaced through chained calls. Calling `handle` multiple times on the same
+ * definition remains supported and creates independent machines.
+ *
+ * @category models
+ * @since 0.15.0
+ */
+export interface Definition<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Input extends Schema.Top = typeof Schema.Void,
+  InitialE = never,
+  InitialR = never,
+  FinalStates extends Machine.StateIdentifier<States> = never,
+  Output = never,
+  Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+> extends
+  Machine<
+    States,
+    Events,
+    Input,
+    Machine.StateIdentifier<States>,
+    never,
+    never,
+    InitialE,
+    InitialR,
+    FinalStates,
+    Output,
+    Emits,
+    never,
+    InputEvents,
+    ParentEvents
+  >
+{
+  /**
+   * Adds typed state handlers and returns an independent machine
+   * implementation. Event dispatch maps and transition descriptors are
+   * captured by value, so later mutation of the supplied objects cannot alter
+   * the resulting machine.
    *
    * @since 0.4.0
    */
@@ -236,31 +291,35 @@ export interface Machine<
     Events,
     Emits,
     Input,
-    UnhandledStates,
-    E,
-    R,
+    Machine.StateIdentifier<States>,
+    never,
+    never,
     InitialE,
     InitialR,
     FinalStates,
     Output,
-    OutputStates,
+    never,
     InputEvents,
     ParentEvents
   >
+}
 
+/**
+ * Namespace containing type-level members associated with {@link Definition}.
+ *
+ * @category models
+ * @since 0.15.0
+ */
+export declare namespace Definition {
   /**
-   * Preserves invocation inference with this machine's public input and parent
-   * protocols. Prefer this bound constructor when an invocation source or
-   * lifecycle handler uses `self` or `parent`.
+   * Any schema-first machine definition.
    *
-   * @since 0.11.0
+   * @category models
+   * @since 0.15.0
    */
-  readonly invoke: Invoker<States, Events, Emits, InputEvents, ParentEvents>
-
-  /** @internal */
-  readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
-  /** @internal */
-  readonly initialDefinition: Machine.InitialDefinition
+  export interface Any extends Machine.Any {
+    readonly handle: any
+  }
 }
 
 export {
@@ -687,8 +746,12 @@ type ValidateCompoundStateNode<
   Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> ? {
       readonly states: ValidateStateTree<Children, true, Extract<Path, string>>
     }
-  : StateDefinitionError<"Compound initial must be one of its direct child keys">
-  : StateDefinitionError<"Compound states must declare an initial child">
+  : StateDefinitionError<
+    "Compound initial must be one of its direct child keys",
+    Path,
+    Extract<Initial, PropertyKey>
+  >
+  : StateDefinitionError<"Compound states must declare an initial child", Path>
 
 type ValidateStateNodeWithoutChildren<Node extends Machine.StateNodeConfig> = "initial" extends keyof Node ?
   StateDefinitionError<"Atomic states cannot declare an initial child">
@@ -723,7 +786,29 @@ type InvalidDefinedStateTreeInput<States extends Machine.StateSchemas> = [States
   [Machine.ValidateStateSchemas<States>] ? never
   : States & Machine.ValidateStateSchemas<States>
 
-interface DefineStates {
+type ReusableStateNodeConfig =
+  | Machine.AtomicStateNodeConfig
+  | Machine.CompoundStateNodeConfig
+  | Machine.ParallelStateNodeConfig
+
+type ReusableStateValidation<Node> = Node extends ReusableStateNodeConfig ? ValidateStateNode<Node, false, "state">
+  : StateDefinitionError<"Reusable states must be active state nodes", "state">
+
+type ValidateDefinedState<Node> = [Node] extends [ReusableStateValidation<Node>] ? []
+  : [validation: ReusableStateValidation<Node>]
+
+type InvalidDefinedStateInput<Node> = [Node] extends [ReusableStateValidation<Node>] ? never
+  : Node & ReusableStateValidation<Node>
+
+interface StateConstructor {
+  <const Node>(
+    node: Node & DefineStateNodeInput<NoInfer<Node>>,
+    ..._validation: ValidateDefinedState<NoInfer<Node>>
+  ): Node
+  <const Node>(node: InvalidDefinedStateInput<Node>): never
+}
+
+interface StatesConstructor {
   <const States extends Machine.StateSchemas>(
     states: States & DefineStateTreeInput<NoInfer<States>>,
     ..._validation: ValidateDefinedStates<NoInfer<States>>
@@ -1867,10 +1952,10 @@ export declare namespace Inspection {
     readonly sessionId: string
     readonly owner: Subject
     readonly ownerPath: string
-    readonly kind: "Effect" | "Timer"
+    readonly kind: "Effect" | "Stream" | "Timer"
   }
 
-  /** Announces an Effect or timer invocation starting. */
+  /** Announces an Effect, Stream, or timer invocation starting. */
   export interface ActivityStarted extends Base {
     readonly _tag: "ActivityStarted"
     readonly activity: Activity
@@ -2410,8 +2495,6 @@ export declare namespace Machine {
     /** @internal */
     readonly handlers: any
     /** @internal */
-    readonly handle: any
-    /** @internal */
     readonly invoke: any
     /** @internal */
     readonly initial: any
@@ -2882,12 +2965,12 @@ export declare namespace Machine {
   export type StateSchemas = StateTree
 
   /**
-   * Builder for initial state snapshots generated by `defineStates`.
+   * Builder for initial state snapshots generated by `states`.
    *
    * **When to use**
    *
    * Use when you need the type of the `initial` property returned by
-   * `defineStates` or want to expose an initial snapshot builder from a helper.
+   * `states` or want to expose an initial snapshot builder from a helper.
    *
    * **Details**
    *
@@ -2900,7 +2983,7 @@ export declare namespace Machine {
   type InitialBuilder<States extends StateSchemas> = InitialSnapshotBuilderWithPrefix<States>
 
   /**
-   * State definitions and snapshot access helpers returned by `defineStates`.
+   * State definitions and snapshot access helpers returned by `states`.
    *
    * **Details**
    *
@@ -2912,9 +2995,19 @@ export declare namespace Machine {
    * @since 0.4.0
    */
   export interface DefinedStates<States extends StateSchemas> {
-    /** Original state tree supplied to {@link defineStates}. */
+    /** Captured state tree supplied to {@link states}. */
     readonly states: States
 
+    /**
+     * Checks and preserves one active state path from this definition.
+     *
+     * This is useful for named path helpers, including finite template-literal
+     * families. Every member of a path union must exist in the state tree.
+     *
+     * @since 0.15.0
+     */
+    readonly path: <const Path extends StateIdentifier<States>>(path: Path) => Path
+
     /**
      * Returns the decoded value for an active state path. The supplied
      * snapshot may be a complete root snapshot or a snapshot previously
@@ -3158,7 +3251,7 @@ export declare namespace Machine {
     | {
       readonly type: "invoke"
       readonly id: string
-      readonly outcome: "done" | "failure" | "snapshot"
+      readonly outcome: "element" | "done" | "failure" | "snapshot"
     }
 
   /** Static topology selected by a transition branch. */
@@ -3180,16 +3273,12 @@ export declare namespace Machine {
       readonly selection: TransitionTargetSelection<Path | undefined>
     }
     | {
-      readonly type: "case"
+      readonly type: "branch"
+      readonly key: string
       readonly title: string
       readonly target: Path | undefined
       readonly selection: TransitionTargetSelection<Path | undefined>
     }
-    | {
-      readonly type: "otherwise"
-      readonly target: Path | undefined
-      readonly selection: TransitionTargetSelection<Path | undefined>
-    }
 
   /** The statically selected root entry for machine startup. */
   export interface InitialDefinition<Path extends string = string> {
@@ -3202,8 +3291,8 @@ export declare namespace Machine {
    *
    * **Details**
    *
-   * Every branch exposes its selected target without executing its predicate
-   * or resolver. A compound local or branch target covers its descendants;
+   * Every branch exposes its selected target without executing its resolver.
+   * A compound local or branch target covers its descendants;
    * `undefined` identifies an explicitly targetless branch.
    *
    * @category models
@@ -3249,6 +3338,8 @@ export declare namespace Machine {
     readonly reenter: boolean
     /** Zero-based index of the selected static branch. */
     readonly branchIndex: number
+    /** Stable key of a named branch, or `undefined` for a direct transition. */
+    readonly branchKey: string | undefined
     /** Path returned by the handler, including a choice or history pseudo-state. */
     readonly target: TargetPath | undefined
     /**
@@ -4557,6 +4648,25 @@ export declare namespace Machine {
     readonly output: Output
   }
 
+  /** Context passed to a Stream invocation's element transition. */
+  export interface InvokeElementContext<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    Element,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > extends MachineReferences<InputEvents, ParentEvents> {
+    readonly id: string
+    readonly state: StateByIdentifier<States, StateId>
+    readonly containingState: ParentStateValue<States, StateId>
+    readonly ancestors: ParentStateValues<States, StateId>
+    readonly snapshot: Snapshot<States>
+    readonly target: TargetBuilder<States, StateId>
+    readonly element: Element
+  }
+
   /** Context passed to an invocation typed-failure transition. */
   export interface InvokeFailureContext<
     States extends StateSchemas,
@@ -4837,14 +4947,9 @@ export declare namespace Machine {
    * @category utility types
    * @since 0.4.0
    */
-  export type EventTransitionReturn<Transition> =
-    | (Transition extends { readonly resolve?: infer Resolve } ?
-      NonNullable<Resolve> extends (...args: any) => infer Ret ? Ret : never
-      : never)
-    | (Transition extends { readonly cases: infer Cases extends ReadonlyArray<unknown> } ?
-      EventTransitionReturn<Cases[number]>
-      : never)
-    | (Transition extends { readonly otherwise: infer Otherwise } ? EventTransitionReturn<Otherwise> : never)
+  export type EventTransitionReturn<Transition> = Transition extends { readonly resolve?: infer Resolve } ?
+    NonNullable<Resolve> extends (...args: any) => infer Ret ? Ret : never
+    : never
   /**
    * Extracts the return value from a state's event handlers.
    *
@@ -4909,6 +5014,15 @@ export declare namespace Machine {
         Effect.Success<Fx>
       >
     : never
+    : Invoke extends { readonly stream: infer Source } ?
+      InvokeFactoryResult<Source> extends infer SourceStream extends Stream.Stream<any, any, any> ? Logic<
+          void,
+          never,
+          Stream.Error<SourceStream>,
+          Stream.Services<SourceStream>,
+          void
+        >
+      : never
     : Invoke extends { readonly after: unknown } ? Logic<void, never, never, never, void>
     : Invoke extends { readonly logic: infer Source } ? InvokeResolvedSource<Source>
     : Invoke extends { readonly child: infer Child } ? ChildMachineLogic<Child>
@@ -4980,6 +5094,7 @@ export declare namespace Machine {
   export type InvokeOutcomeReturn<Invoke> = Invoke extends unknown ?
       | (Invoke extends { readonly onDone?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
       | (Invoke extends { readonly onFailure?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
+      | (Invoke extends { readonly onElement?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
       | (Invoke extends { readonly onSnapshot?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
     : never
   /**
@@ -5050,8 +5165,6 @@ export declare namespace Machine {
     | Effect.Services<ChoiceReturn<Config>>
     | InvokeRequirements<Config>
 
-  type TransitionWhenContext<Context> = Omit<Context, "target">
-
   /** Type evidence retained by {@link transition} without affecting runtime data. */
   export interface TransitionTyped<
     States extends StateSchemas,
@@ -5082,11 +5195,40 @@ export declare namespace Machine {
     Context,
     Reenter extends boolean = false
   > =
-    & (TransitionTyped<States, Events, Emits, StateId, Context, Reenter> | TargetlessTransitionTyped)
+    & (
+      | TransitionTyped<States, Events, Emits, StateId, Context, Reenter>
+      | TargetlessTransitionTyped
+      | TargetlessTransitionInput<Events, Emits, Context>
+    )
     & {
       readonly reenter?: [Reenter] extends [true] ? boolean : never
     }
 
+  /** Direct shorthand for a non-reentering targetless transition. */
+  // Keep the context generic so omitting `target` is deferred until a resolver
+  // is actually authored instead of expanding every TransitionConfig eagerly.
+  interface TargetlessTransitionResolver<
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    Context
+  > {
+    <ResolvedContext extends Omit<Context, "target">>(
+      context: ResolvedContext,
+      enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
+    ): undefined
+  }
+
+  export type TargetlessTransitionInput<
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    Context
+  > = {
+    readonly target: TargetlessSelector
+    readonly resolve?: TargetlessTransitionResolver<Events, Emits, Context>
+    readonly branches?: never
+    readonly reenter?: never
+  }
+
   export type SelectionBuilder<Selection> = Selection extends TargetSelection<infer Builder, any, any> ? Builder : never
   export type SelectionKind<Selection> = Selection extends TargetSelection<any, any, infer Kind> ? Kind : never
   export type SelectionPath<Selection> = Selection extends TargetSelection<any, infer Path, any> ? Path : never
@@ -5099,21 +5241,18 @@ export declare namespace Machine {
 
   export type TransitionResolveContext<
     Context,
-    Selection,
-    Match = never
+    Selection
   > =
     & Omit<Context, "target">
-    & ([Match] extends [never] ? {} : { readonly match: Match })
     & (SelectionKind<Selection> extends "none" ? {} : { readonly target: SelectionBuilder<Selection> })
 
   export type TransitionResolver<
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     Context,
-    Selection,
-    Match = never
+    Selection
   > = (
-    context: TransitionResolveContext<Context, Selection, Match>,
+    context: TransitionResolveContext<Context, Selection>,
     enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
   ) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined
 
@@ -5128,51 +5267,95 @@ export declare namespace Machine {
   > = {
     readonly target: (to: TargetSelector<States, StateId>) => Selection
     readonly resolve?: TransitionResolver<Events, Emits, Context, Selection>
-    readonly cases?: never
-    readonly otherwise?: never
+    readonly branches?: never
     readonly reenter?: Reenter
   }
 
-  export type TransitionCaseInput<
-    States extends StateSchemas,
+  /** One named destination declared by a branching transition. */
+  export interface TransitionBranchInput<
+    Selection extends TargetSelection<any, any, any> = TargetSelection<any, any, any>
+  > {
+    readonly target: Selection
+    readonly title?: string
+  }
+
+  /** Opaque evidence that a branching resolver selected one declared branch. */
+  export interface SelectedBranch<out Key extends string, out Result> {
+    readonly [Topology.SelectedBranchTypeId]: {
+      readonly key: Types.Covariant<Key>
+      readonly result: Types.Covariant<Result>
+    }
+  }
+
+  type SelectedBranchCallable<Callable, Key extends string> = Callable extends {
+    (...args: infer Arguments1): infer Result1
+    (...args: infer Arguments2): infer Result2
+  } ? {
+      (...args: Arguments1): SelectedBranch<Key, Result1>
+      (...args: Arguments2): SelectedBranch<Key, Result2>
+    }
+    : Callable extends (...args: infer Arguments) => infer Result ? (...args: Arguments) => SelectedBranch<Key, Result>
+    : {}
+
+  type SelectedBranchBuilderProperties<Builder, Key extends string> = {
+    readonly [Property in keyof Builder]: Builder[Property] extends (...args: any) => any ?
+      SelectedBranchCallable<Builder[Property], Key>
+      : Builder[Property]
+  }
+
+  /** Target-specific builder that brands every construction with its branch key. */
+  export type SelectedBranchBuilder<Builder, Key extends string> =
+    & SelectedBranchCallable<Builder, Key>
+    & SelectedBranchBuilderProperties<Builder, Key>
+
+  export type BranchSelectors<Branches extends Readonly<Record<string, TransitionBranchInput>>> = {
+    readonly [Key in Extract<keyof Branches, string>]: SelectedBranchBuilder<
+      SelectionBuilder<Branches[Key]["target"]>,
+      Key
+    >
+  }
+
+  export type BranchSelectionResult<Branches extends Readonly<Record<string, TransitionBranchInput>>> = {
+    readonly [Key in Extract<keyof Branches, string>]: SelectedBranch<
+      Key,
+      SelectedTargetResult<Branches[Key]["target"]>
+    >
+  }[Extract<keyof Branches, string>]
+
+  export type TransitionBranchesResolveContext<
+    Context,
+    Branches extends Readonly<Record<string, TransitionBranchInput>>
+  > = Omit<Context, "target"> & { readonly select: BranchSelectors<Branches> }
+
+  export type TransitionBranchesResolver<
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateNodeIdentifier<States>,
     Context,
-    Selection extends TargetSelection<any, any, any>,
-    Match
-  > = {
-    readonly title: string
-    readonly when: (context: TransitionWhenContext<Context>) => Option.Option<Match>
-    readonly target: (to: TargetSelector<States, StateId>) => Selection
-    readonly resolve?: TransitionResolver<Events, Emits, Context, Selection, NoInfer<Match>>
-    readonly cases?: never
-    readonly otherwise?: never
-    readonly reenter?: never
-  }
+    Branches extends Readonly<Record<string, TransitionBranchInput>>
+  > = (
+    context: TransitionBranchesResolveContext<Context, Branches>,
+    enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
+  ) => BranchSelectionResult<Branches>
 
-  export type TransitionConditionalInput<
+  export type TransitionBranchesInput<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateNodeIdentifier<States>,
     Context,
     Reenter extends boolean,
-    Cases extends readonly [TransitionCaseTyped, ...ReadonlyArray<TransitionCaseTyped>],
-    OtherwiseSelection extends TargetSelection<any, any, any>
+    Branches extends Readonly<Record<string, TransitionBranchInput>>
   > = {
     readonly target?: never
-    readonly resolve?: never
-    readonly cases: (branch: TransitionCaseConstructor<States, Events, Emits, StateId, Context>) => Cases
-    readonly otherwise: TransitionDirectInput<
-      States,
-      Events,
-      Emits,
-      StateId,
-      Context,
-      never,
-      OtherwiseSelection
-    >
+    /**
+     * Declares every possible destination under a stable semantic key.
+     *
+     * Branches are captured once in ECMAScript property order. Array-index
+     * keys are rejected so reordering ordinary named properties affects only
+     * presentation order; the key remains the testing and inspection identity.
+     */
+    readonly branches: (to: TargetSelector<States, StateId>) => Branches
+    readonly resolve: TransitionBranchesResolver<Events, Emits, Context, Branches>
     readonly reenter?: Reenter
   }
 
@@ -5223,12 +5406,29 @@ export declare namespace Machine {
         readonly effect: (
           context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
         ) => Effect.Effect<any, any, any>
+        readonly stream?: never
         readonly after?: never
         readonly logic?: never
         readonly child?: never
         readonly address?: never
         readonly onDone?: unknown
         readonly onFailure?: unknown
+        readonly onElement?: never
+        readonly onSnapshot?: never
+      }
+      | {
+        readonly id: string
+        readonly stream: (
+          context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        ) => Stream.Stream<any, any, any>
+        readonly effect?: never
+        readonly after?: never
+        readonly logic?: never
+        readonly child?: never
+        readonly address?: never
+        readonly onElement?: unknown
+        readonly onDone: unknown
+        readonly onFailure?: unknown
         readonly onSnapshot?: never
       }
       | {
@@ -5238,11 +5438,13 @@ export declare namespace Machine {
           InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
         >
         readonly effect?: never
+        readonly stream?: never
         readonly logic?: never
         readonly child?: never
         readonly address?: never
         readonly onDone: unknown
         readonly onFailure?: never
+        readonly onElement?: never
         readonly onSnapshot?: never
       }
       | {
@@ -5253,10 +5455,12 @@ export declare namespace Machine {
           InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
         >
         readonly effect?: never
+        readonly stream?: never
         readonly after?: never
         readonly child?: never
         readonly onDone?: unknown
         readonly onFailure?: unknown
+        readonly onElement?: never
         readonly onSnapshot?: unknown
       }
       | {
@@ -5268,10 +5472,12 @@ export declare namespace Machine {
         readonly id?: never
         readonly address?: never
         readonly effect?: never
+        readonly stream?: never
         readonly after?: never
         readonly logic?: never
         readonly onDone?: unknown
         readonly onFailure?: unknown
+        readonly onElement?: never
         readonly onSnapshot?: unknown
       }
     )
@@ -5306,6 +5512,11 @@ export declare namespace Machine {
     : { readonly onFailure?: never }
     : never
 
+  export type InvokeElementRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
+    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onElement: Required }
+    : { readonly onElement?: never }
+    : never
+
   export type TimerInvokeArgs<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
@@ -5320,10 +5531,12 @@ export declare namespace Machine {
       InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
     >
     readonly effect?: never
+    readonly stream?: never
     readonly logic?: never
     readonly child?: never
     readonly address?: never
     readonly onFailure?: never
+    readonly onElement?: never
     readonly onSnapshot?: never
     readonly onDone: InvokeTransition<
       States,
@@ -5355,8 +5568,10 @@ export declare namespace Machine {
       readonly address: Address & ChildAddress.Compatibility<Address, ChildEvent>
       readonly logic: Source
       readonly effect?: never
+      readonly stream?: never
       readonly after?: never
       readonly child?: never
+      readonly onElement?: never
       readonly onSnapshot?: InvokeTransition<
         States,
         Events,
@@ -5418,8 +5633,10 @@ export declare namespace Machine {
       readonly id?: never
       readonly address?: never
       readonly effect?: never
+      readonly stream?: never
       readonly after?: never
       readonly logic?: never
+      readonly onElement?: never
       readonly onSnapshot?: InvokeTransition<
         States,
         Events,
@@ -5533,6 +5750,55 @@ export declare namespace Machine {
           >
           & { readonly onSnapshot?: never }
       : never
+    : Raw extends { readonly stream: infer Source } ?
+      InvokeFactoryResult<Source> extends infer SourceStream extends Stream.Stream<any, any, any> ?
+          & InvokeElementRequirement<
+            Stream.Success<SourceStream>,
+            InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeElementContext<
+                States,
+                Events,
+                Emits,
+                StateId,
+                Stream.Success<SourceStream>,
+                InputEvents,
+                ParentEvents
+              >
+            >
+          >
+          & {
+            readonly onDone: InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
+            >
+          }
+          & InvokeFailureRequirement<
+            Stream.Error<SourceStream>,
+            InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeFailureContext<
+                States,
+                Events,
+                Emits,
+                StateId,
+                Stream.Error<SourceStream>,
+                InputEvents,
+                ParentEvents
+              >
+            >
+          >
+          & { readonly onSnapshot?: never }
+      : never
     : Raw extends { readonly after: unknown } ? {
         readonly onDone: InvokeTransition<
           States,
@@ -6280,6 +6546,7 @@ export declare namespace Machine {
 
   type TransitionResultInitialTargetPath<Result> = IsAny<Result> extends true ? never
     : Result extends Effect.Effect<infer Success, any, any> ? TransitionResultInitialTargetPath<Success>
+    : Result extends SelectedBranch<any, infer Selected> ? TransitionResultInitialTargetPath<Selected>
     : Result extends StateConstruction<infer Constructed> ? TransitionResultInitialTargetPath<Constructed>
     : Result extends {
       readonly [Topology.InitialTargetTypeId]: typeof Topology.InitialTargetTypeId
@@ -6827,6 +7094,16 @@ export declare namespace Machine {
   >
 }
 
+/**
+ * Extracts the complete logical snapshot represented by a state definition.
+ *
+ * @category utility types
+ * @since 0.15.0
+ */
+export type Snapshot<Defined extends Machine.DefinedStates<any>> = Defined extends Machine.DefinedStates<infer States>
+  ? Machine.Snapshot<States>
+  : never
+
 /**
  * Returns `true` if a value is a `Machine`.
  *
@@ -6877,7 +7154,44 @@ export const isFinal: <
 ) => state is Machine.SnapshotContainingFinal<States, FinalStates> = internal.isFinal as any
 
 /**
- * Defines a state tree while preserving literal state paths.
+ * Defines one reusable active state while preserving its exact child topology.
+ *
+ * Prefer declaring state nodes inline in {@link states}. Use this constructor
+ * only when the same state definition is mounted more than once.
+ * Tagged schemas are already reusable and do not need this constructor.
+ *
+ * **Example** (Repeated compound state)
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * const TradingState = Schema.TaggedUnion({
+ *   InSession: {},
+ *   Applying: {}
+ * })
+ * const TradingSlot = Machine.state({
+ *   initial: "Idle",
+ *   states: {
+ *     Idle: {},
+ *     InSession: TradingState.cases.InSession,
+ *     Applying: TradingState.cases.Applying
+ *   }
+ * })
+ *
+ * const States = Machine.states({
+ *   slot1: TradingSlot,
+ *   slot2: TradingSlot
+ * })
+ * ```
+ *
+ * @category constructors
+ * @since 0.15.0
+ */
+export const state: StateConstructor = internal.state as StateConstructor
+
+/**
+ * Defines the complete state tree while preserving literal state paths.
  *
  * **When to use**
  *
@@ -6886,7 +7200,8 @@ export const isFinal: <
  *
  * **Details**
  *
- * The returned `states` property is the same object passed to `defineStates`.
+ * The returned `states` property is an immutable structural capture of the
+ * supplied tree.
  * `Machine.make` derives its initial target selector from that tree and
  * enforces compound and parallel initial-state rules. Active nodes may omit
  * `schema` when they own no value and still participate fully in targeting,
@@ -6900,7 +7215,7 @@ export const isFinal: <
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
  *
- * const States = Machine.defineStates({ idle: Idle })
+ * const States = Machine.states({ idle: Idle })
  *
  * Machine.make({
  *   states: States.states,
@@ -6915,7 +7230,7 @@ export const isFinal: <
  * @category constructors
  * @since 0.4.0
  */
-export const defineStates: DefineStates = internal.defineStates
+export const states: StatesConstructor = internal.states
 
 type InitialDirectInput<
   States extends Machine.StateSchemas,
@@ -6967,19 +7282,15 @@ type MakeResult<
   InitialR,
   InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
   ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
-> = Machine<
+> = Definition<
   States,
   readonly [...InputEvents, ...InternalEvents],
   Input,
-  Machine.StateIdentifier<States>,
-  never,
-  never,
   InitialE,
   InitialR,
   Machine.FinalStateFromDefinition<States>,
   Machine.TerminalOutput<States>,
   Emits,
-  never,
   InputEvents,
   ParentEvents
 >
@@ -7028,7 +7339,7 @@ interface Make {
  * State and event schemas provide runtime boundary validation while their
  * decoded types drive handler, state, event, target, error, and service
  * inference. State-tree validation is applied whether `states` comes from
- * `defineStates` or is passed inline. Call `handle` on the returned definition
+ * `states` or is passed inline. Call `handle` on the returned definition
  * to implement state behavior with ordinary TypeScript control flow.
  *
  * `Machine.events` defines the public input protocol. `Machine.internalEvents`
@@ -7053,7 +7364,7 @@ interface Make {
  *   by: Schema.Number
  * }) {}
  *
- * const States = Machine.defineStates({ Count })
+ * const States = Machine.states({ Count })
  * const Events = Machine.events(Increment)
  *
  * const counter = Machine.make({
@@ -7076,7 +7387,7 @@ interface Make {
  * })
  * ```
  *
- * @see {@link defineStates} for typed state-tree helpers.
+ * @see {@link states} for typed state-tree helpers.
  * @category constructors
  * @since 0.4.0
  */
@@ -7104,9 +7415,14 @@ export type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventO
  * **Example**
  *
  * ```ts
- * const Events = Machine.events(Increment, Reset)
- * const machine = Machine.make({ events: Events, ... })
- * yield* ref.send(Events.Increment({ by: 1 }))
+ * export const Event = Machine.events(
+ *   Schema.TaggedUnion({
+ *     Increment: { by: Schema.Number },
+ *     Reset: {}
+ *   })
+ * )
+ * const machine = Machine.make({ events: Event, ... })
+ * yield* ref.send(Event.Increment({ by: 1 }))
  * ```
  *
  * @category constructors
@@ -7132,11 +7448,16 @@ export const events: {
  * **Example**
  *
  * ```ts
- * const InternalEvents = Machine.internalEvents(Loaded, Failed)
- * const machine = Machine.make({ internalEvents: InternalEvents, ... })
+ * const Internal = Machine.internalEvents(
+ *   Schema.TaggedUnion({
+ *     Loaded: { value: Schema.String },
+ *     Failed: { message: Schema.String }
+ *   })
+ * )
+ * const machine = Machine.make({ internalEvents: Internal, ... })
  *
  * // Inside a transition callback:
- * enqueue.raise(InternalEvents.Loaded({ value }))
+ * enqueue.raise(Internal.Loaded({ value }))
  * ```
  *
  * @category constructors
@@ -7157,6 +7478,17 @@ export const internalEvents: {
  * implicitly to a parent machine. Observe them through `MachineRef.emissions` or
  * the AtomMachine emission stream adapters.
  *
+ * **Example**
+ *
+ * ```ts
+ * const Emitted = Machine.emittedEvents(
+ *   Schema.TaggedUnion({
+ *     Saved: { id: Schema.String }
+ *   })
+ * )
+ * const machine = Machine.make({ emittedEvents: Emitted, ... })
+ * ```
+ *
  * @category constructors
  * @since 0.10.0
  */
@@ -7199,7 +7531,7 @@ export const emittedEvents: {
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
@@ -7284,7 +7616,7 @@ export const encodeSnapshot: <
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
@@ -7348,17 +7680,21 @@ type EffectInvokeSource<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
   StateId extends Machine.StateIdentifier<States>,
   Source extends (
-    context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
+    context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
   ) => Effect.Effect<unknown, unknown, unknown>
 > = {
   readonly id: InvokeLifecycleId
   readonly effect: Source
+  readonly stream?: never
   readonly after?: never
   readonly logic?: never
   readonly child?: never
   readonly address?: never
+  readonly onElement?: never
   readonly onSnapshot?: never
 }
 
@@ -7366,6 +7702,8 @@ type EffectDoneHandler<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
   StateId extends Machine.StateIdentifier<States>,
   Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
 > = Machine.InvokeTransition<
@@ -7379,8 +7717,8 @@ type EffectDoneHandler<
     Emits,
     StateId,
     Effect.Success<ReturnType<NoInfer<Source>>>,
-    readonly [],
-    readonly []
+    InputEvents,
+    ParentEvents
   >
 >
 
@@ -7388,6 +7726,8 @@ type EffectFailureHandler<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
   StateId extends Machine.StateIdentifier<States>,
   Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
 > = Machine.InvokeTransition<
@@ -7401,8 +7741,8 @@ type EffectFailureHandler<
     Emits,
     StateId,
     Effect.Error<ReturnType<NoInfer<Source>>>,
-    readonly [],
-    readonly []
+    InputEvents,
+    ParentEvents
   >
 >
 
@@ -7410,10 +7750,12 @@ type EffectInvokeResult<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
   StateId extends Machine.StateIdentifier<States>,
   Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
 > =
-  & Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []>
+  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
   & Machine.InvokeTyped<
     Effect.Success<ReturnType<Source>>,
     Effect.Error<ReturnType<Source>>,
@@ -7421,6 +7763,110 @@ type EffectInvokeResult<
     never
   >
 
+type StreamInvokeSource<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<any>) => unknown
+> = {
+  readonly id: InvokeLifecycleId
+  readonly stream:
+    & Source
+    & ((context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown)
+  readonly effect?: never
+  readonly after?: never
+  readonly logic?: never
+  readonly child?: never
+  readonly address?: never
+  readonly onSnapshot?: never
+}
+
+type StreamSourceResult<Source extends (...args: ReadonlyArray<any>) => unknown> = ReturnType<Source> extends
+  infer Result extends Stream.Stream<any, any, any> ? Result : never
+
+type StreamElementHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<any>) => unknown
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  StateId,
+  Machine.InvokeElementContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Stream.Success<StreamSourceResult<NoInfer<Source>>>,
+    InputEvents,
+    ParentEvents
+  >
+>
+
+type StreamDoneHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  StateId,
+  Machine.InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
+>
+
+type StreamFailureHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<any>) => unknown
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  StateId,
+  Machine.InvokeFailureContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Stream.Error<StreamSourceResult<NoInfer<Source>>>,
+    InputEvents,
+    ParentEvents
+  >
+>
+
+type StreamInvokeResult<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<any>) => unknown
+> =
+  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  & Machine.InvokeTyped<
+    void,
+    Stream.Error<StreamSourceResult<Source>>,
+    Stream.Services<StreamSourceResult<Source>>,
+    never
+  >
+
 type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false
 
 type BoundEffectInvokeSource<
@@ -7436,10 +7882,12 @@ type BoundEffectInvokeSource<
 > = {
   readonly id: InvokeLifecycleId
   readonly effect: Source
+  readonly stream?: never
   readonly after?: never
   readonly logic?: never
   readonly child?: never
   readonly address?: never
+  readonly onElement?: never
   readonly onSnapshot?: never
 }
 
@@ -7508,66 +7956,36 @@ type BoundEffectInvokeResult<
     never
   >
 
-/** Type evidence retained for a case created by a conditional transition's local builder. */
-interface TransitionCaseTyped {
-  readonly [TransitionCaseTypeId]: true
-}
-
-/** Locally bound constructor that preserves each conditional transition case independently. */
-interface TransitionCaseConstructor<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateNodeIdentifier<States>,
-  Context
-> {
-  <
-    const Selection extends Machine.TargetSelection<any, any, any>,
-    const Match
-  >(
-    config: Machine.TransitionCaseInput<States, Events, Emits, StateId, Context, Selection, Match>
-  ):
-    & Machine.TransitionCaseInput<States, Events, Emits, StateId, Context, Selection, Match>
-    & TransitionCaseTyped
-}
-
-/**
- * Captures one exact transition topology while preserving handler inference.
- *
- * @category constructors
- * @since 0.14.0
- */
-type ConditionalTransitionResult<
+/** Captures one exact named-branch topology while preserving handler inference. */
+type BranchingTransitionResult<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
   StateId extends Machine.StateNodeIdentifier<States>,
   Context,
   Reenter extends boolean,
-  Cases extends readonly [
-    TransitionCaseTyped,
-    ...ReadonlyArray<TransitionCaseTyped>
-  ],
-  OtherwiseSelection extends Machine.TargetSelection<any, any, any>
+  Branches extends Readonly<Record<string, Machine.TransitionBranchInput>>
 > =
-  & Omit<
-    Machine.TransitionConditionalInput<
-      States,
-      Events,
-      Emits,
-      StateId,
-      Context,
-      Reenter,
-      Cases,
-      OtherwiseSelection
-    >,
-    "cases"
-  >
-  & { readonly cases: Cases }
+  & Machine.TransitionBranchesInput<States, Events, Emits, StateId, Context, Reenter, Branches>
   & Machine.TransitionTyped<States, Events, Emits, StateId, Context, Reenter>
 
+type TransitionBranchRecordError<Message extends string, Key extends PropertyKey = never> = {
+  readonly "~effect/Machine/TransitionBranchRecordError": Message
+  readonly key: Key
+}
+
+type InvalidStaticTransitionBranchKey<Branches> = Extract<keyof Branches, "" | number | symbol>
+
+type ValidateTransitionBranchRecord<Branches> = [keyof Branches] extends [never] ?
+  TransitionBranchRecordError<"Branch records must contain at least one branch">
+  : [InvalidStaticTransitionBranchKey<Branches>] extends [never] ? unknown
+  : TransitionBranchRecordError<
+    "Branch keys must be non-empty, non-index strings",
+    InvalidStaticTransitionBranchKey<Branches>
+  >
+
 /**
- * Contextually types direct and conditional transition definitions.
+ * Contextually types direct and branching transition definitions.
  *
  * @category constructors
  * @since 0.14.0
@@ -7593,32 +8011,28 @@ export interface TransitionConstructor {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateNodeIdentifier<States>,
     Context,
-    const Cases extends readonly [
-      TransitionCaseTyped,
-      ...ReadonlyArray<TransitionCaseTyped>
-    ],
-    const OtherwiseSelection extends Machine.TargetSelection<any, any, any>,
+    const Branches extends Readonly<Record<string, Machine.TransitionBranchInput>>,
     Reenter extends boolean = never
   >(
-    config: Machine.TransitionConditionalInput<
-      States,
-      Events,
-      Emits,
-      StateId,
-      Context,
-      Reenter,
-      Cases,
-      OtherwiseSelection
-    >
-  ): ConditionalTransitionResult<
+    config:
+      & Machine.TransitionBranchesInput<
+        States,
+        Events,
+        Emits,
+        StateId,
+        Context,
+        Reenter,
+        Branches
+      >
+      & ValidateTransitionBranchRecord<NoInfer<Branches>>
+  ): BranchingTransitionResult<
     States,
     Events,
     Emits,
     StateId,
     Context,
     Reenter,
-    Cases,
-    OtherwiseSelection
+    Branches
   >
 }
 
@@ -7627,9 +8041,9 @@ export interface TransitionConstructor {
  *
  * It is required for every event, lifecycle, choice, and invocation transition
  * so the destination selected by `target` can contextually type the
- * corresponding resolver. Conditional transitions use the locally bound
- * `branch` constructor so every case independently infers its matched value and
- * selected destination, with no limit on the number of cases.
+ * corresponding resolver. Branching transitions declare every possible
+ * destination up front, then select one through ordinary TypeScript control
+ * flow in `resolve`.
  *
  * ```ts
  * Machine.transition({
@@ -7638,31 +8052,61 @@ export interface TransitionConstructor {
  * })
  *
  * Machine.transition({
- *   cases: (branch) => [
- *     branch({
- *       title: "has cached data",
- *       when: ({ event }) => event.cached,
- *       target: (to) => to.full.Ready(),
- *       resolve: ({ match, target }) => target.from({ data: match })
- *     })
- *   ],
- *   otherwise: {
- *     target: (to) => to.full.Loading(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   branches: (to) => ({
+ *     cached: { target: to.full.Ready() },
+ *     loading: { target: to.full.Loading() }
+ *   }),
+ *   resolve: ({ event, select }) => event.cached
+ *     ? select.cached.from({ data: event.cached })
+ *     : select.loading.from()
  * })
  * ```
  *
  * @category constructors
  * @since 0.14.0
  */
-export const transition: TransitionConstructor = ((config: unknown) => {
-  if (!hasProperty(config, "cases") || typeof config.cases !== "function") return config
-  return {
-    ...config,
-    cases: config.cases(<Case extends object>(branch: Case): Case => branch)
-  }
-}) as TransitionConstructor
+export const transition: TransitionConstructor = ((config: unknown) => config) as TransitionConstructor
+
+/**
+ * Sentinel used by direct targetless transition shorthands.
+ *
+ * This is the concise form of `target: (to) => to.none()`.
+ *
+ * ```ts
+ * onElement: {
+ *   target: Machine.targetless,
+ *   resolve: ({ element }, enqueue) => {
+ *     enqueue.raise(new MeasurementReceived({ value: element }))
+ *   }
+ * }
+ *
+ * onDone: { target: Machine.targetless }
+ * ```
+ *
+ * @category constructors
+ * @since 0.16.0
+ */
+export interface TargetlessSelector {
+  readonly "~effect/Machine/TargetlessSelector": true
+  <
+    const States extends Machine.StateSchemas,
+    StateId extends Machine.StateNodeIdentifier<States>
+  >(to: Machine.TargetSelector<States, StateId>): ReturnType<Machine.TargetSelector<States, StateId>["none"]>
+}
+
+/**
+ * Selects no transition target while keeping enqueue operations explicit.
+ *
+ * Use as the `target` of a direct handler object when the handler should keep
+ * the current state configuration and only raise, emit, or send events.
+ *
+ * @category constructors
+ * @since 0.16.0
+ */
+export const targetless: TargetlessSelector = Object.assign(
+  (to: Machine.TargetSelector<any, any>) => to.none(),
+  { "~effect/Machine/TargetlessSelector": true as const }
+)
 
 /**
  * Machine-bound invocation constructor that preserves the owning machine's
@@ -7777,6 +8221,73 @@ export interface Invoker<
         readonly onFailure?: never
       }
   ): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<unknown, unknown, any>
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      },
+    ..._validation: InvokeChannelIsNever<Stream.Success<ReturnType<Source>>> extends true ? [
+        "onElement must be omitted when the Stream element is never"
+      ]
+      : InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
+          "onFailure must be omitted when the Stream error is never"
+        ]
+      : []
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<never, unknown, any>
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement?: never
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      },
+    ..._validation: InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
+        "onFailure must be omitted when the Stream error is never"
+      ]
+      : []
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<never, never, any>
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement?: never
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure?: never
+      }
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<unknown, never, any>
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure?: never
+      }
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <StateId extends Machine.StateIdentifier<States>, const Config extends object>(
     config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>
   ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
@@ -7883,25 +8394,27 @@ export interface Invoker<
 /**
  * Preserves inference for a state-owned invocation configuration.
  *
- * Use `effect` for one-shot work, `after` for a cancellable timer, `logic` for
- * reusable process logic, or `child` for a complete child machine. `onDone` is
- * required whenever the source can complete with an output, while `onFailure`
- * is required only when the source has a typed failure channel.
+ * Use `effect` for one-shot work, `stream` for repeated values, `after` for a
+ * cancellable timer, `logic` for reusable process logic, or `child` for a
+ * complete child machine. Stream elements are handled by `onElement` before
+ * the next element is pulled. `onDone` is required whenever the source can
+ * complete, while `onFailure` is required only when the source has a typed
+ * failure channel.
  *
  * This constructor is an identity at runtime, but preserves lifecycle callback
- * inference through published declarations. Effect factories run when their
- * owning state is entered and infer the owner context, output, error, and
- * service channels together without a return annotation. Durations may be
+ * inference through published declarations. Effect and Stream factories run
+ * when their owning state is entered and infer the owner context, value,
+ * output, error, and service channels together without a return annotation.
+ * Durations may be
  * supplied directly or derived from the owning state's entry context. Logic
  * invocations require both a lifecycle `id` and a typed communication
  * `address`. Child descriptors already own their identity, so `id` and
  * `address` must not be repeated.
  *
- * Owner references are intentionally non-sendable here because this standalone
- * constructor does not know the owning definition. When a callback sends to
- * `self` or `parent`, use the bound constructor on the owning definition
- * (`definition.invoke(...)`) so the exact public input and `parentEvents`
- * protocols are available.
+ * Inside `handle(...)`, the owning definition contextually supplies its public
+ * input and `parentEvents` protocols. Invocation sources and lifecycle handlers
+ * can therefore send through `self` and `parent` without naming the definition.
+ * The bound `definition.invoke(...)` constructor remains an equivalent form.
  *
  * ```ts
  * invoke: Machine.invoke({
@@ -7932,14 +8445,16 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
-    ) => Effect.Effect<unknown, unknown, unknown>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<unknown, unknown, unknown>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & EffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
-        readonly onDone: EffectDoneHandler<States, Events, Emits, StateId, Source>
-        readonly onFailure: EffectFailureHandler<States, Events, Emits, StateId, Source>
+        readonly onDone: EffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+        readonly onFailure: EffectFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       },
     ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
         "onDone must be omitted when the Effect output is never"
@@ -7948,71 +8463,166 @@ export const invoke: {
           "onFailure must be omitted when the Effect error is never"
         ]
       : []
-  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
-    ) => Effect.Effect<unknown, never, unknown>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<unknown, never, unknown>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & EffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
-        readonly onDone: EffectDoneHandler<States, Events, Emits, StateId, Source>
+        readonly onDone: EffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
         readonly onFailure?: never
       },
     ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
         "onDone must be omitted when the Effect output is never"
       ]
       : []
-  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
-    ) => Effect.Effect<never, unknown, unknown>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<never, unknown, unknown>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & EffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
         readonly onDone?: never
-        readonly onFailure: EffectFailureHandler<States, Events, Emits, StateId, Source>
+        readonly onFailure: EffectFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       },
     ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
         "onFailure must be omitted when the Effect error is never"
       ]
       : []
-  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
-    ) => Effect.Effect<never, never, unknown>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<never, never, unknown>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & EffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
         readonly onDone?: never
         readonly onFailure?: never
       }
-  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
-    const Config extends object
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<unknown, unknown, any>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
-    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, readonly [], readonly []>
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      },
+    ..._validation: InvokeChannelIsNever<Stream.Success<ReturnType<Source>>> extends true ? [
+        "onElement must be omitted when the Stream element is never"
+      ]
+      : InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
+          "onFailure must be omitted when the Stream error is never"
+        ]
+      : []
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    const States extends Machine.StateSchemas,
+    const Events extends ReadonlyArray<Machine.TaggedSchema>,
+    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<never, unknown, any>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement?: never
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      },
+    ..._validation: InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
+        "onFailure must be omitted when the Stream error is never"
+      ]
+      : []
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    const States extends Machine.StateSchemas,
+    const Events extends ReadonlyArray<Machine.TaggedSchema>,
+    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<never, never, any>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement?: never
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure?: never
+      }
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    const States extends Machine.StateSchemas,
+    const Events extends ReadonlyArray<Machine.TaggedSchema>,
+    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<unknown, never, any>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure?: never
+      }
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    const States extends Machine.StateSchemas,
+    const Events extends ReadonlyArray<Machine.TaggedSchema>,
+    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
+    StateId extends Machine.StateIdentifier<States>,
+    const Config extends object,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+  >(
+    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>
   ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
   <
     const States extends Machine.StateSchemas,
@@ -8025,7 +8635,9 @@ export const invoke: {
     ChildRequirements,
     ChildOutput,
     ChildInitialError,
-    Address extends ChildAddress<never>
+    Address extends ChildAddress<never>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config: Machine.LogicInvokeArgs<
       States,
@@ -8039,7 +8651,7 @@ export const invoke: {
       ChildOutput,
       ChildInitialError,
       Address,
-      (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Logic<
+      (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Logic<
         ChildState,
         ChildEvent,
         ChildError,
@@ -8047,11 +8659,11 @@ export const invoke: {
         ChildOutput,
         ChildInitialError
       >,
-      readonly [],
-      readonly []
+      InputEvents,
+      ParentEvents
     >
   ):
-    & Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []>
+    & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
     & Machine.InvokeTyped<
       ChildOutput,
       ChildError,
@@ -8070,7 +8682,9 @@ export const invoke: {
     ChildOutput,
     ChildInitialError,
     Address extends ChildAddress<never>,
-    const Config extends object
+    const Config extends object,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
       & Config
@@ -8087,8 +8701,8 @@ export const invoke: {
         ChildInitialError,
         Address,
         Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
-        readonly [],
-        readonly []
+        InputEvents,
+        ParentEvents
       >
   ):
     & Config
@@ -8105,11 +8719,13 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Child extends ChildMachine.Any,
-    const Config extends object
+    const Config extends object,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
       & Config
-      & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, readonly [], readonly []>
+      & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, InputEvents, ParentEvents>
   ):
     & Config
     & Machine.InvokeOwned<States, Events, Emits, StateId>
@@ -8147,7 +8763,7 @@ export const invoke: {
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
@@ -8282,9 +8898,8 @@ export const initialDefinition: <M extends Machine.Any>(machine: M) => Machine.I
  *
  * Event handlers retain their handler-key order within each source state and
  * are followed by eventless and completion handlers. This function does not
- * execute predicates or resolvers. Every direct, conditional, fallback, and
- * targetless branch exposes the destination selected by its required static
- * `target` declaration.
+ * execute resolvers. Every direct, named, and targetless branch exposes the
+ * destination selected by its required static `target` declaration.
  *
  * @category getters
  * @since 0.4.0
@@ -8403,7 +9018,7 @@ export const enabled: <
  * class Off extends Schema.TaggedClass<Off>("Off")("Off", {}) {}
  * class On extends Schema.TaggedClass<On>("On")("On", {}) {}
  * class Toggle extends Schema.TaggedClass<Toggle>("Toggle")("Toggle", {}) {}
- * const States = Machine.defineStates({ Off, On })
+ * const States = Machine.states({ Off, On })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(Toggle),
@@ -8786,7 +9401,7 @@ export const prepare: <
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
@@ -8899,7 +9514,7 @@ export const start: <
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),