@typeonce/effect-machine 0.12.0 → 0.14.0

package/src/Machine.ts

@@ -7,6 +7,7 @@
 import type * as Cause from "effect/Cause"
 import type * as Duration from "effect/Duration"
 import type * as Effect from "effect/Effect"
+import type * as Exit from "effect/Exit"
 import type * as Option from "effect/Option"
 import type { Pipeable } from "effect/Pipeable"
 import { hasProperty } from "effect/Predicate"
@@ -52,6 +53,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
 
 const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId = internal.ChildMachineLogicTypeId
 
@@ -257,6 +259,8 @@ export interface Machine<
 
   /** @internal */
   readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
+  /** @internal */
+  readonly initialDefinition: Machine.InitialDefinition
 }
 
 export {
@@ -536,6 +540,7 @@ type IncompatibleRuntime<Requirements, Events, Emits> = Requirements extends Run
   : never
 
 const InvokeTypeId: typeof internal.InvokeTypeId = internal.InvokeTypeId
+const TransitionTypeId: typeof internal.TransitionTypeId = internal.TransitionTypeId
 
 type StateDefinitionError<
   Message extends string,
@@ -840,6 +845,42 @@ type NodeMethod<
 > = Machine.NodeSchema<Node> extends never ? FromMethod<FromArguments, Result>
   : ((...args: Arguments) => Result) & FromMethod<FromArguments, Result>
 
+type NodeMethodWithInitial<
+  Node,
+  Arguments extends ReadonlyArray<unknown>,
+  Result,
+  FromArguments extends ReadonlyArray<unknown>,
+  Path extends string
+> = Machine.NodeSchema<Node> extends never ? {
+    readonly from: FromCallable<FromArguments, Machine.StateConstruction<Result>>
+    readonly initial: InitialTargetFactory<Node, Path>
+  }
+  :
+    & ((...args: Arguments) => Result)
+    & {
+      readonly from: FromCallable<FromArguments, Machine.StateConstruction<Result>>
+      readonly initial: InitialTargetFactory<Node, Path>
+    }
+
+interface InitialTargetMethod<
+  Node,
+  Path extends string
+> {
+  /** Enters this state through its declared initial configuration. */
+  readonly initial: InitialTargetFactory<Node, Path>
+}
+
+interface InitialTargetFactory<
+  Node,
+  Path extends string
+> {
+  (...args: WithNodeValue<Node, readonly []>): Machine.InitialTarget<Path>
+  readonly from: FromCallable<
+    WithNodeInput<Node, readonly []>,
+    Machine.StateConstruction<Machine.InitialTarget<Path>>
+  >
+}
+
 type NodeConstructionSelectorFromCallable<Node, Builder, Result> = Machine.NodeSchema<Node> extends never ? {
     <Selected extends ConstructionResult<Result>>(
       state: (builder: Builder) => Selected
@@ -847,15 +888,19 @@ type NodeConstructionSelectorFromCallable<Node, Builder, Result> = Machine.NodeS
   }
   : ConstructionSelectorFromCallable<NodeMakeInput<Node>, Builder, Result>
 
-type NestedTargetMethod<Node, Builder, Result> = Machine.NodeSchema<Node> extends never ? {
+type NestedTargetMethod<Node, Builder, Result, Path extends string> = Machine.NodeSchema<Node> extends never ? {
     readonly from: NodeConstructionSelectorFromCallable<Node, Builder, Result>
+    readonly initial: InitialTargetFactory<Node, Path>
   }
   :
     & (<Selected extends ConstructionResult<Result>>(
       value: NodeValue<Node>,
       state: (builder: Builder) => Selected
     ) => Selected)
-    & { readonly from: NodeConstructionSelectorFromCallable<Node, Builder, Result> }
+    & {
+      readonly from: NodeConstructionSelectorFromCallable<Node, Builder, Result>
+      readonly initial: InitialTargetFactory<Node, Path>
+    }
 
 type ConstructionSelectorFromCallable<Input, Builder, Result> = {} extends Input ? {
     <Selected extends ConstructionResult<Result>>(
@@ -1093,6 +1138,14 @@ type FullSnapshotResult<
   Path extends string = Machine.JoinPath<Prefix, StateId>
 > = Machine.SnapshotByIdentifierWithPath<States, StateId, Path>
 
+type InitialEntryStateKey<States extends Machine.StateSchemas> = {
+  readonly [Key in ActiveStateKey<States>]: States[Key] extends { readonly states: Machine.StateSchemas } ? Key : never
+}[ActiveStateKey<States>]
+
+type FullInitialTargetBuilder<States extends Machine.StateSchemas> = {
+  readonly [Key in InitialEntryStateKey<States>]: InitialTargetMethod<States[Key], Key>
+}
+
 type FullParallelBuilder<
   States extends Machine.StateSchemas,
   Prefix extends string,
@@ -1383,9 +1436,10 @@ type LocalTargetMethod<
     Source extends Path | `${Path}.${string}` ? NestedTargetMethod<
         Node,
         LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>,
-        LocalTargetResultWithPrefix<AllStates, Children, Path>
+        LocalTargetResultWithPrefix<AllStates, Children, Path>,
+        Path
       >
-    : NodeMethod<
+    : NodeMethodWithInitial<
       Node,
       WithNodeValue<Node, [
         states: (
@@ -1397,12 +1451,14 @@ type LocalTargetMethod<
         states: (
           builder: FullParallelBuilder<Children, Path>
         ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-      ]>
+      ]>,
+      Path
     >
   : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? NestedTargetMethod<
       Node,
       LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>,
-      LocalTargetResultWithPrefix<AllStates, Children, Path>
+      LocalTargetResultWithPrefix<AllStates, Children, Path>,
+      Path
     >
   : NodeMethod<
     Node,
@@ -1497,10 +1553,11 @@ type BranchTargetMethod<
         & NestedTargetMethod<
           Node,
           BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>,
-          BranchTargetResultWithPrefix<AllStates, Children, Path>
+          BranchTargetResultWithPrefix<AllStates, Children, Path>,
+          Path
         >
         & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>
-    : NodeMethod<
+    : NodeMethodWithInitial<
       Node,
       WithNodeValue<Node, [
         states: (
@@ -1512,13 +1569,15 @@ type BranchTargetMethod<
         states: (
           builder: FullParallelBuilder<Children, Path>
         ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-      ]>
+      ]>,
+      Path
     >
   : Node extends { readonly states: infer Children extends Machine.StateSchemas } ?
       & NestedTargetMethod<
         Node,
         BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>,
-        BranchTargetResultWithPrefix<AllStates, Children, Path>
+        BranchTargetResultWithPrefix<AllStates, Children, Path>,
+        Path
       >
       & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>
   : NodeMethod<
@@ -1664,6 +1723,187 @@ export type RuntimeSnapshot<State, Error = never, Output = never> =
     readonly state: State
   }
 
+/**
+ * Live, root-scoped records describing one prepared machine tree.
+ *
+ * Inspection records deliberately erase machine-specific values to `unknown`:
+ * one stream may contain unrelated root, child-machine, and `Logic` protocols.
+ * The record structure remains a closed discriminated union, while typed
+ * application observation continues through `changes` and `emissions`.
+ *
+ * @category models
+ * @since 0.13.0
+ */
+export declare namespace Inspection {
+  /** Read-only identity of a local machine endpoint. */
+  export interface Endpoint {
+    readonly id: string
+    readonly sessionId: string
+  }
+
+  /** Read-only identity of a runtime represented in the inspection tree. */
+  export interface Subject extends Endpoint {
+    readonly kind: "Machine" | "Logic"
+  }
+
+  /** Causal origin of an inspected runtime. */
+  export type Origin =
+    | { readonly _tag: "Root" }
+    | {
+      readonly _tag: "Invoke"
+      readonly ownerPath: string
+      readonly invokeId: string
+    }
+    | {
+      readonly _tag: "Spawn"
+      readonly address: string | undefined
+    }
+
+  /** Causal owner of a send or emission. */
+  export type Causation =
+    | { readonly _tag: "Initialization" }
+    | { readonly _tag: "Macrostep"; readonly macrostepId: number }
+    | { readonly _tag: "Activity"; readonly activitySessionId: string }
+
+  /** Closed command projection safe for observation. */
+  export type Command =
+    | {
+      readonly _tag: "SendTo"
+      readonly target: Endpoint | { readonly id: string }
+      readonly event: unknown
+    }
+    | {
+      readonly _tag: "Stop"
+      readonly target: Endpoint | { readonly id: string }
+    }
+
+  /** One statechart microstep in a committed macrostep. */
+  export interface Microstep {
+    readonly event: unknown
+    readonly transitions: ReadonlyArray<Machine.RetainedTransition>
+    readonly raisedEvents: ReadonlyArray<unknown>
+    readonly emittedEvents: ReadonlyArray<unknown>
+    readonly commands: ReadonlyArray<Command>
+    readonly exitPaths: ReadonlyArray<string>
+    readonly entryPaths: ReadonlyArray<string>
+    readonly changed: boolean
+  }
+
+  /** Common ordering and identity fields for every record. */
+  export interface Base {
+    /** Total publication order within this prepared root. */
+    readonly sequence: number
+    /** Session id of the prepared root that owns this inspection stream. */
+    readonly rootSessionId: string
+    /** Runtime instance described by this record. */
+    readonly subject: Subject
+  }
+
+  /** Announces allocation of a root or owned process identity. */
+  export interface Created extends Base {
+    readonly _tag: "Created"
+    readonly parent: Subject | undefined
+    readonly origin: Origin
+    /** Compiled statechart definition; absent for generic `Logic`. */
+    readonly definition: Machine.Any | undefined
+  }
+
+  /** Announces successful initialization. */
+  export interface Initialized extends Base {
+    readonly _tag: "Initialized"
+    readonly snapshot: RuntimeSnapshot<unknown, unknown, unknown>
+    readonly initialEntryPaths: ReadonlyArray<string>
+    readonly microsteps: ReadonlyArray<Microstep>
+  }
+
+  /** Announces failure before an initial runtime snapshot exists. */
+  export interface StartFailed extends Base {
+    readonly _tag: "StartFailed"
+    readonly cause: Cause.Cause<unknown>
+  }
+
+  /** Announces acceptance of an event by a local mailbox. */
+  export interface EventSent extends Base {
+    readonly _tag: "EventSent"
+    readonly deliveryId: number
+    readonly source: Subject | undefined
+    readonly target: Endpoint
+    readonly event: unknown
+    readonly causedBy: Causation | undefined
+  }
+
+  /** Announces complete processing of one statechart mailbox event. */
+  export interface EventProcessed extends Base {
+    readonly _tag: "EventProcessed"
+    readonly macrostepId: number
+    readonly deliveryId: number
+    readonly source: Subject | undefined
+    readonly event: unknown
+    readonly before: RuntimeSnapshot<unknown, unknown, unknown>
+    readonly after: RuntimeSnapshot<unknown, unknown, unknown>
+    readonly handled: boolean
+    readonly configurationChanged: boolean
+    readonly microsteps: ReadonlyArray<Microstep>
+  }
+
+  /** Announces a direct state update made by generic `Logic`. */
+  export interface StateChanged extends Base {
+    readonly _tag: "StateChanged"
+    readonly before: unknown
+    readonly after: unknown
+    readonly causedByDeliveryId: number | undefined
+  }
+
+  /** Announces actual publication on a machine's domain emission stream. */
+  export interface Emitted extends Base {
+    readonly _tag: "Emitted"
+    readonly emission: unknown
+    readonly causedBy: Causation | undefined
+  }
+
+  /** Identity of one Effect or timer invocation run. */
+  export interface Activity {
+    readonly id: string
+    readonly sessionId: string
+    readonly owner: Subject
+    readonly ownerPath: string
+    readonly kind: "Effect" | "Timer"
+  }
+
+  /** Announces an Effect or timer invocation starting. */
+  export interface ActivityStarted extends Base {
+    readonly _tag: "ActivityStarted"
+    readonly activity: Activity
+  }
+
+  /** Announces an Effect or timer invocation outcome. */
+  export interface ActivityStopped extends Base {
+    readonly _tag: "ActivityStopped"
+    readonly activity: Activity
+    /** Success or failure from the invoke; interruption means its owner stopped it. */
+    readonly exit: Exit.Exit<unknown, unknown>
+  }
+
+  /** Announces a terminal local runtime snapshot. */
+  export interface Terminated extends Base {
+    readonly _tag: "Terminated"
+    readonly snapshot: RuntimeSnapshot<unknown, unknown, unknown>
+  }
+
+  /** Complete live inspection protocol. */
+  export type Event =
+    | Created
+    | Initialized
+    | StartFailed
+    | EventSent
+    | EventProcessed
+    | StateChanged
+    | Emitted
+    | ActivityStarted
+    | ActivityStopped
+    | Terminated
+}
+
 /**
  * Represents a classified terminal outcome derived from a runtime snapshot.
  *
@@ -1726,6 +1966,14 @@ export interface Prepared<out State, in Event, out Error, out Output, out Emitte
   /** Streams ephemeral notifications published after subscription. */
   readonly emissions: Stream.Stream<Emitted>
 
+  /**
+   * Streams ordered operational records for this root and every locally owned
+   * descendant. The stream is hot, non-replayed, never fails, and completes
+   * after the prepared root terminates. Subscribe before evaluating `start` to
+   * observe initialization.
+   */
+  readonly inspection: Stream.Stream<Inspection.Event>
+
   /** Initializes this machine once and returns its running reference. */
   readonly start: Effect.Effect<MachineRef<State, Event, Error, Output, Emitted>, StartError, StartRequirements>
 }
@@ -2167,6 +2415,8 @@ export declare namespace Machine {
     readonly invoke: any
     /** @internal */
     readonly initial: any
+    /** @internal */
+    readonly initialDefinition: InitialDefinition
   }
 
   /**
@@ -2647,15 +2897,15 @@ export declare namespace Machine {
    * @category utility types
    * @since 0.4.0
    */
-  export type InitialBuilder<States extends StateSchemas> = InitialSnapshotBuilderWithPrefix<States>
+  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
@@ -2665,9 +2915,6 @@ export declare namespace Machine {
     /** 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
@@ -2914,31 +3161,50 @@ export declare namespace Machine {
       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
-   */
-  export type TransitionTargets<Path extends string = string> =
+  /** Static topology selected by a transition branch. */
+  export 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. */
+  export type TransitionBranch<Path extends string = string> =
     | {
-      readonly type: "dynamic"
+      readonly type: "direct"
+      readonly target: Path | undefined
+      readonly selection: TransitionTargetSelection<Path | undefined>
     }
     | {
-      readonly type: "declared"
-      readonly paths: ReadonlyArray<Path>
+      readonly type: "case"
+      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> {
+    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
@@ -2951,7 +3217,7 @@ export declare namespace Machine {
     readonly source: SourcePath
     readonly trigger: TransitionTrigger<EventTag>
     readonly reenter: boolean
-    readonly targets: TransitionTargets<TargetPath>
+    readonly branches: ReadonlyArray<TransitionBranch<TargetPath>>
   }
 
   /**
@@ -2981,9 +3247,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
   }
 
@@ -3813,9 +4084,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
@@ -3843,6 +4112,23 @@ export declare namespace Machine {
     readonly parent: Extract<ParentPath<HistoryId>, StateIdentifier<States>>
   }
 
+  /**
+   * Transition instruction that enters a compound or parallel state through
+   * its declared initial configuration.
+   *
+   * @category models
+   * @since 0.13.0
+   */
+  export interface InitialTarget<StateId extends string> {
+    readonly [Topology.TargetTypeId]: typeof Topology.TargetTypeId
+    readonly [Topology.TargetSnapshotTypeId]?: never
+    readonly [Topology.InitialTargetTypeId]: typeof Topology.InitialTargetTypeId
+    readonly _tag: "InitialTarget"
+    readonly path: StateId
+    readonly value: never
+    readonly values?: never
+  }
+
   /** Branded transient target instruction used while constructing initial states. */
   export interface ChoiceTargetInstruction<ChoiceId extends string = string> {
     readonly [Topology.ChoiceTargetTypeId]: typeof Topology.ChoiceTargetTypeId
@@ -3873,7 +4159,9 @@ export declare namespace Machine {
    * @category utility types
    * @since 0.4.0
    */
-  export type FullTargetBuilder<States extends StateSchemas> = FullSnapshotBuilderWithPrefix<States>
+  export type FullTargetBuilder<States extends StateSchemas> = [InitialEntryStateKey<States>] extends [never] ?
+    FullSnapshotBuilderWithPrefix<States>
+    : FullSnapshotBuilderWithPrefix<States> & FullInitialTargetBuilder<States>
 
   /**
    * Builder for a complete fallback configuration containing a history owner.
@@ -3953,8 +4241,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
      */
@@ -3995,6 +4282,159 @@ export declare namespace Machine {
     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
+   */
+  export 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. */
+  export 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. */
+  export 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.
    *
@@ -4292,7 +4732,8 @@ export declare namespace Machine {
   export type InitialResult<States extends StateSchemas, E, R> =
     | Snapshot<States>
     | InitialSnapshot<States>
-    | StateConstruction<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. */
   export type InitialSnapshot<States extends StateSchemas> = {
@@ -4376,8 +4817,8 @@ export declare namespace Machine {
     ? NonNullable<Config[Key]> extends (...args: any) => infer Ret ? Ret : never
     : never
   /** Extracts the return value from an implicit initial child implementation. */
-  export type StateInitialReturn<Config> = Config extends { readonly initial?: infer Initial }
-    ? NonNullable<Initial> extends (...args: any) => infer Ret ? Ret : never
+  export type StateInitializeReturn<Config> = Config extends { readonly initialize?: infer Initialize }
+    ? NonNullable<Initialize> extends (...args: any) => infer Ret ? Ret : never
     : never
   /** Extracts the return values from a state's history defaults. */
   export type HistoryDefaultReturn<Config> = Config extends { readonly history?: infer History } ? {
@@ -4388,19 +4829,22 @@ export declare namespace Machine {
     }[keyof NonNullable<History>]
     : never
   /** Extracts the return value from a choice resolver. */
-  export type ChoiceReturn<Config> = Config extends {
-    readonly choice: { readonly transition: (...args: any) => infer Ret }
-  } ? Ret :
-    never
+  export type ChoiceReturn<Config> = Config extends { readonly choice: infer Choice } ? EventTransitionReturn<Choice>
+    : never
   /**
    * Extracts the return value from an event transition config.
    *
    * @category utility types
    * @since 0.4.0
    */
-  export type EventTransitionReturn<Transition> = Transition extends (...args: any) => infer Ret ? Ret
-    : Transition extends { readonly transition: (...args: any) => infer Ret } ? Ret
-    : never
+  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)
   /**
    * Extracts the return value from a state's event handlers.
    *
@@ -4434,6 +4878,8 @@ export declare namespace Machine {
    */
   export type InvokeResolvedSource<Source> = Source extends (...args: any) => infer Resolved ? Resolved : Source
 
+  type InvokeFactoryResult<Source> = Source extends (...args: any) => infer Resolved ? Resolved : never
+
   type ChildMachineLogic<Child> = Child extends ChildMachine<string, infer M> ? Logic<
       Snapshot<States<M>>,
       EventInput<InputEvent<M>>,
@@ -4455,7 +4901,7 @@ export declare namespace Machine {
     : never
 
   export type InvokeLogic<Invoke> = Invoke extends { readonly effect: infer Source } ?
-    InvokeResolvedSource<Source> extends infer Fx extends Effect.Effect<any, any, any> ? Logic<
+    InvokeFactoryResult<Source> extends infer Fx extends Effect.Effect<any, any, any> ? Logic<
         void,
         never,
         Effect.Error<Fx>,
@@ -4600,34 +5046,146 @@ export declare namespace Machine {
     | Effect.Services<DoneReturn<Config>>
     | Effect.Services<StateActionReturn<Config, "entry">>
     | Effect.Services<StateActionReturn<Config, "exit">>
-    | Effect.Services<StateInitialReturn<Config>>
     | Effect.Services<HistoryDefaultReturn<Config>>
     | Effect.Services<ChoiceReturn<Config>>
     | InvokeRequirements<Config>
 
-  export type InvokeTransition<
+  type TransitionWhenContext<Context> = Omit<Context, "target">
+
+  /** Type evidence retained by {@link transition} without affecting runtime data. */
+  export interface TransitionTyped<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    Context
+    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. */
+  export interface TargetlessTransitionTyped {
+    readonly [TransitionTypeId]: {
+      readonly targetless: true
+    }
+  }
+
+  /** The only transition value accepted by machine handler APIs. */
+  export type TransitionConfig<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateNodeIdentifier<States>,
+    Context,
+    Reenter extends boolean = false
   > =
-    | ((context: Context, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>)
-    | {
-      readonly reenter?: boolean
-      readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>
-      readonly transition: (
-        context: Context,
-        enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
-      ) => HandlerResult<States, any, any>
+    & (TransitionTyped<States, Events, Emits, StateId, Context, Reenter> | TargetlessTransitionTyped)
+    & {
+      readonly reenter?: [Reenter] extends [true] ? boolean : never
     }
 
-  export type InvokeSource<Value, Context> = Value | ((context: Context) => Value)
+  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
+  export type TargetBuilderResult<Builder> =
+    | (Builder extends (...args: any) => infer Result ? Result : never)
+    | (Builder extends { readonly from: (...args: any) => infer Result } ? Result : never)
+  export type SelectedTargetResult<Selection> = SelectionBuilder<Selection> extends infer Builder ?
+    TargetBuilderResult<Builder>
+    : never
+
+  export type TransitionResolveContext<
+    Context,
+    Selection,
+    Match = never
+  > =
+    & 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
+  > = (
+    context: TransitionResolveContext<Context, Selection, Match>,
+    enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
+  ) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined
+
+  export 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
+  }
+
+  export 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
+  }
 
-  interface AnyLogicSource {
-    initial(...args: ReadonlyArray<any>): Effect.Effect<any, any, any>
-    run(...args: ReadonlyArray<any>): Effect.Effect<any, any, any>
+  export 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
   }
 
+  export 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>
+
+  export type InvokeSource<Value, Context> = Value | ((context: Context) => Value)
+
   /** Inline state-owned work that runs for the lifetime of its active state. */
   export interface InvokeOwned<
     States extends StateSchemas,
@@ -4662,10 +5220,9 @@ export declare namespace Machine {
     & (
       | {
         readonly id: string
-        readonly effect: InvokeSource<
-          Effect.Effect<any, any, any>,
-          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-        >
+        readonly effect: (
+          context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        ) => Effect.Effect<any, any, any>
         readonly after?: never
         readonly logic?: never
         readonly child?: never
@@ -4692,7 +5249,7 @@ export declare namespace Machine {
         readonly id: string
         readonly address: string
         readonly logic: InvokeSource<
-          AnyLogicSource,
+          Logic<any, any, any, any, any, any>,
           InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
         >
         readonly effect?: never
@@ -4749,61 +5306,7 @@ export declare namespace Machine {
     : { readonly onFailure?: never }
     : never
 
-  export type EffectInvokeArgs<
-    States extends StateSchemas,
-    Events extends ReadonlyArray<TaggedSchema>,
-    Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
-    Fx extends Effect.Effect<any, any, any>,
-    Source = Fx,
-    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
-    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > =
-    & {
-      readonly id: InvokeLifecycleId
-      readonly effect: Source
-      readonly after?: never
-      readonly logic?: never
-      readonly child?: never
-      readonly address?: never
-      readonly onSnapshot?: never
-    }
-    & InvokeDoneRequirement<
-      Effect.Success<NoInfer<Fx>>,
-      InvokeTransition<
-        States,
-        Events,
-        Emits,
-        InvokeDoneContext<
-          States,
-          Events,
-          Emits,
-          StateId,
-          Effect.Success<NoInfer<Fx>>,
-          InputEvents,
-          ParentEvents
-        >
-      >
-    >
-    & InvokeFailureRequirement<
-      Effect.Error<NoInfer<Fx>>,
-      InvokeTransition<
-        States,
-        Events,
-        Emits,
-        InvokeFailureContext<
-          States,
-          Events,
-          Emits,
-          StateId,
-          Effect.Error<NoInfer<Fx>>,
-          InputEvents,
-          ParentEvents
-        >
-      >
-    >
-
-  export type TimerInvokeArgs<
+  export type TimerInvokeArgs<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -4826,6 +5329,7 @@ export declare namespace Machine {
       States,
       Events,
       Emits,
+      StateId,
       InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
     >
   }
@@ -4857,35 +5361,38 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
+        StateId,
         InvokeSnapshotContext<
           States,
           Events,
           Emits,
           StateId,
-          ChildState,
-          ChildError,
-          ChildOutput,
+          NoInfer<ChildState>,
+          NoInfer<ChildError>,
+          NoInfer<ChildOutput>,
           InputEvents,
           ParentEvents
         >
       >
     }
     & InvokeDoneRequirement<
-      ChildOutput,
+      NoInfer<ChildOutput>,
       InvokeTransition<
         States,
         Events,
         Emits,
-        InvokeDoneContext<States, Events, Emits, StateId, ChildOutput, InputEvents, ParentEvents>
+        StateId,
+        InvokeDoneContext<States, Events, Emits, StateId, NoInfer<ChildOutput>, InputEvents, ParentEvents>
       >
     >
     & InvokeFailureRequirement<
-      ChildError,
+      NoInfer<ChildError>,
       InvokeTransition<
         States,
         Events,
         Emits,
-        InvokeFailureContext<States, Events, Emits, StateId, ChildError, InputEvents, ParentEvents>
+        StateId,
+        InvokeFailureContext<States, Events, Emits, StateId, NoInfer<ChildError>, InputEvents, ParentEvents>
       >
     >
 
@@ -4917,6 +5424,7 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
+        StateId,
         InvokeSnapshotContext<
           States,
           Events,
@@ -4942,6 +5450,7 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
+        StateId,
         InvokeDoneContext<
           States,
           Events,
@@ -4959,6 +5468,7 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
+        StateId,
         InvokeFailureContext<
           States,
           Events,
@@ -4971,12 +5481,24 @@ export declare namespace Machine {
       >
     >
 
-  export type LogicStateOf<Value> = Value extends Logic<infer State, any, any, any, any, any> ? State : never
-  export type LogicEventOf<Value> = Value extends Logic<any, infer Event, any, any, any, any> ? Event : never
-  export type LogicErrorOf<Value> = Value extends Logic<any, any, infer Error, any, any, any> ? Error : never
-  export type LogicServicesOf<Value> = Value extends Logic<any, any, any, infer Services, any, any> ? Services : never
-  export type LogicOutputOf<Value> = Value extends Logic<any, any, any, any, infer Output, any> ? Output : never
-  export type LogicInitialErrorOf<Value> = Value extends Logic<any, any, any, any, any, infer Error> ? Error : never
+  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
+
+  export type LogicStateOf<Value> = Effect.Success<LogicInitialEffectOf<Value>>
+  export 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
+  export type LogicErrorOf<Value> = Effect.Error<LogicRunEffectOf<Value>>
+  export type LogicServicesOf<Value> = Effect.Services<LogicInitialEffectOf<Value> | LogicRunEffectOf<Value>>
+  export type LogicOutputOf<Value> = Effect.Success<LogicRunEffectOf<Value>>
+  export type LogicInitialErrorOf<Value> = Effect.Error<LogicInitialEffectOf<Value>>
 
   type ContextualInvokeConfig<
     States extends StateSchemas,
@@ -4988,13 +5510,14 @@ export declare namespace Machine {
     Raw
   > = Raw extends InvokeTyped<any, any, any, any, any> ? unknown
     : Raw extends { readonly effect: infer Source } ?
-      InvokeResolvedSource<Source> extends infer Fx extends Effect.Effect<any, any, any> ?
+      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>
             >
           >
@@ -5004,6 +5527,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
+              StateId,
               InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>
             >
           >
@@ -5014,6 +5538,7 @@ export declare namespace Machine {
           States,
           Events,
           Emits,
+          StateId,
           InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
         >
         readonly onFailure?: never
@@ -5027,6 +5552,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
+              StateId,
               InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>, InputEvents, ParentEvents>
             >
           >
@@ -5036,6 +5562,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
+              StateId,
               InvokeFailureContext<
                 States,
                 Events,
@@ -5058,6 +5585,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
+              StateId,
               InvokeSnapshotContext<
                 States,
                 Events,
@@ -5080,6 +5608,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
+              StateId,
               InvokeDoneContext<
                 States,
                 Events,
@@ -5097,6 +5626,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
+              StateId,
               InvokeFailureContext<
                 States,
                 Events,
@@ -5119,6 +5649,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
+              StateId,
               InvokeSnapshotContext<
                 States,
                 Events,
@@ -5209,57 +5740,40 @@ export declare namespace Machine {
     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 initial?: StateInitialHandler<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    readonly initialize?: StateInitializeHandler<States, Events, Emits, StateId, InputEvents, ParentEvents>
   } & ActiveOutputHandlerConfig<States, Events, StateId>
 
-  /** Values supplied when a statechart implicitly enters a state's initial children. */
-  export type StateInitialValue<
+  /**
+   * Values constructed for a state's schema-valued direct initial children.
+   *
+   * @category utility types
+   * @since 0.13.0
+   */
+  export type StateInitializeValue<
     States extends StateSchemas,
     StateId extends StateIdentifier<States>
   > = NodeByIdentifier<States, StateId> extends infer Node ?
@@ -5270,23 +5784,92 @@ export declare namespace Machine {
       }
     : Node extends { readonly states: infer Children extends StateSchemas; readonly initial: infer Initial } ?
       Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never
-        : NodeValue<Children[Initial]>
+        : { readonly [Key in Initial]: NodeValue<Children[Initial]> }
       : never
     : never
     : never
 
-  /** Context passed to an implicit child-state initializer. */
-  export type StateInitialContext<
+  type StateInitializeCompoundBuilder<Node, Initial extends PropertyKey> = Node extends {
+    readonly states: infer Children extends StateSchemas
+  } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never
+      : NodeBuilderMethod<
+        Children[Initial],
+        readonly [value: NodeValue<Children[Initial]>],
+        SnapshotBuilderComplete<{ readonly [Key in Initial]: NodeValue<Children[Initial]> }>,
+        readonly [input: NodeMakeInput<Children[Initial]>],
+        SnapshotBuilderComplete<{ readonly [Key in Initial]: NodeValue<Children[Initial]> }, true>
+      >
+    : never
+    : never
+
+  type StateInitializeParallelBuilder<
+    Children extends StateSchemas,
+    Remaining extends ActiveStateKey<Children> = {
+      readonly [Key in ActiveStateKey<Children>]: NodeSchema<Children[Key]> extends never ? never : Key
+    }[ActiveStateKey<Children>],
+    Values = {},
+    Constructed extends boolean = false
+  > =
+    & SnapshotBuilderComplete<Values, Constructed>
+    & {
+      readonly [Key in Remaining]: NodeBuilderMethod<
+        Children[Key],
+        readonly [value: NodeValue<Children[Key]>],
+        StateInitializeParallelBuilder<
+          Children,
+          Exclude<Remaining, Key>,
+          Values & { readonly [Region in Key]: NodeValue<Children[Key]> },
+          Constructed
+        >,
+        readonly [input: NodeMakeInput<Children[Key]>],
+        StateInitializeParallelBuilder<
+          Children,
+          Exclude<Remaining, Key>,
+          Values & { readonly [Region in Key]: NodeValue<Children[Key]> },
+          true
+        >
+      >
+    }
+
+  /**
+   * Builder bound to the direct initial child or regions owned by a state.
+   *
+   * @category utility types
+   * @since 0.13.0
+   */
+  export type StateInitializeBuilder<
+    States extends StateSchemas,
+    StateId extends StateIdentifier<States>,
+    Node = NodeByIdentifier<States, StateId>
+  > = Node extends { readonly type: "parallel"; readonly states: infer Children extends StateSchemas } ?
+    StateInitializeParallelBuilder<Children>
+    : Node extends { readonly initial: infer Initial } ? StateInitializeCompoundBuilder<Node, Initial & PropertyKey>
+    : never
+
+  /**
+   * Context passed to an implicit child-state initializer.
+   *
+   * @category models
+   * @since 0.13.0
+   */
+  export type StateInitializeContext<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > = StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  > = StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents> & {
+    readonly builder: StateInitializeBuilder<States, StateId>
+  }
 
-  /** Initial child value implementation for a compound or parallel state. */
-  export type StateInitialHandler<
+  /**
+   * Initial child value implementation for a compound or parallel state.
+   *
+   * @category models
+   * @since 0.13.0
+   */
+  export type StateInitializeHandler<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -5294,9 +5877,9 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = (
-    context: StateInitialContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
+    context: StateInitializeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
     enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
-  ) => StateInitialValue<States, StateId>
+  ) => SnapshotBuilderComplete<StateInitializeValue<States, StateId>, boolean>
 
   /** Context used only when a history node has no previously captured record. */
   export interface HistoryDefaultContext<
@@ -5351,14 +5934,13 @@ export declare namespace Machine {
     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
@@ -5366,7 +5948,7 @@ export declare namespace Machine {
     readonly on?: never
     readonly onDone?: never
     readonly output?: never
-    readonly initial?: never
+    readonly initialize?: never
   }
 
   /**
@@ -5589,7 +6171,7 @@ export declare namespace Machine {
     | "entry"
     | "exit"
     | "history"
-    | "initial"
+    | "initialize"
     | "invoke"
     | "on"
     | "onDone"
@@ -5696,62 +6278,73 @@ export declare namespace Machine {
     }
     : 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 DeclaredTransitionTarget<Transition> = Transition extends {
-    readonly targets: infer Targets extends ReadonlyArray<string>
-  } ? Targets[number]
+  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"
+    } ? Result extends { readonly path: infer Path extends string } ? Path : never
     : never
 
-  type ExcludeDeclaredTransitionTarget<Returned, Declared extends string> = Returned extends string ?
-    Returned extends Declared | `${Declared}.${string}` ? never : Returned
-    : never
+  type HandlerConfigInitialTargetPath<Config> = TransitionResultInitialTargetPath<
+    | EventHandlerReturn<Config>
+    | AlwaysReturn<Config>
+    | DoneReturn<Config>
+    | ChoiceReturn<Config>
+    | InvokeOutcomeReturn<InvokeReturn<Config>>
+  >
 
-  type UndeclaredTransitionTarget<Transition> = "targets" extends keyof Transition ? ExcludeDeclaredTransitionTarget<
-      TransitionResultTargetPath<EventTransitionReturn<Transition>>,
-      DeclaredTransitionTarget<Transition>
+  type RequiredInitializersForTargetPath<
+    AllStates extends StateSchemas,
+    Path
+  > = string extends Path ? never : Path extends StateIdentifier<AllStates> ? InitializerClosureForNode<
+      AllStates,
+      NodeByIdentifier<AllStates, Path>,
+      Path
     >
+  : never
+
+  type HandlerInitializeValidationAtPath<Config, Path extends string> = HandlerConfigAtPath<Config, Path> extends
+    infer StateConfig ? [StateConfig] extends [never] ? HandlerValidationAtPath<Path, {
+        readonly initialize: HandlerValidationError<
+          "State requires initialize because a transition enters its declared initial configuration",
+          Path
+        >
+      }>
+    : "initialize" extends keyof StateConfig ? never
+    : HandlerValidationAtPath<Path, {
+      readonly initialize: HandlerValidationError<
+        "State requires initialize because a transition enters its declared initial configuration",
+        Path
+      >
+    }>
     : 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 HandlerInitialTargetValidationForPaths<
+    AllStates extends StateSchemas,
+    Config,
+    Required
+  > = Types.UnionToIntersection<
+    Required extends string ? HandlerInitializeValidationAtPath<Config, Required> : unknown
+  >
 
-  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 HandlerTreeInitialTargetPath<Config> = string extends keyof Config ? never
+    : Config extends object ? {
+        readonly [Key in keyof Config]:
+          | HandlerConfigInitialTargetPath<HandlerConfigPart<Config[Key]>>
+          | (Config[Key] extends { readonly states: infer Children } ? HandlerTreeInitialTargetPath<Children> : never)
+      }[keyof Config]
+    : never
 
-  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]
-      >
-    }
+  type HandlerInitialTargetValidation<
+    AllStates extends StateSchemas,
+    Config
+  > = HandlerTreeInitialTargetPath<Config> extends infer TargetPath ? HandlerInitialTargetValidationForPaths<
+      AllStates,
+      Config,
+      RequiredInitializersForTargetPath<AllStates, TargetPath>
+    >
     : unknown
 
   type HandlerChildrenValidation<
@@ -5809,6 +6402,19 @@ export declare namespace Machine {
       : unknown
       : unknown)
 
+  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,
@@ -5820,17 +6426,14 @@ export declare namespace Machine {
     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
 
@@ -5846,17 +6449,6 @@ export declare namespace Machine {
     >
   }
 
-  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,
@@ -5944,7 +6536,7 @@ export declare namespace Machine {
     AllStates extends StateSchemas,
     StateId extends StateIdentifier<AllStates>,
     Config
-  > = StateId extends RequiredHistoryInitializers<AllStates> ? "initial" extends keyof Config ? true : false : true
+  > = StateId extends RequiredHistoryInitializers<AllStates> ? "initialize" extends keyof Config ? true : false : true
 
   type HandlerHasRequiredHistoryDefaults<Node, Config> = Node extends {
     readonly states: infer Children extends StateSchemas
@@ -5984,7 +6576,6 @@ export declare namespace Machine {
     | Effect.Error<DoneReturn<Config>>
     | Effect.Error<StateActionReturn<Config, "entry">>
     | Effect.Error<StateActionReturn<Config, "exit">>
-    | Effect.Error<StateInitialReturn<Config>>
     | Effect.Error<HistoryDefaultReturn<Config>>
     | Effect.Error<ChoiceReturn<Config>>
     | InvokeError<Config>
@@ -6107,6 +6698,11 @@ export declare namespace Machine {
             StateIdentifier<States>
           >
         >
+        & ([StateIdentifier<States>] extends [UnhandledStates] ? HandlerInitialTargetValidation<
+            States,
+            NoInfer<Config>
+          >
+          : unknown)
     ): HandleTreeResult<
       States,
       Events,
@@ -6153,19 +6749,14 @@ export declare namespace Machine {
   > = 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>
-      }
+      TransitionConfig<
+        States,
+        Events,
+        Emits,
+        StateId,
+        HandlerContext<States, Events, Emits, StateId, EventTag, E, R>,
+        true
+      >
     >
   >
 
@@ -6193,30 +6784,20 @@ export declare namespace Machine {
       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)
@@ -6301,15 +6882,15 @@ export const isFinal: <
  * **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)
  *
@@ -6324,7 +6905,10 @@ export const isFinal: <
  * Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: () => States.initial.idle.from()
+ *   initial: {
+ *     target: (to) => to.idle(),
+ *     resolve: ({ target }) => target.from()
+ *   }
  * })
  * ```
  *
@@ -6333,6 +6917,20 @@ export const isFinal: <
  */
 export const defineStates: DefineStates = internal.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>,
@@ -6357,7 +6955,7 @@ type MakeConfig<
   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<
@@ -6395,9 +6993,15 @@ interface Make {
     InitialE = never,
     InitialR = never,
     const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents 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: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>,
+    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>
   <
@@ -6455,18 +7059,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
  */
@@ -6593,7 +7203,10 @@ export 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*() {
@@ -6675,7 +7288,10 @@ export const encodeSnapshot: <
  * 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*() {
@@ -6728,7 +7344,7 @@ export const decodeSnapshot: <
   Machine.SnapshotDecodingServices<States>
 > = internal.decodeSnapshot as any
 
-type DynamicEffectInvokeSource<
+type EffectInvokeSource<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
@@ -6746,7 +7362,7 @@ type DynamicEffectInvokeSource<
   readonly onSnapshot?: never
 }
 
-type DynamicEffectDoneHandler<
+type EffectDoneHandler<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
@@ -6756,6 +7372,7 @@ type DynamicEffectDoneHandler<
   States,
   Events,
   Emits,
+  StateId,
   Machine.InvokeDoneContext<
     States,
     Events,
@@ -6767,7 +7384,7 @@ type DynamicEffectDoneHandler<
   >
 >
 
-type DynamicEffectFailureHandler<
+type EffectFailureHandler<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
@@ -6777,6 +7394,7 @@ type DynamicEffectFailureHandler<
   States,
   Events,
   Emits,
+  StateId,
   Machine.InvokeFailureContext<
     States,
     Events,
@@ -6788,7 +7406,7 @@ type DynamicEffectFailureHandler<
   >
 >
 
-type DynamicEffectInvokeResult<
+type EffectInvokeResult<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
@@ -6805,7 +7423,7 @@ type DynamicEffectInvokeResult<
 
 type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false
 
-type BoundDynamicEffectInvokeSource<
+type BoundEffectInvokeSource<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
@@ -6825,7 +7443,7 @@ type BoundDynamicEffectInvokeSource<
   readonly onSnapshot?: never
 }
 
-type BoundDynamicEffectDoneHandler<
+type BoundEffectDoneHandler<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
@@ -6837,6 +7455,7 @@ type BoundDynamicEffectDoneHandler<
   States,
   Events,
   Emits,
+  StateId,
   Machine.InvokeDoneContext<
     States,
     Events,
@@ -6848,7 +7467,7 @@ type BoundDynamicEffectDoneHandler<
   >
 >
 
-type BoundDynamicEffectFailureHandler<
+type BoundEffectFailureHandler<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
@@ -6860,6 +7479,7 @@ type BoundDynamicEffectFailureHandler<
   States,
   Events,
   Emits,
+  StateId,
   Machine.InvokeFailureContext<
     States,
     Events,
@@ -6871,7 +7491,7 @@ type BoundDynamicEffectFailureHandler<
   >
 >
 
-type BoundDynamicEffectInvokeResult<
+type BoundEffectInvokeResult<
   States extends Machine.StateSchemas,
   Events extends ReadonlyArray<Machine.TaggedSchema>,
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
@@ -6888,6 +7508,162 @@ type BoundDynamicEffectInvokeResult<
     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 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
+
 /**
  * Machine-bound invocation constructor that preserves the owning machine's
  * public input and parent protocols in every invocation callback.
@@ -6909,9 +7685,9 @@ export interface Invoker<
     ) => Effect.Effect<unknown, unknown, unknown>
   >(
     config:
-      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & BoundEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
-        readonly onDone: BoundDynamicEffectDoneHandler<
+        readonly onDone: BoundEffectDoneHandler<
           States,
           Events,
           Emits,
@@ -6920,7 +7696,7 @@ export interface Invoker<
           StateId,
           Source
         >
-        readonly onFailure: BoundDynamicEffectFailureHandler<
+        readonly onFailure: BoundEffectFailureHandler<
           States,
           Events,
           Emits,
@@ -6937,7 +7713,7 @@ export interface Invoker<
           "onFailure must be omitted when the Effect error is never"
         ]
       : []
-  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  ): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
@@ -6945,9 +7721,9 @@ export interface Invoker<
     ) => Effect.Effect<unknown, never, unknown>
   >(
     config:
-      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & BoundEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
-        readonly onDone: BoundDynamicEffectDoneHandler<
+        readonly onDone: BoundEffectDoneHandler<
           States,
           Events,
           Emits,
@@ -6962,7 +7738,7 @@ export interface Invoker<
         "onDone must be omitted when the Effect output is never"
       ]
       : []
-  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  ): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
@@ -6970,10 +7746,10 @@ export interface Invoker<
     ) => Effect.Effect<never, unknown, unknown>
   >(
     config:
-      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & BoundEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
         readonly onDone?: never
-        readonly onFailure: BoundDynamicEffectFailureHandler<
+        readonly onFailure: BoundEffectFailureHandler<
           States,
           Events,
           Emits,
@@ -6987,7 +7763,7 @@ export interface Invoker<
         "onFailure must be omitted when the Effect error is never"
       ]
       : []
-  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  ): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
@@ -6995,105 +7771,85 @@ export interface Invoker<
     ) => Effect.Effect<never, never, unknown>
   >(
     config:
-      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & BoundEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
         readonly onDone?: never
         readonly onFailure?: never
       }
-  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  ): 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>,
-    const Fx extends Effect.Effect<any, any, any>,
-    const Config extends object
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => unknown,
+    Address extends ChildAddress<never>
   >(
     config:
-      & Config
-      & Machine.EffectInvokeArgs<
+      & { readonly logic: Source }
+      & Machine.LogicInvokeArgs<
         States,
         Events,
         Emits,
         StateId,
-        Fx,
-        Fx,
+        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
-      >
-  ):
-    & Config
-    & Machine.InvokeOwned<States, Events, Emits, StateId>
-    & Machine.InvokeTyped<Effect.Success<Fx>, Effect.Error<Fx>, Effect.Services<Fx>, never>
-  <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
-    >
+    ..._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<ChildOutput, ChildError, ChildRequirements, ChildInitialError>
+    & Machine.InvokeTyped<
+      Machine.LogicOutputOf<ReturnType<Source>>,
+      Machine.LogicErrorOf<ReturnType<Source>>,
+      Machine.LogicServicesOf<ReturnType<Source>>,
+      Machine.LogicInitialErrorOf<ReturnType<Source>>
+    >
   <
     StateId extends Machine.StateIdentifier<States>,
-    ChildState,
-    ChildEvent,
-    ChildError,
-    ChildRequirements,
-    ChildOutput,
-    ChildInitialError,
-    Address extends ChildAddress<never>,
-    const Config extends object
+    const Source,
+    Address extends ChildAddress<never>
   >(
     config:
-      & Config
+      & { readonly logic: Source }
       & Machine.LogicInvokeArgs<
         States,
         Events,
         Emits,
         StateId,
-        ChildState,
-        ChildEvent,
-        ChildError,
-        ChildRequirements,
-        ChildOutput,
-        ChildInitialError,
+        Machine.LogicStateOf<Source>,
+        Machine.LogicEventOf<Source>,
+        Machine.LogicErrorOf<Source>,
+        Machine.LogicServicesOf<Source>,
+        Machine.LogicOutputOf<Source>,
+        Machine.LogicInitialErrorOf<Source>,
         Address,
-        Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
+        Source,
         InputEvents,
         ParentEvents
-      >
+      >,
+    ..._validation: Source extends { readonly initial: unknown; readonly run: unknown } ? [] : [
+      "logic must implement Machine.Logic"
+    ]
   ):
-    & Config
-    & Machine.InvokeOwned<States, Events, Emits, StateId>
-    & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>
+    & 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,
@@ -7133,12 +7889,13 @@ export interface Invoker<
  * 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. Effects and durations may be
- * supplied directly or derived from the owning state's entry context. Dynamic
- * Effect sources infer the owner context, output, error, and service channels
- * together without a return annotation. Logic invocations require both a
- * lifecycle `id` and a typed communication `address`. Child descriptors already
- * own their identity, so `id` and `address` must not be repeated.
+ * 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
+ * supplied directly or derived from the owning state's entry context. Logic
+ * invocations require both a lifecycle `id` and a typed communication
+ * `address`. Child descriptors already own their identity, so `id` and
+ * `address` must not be repeated.
  *
  * Owner references are intentionally non-sendable here because this standalone
  * constructor does not know the owning definition. When a callback sends to
@@ -7149,12 +7906,19 @@ export interface Invoker<
  * ```ts
  * invoke: Machine.invoke({
  *   id: "load",
- *   effect: Effect.tryPromise({
- *     try: () => fetch("/api/data").then((response) => response.json()),
- *     catch: (cause) => new LoadError({ cause })
+ *   effect: () =>
+ *     Effect.tryPromise({
+ *       try: () => fetch("/api/data").then((response) => response.json()),
+ *       catch: (cause) => new LoadError({ cause })
+ *     }),
+ *   onDone: Machine.transition({
+ *     target: (to) => to.full.Ready(),
+ *     resolve: ({ output, target }) => target.from({ data: output })
  *   }),
- *   onDone: ({ output, target }) => target.full.Ready({ data: output }),
- *   onFailure: ({ error, target }) => target.full.Failed({ error })
+ *   onFailure: Machine.transition({
+ *     target: (to) => to.full.Failed(),
+ *     resolve: ({ error, target }) => target.from({ error })
+ *   })
  * })
  * ```
  *
@@ -7172,10 +7936,10 @@ export const invoke: {
     ) => Effect.Effect<unknown, unknown, unknown>
   >(
     config:
-      & DynamicEffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, StateId, Source>
       & {
-        readonly onDone: DynamicEffectDoneHandler<States, Events, Emits, StateId, Source>
-        readonly onFailure: DynamicEffectFailureHandler<States, Events, Emits, StateId, Source>
+        readonly onDone: EffectDoneHandler<States, Events, Emits, StateId, Source>
+        readonly onFailure: EffectFailureHandler<States, Events, Emits, StateId, Source>
       },
     ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
         "onDone must be omitted when the Effect output is never"
@@ -7184,7 +7948,7 @@ export const invoke: {
           "onFailure must be omitted when the Effect error is never"
         ]
       : []
-  ): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -7195,16 +7959,16 @@ export const invoke: {
     ) => Effect.Effect<unknown, never, unknown>
   >(
     config:
-      & DynamicEffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, StateId, Source>
       & {
-        readonly onDone: DynamicEffectDoneHandler<States, Events, Emits, StateId, Source>
+        readonly onDone: EffectDoneHandler<States, Events, Emits, StateId, Source>
         readonly onFailure?: never
       },
     ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
         "onDone must be omitted when the Effect output is never"
       ]
       : []
-  ): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -7215,16 +7979,16 @@ export const invoke: {
     ) => Effect.Effect<never, unknown, unknown>
   >(
     config:
-      & DynamicEffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, StateId, Source>
       & {
         readonly onDone?: never
-        readonly onFailure: DynamicEffectFailureHandler<States, Events, Emits, StateId, Source>
+        readonly onFailure: EffectFailureHandler<States, Events, Emits, StateId, Source>
       },
     ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
         "onFailure must be omitted when the Effect error is never"
       ]
       : []
-  ): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -7235,32 +7999,12 @@ export const invoke: {
     ) => Effect.Effect<never, never, unknown>
   >(
     config:
-      & DynamicEffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, StateId, Source>
       & {
         readonly onDone?: never
         readonly onFailure?: never
       }
-  ): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Fx extends Effect.Effect<any, any, any>,
-    const Config extends object
-  >(
-    config:
-      & Config
-      & Machine.EffectInvokeArgs<States, Events, Emits, StateId, Fx, Fx, readonly [], readonly []>
-  ):
-    & Config
-    & Machine.InvokeOwned<States, Events, Emits, StateId>
-    & Machine.InvokeTyped<
-      Effect.Success<Fx>,
-      Effect.Error<Fx>,
-      Effect.Services<Fx>,
-      never
-    >
+  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -7407,7 +8151,10 @@ export 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)
@@ -7514,6 +8261,20 @@ export const stateNodes: <M extends Machine.Any>(machine: M) => ReadonlyArray<
   >
 > = internal.stateNodes
 
+/**
+ * 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 const initialDefinition: <M extends Machine.Any>(machine: M) => Machine.InitialDefinition<
+  Machine.RootStateIdentifier<Machine.StateIdentifier<Machine.States<M>>>
+> = internal.initialDefinition
+
 /**
  * Returns every registered transition handler in state definition order.
  *
@@ -7521,9 +8282,9 @@ export const stateNodes: <M extends Machine.Any>(machine: M) => ReadonlyArray<
  *
  * 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
@@ -7646,8 +8407,21 @@ export const enabled: <
  * 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)
@@ -7780,41 +8554,6 @@ export const logic: <
   ) => Effect.Effect<Output, Error, Requirements>
 }) => Logic<State, Event, Error, Requirements | InitialRequirements, Output, InitialError> = internal.logic
 
-/**
- * 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 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> = internal.transition
-
 /**
  * Creates a typed descriptor for a complete child machine.
  *
@@ -8051,7 +8790,10 @@ export const prepare: <
  * 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*() {
@@ -8161,7 +8903,10 @@ export const start: <
  * 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*() {