@typeonce/effect-machine 0.15.0 → 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
@@ -1020,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;
@@ -2014,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> {
@@ -2028,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> {
@@ -2047,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
@@ -2084,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;
         /**
@@ -2944,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;
@@ -3136,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.
      *
@@ -3175,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;
@@ -3251,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;
@@ -3302,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]: {
@@ -3316,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;
@@ -3326,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];
+    };
+    /** 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 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>> = {
+    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>;
@@ -3375,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;
@@ -3408,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. */
@@ -3438,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>>;
     };
@@ -3454,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 []> = {
@@ -3463,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;
@@ -3489,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;
     } ? {
@@ -3739,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 {
@@ -4243,69 +4327,73 @@ export declare const decodeSnapshot: <const States extends Machine.StateSchemas,
 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 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({
@@ -4314,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()
  * })
  * ```
  *
@@ -4333,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.
@@ -4365,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;
@@ -4387,15 +4529,18 @@ 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
@@ -4453,6 +4598,32 @@ export declare const invoke: {
         readonly onDone?: never;
         readonly onFailure?: never;
     }): 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>;
@@ -4558,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