@typeonce/effect-machine 0.13.0 → 0.14.1

package/dist/Machine.d.ts

@@ -41,6 +41,7 @@ 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
@@ -176,6 +177,8 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
     readonly invoke: Invoker<States, Events, Emits, InputEvents, ParentEvents>;
     /** @internal */
     readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>;
+    /** @internal */
+    readonly initialDefinition: Machine.InitialDefinition;
 }
 export { 
 /**
@@ -412,6 +415,7 @@ export declare namespace Runtime {
 type ExcludeCompatibleRuntime<Requirements, Events, Emits> = Requirements extends Runtime.Requirement<infer RequiredEvents, infer RequiredEmits> ? IsAny<Requirements> extends true ? Requirements : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements : Requirements : Requirements;
 type IncompatibleRuntime<Requirements, Events, Emits> = Requirements extends Runtime.Requirement<infer RequiredEvents, infer RequiredEmits> ? IsAny<Requirements> extends true ? never : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements : Requirements : never;
 declare const InvokeTypeId: typeof internal.InvokeTypeId;
+declare const TransitionTypeId: typeof internal.TransitionTypeId;
 type StateDefinitionError<Message extends string, Path extends PropertyKey = never, Details extends PropertyKey = never> = {
     readonly "~effect/Machine/DefinitionError": Message;
     readonly path: Path;
@@ -1400,6 +1404,8 @@ export declare namespace Machine {
         readonly invoke: any;
         /** @internal */
         readonly initial: any;
+        /** @internal */
+        readonly initialDefinition: InitialDefinition;
     }
     /**
      * Extracts the state schema tree carried by a machine definition.
@@ -1784,12 +1790,12 @@ export declare namespace Machine {
      */
     type InitialBuilder<States extends StateSchemas> = InitialSnapshotBuilderWithPrefix<States>;
     /**
-     * State definitions and snapshot builders returned by `defineStates`.
+     * State definitions and snapshot access helpers returned by `defineStates`.
      *
      * **Details**
      *
      * The `states` property is the original state tree and can be passed directly
-     * to `make`. The `initial` property builds path-safe snapshots for the same
+     * to `make`. The remaining helpers match and read snapshots for the same
      * state tree.
      *
      * @category models
@@ -1798,8 +1804,6 @@ export declare namespace Machine {
     interface DefinedStates<States extends StateSchemas> {
         /** Original state tree supplied to {@link defineStates}. */
         readonly states: States;
