@typeonce/effect-machine 0.15.0 → 0.16.0

package/src/Machine.ts

@@ -53,7 +53,6 @@ declare const MachineTypeId: unique symbol
 declare const EventConstructionTypeId: unique symbol
 declare const EmittedEventConstructionTypeId: unique symbol
 declare const EventProtocolTypeId: unique symbol
-declare const TransitionCaseTypeId: unique symbol
 
 const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId = internal.ChildMachineLogicTypeId
 
@@ -1953,10 +1952,10 @@ export declare namespace Inspection {
     readonly sessionId: string
     readonly owner: Subject
     readonly ownerPath: string
-    readonly kind: "Effect" | "Timer"
+    readonly kind: "Effect" | "Stream" | "Timer"
   }
 
-  /** Announces an Effect or timer invocation starting. */
+  /** Announces an Effect, Stream, or timer invocation starting. */
   export interface ActivityStarted extends Base {
     readonly _tag: "ActivityStarted"
     readonly activity: Activity
@@ -3252,7 +3251,7 @@ export declare namespace Machine {
     | {
       readonly type: "invoke"
       readonly id: string
-      readonly outcome: "done" | "failure" | "snapshot"
+      readonly outcome: "element" | "done" | "failure" | "snapshot"
     }
 
   /** Static topology selected by a transition branch. */
@@ -3274,16 +3273,12 @@ export declare namespace Machine {
       readonly selection: TransitionTargetSelection<Path | undefined>
     }
     | {
-      readonly type: "case"
+      readonly type: "branch"
+      readonly key: string
       readonly title: string
       readonly target: Path | undefined
       readonly selection: TransitionTargetSelection<Path | undefined>
     }
-    | {
-      readonly type: "otherwise"
-      readonly target: Path | undefined
-      readonly selection: TransitionTargetSelection<Path | undefined>
-    }
 
   /** The statically selected root entry for machine startup. */
   export interface InitialDefinition<Path extends string = string> {
@@ -3296,8 +3291,8 @@ export declare namespace Machine {
    *
    * **Details**
    *
-   * Every branch exposes its selected target without executing its predicate
-   * or resolver. A compound local or branch target covers its descendants;
+   * Every branch exposes its selected target without executing its resolver.
+   * A compound local or branch target covers its descendants;
    * `undefined` identifies an explicitly targetless branch.
    *
    * @category models
@@ -3343,6 +3338,8 @@ export declare namespace Machine {
     readonly reenter: boolean
     /** Zero-based index of the selected static branch. */
     readonly branchIndex: number
+    /** Stable key of a named branch, or `undefined` for a direct transition. */
+    readonly branchKey: string | undefined
     /** Path returned by the handler, including a choice or history pseudo-state. */
     readonly target: TargetPath | undefined
     /**
@@ -4651,6 +4648,25 @@ export declare namespace Machine {
     readonly output: Output
   }
 
+  /** Context passed to a Stream invocation's element transition. */
+  export interface InvokeElementContext<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    Element,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > extends MachineReferences<InputEvents, ParentEvents> {
+    readonly id: string
+    readonly state: StateByIdentifier<States, StateId>
+    readonly containingState: ParentStateValue<States, StateId>
+    readonly ancestors: ParentStateValues<States, StateId>
+    readonly snapshot: Snapshot<States>
+    readonly target: TargetBuilder<States, StateId>
+    readonly element: Element
+  }
+
   /** Context passed to an invocation typed-failure transition. */
   export interface InvokeFailureContext<
     States extends StateSchemas,
@@ -4931,14 +4947,9 @@ export declare namespace Machine {
    * @category utility types
    * @since 0.4.0
    */
-  export type EventTransitionReturn<Transition> =
-    | (Transition extends { readonly resolve?: infer Resolve } ?
-      NonNullable<Resolve> extends (...args: any) => infer Ret ? Ret : never
-      : never)
-    | (Transition extends { readonly cases: infer Cases extends ReadonlyArray<unknown> } ?
-      EventTransitionReturn<Cases[number]>
-      : never)
-    | (Transition extends { readonly otherwise: infer Otherwise } ? EventTransitionReturn<Otherwise> : never)
+  export type EventTransitionReturn<Transition> = Transition extends { readonly resolve?: infer Resolve } ?
+    NonNullable<Resolve> extends (...args: any) => infer Ret ? Ret : never
+    : never
   /**
    * Extracts the return value from a state's event handlers.
    *
@@ -5003,6 +5014,15 @@ export declare namespace Machine {
         Effect.Success<Fx>
       >
     : never
+    : Invoke extends { readonly stream: infer Source } ?
+      InvokeFactoryResult<Source> extends infer SourceStream extends Stream.Stream<any, any, any> ? Logic<
+          void,
+          never,
+          Stream.Error<SourceStream>,
+          Stream.Services<SourceStream>,
+          void
+        >
+      : never
     : Invoke extends { readonly after: unknown } ? Logic<void, never, never, never, void>
     : Invoke extends { readonly logic: infer Source } ? InvokeResolvedSource<Source>
     : Invoke extends { readonly child: infer Child } ? ChildMachineLogic<Child>
@@ -5074,6 +5094,7 @@ export declare namespace Machine {
   export type InvokeOutcomeReturn<Invoke> = Invoke extends unknown ?
       | (Invoke extends { readonly onDone?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
       | (Invoke extends { readonly onFailure?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
+      | (Invoke extends { readonly onElement?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
       | (Invoke extends { readonly onSnapshot?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
     : never
   /**
@@ -5144,8 +5165,6 @@ export declare namespace Machine {
     | Effect.Services<ChoiceReturn<Config>>
     | InvokeRequirements<Config>
 
-  type TransitionWhenContext<Context> = Omit<Context, "target">
-
   /** Type evidence retained by {@link transition} without affecting runtime data. */
   export interface TransitionTyped<
     States extends StateSchemas,
@@ -5176,11 +5195,40 @@ export declare namespace Machine {
     Context,
     Reenter extends boolean = false
   > =
-    & (TransitionTyped<States, Events, Emits, StateId, Context, Reenter> | TargetlessTransitionTyped)
+    & (
+      | TransitionTyped<States, Events, Emits, StateId, Context, Reenter>
+      | TargetlessTransitionTyped
+      | TargetlessTransitionInput<Events, Emits, Context>
+    )
     & {
       readonly reenter?: [Reenter] extends [true] ? boolean : never
     }
 
+  /** Direct shorthand for a non-reentering targetless transition. */
+  // Keep the context generic so omitting `target` is deferred until a resolver
+  // is actually authored instead of expanding every TransitionConfig eagerly.
+  interface TargetlessTransitionResolver<
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    Context
+  > {
+    <ResolvedContext extends Omit<Context, "target">>(
+      context: ResolvedContext,
+      enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
+    ): undefined
+  }
+
+  export type TargetlessTransitionInput<
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    Context
+  > = {
+    readonly target: TargetlessSelector
+    readonly resolve?: TargetlessTransitionResolver<Events, Emits, Context>
+    readonly branches?: never
+    readonly reenter?: never
+  }
+
   export type SelectionBuilder<Selection> = Selection extends TargetSelection<infer Builder, any, any> ? Builder : never
   export type SelectionKind<Selection> = Selection extends TargetSelection<any, any, infer Kind> ? Kind : never
   export type SelectionPath<Selection> = Selection extends TargetSelection<any, infer Path, any> ? Path : never
@@ -5193,21 +5241,18 @@ export declare namespace Machine {
 
   export type TransitionResolveContext<
     Context,
-    Selection,
-    Match = never
+    Selection
   > =
     & Omit<Context, "target">
-    & ([Match] extends [never] ? {} : { readonly match: Match })
     & (SelectionKind<Selection> extends "none" ? {} : { readonly target: SelectionBuilder<Selection> })
 
   export type TransitionResolver<
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     Context,
-    Selection,
-    Match = never
+    Selection
   > = (
-    context: TransitionResolveContext<Context, Selection, Match>,
+    context: TransitionResolveContext<Context, Selection>,
     enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
   ) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined
 
@@ -5222,51 +5267,95 @@ export declare namespace Machine {
   > = {
     readonly target: (to: TargetSelector<States, StateId>) => Selection
     readonly resolve?: TransitionResolver<Events, Emits, Context, Selection>
-    readonly cases?: never
-    readonly otherwise?: never
+    readonly branches?: never
     readonly reenter?: Reenter
   }
 
-  export type TransitionCaseInput<
-    States extends StateSchemas,
+  /** One named destination declared by a branching transition. */
+  export interface TransitionBranchInput<
+    Selection extends TargetSelection<any, any, any> = TargetSelection<any, any, any>
+  > {
+    readonly target: Selection
+    readonly title?: string
+  }
+
+  /** Opaque evidence that a branching resolver selected one declared branch. */
+  export interface SelectedBranch<out Key extends string, out Result> {
+    readonly [Topology.SelectedBranchTypeId]: {
+      readonly key: Types.Covariant<Key>
+      readonly result: Types.Covariant<Result>
+    }
+  }
+
+  type SelectedBranchCallable<Callable, Key extends string> = Callable extends {
+    (...args: infer Arguments1): infer Result1
+    (...args: infer Arguments2): infer Result2
+  } ? {
+      (...args: Arguments1): SelectedBranch<Key, Result1>
+      (...args: Arguments2): SelectedBranch<Key, Result2>
+    }
+    : Callable extends (...args: infer Arguments) => infer Result ? (...args: Arguments) => SelectedBranch<Key, Result>
+    : {}
+
+  type SelectedBranchBuilderProperties<Builder, Key extends string> = {
+    readonly [Property in keyof Builder]: Builder[Property] extends (...args: any) => any ?
+      SelectedBranchCallable<Builder[Property], Key>
+      : Builder[Property]
+  }
+
+  /** Target-specific builder that brands every construction with its branch key. */
+  export type SelectedBranchBuilder<Builder, Key extends string> =
+    & SelectedBranchCallable<Builder, Key>
+    & SelectedBranchBuilderProperties<Builder, Key>
+
+  export type BranchSelectors<Branches extends Readonly<Record<string, TransitionBranchInput>>> = {
+    readonly [Key in Extract<keyof Branches, string>]: SelectedBranchBuilder<
+      SelectionBuilder<Branches[Key]["target"]>,
+      Key
+    >
+  }
+
+  export type BranchSelectionResult<Branches extends Readonly<Record<string, TransitionBranchInput>>> = {
+    readonly [Key in Extract<keyof Branches, string>]: SelectedBranch<
+      Key,
+      SelectedTargetResult<Branches[Key]["target"]>
+    >
+  }[Extract<keyof Branches, string>]
+
+  export type TransitionBranchesResolveContext<
+    Context,
+    Branches extends Readonly<Record<string, TransitionBranchInput>>
+  > = Omit<Context, "target"> & { readonly select: BranchSelectors<Branches> }
+
+  export type TransitionBranchesResolver<
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateNodeIdentifier<States>,
     Context,
-    Selection extends TargetSelection<any, any, any>,
-    Match
-  > = {
-    readonly title: string
-    readonly when: (context: TransitionWhenContext<Context>) => Option.Option<Match>
-    readonly target: (to: TargetSelector<States, StateId>) => Selection
-    readonly resolve?: TransitionResolver<Events, Emits, Context, Selection, NoInfer<Match>>
-    readonly cases?: never
-    readonly otherwise?: never
-    readonly reenter?: never
-  }
+    Branches extends Readonly<Record<string, TransitionBranchInput>>
+  > = (
+    context: TransitionBranchesResolveContext<Context, Branches>,
+    enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
+  ) => BranchSelectionResult<Branches>
 
-  export type TransitionConditionalInput<
+  export type TransitionBranchesInput<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateNodeIdentifier<States>,
     Context,
     Reenter extends boolean,
-    Cases extends readonly [TransitionCaseTyped, ...ReadonlyArray<TransitionCaseTyped>],
-    OtherwiseSelection extends TargetSelection<any, any, any>
+    Branches extends Readonly<Record<string, TransitionBranchInput>>
   > = {
     readonly target?: never
-    readonly resolve?: never
-    readonly cases: (branch: TransitionCaseConstructor<States, Events, Emits, StateId, Context>) => Cases
-    readonly otherwise: TransitionDirectInput<
-      States,
-      Events,
-      Emits,
-      StateId,
-      Context,
-      never,
-      OtherwiseSelection
-    >
+    /**
+     * Declares every possible destination under a stable semantic key.
+     *
+     * Branches are captured once in ECMAScript property order. Array-index
+     * keys are rejected so reordering ordinary named properties affects only
+     * presentation order; the key remains the testing and inspection identity.
+     */
+    readonly branches: (to: TargetSelector<States, StateId>) => Branches
+    readonly resolve: TransitionBranchesResolver<Events, Emits, Context, Branches>
     readonly reenter?: Reenter
   }
 
@@ -5317,12 +5406,29 @@ export declare namespace Machine {
         readonly effect: (
           context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
         ) => Effect.Effect<any, any, any>
+        readonly stream?: never
         readonly after?: never
         readonly logic?: never
         readonly child?: never
         readonly address?: never
         readonly onDone?: unknown
         readonly onFailure?: unknown
+        readonly onElement?: never
+        readonly onSnapshot?: never
+      }
+      | {
+        readonly id: string
+        readonly stream: (
+          context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        ) => Stream.Stream<any, any, any>
+        readonly effect?: never
+        readonly after?: never
+        readonly logic?: never
+        readonly child?: never
+        readonly address?: never
+        readonly onElement?: unknown
+        readonly onDone: unknown
+        readonly onFailure?: unknown
         readonly onSnapshot?: never
       }
       | {
@@ -5332,11 +5438,13 @@ export declare namespace Machine {
           InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
         >
         readonly effect?: never
+        readonly stream?: never
         readonly logic?: never
         readonly child?: never
         readonly address?: never
         readonly onDone: unknown
         readonly onFailure?: never
+        readonly onElement?: never
         readonly onSnapshot?: never
       }
       | {
@@ -5347,10 +5455,12 @@ export declare namespace Machine {
           InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
         >
         readonly effect?: never
+        readonly stream?: never
         readonly after?: never
         readonly child?: never
         readonly onDone?: unknown
         readonly onFailure?: unknown
+        readonly onElement?: never
         readonly onSnapshot?: unknown
       }
       | {
@@ -5362,10 +5472,12 @@ export declare namespace Machine {
         readonly id?: never
         readonly address?: never
         readonly effect?: never
+        readonly stream?: never
         readonly after?: never
         readonly logic?: never
         readonly onDone?: unknown
         readonly onFailure?: unknown
+        readonly onElement?: never
         readonly onSnapshot?: unknown
       }
     )
@@ -5400,6 +5512,11 @@ export declare namespace Machine {
     : { readonly onFailure?: never }
     : never
 
+  export type InvokeElementRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
+    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onElement: Required }
+    : { readonly onElement?: never }
+    : never
+
   export type TimerInvokeArgs<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
@@ -5414,10 +5531,12 @@ export declare namespace Machine {
       InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
     >
     readonly effect?: never
+    readonly stream?: never
     readonly logic?: never
     readonly child?: never
     readonly address?: never
     readonly onFailure?: never
+    readonly onElement?: never
     readonly onSnapshot?: never
     readonly onDone: InvokeTransition<
       States,
@@ -5449,8 +5568,10 @@ export declare namespace Machine {
       readonly address: Address & ChildAddress.Compatibility<Address, ChildEvent>
       readonly logic: Source
       readonly effect?: never
+      readonly stream?: never
       readonly after?: never
       readonly child?: never
+      readonly onElement?: never
       readonly onSnapshot?: InvokeTransition<
         States,
         Events,
@@ -5512,8 +5633,10 @@ export declare namespace Machine {
       readonly id?: never
       readonly address?: never
       readonly effect?: never
+      readonly stream?: never
       readonly after?: never
       readonly logic?: never
+      readonly onElement?: never
       readonly onSnapshot?: InvokeTransition<
         States,
         Events,
@@ -5627,6 +5750,55 @@ export declare namespace Machine {
           >
           & { readonly onSnapshot?: never }
       : never
+    : Raw extends { readonly stream: infer Source } ?
+      InvokeFactoryResult<Source> extends infer SourceStream extends Stream.Stream<any, any, any> ?
+          & InvokeElementRequirement<
+            Stream.Success<SourceStream>,
+            InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeElementContext<
+                States,
+                Events,
+                Emits,
+                StateId,
+                Stream.Success<SourceStream>,
+                InputEvents,
+                ParentEvents
+              >
+            >
+          >
+          & {
+            readonly onDone: InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
+            >
+          }
+          & InvokeFailureRequirement<
+            Stream.Error<SourceStream>,
+            InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeFailureContext<
+                States,
+                Events,
+                Emits,
+                StateId,
+                Stream.Error<SourceStream>,
+                InputEvents,
+                ParentEvents
+              >
+            >
+          >
+          & { readonly onSnapshot?: never }
+      : never
     : Raw extends { readonly after: unknown } ? {
         readonly onDone: InvokeTransition<
           States,
@@ -6374,6 +6546,7 @@ export declare namespace Machine {
 
   type TransitionResultInitialTargetPath<Result> = IsAny<Result> extends true ? never
     : Result extends Effect.Effect<infer Success, any, any> ? TransitionResultInitialTargetPath<Success>
+    : Result extends SelectedBranch<any, infer Selected> ? TransitionResultInitialTargetPath<Selected>
     : Result extends StateConstruction<infer Constructed> ? TransitionResultInitialTargetPath<Constructed>
     : Result extends {
       readonly [Topology.InitialTargetTypeId]: typeof Topology.InitialTargetTypeId
@@ -7516,10 +7689,12 @@ type EffectInvokeSource<
 > = {
   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
 }
 
@@ -7588,6 +7763,110 @@ type EffectInvokeResult<
     never
   >
 
+type StreamInvokeSource<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<any>) => unknown
+> = {
+  readonly id: InvokeLifecycleId
+  readonly stream:
+    & Source
+    & ((context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown)
+  readonly effect?: never
+  readonly after?: never
+  readonly logic?: never
+  readonly child?: never
+  readonly address?: never
+  readonly onSnapshot?: never
+}
+
+type StreamSourceResult<Source extends (...args: ReadonlyArray<any>) => unknown> = ReturnType<Source> extends
+  infer Result extends Stream.Stream<any, any, any> ? Result : never
+
+type StreamElementHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<any>) => unknown
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  StateId,
+  Machine.InvokeElementContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Stream.Success<StreamSourceResult<NoInfer<Source>>>,
+    InputEvents,
+    ParentEvents
+  >
+>
+
+type StreamDoneHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  StateId,
+  Machine.InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
+>
+
+type StreamFailureHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<any>) => unknown
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  StateId,
+  Machine.InvokeFailureContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Stream.Error<StreamSourceResult<NoInfer<Source>>>,
+    InputEvents,
+    ParentEvents
+  >
+>
+
+type StreamInvokeResult<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<any>) => unknown
+> =
+  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  & Machine.InvokeTyped<
+    void,
+    Stream.Error<StreamSourceResult<Source>>,
+    Stream.Services<StreamSourceResult<Source>>,
+    never
+  >
+
 type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false
 
 type BoundEffectInvokeSource<
@@ -7603,10 +7882,12 @@ type BoundEffectInvokeSource<
 > = {
   readonly id: InvokeLifecycleId
   readonly effect: Source
+  readonly stream?: never
   readonly after?: never
   readonly logic?: never
   readonly child?: never
   readonly address?: never
+  readonly onElement?: never
   readonly onSnapshot?: never
 }
 
@@ -7675,66 +7956,36 @@ type BoundEffectInvokeResult<
     never
   >
 
-/** Type evidence retained for a case created by a conditional transition's local builder. */
-interface TransitionCaseTyped {
-  readonly [TransitionCaseTypeId]: true
-}
-
-/** Locally bound constructor that preserves each conditional transition case independently. */
-interface TransitionCaseConstructor<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateNodeIdentifier<States>,
-  Context
-> {
-  <
-    const Selection extends Machine.TargetSelection<any, any, any>,
-    const Match
-  >(
-    config: Machine.TransitionCaseInput<States, Events, Emits, StateId, Context, Selection, Match>
-  ):
-    & Machine.TransitionCaseInput<States, Events, Emits, StateId, Context, Selection, Match>
-    & TransitionCaseTyped
-}
-
-/**
- * Captures one exact transition topology while preserving handler inference.
- *
- * @category constructors
- * @since 0.14.0
- */
-type ConditionalTransitionResult<
+/** Captures one exact named-branch topology while preserving handler inference. */
+type BranchingTransitionResult<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
   StateId extends Machine.StateNodeIdentifier<States>,
   Context,
   Reenter extends boolean,
-  Cases extends readonly [
-    TransitionCaseTyped,
-    ...ReadonlyArray<TransitionCaseTyped>
-  ],
-  OtherwiseSelection extends Machine.TargetSelection<any, any, any>
+  Branches extends Readonly<Record<string, Machine.TransitionBranchInput>>
 > =
-  & Omit<
-    Machine.TransitionConditionalInput<
-      States,
-      Events,
-      Emits,
-      StateId,
-      Context,
-      Reenter,
-      Cases,
-      OtherwiseSelection
-    >,
-    "cases"
-  >
-  & { readonly cases: Cases }
+  & Machine.TransitionBranchesInput<States, Events, Emits, StateId, Context, Reenter, Branches>
   & Machine.TransitionTyped<States, Events, Emits, StateId, Context, Reenter>
 
+type TransitionBranchRecordError<Message extends string, Key extends PropertyKey = never> = {
+  readonly "~effect/Machine/TransitionBranchRecordError": Message
+  readonly key: Key
+}
+
+type InvalidStaticTransitionBranchKey<Branches> = Extract<keyof Branches, "" | number | symbol>
+
+type ValidateTransitionBranchRecord<Branches> = [keyof Branches] extends [never] ?
+  TransitionBranchRecordError<"Branch records must contain at least one branch">
+  : [InvalidStaticTransitionBranchKey<Branches>] extends [never] ? unknown
+  : TransitionBranchRecordError<
+    "Branch keys must be non-empty, non-index strings",
+    InvalidStaticTransitionBranchKey<Branches>
+  >
+
 /**
- * Contextually types direct and conditional transition definitions.
+ * Contextually types direct and branching transition definitions.
  *
  * @category constructors
  * @since 0.14.0
@@ -7760,32 +8011,28 @@ export interface TransitionConstructor {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateNodeIdentifier<States>,
     Context,
-    const Cases extends readonly [
-      TransitionCaseTyped,
-      ...ReadonlyArray<TransitionCaseTyped>
-    ],
-    const OtherwiseSelection extends Machine.TargetSelection<any, any, any>,
+    const Branches extends Readonly<Record<string, Machine.TransitionBranchInput>>,
     Reenter extends boolean = never
   >(
-    config: Machine.TransitionConditionalInput<
-      States,
-      Events,
-      Emits,
-      StateId,
-      Context,
-      Reenter,
-      Cases,
-      OtherwiseSelection
-    >
-  ): ConditionalTransitionResult<
+    config:
+      & Machine.TransitionBranchesInput<
+        States,
+        Events,
+        Emits,
+        StateId,
+        Context,
+        Reenter,
+        Branches
+      >
+      & ValidateTransitionBranchRecord<NoInfer<Branches>>
+  ): BranchingTransitionResult<
     States,
     Events,
     Emits,
     StateId,
     Context,
     Reenter,
-    Cases,
-    OtherwiseSelection
+    Branches
   >
 }
 
@@ -7794,9 +8041,9 @@ export interface TransitionConstructor {
  *
  * It is required for every event, lifecycle, choice, and invocation transition
  * so the destination selected by `target` can contextually type the
- * corresponding resolver. Conditional transitions use the locally bound
- * `branch` constructor so every case independently infers its matched value and
- * selected destination, with no limit on the number of cases.
+ * corresponding resolver. Branching transitions declare every possible
+ * destination up front, then select one through ordinary TypeScript control
+ * flow in `resolve`.
  *
  * ```ts
  * Machine.transition({
@@ -7805,31 +8052,61 @@ export interface TransitionConstructor {
  * })
  *
  * Machine.transition({
- *   cases: (branch) => [
- *     branch({
- *       title: "has cached data",
- *       when: ({ event }) => event.cached,
- *       target: (to) => to.full.Ready(),
- *       resolve: ({ match, target }) => target.from({ data: match })
- *     })
- *   ],
- *   otherwise: {
- *     target: (to) => to.full.Loading(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   branches: (to) => ({
+ *     cached: { target: to.full.Ready() },
+ *     loading: { target: to.full.Loading() }
+ *   }),
+ *   resolve: ({ event, select }) => event.cached
+ *     ? select.cached.from({ data: event.cached })
+ *     : select.loading.from()
  * })
  * ```
  *
  * @category constructors
  * @since 0.14.0
  */
-export const transition: TransitionConstructor = ((config: unknown) => {
-  if (!hasProperty(config, "cases") || typeof config.cases !== "function") return config
-  return {
-    ...config,
-    cases: config.cases(<Case extends object>(branch: Case): Case => branch)
-  }
-}) as TransitionConstructor
+export const transition: TransitionConstructor = ((config: unknown) => config) as TransitionConstructor
+
+/**
+ * Sentinel used by direct targetless transition shorthands.
+ *
+ * This is the concise form of `target: (to) => to.none()`.
+ *
+ * ```ts
+ * onElement: {
+ *   target: Machine.targetless,
+ *   resolve: ({ element }, enqueue) => {
+ *     enqueue.raise(new MeasurementReceived({ value: element }))
+ *   }
+ * }
+ *
+ * onDone: { target: Machine.targetless }
+ * ```
+ *
+ * @category constructors
+ * @since 0.16.0
+ */
+export interface TargetlessSelector {
+  readonly "~effect/Machine/TargetlessSelector": true
+  <
+    const States extends Machine.StateSchemas,
+    StateId extends Machine.StateNodeIdentifier<States>
+  >(to: Machine.TargetSelector<States, StateId>): ReturnType<Machine.TargetSelector<States, StateId>["none"]>
+}
+
+/**
+ * Selects no transition target while keeping enqueue operations explicit.
+ *
+ * Use as the `target` of a direct handler object when the handler should keep
+ * the current state configuration and only raise, emit, or send events.
+ *
+ * @category constructors
+ * @since 0.16.0
+ */
+export const targetless: TargetlessSelector = Object.assign(
+  (to: Machine.TargetSelector<any, any>) => to.none(),
+  { "~effect/Machine/TargetlessSelector": true as const }
+)
 
 /**
  * Machine-bound invocation constructor that preserves the owning machine's
@@ -7944,6 +8221,73 @@ export interface Invoker<
         readonly onFailure?: never
       }
   ): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<unknown, unknown, any>
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      },
+    ..._validation: InvokeChannelIsNever<Stream.Success<ReturnType<Source>>> extends true ? [
+        "onElement must be omitted when the Stream element is never"
+      ]
+      : InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
+          "onFailure must be omitted when the Stream error is never"
+        ]
+      : []
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<never, unknown, any>
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement?: never
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      },
+    ..._validation: InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
+        "onFailure must be omitted when the Stream error is never"
+      ]
+      : []
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<never, never, any>
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement?: never
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure?: never
+      }
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Stream.Stream<unknown, never, any>
+  >(
+    config:
+      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
+        readonly onFailure?: never
+      }
+  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <StateId extends Machine.StateIdentifier<States>, const Config extends object>(
     config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>
   ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
@@ -8050,15 +8394,18 @@ export interface Invoker<
 /**
  * Preserves inference for a state-owned invocation configuration.
  *
- * Use `effect` for one-shot work, `after` for a cancellable timer, `logic` for
- * reusable process logic, or `child` for a complete child machine. `onDone` is
- * required whenever the source can complete with an output, while `onFailure`
- * is required only when the source has a typed failure channel.
+ * Use `effect` for one-shot work, `stream` for repeated values, `after` for a
+ * cancellable timer, `logic` for reusable process logic, or `child` for a
+ * complete child machine. Stream elements are handled by `onElement` before
+ * the next element is pulled. `onDone` is required whenever the source can
+ * complete, while `onFailure` is required only when the source has a typed
+ * failure channel.
  *
  * This constructor is an identity at runtime, but preserves lifecycle callback
- * inference through published declarations. Effect factories run when their
- * owning state is entered and infer the owner context, output, error, and
- * service channels together without a return annotation. Durations may be
+ * inference through published declarations. Effect and Stream factories run
+ * when their owning state is entered and infer the owner context, value,
+ * output, error, and service channels together without a return annotation.
+ * Durations may be
  * supplied directly or derived from the owning state's entry context. Logic
  * invocations require both a lifecycle `id` and a typed communication
  * `address`. Child descriptors already own their identity, so `id` and
@@ -8179,6 +8526,93 @@ export const invoke: {
         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>,
@@ -8464,9 +8898,8 @@ export const initialDefinition: <M extends Machine.Any>(machine: M) => Machine.I
  *
  * Event handlers retain their handler-key order within each source state and
  * are followed by eventless and completion handlers. This function does not
- * execute predicates or resolvers. Every direct, conditional, fallback, and
- * targetless branch exposes the destination selected by its required static
- * `target` declaration.
+ * execute resolvers. Every direct, named, and targetless branch exposes the
+ * destination selected by its required static `target` declaration.
  *
  * @category getters
  * @since 0.4.0