@typeonce/effect-machine 0.14.1 → 0.16.0

package/dist/Machine.d.ts

@@ -41,7 +41,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;
 declare const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId;
 /**
  * Type identifier used for the synthetic event passed to startup lifecycle
@@ -77,7 +76,7 @@ export declare const InitialEvent: InitialEvent;
 export declare const isInitialEvent: (u: unknown) => u is InitialEvent;
 type IsAny<A> = 0 extends (1 & A) ? true : false;
 /**
- * A schema-first machine definition.
+ * A schema-first machine implementation.
  *
  * **Details**
  *
@@ -157,20 +156,9 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
     /** @internal */
     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.
-     *
-     * @since 0.4.0
-     */
-    readonly handle: Machine.Handler<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents>;
-    /**
-     * 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`.
+     * 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
      */
@@ -180,6 +168,48 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
     /** @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
+     */
+    readonly handle: Machine.Handler<States, Events, Emits, Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, FinalStates, Output, never, InputEvents, ParentEvents>;
+}
+/**
+ * Namespace containing type-level members associated with {@link Definition}.
+ *
+ * @category models
+ * @since 0.15.0
+ */
+export declare namespace Definition {
+    /**
+     * Any schema-first machine definition.
+     *
+     * @category models
+     * @since 0.15.0
+     */
+    interface Any extends Machine.Any {
+        readonly handle: any;
+    }
+}
 export { 
 /**
  * Error returned by `spawn` when a child process with the same id already
@@ -467,7 +497,7 @@ type ValidateCompoundStateNode<Node extends Machine.StateNodeConfig, Children ex
     readonly initial: infer Initial;
 } ? 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"> : Node extends {
     readonly type: infer Type;
 } ? Type extends "final" ? ValidateOutputSchema<Node> : Type extends "active" | undefined ? "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown : StateDefinitionError<"State node type must be active, final, or parallel"> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown;
@@ -491,7 +521,15 @@ type ValidateDefinedStates<States extends Machine.StateSchemas> = [States] exten
 type InvalidDefinedStateTreeInput<States extends Machine.StateSchemas> = [States] extends [
     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>>): Machine.DefinedStates<States>;
     <const States extends Machine.StateSchemas>(states: InvalidDefinedStateTreeInput<States>): never;
 }
@@ -981,9 +1019,9 @@ 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. */
     interface ActivityStarted extends Base {
         readonly _tag: "ActivityStarted";
         readonly activity: Activity;
@@ -1399,8 +1437,6 @@ export declare namespace Machine {
         /** @internal */
         readonly handlers: any;
         /** @internal */
-        readonly handle: any;
-        /** @internal */
         readonly invoke: any;
         /** @internal */
         readonly initial: any;
@@ -1773,12 +1809,12 @@ export declare namespace Machine {
      */
     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**
      *
@@ -1790,7 +1826,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**
      *
@@ -1802,8 +1838,17 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     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
@@ -1968,7 +2013,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. */
     interface TransitionTargetSelection<Path extends string | undefined = string | undefined, Kind extends Topology.TargetSelectionKind = Topology.TargetSelectionKind, Scope extends Topology.TargetSelectionScope | undefined = Topology.TargetSelectionScope | undefined> {
@@ -1982,14 +2027,11 @@ export declare namespace Machine {
         readonly target: Path | undefined;
         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. */
     interface InitialDefinition<Path extends string = string> {
@@ -2001,8 +2043,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
@@ -2038,6 +2080,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;
         /**
@@ -2898,6 +2942,16 @@ export declare namespace Machine {
         readonly target: TargetBuilder<States, StateId>;
         readonly output: Output;
     }
+    /** Context passed to a Stream invocation's element transition. */
+    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. */
     interface InvokeFailureContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Error, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly id: string;
@@ -3090,13 +3144,9 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type EventTransitionReturn<Transition> = (Transition extends {
+    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);
+    } ? NonNullable<Resolve> extends (...args: any) => infer Ret ? Ret : never : never;
     /**
      * Extracts the return value from a state's event handlers.
      *
@@ -3129,6 +3179,8 @@ export declare namespace Machine {
     type InvokeLogic<Invoke> = Invoke extends {
         readonly effect: infer Source;
     } ? InvokeFactoryResult<Source> extends infer Fx extends Effect.Effect<any, any, any> ? Logic<void, never, Effect.Error<Fx>, Effect.Services<Fx>, 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;
@@ -3205,6 +3257,8 @@ export declare namespace Machine {
         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;
@@ -3256,7 +3310,6 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type ConfigServices<Config> = Effect.Services<EventHandlerReturn<Config>> | Effect.Services<AlwaysReturn<Config>> | Effect.Services<DoneReturn<Config>> | Effect.Services<StateActionReturn<Config, "entry">> | Effect.Services<StateActionReturn<Config, "exit">> | Effect.Services<HistoryDefaultReturn<Config>> | Effect.Services<ChoiceReturn<Config>> | InvokeRequirements<Config>;
-    type TransitionWhenContext<Context> = Omit<Context, "target">;
     /** Type evidence retained by {@link transition} without affecting runtime data. */
     interface TransitionTyped<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean> {
         readonly [TransitionTypeId]: {
@@ -3270,9 +3323,19 @@ export declare namespace Machine {
         };
     }
     /** The only transition value accepted by machine handler APIs. */
-    type TransitionConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean = false> = (TransitionTyped<States, Events, Emits, StateId, Context, Reenter> | TargetlessTransitionTyped) & {
+    type TransitionConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean = false> = (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. */
+    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;
+    }
+    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;
+    };
     type SelectionBuilder<Selection> = Selection extends TargetSelection<infer Builder, any, any> ? Builder : never;
     type SelectionKind<Selection> = Selection extends TargetSelection<any, any, infer Kind> ? Kind : never;
     type SelectionPath<Selection> = Selection extends TargetSelection<any, infer Path, any> ? Path : never;
@@ -3280,33 +3343,61 @@ export declare namespace Machine {
         readonly from: (...args: any) => infer Result;
     } ? Result : never);
     type SelectedTargetResult<Selection> = SelectionBuilder<Selection> extends infer Builder ? TargetBuilderResult<Builder> : never;
-    type TransitionResolveContext<Context, Selection, Match = never> = Omit<Context, "target"> & ([Match] extends [never] ? {} : {
-        readonly match: Match;
-    }) & (SelectionKind<Selection> extends "none" ? {} : {
+    type TransitionResolveContext<Context, Selection> = Omit<Context, "target"> & (SelectionKind<Selection> extends "none" ? {} : {
         readonly target: SelectionBuilder<Selection>;
     });
-    type TransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection, Match = never> = (context: TransitionResolveContext<Context, Selection, Match>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined;
+    type TransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined;
     type TransitionDirectInput<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, any>> = {
         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;
     };
-    type TransitionCaseInput<States extends StateSchemas, 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;
+    /** One named destination declared by a branching transition. */
+    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. */
+    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];
     };
-    type TransitionConditionalInput<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>> = {
+    /** Target-specific builder that brands every construction with its branch key. */
+    type SelectedBranchBuilder<Builder, Key extends string> = SelectedBranchCallable<Builder, Key> & SelectedBranchBuilderProperties<Builder, Key>;
+    type BranchSelectors<Branches extends Readonly<Record<string, TransitionBranchInput>>> = {
+        readonly [Key in Extract<keyof Branches, string>]: SelectedBranchBuilder<SelectionBuilder<Branches[Key]["target"]>, Key>;
+    };
+    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>];
+    type TransitionBranchesResolveContext<Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = Omit<Context, "target"> & {
+        readonly select: BranchSelectors<Branches>;
+    };
+    type TransitionBranchesResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = (context: TransitionBranchesResolveContext<Context, Branches>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => BranchSelectionResult<Branches>;
+    type TransitionBranchesInput<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, 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;
     };
     type InvokeTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context> = TransitionConfig<States, Events, Emits, StateId, Context, true>;
@@ -3329,32 +3420,50 @@ export declare namespace Machine {
     type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = InvokeOwned<States, Events, Emits, StateId> & ({
         readonly id: string;
         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;
     } | {
         readonly id: string;
         readonly after: InvokeSource<Duration.Input, 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;
     } | {
         readonly id: string;
         readonly address: string;
         readonly logic: InvokeSource<Logic<any, any, any, any, any, any>, 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;
     } | {
         readonly child: ChildMachine.Any;
@@ -3362,10 +3471,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;
     });
     /** State-bound inline invocation configuration. */
@@ -3392,14 +3503,23 @@ export declare namespace Machine {
     } : {
         readonly onFailure?: never;
     } : never;
+    type InvokeElementRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends infer Requirement ? Requirement extends {
+        readonly handler: infer Required;
+    } ? {
+        readonly onElement: Required;
+    } : {
+        readonly onElement?: never;
+    } : never;
     type TimerInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         readonly id: InvokeLifecycleId;
         readonly after: InvokeSource<Duration.Input, 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, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
     };
@@ -3408,8 +3528,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, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, NoInfer<ChildState>, NoInfer<ChildError>, NoInfer<ChildOutput>, InputEvents, ParentEvents>>;
     } & InvokeDoneRequirement<NoInfer<ChildOutput>, InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, NoInfer<ChildOutput>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<NoInfer<ChildError>, InvokeTransition<States, Events, Emits, StateId, InvokeFailureContext<States, Events, Emits, StateId, NoInfer<ChildError>, InputEvents, ParentEvents>>>;
     type ChildInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildDefinition extends Machine.Any, Child extends ChildMachine<string, ChildDefinition>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
@@ -3417,8 +3539,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, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>;
     } & (Input<ChildDefinition> extends typeof Schema.Void ? {
         readonly input?: never;
@@ -3443,6 +3567,12 @@ export declare namespace Machine {
         readonly effect: infer Source;
     } ? InvokeFactoryResult<Source> extends infer Fx extends Effect.Effect<any, any, any> ? InvokeDoneRequirement<Effect.Success<Fx>, InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Effect.Error<Fx>, InvokeTransition<States, Events, Emits, StateId, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>>> & {
         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;
     } ? {
@@ -3693,7 +3823,7 @@ export declare namespace Machine {
             readonly [Key in UnknownKeys]: HandlerValidationError<"Handler config contains an event key that does not exist", StateId, Key>;
         };
     } : unknown;
-    type TransitionResultInitialTargetPath<Result> = IsAny<Result> extends true ? never : Result extends Effect.Effect<infer Success, any, any> ? TransitionResultInitialTargetPath<Success> : Result extends StateConstruction<infer Constructed> ? TransitionResultInitialTargetPath<Constructed> : Result extends {
+    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;
         readonly _tag: "InitialTarget";
     } ? Result extends {
@@ -3818,6 +3948,13 @@ export declare namespace Machine {
      */
     type StateConfigs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, StateConfig<States, Events, Emits, StateId, EventTag, E, R> | ChoiceStateConfig<States, Events, Emits, ChoiceIdentifier<States>>>>;
 }
+/**
+ * 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`.
  *
@@ -3833,7 +3970,43 @@ export declare const isMachine: (u: unknown) => u is Machine.Any;
  */
 export declare const isFinal: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, state: Machine.Snapshot<States>) => state is Machine.SnapshotContainingFinal<States, FinalStates>;
 /**
- * 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 declare const state: StateConstructor;
+/**
+ * Defines the complete state tree while preserving literal state paths.
  *
  * **When to use**
  *
@@ -3842,7 +4015,8 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *
  * **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,
@@ -3856,7 +4030,7 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *
  * 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,
@@ -3871,7 +4045,7 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  * @category constructors
  * @since 0.4.0
  */
-export declare const defineStates: DefineStates;
+export declare const states: StatesConstructor;
 type InitialDirectInput<States extends Machine.StateSchemas, Input, Selection extends Machine.TargetSelection<any, any, any>> = {
     readonly target: (to: Machine.InitialSelector<States>) => Selection;
     readonly resolve?: (context: {
@@ -3891,7 +4065,7 @@ type MakeConfig<States extends Machine.StateSchemas, InputEvents extends Readonl
     readonly input?: Input;
     readonly initial: unknown;
 };
-type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = Machine<States, readonly [...InputEvents, ...InternalEvents], Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, never, InputEvents, ParentEvents>;
+type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = Definition<States, readonly [...InputEvents, ...InternalEvents], Input, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, InputEvents, ParentEvents>;
 interface Make {
     <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const InitialSelection extends Machine.TargetSelection<any, any, any> = Machine.TargetSelection<any, any, any>>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "initial"> & {
         readonly initial: InitialDirectInput<States, Input["Type"], InitialSelection>;
@@ -3908,7 +4082,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`
@@ -3933,7 +4107,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({
@@ -3956,7 +4130,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
  */
@@ -3980,9 +4154,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
@@ -4003,11 +4182,16 @@ export declare 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
@@ -4023,6 +4207,17 @@ export declare 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
  */
@@ -4060,7 +4255,7 @@ export declare 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(),
@@ -4107,7 +4302,7 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * 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(),
@@ -4129,72 +4324,76 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * @since 0.4.0
  */
 export declare const decodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
-type EffectInvokeSource<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Effect.Effect<unknown, unknown, unknown>> = {
+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, 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;
+};
+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<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
+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<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
+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, InputEvents, ParentEvents> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, 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 EffectDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, readonly [], readonly []>>;
-type EffectFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, readonly [], readonly []>>;
-type EffectInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits 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.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, 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<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, 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;
 };
 type BoundEffectDoneHandler<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<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
 type BoundEffectFailureHandler<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<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
 type BoundEffectInvokeResult<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, InputEvents, ParentEvents> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, 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<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>> = Omit<Machine.TransitionConditionalInput<States, Events, Emits, StateId, Context, Reenter, Cases, OtherwiseSelection>, "cases"> & {
-    readonly cases: Cases;
-} & Machine.TransitionTyped<States, Events, Emits, StateId, Context, Reenter>;
+/** 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, Branches extends Readonly<Record<string, Machine.TransitionBranchInput>>> = 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
  */
 export interface TransitionConstructor {
     <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateNodeIdentifier<States>, Context, const Selection extends Machine.TargetSelection<any, any, any>, Reenter extends boolean = never>(config: Machine.TransitionDirectInput<States, Events, Emits, StateId, Context, Reenter, Selection>): Machine.TransitionDirectInput<States, Events, Emits, StateId, Context, Reenter, Selection> & (Machine.SelectionKind<Selection> extends "none" ? Machine.TargetlessTransitionTyped : Machine.TransitionTyped<States, Events, Emits, StateId, Context, Reenter>);
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, 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>, Reenter extends boolean = never>(config: Machine.TransitionConditionalInput<States, Events, Emits, StateId, Context, Reenter, Cases, OtherwiseSelection>): ConditionalTransitionResult<States, Events, Emits, StateId, Context, Reenter, Cases, OtherwiseSelection>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateNodeIdentifier<States>, Context, const Branches extends Readonly<Record<string, Machine.TransitionBranchInput>>, Reenter extends boolean = never>(config: Machine.TransitionBranchesInput<States, Events, Emits, StateId, Context, Reenter, Branches> & ValidateTransitionBranchRecord<NoInfer<Branches>>): BranchingTransitionResult<States, Events, Emits, StateId, Context, Reenter, Branches>;
 }
 /**
  * Defines a statically inspectable transition.
  *
  * 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({
@@ -4203,18 +4402,13 @@ 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()
  * })
  * ```
  *
@@ -4222,6 +4416,39 @@ export interface TransitionConstructor {
  * @since 0.14.0
  */
 export declare const transition: 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 declare const targetless: TargetlessSelector;
 /**
  * Machine-bound invocation constructor that preserves the owning machine's
  * public input and parent protocols in every invocation callback.
@@ -4254,6 +4481,32 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
         readonly onDone?: never;
         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>;
     <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown, Address extends ChildAddress<never>>(config: {
         readonly logic: Source;
@@ -4276,25 +4529,27 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
 /**
  * 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({
@@ -4319,34 +4574,60 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
  * @since 0.9.0
  */
 export declare const invoke: {
-    <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, unknown, unknown>>(config: EffectInvokeSource<States, Events, Emits, StateId, Source> & {
-        readonly onDone: EffectDoneHandler<States, Events, Emits, StateId, Source>;
-        readonly onFailure: EffectFailureHandler<States, Events, Emits, 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>) => Effect.Effect<unknown, unknown, unknown>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, 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"
     ] : InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
         "onFailure must be omitted when the Effect error is never"
-    ] : []): EffectInvokeResult<States, Events, Emits, 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>>(config: EffectInvokeSource<States, Events, Emits, StateId, Source> & {
-        readonly onDone: EffectDoneHandler<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, 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, InputEvents, ParentEvents, 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>;
-    <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>>(config: EffectInvokeSource<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, 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, 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>;
-    <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>>(config: EffectInvokeSource<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, 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, InputEvents, ParentEvents, StateId, Source> & {
         readonly onDone?: never;
         readonly onFailure?: never;
-    }): EffectInvokeResult<States, Events, Emits, 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>(config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, readonly [], readonly []>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>>(config: Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, readonly [], readonly []>): Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object>(config: Config & Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, readonly [], readonly []>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, readonly [], readonly []>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
+    }): 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, InputEvents, ParentEvents>) => Stream.Stream<unknown, 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: 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, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, InputEvents, ParentEvents>): Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, 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, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
 };
 /**
  * Plans the initial state for a machine without executing machine commands.
@@ -4373,7 +4654,7 @@ export declare 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(),
@@ -4448,9 +4729,8 @@ export declare const initialDefinition: <M extends Machine.Any>(machine: M) => M
  *
  * 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
@@ -4515,7 +4795,7 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * 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),
@@ -4722,7 +5002,7 @@ export declare const prepare: <const States extends Machine.StateSchemas, const
  * 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(),
@@ -4775,7 +5055,7 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * 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(),