-        /** Type-safe builders for constructing valid initial snapshots. */
-        readonly initial: InitialBuilder<States>;
         /**
          * Returns the decoded value for an active state path. The supplied
          * snapshot may be a complete root snapshot or a snapshot previously
@@ -1966,28 +1970,40 @@ export declare namespace Machine {
         readonly id: string;
         readonly outcome: "done" | "failure" | "snapshot";
     };
-    /**
-     * Statically inspectable destination paths for a transition handler.
-     * A declared parent path covers every descendant below that state.
-     *
-     * @category models
-     * @since 0.4.0
-     */
-    type TransitionTargets<Path extends string = string> = {
-        readonly type: "dynamic";
+    /** 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> {
+        readonly path: Path;
+        readonly kind: Kind;
+        readonly scope: Scope;
+    }
+    /** One statically captured branch of a transition definition. */
+    type TransitionBranch<Path extends string = string> = {
+        readonly type: "direct";
+        readonly target: Path | undefined;
+        readonly selection: TransitionTargetSelection<Path | undefined>;
+    } | {
+        readonly type: "case";
+        readonly title: string;
+        readonly target: Path | undefined;
+        readonly selection: TransitionTargetSelection<Path | undefined>;
     } | {
-        readonly type: "declared";
-        readonly paths: ReadonlyArray<Path>;
+        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> {
+        readonly target: Path;
+        readonly selection: TransitionTargetSelection<Path, "state" | "initial", "initial">;
+    }
     /**
      * Inspectable registration for a transition handler.
      *
      * **Details**
      *
-     * Event, eventless, completion, and invocation lifecycle handlers may
-     * declare an upper bound of possible target paths. A handler without that
-     * declaration is explicitly reported as dynamic. The source, trigger, and
-     * reentry behavior are available without executing the handler.
+     * Every branch exposes its selected target without executing its predicate
+     * or resolver. A compound local or branch target covers its descendants;
+     * `undefined` identifies an explicitly targetless branch.
      *
      * @category models
      * @since 0.4.0
@@ -1996,7 +2012,7 @@ export declare namespace Machine {
         readonly source: SourcePath;
         readonly trigger: TransitionTrigger<EventTag>;
         readonly reenter: boolean;
-        readonly targets: TransitionTargets<TargetPath>;
+        readonly branches: ReadonlyArray<TransitionBranch<TargetPath>>;
     }
     /**
      * Serializable description of state-owned work.
@@ -2020,9 +2036,14 @@ export declare namespace Machine {
         readonly source: SourcePath;
         readonly trigger: TransitionTrigger<EventTag>;
         readonly reenter: boolean;
-        /** Path returned by the handler, including a history pseudo-state. */
+        /** Zero-based index of the selected static branch. */
+        readonly branchIndex: number;
+        /** Path returned by the handler, including a choice or history pseudo-state. */
         readonly target: TargetPath | undefined;
-        /** Concrete path used after resolving history, otherwise equal to `target`. */
+        /**
+         * Concrete path used after resolving choice, initial, or history routing.
+         * Choice microsteps retain each intermediate pseudo-state edge separately.
+         */
         readonly resolvedTarget: TargetPath | undefined;
     }
     /**
@@ -2585,9 +2606,7 @@ export declare namespace Machine {
      * Opaque result returned by an explicitly targetless transition.
      *
      * The transition remains handled and retains its queued commands, raised
-     * events, and emitted events, but selects no concrete destination. Declared
-     * `targets` constrain only concrete destinations, so this result is always
-     * permitted from ordinary transition handlers.
+     * events, and emitted events, but selects no concrete destination.
      *
      * @category models
      * @since 0.10.0
@@ -2707,8 +2726,7 @@ export declare namespace Machine {
          *
          * The event or lifecycle outcome is handled and queued operations are
          * retained, while the current state configuration remains the transition
-         * result. This remains valid when the handler declares concrete `targets`,
-         * because those paths are an upper bound rather than an exhaustive result.
+         * result.
          *
          * @since 0.10.0
          */
@@ -2744,6 +2762,66 @@ export declare namespace Machine {
         /** Restores a declared shallow or deep history pseudo-state. */
         readonly history: HistoryTargetBuilder<States>;
     }
+    /**
+     * Opaque exact destination selected while a machine definition is captured.
+     * The selection contains topology only; state values are constructed later
+     * by the selected branch's resolver.
+     *
+     * @category models
+     * @since 0.14.0
+     */
+    interface TargetSelection<out Result, out Path extends string | undefined = string | undefined, out Kind extends Topology.TargetSelectionKind = Topology.TargetSelectionKind> {
+        readonly [Topology.TargetSelectionTypeId]: typeof Topology.TargetSelectionTypeId;
+        readonly kind: Kind;
+        readonly scope: Topology.TargetSelectionScope | undefined;
+        readonly path: Path;
+        readonly "~effect/Machine/TargetSelectionResult"?: Types.Covariant<Result>;
+    }
+    type SelectionMethod<Builder, Path extends string, Kind extends Topology.TargetSelectionKind = "state"> = () => TargetSelection<Builder, Path, Kind>;
+    type InitialSelectionMethod<Builder, Path extends string> = Builder extends {
+        readonly initial: infer Initial;
+    } ? {
+        readonly initial: SelectionMethod<Initial, Path, "initial">;
+    } : {};
+    type SelectionTreeWithPrefix<AllStates extends StateSchemas, States extends StateSchemas, Prefix extends string, Scope extends "local" | "branch", Builder> = {
+        readonly [Key in Extract<ActiveStateKey<States> | ChoiceStateKey<States>, keyof Builder>]: SelectionNode<AllStates, States[Key], JoinPath<Prefix, Key>, Scope, Builder[Key]>;
+    };
+    type SelectionNode<AllStates extends StateSchemas, Node, Path extends string, Scope extends "local" | "branch", Builder> = Node extends ChoiceStateNodeConfig ? SelectionMethod<Builder, Path, "choice"> : Node extends {
+        readonly states: infer Children extends StateSchemas;
+    } ? SelectionMethod<Builder, Path> & InitialSelectionMethod<Builder, Path> & SelectionTreeWithPrefix<AllStates, Children, Path, Scope, Builder> : SelectionMethod<Builder, Path>;
+    type FullSelectionNode<AllStates extends StateSchemas, Node, Path extends StateIdentifier<AllStates>, Builder> = Node extends {
+        readonly states: StateSchemas;
+    } ? SelectionMethod<Builder, Path> & InitialSelectionMethod<Builder, Path> : SelectionMethod<Builder, Path>;
+    type FullTargetSelector<States extends StateSchemas> = {
+        readonly [Key in Extract<ActiveStateKey<States>, keyof FullTargetBuilder<States>>]: FullSelectionNode<States, States[Key], Extract<Key, StateIdentifier<States>>, FullTargetBuilder<States>[Key]>;
+    };
+    type BranchTargetSelector<States extends StateSchemas, Source extends StateNodeIdentifier<States>, Root extends string = Source extends `${infer Head}.${string}` ? Head : Source> = Root extends ActiveStateKey<States> ? Root extends keyof BranchTargetBuilder<States, Source> ? {
+        readonly [Key in Root]: SelectionNode<States, States[Key], Key, "branch", BranchTargetBuilder<States, Source>[Key]>;
+    } : {} : {};
+    type LocalTargetSelector<States extends StateSchemas, Source extends StateNodeIdentifier<States>> = NearestCompoundScope<States, Source> extends infer Scope extends StateIdentifier<States> ? ChildrenOf<States, Scope> extends infer Children extends StateSchemas ? LocalTargetBuilder<States, Source> extends infer Builder ? SelectionTreeWithPrefix<States, Children, Scope, "local", Builder> & ("with" extends keyof Builder ? {
+        readonly with: SelectionMethod<Builder["with"], Scope>;
+    } : {}) : {} : {} : {};
+    type HistorySelectionTree<AllStates extends StateSchemas, States extends StateSchemas, Prefix extends string, Builder> = {
+        readonly [Key in Extract<HistoryContainingKey<States>, keyof Builder>]: States[Key] extends HistoryStateNodeConfig ? SelectionMethod<Builder[Key], JoinPath<Prefix, Key>, "history"> : States[Key] extends {
+            readonly states: infer Children extends StateSchemas;
+        } ? HistorySelectionTree<AllStates, Children, JoinPath<Prefix, Key>, Builder[Key]> : never;
+    };
+    /** Definition-time topology selector available to an ordinary transition. */
+    interface TargetSelector<States extends StateSchemas, Source extends StateNodeIdentifier<States>> {
+        readonly none: SelectionMethod<TargetBuilder<States, Source>["none"], never, "none">;
+        readonly local: LocalTargetSelector<States, Source>;
+        readonly branch: BranchTargetSelector<States, Source>;
+        readonly full: FullTargetSelector<States>;
+        readonly history: HistorySelectionTree<States, States, "", HistoryTargetBuilder<States>>;
+    }
+    /** Definition-time selector that can choose only a valid top-level initial entry. */
+    type InitialSelector<States extends StateSchemas> = {
+        readonly [Key in Extract<ActiveStateKey<States>, keyof InitialBuilder<States>>]: States[Key] extends {
+            readonly states: StateSchemas;
+        } ? {
+            readonly initial: SelectionMethod<InitialBuilder<States>[Key], Key, "initial">;
+        } : SelectionMethod<InitialBuilder<States>[Key], Key>;
+    };
     /**
      * Context passed to a state/event handler.
      *
@@ -2934,7 +3012,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type InitialResult<States extends StateSchemas, E, R> = Snapshot<States> | InitialSnapshot<States> | StateConstruction<Snapshot<States> | InitialSnapshot<States>>;
+    type InitialResult<States extends StateSchemas, E, R> = Snapshot<States> | InitialSnapshot<States> | InitialTarget<StateIdentifier<States>> | StateConstruction<Snapshot<States> | InitialSnapshot<States> | InitialTarget<StateIdentifier<States>>>;
     /** Initial snapshots may transiently terminate in a declared choice node. */
     type InitialSnapshot<States extends StateSchemas> = {
         readonly [StateId in ActiveStateKey<States>]: InitialSnapshotResult<States, StateId, "">;
@@ -3004,19 +3082,21 @@ export declare namespace Machine {
     }[keyof NonNullable<History>] : never;
     /** Extracts the return value from a choice resolver. */
     type ChoiceReturn<Config> = Config extends {
-        readonly choice: {
-            readonly transition: (...args: any) => infer Ret;
-        };
-    } ? Ret : never;
+        readonly choice: infer Choice;
+    } ? EventTransitionReturn<Choice> : never;
     /**
      * Extracts the return value from an event transition config.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type EventTransitionReturn<Transition> = Transition extends (...args: any) => infer Ret ? Ret : Transition extends {
-        readonly transition: (...args: any) => infer Ret;
-    } ? Ret : never;
+    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);
     /**
      * Extracts the return value from a state's event handlers.
      *
@@ -3176,16 +3256,61 @@ 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 InvokeTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context> = ((context: NoInfer<Context>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
-        readonly reenter?: boolean;
-        readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
-        readonly transition: (context: NoInfer<Context>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
+    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]: {
+            readonly owner: Types.Covariant<readonly [States, Events, Emits, StateId, Context]>;
+        };
+    }
+    /** Type evidence for a targetless transition reusable in every owning context. */
+    interface TargetlessTransitionTyped {
+        readonly [TransitionTypeId]: {
+            readonly targetless: true;
+        };
+    }
+    /** 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) & {
+        readonly reenter?: [Reenter] extends [true] ? boolean : 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;
+    type TargetBuilderResult<Builder> = (Builder extends (...args: any) => infer Result ? Result : never) | (Builder extends {
+        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" ? {} : {
+        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 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 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;
     };
+    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>> = {
+        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>;
+        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>;
     type InvokeSource<Value, Context> = Value | ((context: Context) => Value);
-    interface AnyLogicSource {
-        initial(...args: ReadonlyArray<any>): Effect.Effect<any, any, any>;
-        run(...args: ReadonlyArray<any>): Effect.Effect<any, any, any>;
-    }
     /** Inline state-owned work that runs for the lifetime of its active state. */
     interface InvokeOwned<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly "~effect/Machine/InvokeOwner"?: Types.Covariant<readonly [States, Events, Emits, StateId]>;
@@ -3224,7 +3349,7 @@ export declare namespace Machine {
     } | {
         readonly id: string;
         readonly address: string;
-        readonly logic: InvokeSource<AnyLogicSource, InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
+        readonly logic: InvokeSource<Logic<any, any, any, any, any, any>, InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
         readonly effect?: never;
         readonly after?: never;
         readonly child?: never;
@@ -3276,7 +3401,7 @@ export declare namespace Machine {
         readonly address?: never;
         readonly onFailure?: never;
         readonly onSnapshot?: never;
-        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
+        readonly onDone: InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
     };
     type LogicInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         readonly id: InvokeLifecycleId;
@@ -3285,8 +3410,8 @@ export declare namespace Machine {
         readonly effect?: never;
         readonly after?: never;
         readonly child?: never;
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, ChildState, ChildError, ChildOutput, InputEvents, ParentEvents>>;
-    } & InvokeDoneRequirement<ChildOutput, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, ChildOutput, InputEvents, ParentEvents>>> & InvokeFailureRequirement<ChildError, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, ChildError, InputEvents, ParentEvents>>>;
+        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 []> = {
         readonly child: Child & (ChildDefinition extends EnsureExecutable<Machine.States<ChildDefinition>, Machine.UnhandledStates<ChildDefinition>, Machine.OutputStates<ChildDefinition>> ? unknown : never);
         readonly id?: never;
@@ -3294,42 +3419,50 @@ export declare namespace Machine {
         readonly effect?: never;
         readonly after?: never;
         readonly logic?: never;
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>;
+        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;
     } : {
         readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
-    }) & InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InputEvents, ParentEvents>>>;
-    type LogicStateOf<Value> = Value extends Logic<infer State, any, any, any, any, any> ? State : never;
-    type LogicEventOf<Value> = Value extends Logic<any, infer Event, any, any, any, any> ? Event : never;
-    type LogicErrorOf<Value> = Value extends Logic<any, any, infer Error, any, any, any> ? Error : never;
-    type LogicServicesOf<Value> = Value extends Logic<any, any, any, infer Services, any, any> ? Services : never;
-    type LogicOutputOf<Value> = Value extends Logic<any, any, any, any, infer Output, any> ? Output : never;
-    type LogicInitialErrorOf<Value> = Value extends Logic<any, any, any, any, any, infer Error> ? Error : never;
+    }) & InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, StateId, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InputEvents, ParentEvents>>>;
+    type LogicInitialEffectOf<Value> = Value extends {
+        readonly initial: infer Initial;
+    } ? Initial extends (...args: ReadonlyArray<any>) => infer Result ? Result : never : never;
+    type LogicRunEffectOf<Value> = Value extends {
+        readonly run: infer Run;
+    } ? Run extends (...args: ReadonlyArray<any>) => infer Result ? Result : never : never;
+    type LogicStateOf<Value> = Effect.Success<LogicInitialEffectOf<Value>>;
+    type LogicEventOf<Value> = Value extends {
+        readonly initial: infer Initial;
+    } ? Initial extends (scope: infer LogicScope, ...args: ReadonlyArray<any>) => any ? LogicScope extends Logic.Scope<infer Event> ? Event : never : never : never;
+    type LogicErrorOf<Value> = Effect.Error<LogicRunEffectOf<Value>>;
+    type LogicServicesOf<Value> = Effect.Services<LogicInitialEffectOf<Value> | LogicRunEffectOf<Value>>;
+    type LogicOutputOf<Value> = Effect.Success<LogicRunEffectOf<Value>>;
+    type LogicInitialErrorOf<Value> = Effect.Error<LogicInitialEffectOf<Value>>;
     type ContextualInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Raw> = Raw extends InvokeTyped<any, any, any, any, any> ? unknown : Raw extends {
         readonly effect: infer Source;
-    } ? InvokeFactoryResult<Source> extends infer Fx extends Effect.Effect<any, any, any> ? InvokeDoneRequirement<Effect.Success<Fx>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Effect.Error<Fx>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>>> & {
+    } ? 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 after: unknown;
     } ? {
-        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
+        readonly onDone: InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
         readonly onFailure?: never;
         readonly onSnapshot?: never;
     } : Raw extends {
         readonly logic: infer Source;
         readonly address: infer Address;
-    } ? InvokeResolvedSource<Source> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ? InvokeDoneRequirement<InvokeOutput<Raw>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<InvokeRuntimeError<Raw>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, InvokeRuntimeError<Raw>, InputEvents, ParentEvents>>> & {
+    } ? InvokeResolvedSource<Source> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ? InvokeDoneRequirement<InvokeOutput<Raw>, InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<InvokeRuntimeError<Raw>, InvokeTransition<States, Events, Emits, StateId, InvokeFailureContext<States, Events, Emits, StateId, InvokeRuntimeError<Raw>, InputEvents, ParentEvents>>> & {
         readonly address: ChildAddress<never> & ChildAddress.Compatibility<Address, ChildLogic extends Logic<any, infer ChildEvent, any, any, any, any> ? ChildEvent : never>;
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, ChildLogic extends Logic<infer ChildState, any, any, any, any, any> ? ChildState : never, InvokeRuntimeError<Raw>, InvokeOutput<Raw>, InputEvents, ParentEvents>>;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, ChildLogic extends Logic<infer ChildState, any, any, any, any, any> ? ChildState : never, InvokeRuntimeError<Raw>, InvokeOutput<Raw>, InputEvents, ParentEvents>>;
     } : never : Raw extends {
         readonly child: infer Child extends ChildMachine<string, infer ChildDefinition>;
-    } ? ChildMachineLogic<Child> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ? InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InputEvents, ParentEvents>>> & (Input<ChildDefinition> extends typeof Schema.Void ? {
+    } ? ChildMachineLogic<Child> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ? InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, StateId, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InputEvents, ParentEvents>>> & (Input<ChildDefinition> extends typeof Schema.Void ? {
         readonly input?: never;
     } : {
         readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
     }) & {
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>;
     } : never : never;
     type ContextualInvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Raw> = Raw extends ReadonlyArray<any> ? {
         readonly [Index in keyof Raw]: ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw[Index]>;
@@ -3356,27 +3489,10 @@ export declare namespace Machine {
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
         readonly exit?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
         readonly invoke?: InvokeDefinition<States, Events, Emits, StateId, InputEvents, ParentEvents> | TypedInvokeDefinition;
-        readonly always?: ((context: AlwaysContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
-            /** Statically declared upper bound of possible target paths. */
-            readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
-            readonly transition: (context: AlwaysContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
-        };
-        readonly onDone?: ((context: DoneContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
-            /** Statically declared upper bound of possible target paths. */
-            readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
-            readonly transition: (context: DoneContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
-        };
+        readonly always?: TransitionConfig<States, Events, Emits, StateId, AlwaysContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
+        readonly onDone?: TransitionConfig<States, Events, Emits, StateId, DoneContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
         readonly on?: {
-            readonly [EventTag in TagOf<Events[number]>]?: ((context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
-                readonly reenter?: boolean;
-                /**
-                 * Upper bound of state or history paths this handler may target.
-                 * Returning `target.none()` is always permitted. Declaring a parent state also
-                 * permits concrete descendant targets below it.
-                 */
-                readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
-                readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
-            };
+            readonly [EventTag in TagOf<Events[number]>]?: TransitionConfig<States, Events, Emits, StateId, HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>, true>;
         };
         readonly initialize?: StateInitializeHandler<States, Events, Emits, StateId, InputEvents, ParentEvents>;
     } & ActiveOutputHandlerConfig<States, Events, StateId>;
@@ -3463,11 +3579,7 @@ export declare namespace Machine {
     };
     /** Required implementation for a choice pseudo-state. */
     interface ChoiceStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> {
-        readonly choice: {
-            /** Statically inspectable upper bound of every possible target. */
-            readonly targets: readonly [StateNodeIdentifier<States>, ...ReadonlyArray<StateNodeIdentifier<States>>];
-            readonly transition: (context: ChoiceContext<States, Events, Emits, ChoiceId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => ChoiceResult<States, any, any>;
-        };
+        readonly choice: TransitionConfig<States, Events, Emits, ChoiceId, ChoiceContext<States, Events, Emits, ChoiceId, InputEvents, ParentEvents>>;
         readonly entry?: never;
         readonly exit?: never;
         readonly invoke?: never;
@@ -3581,9 +3693,6 @@ export declare namespace Machine {
             readonly [Key in UnknownKeys]: HandlerValidationError<"Handler config contains an event key that does not exist", StateId, Key>;
         };
     } : unknown;
-    type TransitionResultTargetPath<Result> = IsAny<Result> extends true ? never : Result extends Effect.Effect<infer Success, any, any> ? TransitionResultTargetPath<Success> : Result extends StateConstruction<infer Constructed> ? TransitionResultTargetPath<Constructed> : Result extends {
-        readonly path: infer Path extends string;
-    } ? Path : never;
     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 {
         readonly [Topology.InitialTargetTypeId]: typeof Topology.InitialTargetTypeId;
         readonly _tag: "InitialTarget";
@@ -3604,24 +3713,6 @@ export declare namespace Machine {
         } ? HandlerTreeInitialTargetPath<Children> : never);
     }[keyof Config] : never;
     type HandlerInitialTargetValidation<AllStates extends StateSchemas, Config> = HandlerTreeInitialTargetPath<Config> extends infer TargetPath ? HandlerInitialTargetValidationForPaths<AllStates, Config, RequiredInitializersForTargetPath<AllStates, TargetPath>> : unknown;
-    type DeclaredTransitionTarget<Transition> = Transition extends {
-        readonly targets: infer Targets extends ReadonlyArray<string>;
-    } ? Targets[number] : never;
-    type ExcludeDeclaredTransitionTarget<Returned, Declared extends string> = Returned extends string ? Returned extends Declared | `${Declared}.${string}` ? never : Returned : never;
-    type UndeclaredTransitionTarget<Transition> = "targets" extends keyof Transition ? ExcludeDeclaredTransitionTarget<TransitionResultTargetPath<EventTransitionReturn<Transition>>, DeclaredTransitionTarget<Transition>> : never;
-    type HandlerOnTargetValidationErrors<StateId extends string, On> = {
-        readonly [EventTag in keyof On as [UndeclaredTransitionTarget<On[EventTag]>] extends [never] ? never : EventTag]: HandlerValidationError<"Transition returns a target not listed in targets", StateId, readonly [event: EventTag, target: UndeclaredTransitionTarget<On[EventTag]>]>;
-    };
-    type HandlerOnTargetValidation<StateId extends string, Config> = "on" extends keyof Config ? Config extends {
-        readonly on?: infer On;
-    } ? HandlerOnTargetValidationErrors<StateId, NonNullable<On>> extends infer Errors ? keyof Errors extends never ? unknown : {
-        readonly on: Errors;
-    } : never : unknown : unknown;
-    type HandlerDirectTargetValidation<StateId extends string, Config, Trigger extends "always" | "onDone", Transition = Config extends {
-        readonly [Key in Trigger]?: infer Value;
-    } ? NonNullable<Value> : never, Undeclared extends string = UndeclaredTransitionTarget<Transition>> = Trigger extends keyof Config ? [Undeclared] extends [never] ? unknown : {
-        readonly [Key in Trigger]: HandlerValidationError<"Transition returns a target not listed in targets", StateId, readonly [trigger: Trigger, target: Undeclared]>;
-    } : unknown;
     type HandlerChildrenValidation<Node, Prefix extends string, Config> = "states" extends keyof Config ? Config extends {
         readonly states?: infer ChildrenConfig;
     } ? HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? {
@@ -3645,15 +3736,10 @@ export declare namespace Machine {
     type HandlerRequiredHistoryInitializeValidation<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = [HistoryIdentifier<AllStates>] extends [never] ? unknown : StateId extends RequiredHistoryInitializers<AllStates> ? "initialize" extends keyof Config ? unknown : {
         readonly initialize: HandlerValidationError<"State requires initialize for shallow history restoration", StateId>;
     } : unknown;
-    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = StateId extends ChoiceIdentifier<AllStates> ? HandlerChoiceUnknownConfigKeyValidation<StateId, Config> & HandlerChoiceTargetValidation<StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : StateId extends StateIdentifier<AllStates> ? HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerOnTargetValidation<StateId, Config> & HandlerDirectTargetValidation<StateId, Config, "always"> & HandlerDirectTargetValidation<StateId, Config, "onDone"> & HandlerInvokeParentEventsValidation<InputEvents, StateId, Config> & HandlerChildrenValidation<Node, StateId, Config> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRequiredHistoryInitializeValidation<AllStates, StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : unknown;
+    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = StateId extends ChoiceIdentifier<AllStates> ? HandlerChoiceUnknownConfigKeyValidation<StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : StateId extends StateIdentifier<AllStates> ? HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerInvokeParentEventsValidation<InputEvents, StateId, Config> & HandlerChildrenValidation<Node, StateId, Config> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRequiredHistoryInitializeValidation<AllStates, StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : unknown;
     type HandlerChoiceUnknownConfigKeyValidation<StateId extends string, Config, UnknownKeys extends string = Exclude<Extract<keyof Config, string>, "choice">> = [UnknownKeys] extends [never] ? unknown : {
         readonly [Key in UnknownKeys]: HandlerValidationError<"Choice handler config contains an invalid key", StateId, Key>;
     };
-    type HandlerChoiceTargetValidation<StateId extends string, Config> = Config extends {
-        readonly choice: infer Choice;
-    } ? [UndeclaredTransitionTarget<Choice>] extends [never] ? unknown : {
-        readonly choice: HandlerValidationError<"Choice resolver returns a target not listed in targets", StateId, UndeclaredTransitionTarget<Choice>>;
-    } : unknown;
     type HandlerInvokeParentEventsValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeParentEvents<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown : {
         readonly invoke: HandlerValidationError<"Invoked child expects parent events not accepted by this machine", StateId, Exclude<InvokeParentEvents<InvokeReturn<Config>>, EventOf<Events>>>;
     };
@@ -3708,12 +3794,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    type EventHandlerMap<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, ((context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>) | {
-        readonly reenter?: boolean;
-        /** Statically declared upper bound of possible target paths. */
-        readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
-        readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>;
-    }>>;
+    type EventHandlerMap<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, TransitionConfig<States, Events, Emits, StateId, HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, true>>>;
     /**
      * Runtime state config stored for a single state tag.
      *
@@ -3724,14 +3805,8 @@ export declare namespace Machine {
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<E, R>;
         readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<E, R>;
         readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>;
-        readonly always?: ((context: AlwaysContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>) | {
-            readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
-            readonly transition: (context: AlwaysContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>;
-        };
-        readonly onDone?: ((context: DoneContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>) | {
-            readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
-            readonly transition: (context: DoneContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>;
-        };
+        readonly always?: TransitionConfig<States, Events, Emits, StateId, AlwaysContext<States, Events, Emits, StateId>>;
+        readonly onDone?: TransitionConfig<States, Events, Emits, StateId, DoneContext<States, Events, Emits, StateId>>;
         readonly output?: ((context: FinalOutputContext<States, Events, StateId>) => unknown) | ((context: ParallelOutputContext<States, Events, StateId>) => unknown);
         readonly on?: EventHandlerMap<States, Events, Emits, StateId, EventTag, E, R>;
     }
@@ -3763,15 +3838,15 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  * **When to use**
  *
  * Use when you want to pass a state tree to `make` and also get typed
- * snapshot builders for initial states and tests.
+ * snapshot matching and access helpers.
  *
  * **Details**
  *
  * The returned `states` property is the same object passed to `defineStates`.
- * The returned `initial` builder creates snapshots without user-authored path
- * strings and enforces compound and parallel initial-state rules. Active nodes
- * may omit `schema` when they own no value; those builders expose `.from(...)`
- * and still participate fully in targeting, matching, and snapshots.
+ * `Machine.make` derives its initial target selector from that tree and
+ * enforces compound and parallel initial-state rules. Active nodes may omit
+ * `schema` when they own no value and still participate fully in targeting,
+ * matching, and snapshots.
  *
  * **Example** (Atomic initial snapshot)
  *
@@ -3786,7 +3861,10 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  * Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: () => States.initial.idle.from()
+ *   initial: {
+ *     target: (to) => to.idle(),
+ *     resolve: ({ target }) => target.from()
+ *   }
  * })
  * ```
  *
@@ -3794,6 +3872,15 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  * @since 0.4.0
  */
 export declare const defineStates: DefineStates;
+type InitialDirectInput<States extends Machine.StateSchemas, Input, Selection extends Machine.TargetSelection<any, any, any>> = {
+    readonly target: (to: Machine.InitialSelector<States>) => Selection;
+    readonly resolve?: (context: {
+        readonly input: Input;
+        readonly target: Machine.SelectionBuilder<Selection>;
+    }) => Machine.SelectedTargetResult<Selection>;
+    readonly cases?: never;
+    readonly otherwise?: never;
+};
 type MakeConfig<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = {
     readonly id?: string;
     readonly states: States & DefineStateTreeInput<NoInfer<States>>;
@@ -3802,11 +3889,13 @@ type MakeConfig<States extends Machine.StateSchemas, InputEvents extends Readonl
     readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>;
     readonly parentEvents?: Machine.EventProtocol<"public", ParentEvents>;
     readonly input?: Input;
-    readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>;
+    readonly initial: unknown;
 };
 type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = Machine<States, readonly [...InputEvents, ...InternalEvents], Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, never, InputEvents, ParentEvents>;
 interface Make {
-    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>;
+    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const InitialSelection extends Machine.TargetSelection<any, any, any> = Machine.TargetSelection<any, any, any>>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "initial"> & {
+        readonly initial: InitialDirectInput<States, Input["Type"], InitialSelection>;
+    }, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>;
     <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "states"> & {
         readonly states: InvalidDefinedStateTreeInput<States>;
     }): never;
@@ -3850,18 +3939,24 @@ interface Make {
  * const counter = Machine.make({
  *   states: States.states,
  *   events: Events,
- *   initial: () => States.initial.Count(new Count({ value: 0 }))
+ *   initial: {
+ *     target: (to) => to.Count(),
+ *     resolve: ({ target }) => target(new Count({ value: 0 }))
+ *   }
  * }).handle({
  *   Count: {
  *     on: {
- *       Increment: ({ event, state }) =>
- *         States.initial.Count(new Count({ value: state.value + event.by }))
+ *       Increment: Machine.transition({
+ *         target: (to) => to.full.Count(),
+ *         resolve: ({ event, state, target }) =>
+ *           target(new Count({ value: state.value + event.by }))
+ *       })
  *     }
  *   }
  * })
  * ```
  *
- * @see {@link defineStates} for typed initial snapshot builders.
+ * @see {@link defineStates} for typed state-tree helpers.
  * @category constructors
  * @since 0.4.0
  */
@@ -3969,7 +4064,10 @@ export declare const emittedEvents: {
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: () => States.initial.Idle.from()
+ *   initial: {
+ *     target: (to) => to.Idle(),
+ *     resolve: ({ target }) => target.from()
+ *   }
  * }).handle({ Idle: {} })
  *
  * const encoded = Effect.gen(function*() {
@@ -4013,7 +4111,10 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: () => States.initial.Idle.from()
+ *   initial: {
+ *     target: (to) => to.Idle(),
+ *     resolve: ({ target }) => target.from()
+ *   }
  * }).handle({ Idle: {} })
  *
  * const roundTrip = Effect.gen(function*() {
@@ -4037,8 +4138,8 @@ type EffectInvokeSource<States extends Machine.StateSchemas, Events extends Read
     readonly address?: never;
     readonly onSnapshot?: never;
 };
-type EffectDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, readonly [], readonly []>>;
-type EffectFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, readonly [], readonly []>>;
+type EffectDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, readonly [], readonly []>>;
+type EffectFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, readonly [], readonly []>>;
 type EffectInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never>;
 type 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>> = {
@@ -4050,9 +4151,77 @@ type BoundEffectInvokeSource<States extends Machine.StateSchemas, Events extends
     readonly address?: 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, 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, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
+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>;
+/**
+ * Contextually types direct and conditional 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>;
+}
+/**
+ * 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.
+ *
+ * ```ts
+ * Machine.transition({
+ *   target: (to) => to.full.Ready(),
+ *   resolve: ({ target }) => target.from()
+ * })
+ *
+ * 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()
+ *   }
+ * })
+ * ```
+ *
+ * @category constructors
+ * @since 0.14.0
+ */
+export declare const transition: TransitionConstructor;
 /**
  * Machine-bound invocation constructor that preserves the owning machine's
  * public input and parent protocols in every invocation callback.
@@ -4086,8 +4255,22 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
         readonly onFailure?: never;
     }): BoundEffectInvokeResult<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>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>>(config: Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, (context: Machine.InvokeContext<States, Events, Emits, StateId, 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>;
-    <StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object>(config: Config & Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
+    <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;
+    } & Machine.LogicInvokeArgs<States, Events, Emits, StateId, Machine.LogicStateOf<ReturnType<Source>>, Machine.LogicEventOf<ReturnType<Source>>, Machine.LogicErrorOf<ReturnType<Source>>, Machine.LogicServicesOf<ReturnType<Source>>, Machine.LogicOutputOf<ReturnType<Source>>, Machine.LogicInitialErrorOf<ReturnType<Source>>, Address, Source, InputEvents, ParentEvents>, ..._validation: ReturnType<Source> extends {
+        readonly initial: unknown;
+        readonly run: unknown;
+    } ? [] : [
+        "logic factory must return Machine.Logic"
+    ]): Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Machine.LogicOutputOf<ReturnType<Source>>, Machine.LogicErrorOf<ReturnType<Source>>, Machine.LogicServicesOf<ReturnType<Source>>, Machine.LogicInitialErrorOf<ReturnType<Source>>>;
+    <StateId extends Machine.StateIdentifier<States>, const Source, Address extends ChildAddress<never>>(config: {
+        readonly logic: Source;
+    } & Machine.LogicInvokeArgs<States, Events, Emits, StateId, Machine.LogicStateOf<Source>, Machine.LogicEventOf<Source>, Machine.LogicErrorOf<Source>, Machine.LogicServicesOf<Source>, Machine.LogicOutputOf<Source>, Machine.LogicInitialErrorOf<Source>, Address, Source, InputEvents, ParentEvents>, ..._validation: Source extends {
+        readonly initial: unknown;
+        readonly run: unknown;
+    } ? [] : [
+        "logic must implement Machine.Logic"
+    ]): Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Machine.LogicOutputOf<Source>, Machine.LogicErrorOf<Source>, Machine.LogicServicesOf<Source>, Machine.LogicInitialErrorOf<Source>>;
     <StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
 }
 /**
@@ -4121,8 +4304,14 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
  *       try: () => fetch("/api/data").then((response) => response.json()),
  *       catch: (cause) => new LoadError({ cause })
  *     }),
- *   onDone: ({ output, target }) => target.full.Ready({ data: output }),
- *   onFailure: ({ error, target }) => target.full.Failed({ error })
+ *   onDone: Machine.transition({
+ *     target: (to) => to.full.Ready(),
+ *     resolve: ({ output, target }) => target.from({ data: output })
+ *   }),
+ *   onFailure: Machine.transition({
+ *     target: (to) => to.full.Failed(),
+ *     resolve: ({ error, target }) => target.from({ error })
+ *   })
  * })
  * ```
  *
@@ -4188,7 +4377,10 @@ export declare const invoke: {
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: () => States.initial.Idle.from()
+ *   initial: {
+ *     target: (to) => to.Idle(),
+ *     resolve: ({ target }) => target.from()
+ *   }
  * }).handle({ Idle: {} })
  *
  * const initialState = Effect.map(Machine.planInitial(machine), (plan) => plan.state)
@@ -4238,6 +4430,17 @@ export declare const planInitial: <const States extends Machine.StateSchemas, co
  * @since 0.4.0
  */
 export declare const stateNodes: <M extends Machine.Any>(machine: M) => ReadonlyArray<Machine.StateNode<Machine.StateIdentifier<Machine.States<M>>, Machine.HistoryIdentifier<Machine.States<M>>, Machine.ChoiceIdentifier<Machine.States<M>>>>;
+/**
+ * Returns the statically selected root entry used during machine startup.
+ *
+ * This function does not execute the initial resolver or require machine
+ * input. `kind: "initial"` means that the selected root enters its declared
+ * initial configuration.
+ *
+ * @category getters
+ * @since 0.14.0
+ */
+export declare const initialDefinition: <M extends Machine.Any>(machine: M) => Machine.InitialDefinition<Machine.RootStateIdentifier<Machine.StateIdentifier<Machine.States<M>>>>;
 /**
  * Returns every registered transition handler in state definition order.
  *
@@ -4245,9 +4448,9 @@ export declare const stateNodes: <M extends Machine.Any>(machine: M) => Readonly
  *
  * Event handlers retain their handler-key order within each source state and
  * are followed by eventless and completion handlers. This function does not
- * execute handlers. Object-form event, eventless, and completion handlers with
- * a `targets` declaration expose those possible paths; handlers without one
- * remain dynamic.
+ * execute predicates or resolvers. Every direct, conditional, fallback, and
+ * targetless branch exposes the destination selected by its required static
+ * `target` declaration.
  *
  * @category getters
  * @since 0.4.0
@@ -4316,8 +4519,21 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(Toggle),
- *   initial: () => States.initial.Off.from()
- * }).handle({ Off: { on: { Toggle: () => States.initial.On.from() } }, On: {} })
+ *   initial: {
+ *     target: (to) => to.Off(),
+ *     resolve: ({ target }) => target.from()
+ *   }
+ * }).handle({
+ *   Off: {
+ *     on: {
+ *       Toggle: Machine.transition({
+ *         target: (to) => to.full.On(),
+ *         resolve: ({ target }) => target.from()
+ *       })
+ *     }
+ *   },
+ *   On: {}
+ * })
  *
  * const nextState = Effect.gen(function*() {
  *   const initial = yield* Machine.planInitial(machine)
@@ -4384,37 +4600,6 @@ export declare const logic: <State, Event = never, Output = void, Error = never,
     readonly initial: State | ((scope: Logic.Scope<Event>) => Effect.Effect<State, InitialError, InitialRequirements>);
     readonly run: (context: Logic.Context<State, Event>) => Effect.Effect<Output, Error, Requirements>;
 }) => Logic<State, Event, Error, Requirements | InitialRequirements, Output, InitialError>;
-/**
- * Creates child process logic from an initial state and a transition function.
- *
- * **When to use**
- *
- * Use when a child process only needs sequential event-driven state updates and
- * does not need direct control over intermediate snapshots or child ownership.
- *
- * **Details**
- *
- * Each received event runs the transition Effect against the latest state. The
- * resulting state is published before the next queued event is processed.
- *
- * **Example**
- *
- * ```ts
- * import { Effect } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * const counter = Machine.transition(
- *   0,
- *   (count, event: { readonly by: number }) => Effect.succeed(count + event.by)
- * )
- * ```
- *
- * Use an inline `invoke` with an `effect` source for one-shot work.
- * @see {@link logic} for direct process lifecycle control.
- * @category constructors
- * @since 0.4.0
- */
-export declare const transition: <State, Event, Error = never, Requirements = never>(initial: State, transition: (state: State, event: Event) => Effect.Effect<State, Error, Requirements>) => Logic<State, Event, Error, Requirements, never>;
 /**
  * Creates a typed descriptor for a complete child machine.
  *
@@ -4541,7 +4726,10 @@ export declare const prepare: <const States extends Machine.StateSchemas, const
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: () => States.initial.Idle.from()
+ *   initial: {
+ *     target: (to) => to.Idle(),
+ *     resolve: ({ target }) => target.from()
+ *   }
  * }).handle({ Idle: {} })
  *
  * const state = Effect.gen(function*() {
@@ -4591,7 +4779,10 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: () => States.initial.Idle.from()
+ *   initial: {
+ *     target: (to) => to.Idle(),
+ *     resolve: ({ target }) => target.from()
+ *   }
  * }).handle({ Idle: {} })
  *
  * const resumed = Effect.gen(function*() {