@typeonce/effect-machine 0.16.0 → 0.17.0

package/dist/Machine.d.ts

@@ -41,6 +41,8 @@ declare const MachineTypeId: unique symbol;
 declare const EventConstructionTypeId: unique symbol;
 declare const EmittedEventConstructionTypeId: unique symbol;
 declare const EventProtocolTypeId: unique symbol;
+declare const ParentModeTypeId: unique symbol;
+declare const ParentTypeId = "~effect/Machine/Parent";
 declare const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId;
 /**
  * Type identifier used for the synthetic event passed to startup lifecycle
@@ -127,16 +129,16 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
      */
     readonly emittedEvents: Machine.EventProtocol<"emitted", Emits>;
     /**
-     * Public input events accepted by an owning machine when this machine is
-     * running as a child.
+     * Declared owning-machine protocol, or `undefined` when this machine does
+     * not communicate with its owner.
      *
-     * The protocol types the optional `parent` machine target exposed to
-     * handlers and is checked against a concrete parent's public events at
-     * composition boundaries.
+     * Required parents make the machine child-only and expose a non-optional
+     * `parent` target to handlers. Optional parents keep root execution valid
+     * and expose `parent` as possibly absent.
      *
-     * @since 0.10.0
+     * @since 0.17.0
      */
-    readonly parentEvents: Machine.EventProtocol<"public", ParentEvents>;
+    readonly parent: Machine.ParentDeclarationOf<ParentEvents>;
     /**
      * Optional schema used to decode the machine input before initialization.
      *
@@ -155,14 +157,6 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
     readonly makeTargetBuilder: <Source extends Machine.StateNodeIdentifier<States>>(source: Source) => Machine.TargetBuilder<States, Source>;
     /** @internal */
     readonly handlers: Machine.StateConfigs<States, Events, Emits, UnhandledStates, Machine.TagOf<Events[number]>, E, R>;
-    /**
-     * Machine-bound equivalent of {@link invoke}. Both forms preserve this
-     * machine's public input and parent protocols in invocation callbacks;
-     * `Machine.invoke(...)` inside `handle(...)` is the canonical inline form.
-     *
-     * @since 0.11.0
-     */
-    readonly invoke: Invoker<States, Events, Emits, InputEvents, ParentEvents>;
     /** @internal */
     readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>;
     /** @internal */
@@ -343,18 +337,51 @@ export interface MachineTarget<in Event> {
     readonly sessionId: string;
     readonly send: (event: Event) => Effect.Effect<void, StoppedError>;
 }
+/**
+ * Availability declared for an owning-machine target.
+ *
+ * @category models
+ * @since 0.17.0
+ */
+export type ParentMode = "required" | "optional";
+/**
+ * Owning-machine protocol declared by {@link parent} or
+ * {@link optionalParent}.
+ *
+ * @category models
+ * @since 0.17.0
+ */
+export interface Parent<Mode extends ParentMode, Events extends ReadonlyArray<Machine.TaggedSchema>> {
+    readonly [ParentTypeId]: typeof ParentTypeId;
+    readonly mode: Mode;
+    readonly events: Machine.EventProtocol<"public", Events>;
+}
+/**
+ * Namespace containing type-level members associated with {@link Parent}.
+ *
+ * @category models
+ * @since 0.17.0
+ */
+export declare namespace Parent {
+    /** Any owning-machine protocol declaration. */
+    type Any = Parent<ParentMode, ReadonlyArray<Machine.TaggedSchema>>;
+}
 /**
  * Machine targets available while evaluating machine behavior.
  *
  * @category models
  * @since 0.12.0
  */
-export interface MachineReferences<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> {
+export type MachineReferences<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = {
     /** Target for the current machine. Sending queues a later mailbox event. */
     readonly self: MachineTarget<Machine.EventInputOf<InputEvents>>;
+} & (Machine.ParentModeOf<ParentEvents> extends "required" ? {
+    /** Required target for the machine that owns this child. */
+    readonly parent: MachineTarget<Machine.EventInputOf<ParentEvents>>;
+} : Machine.ParentModeOf<ParentEvents> extends "optional" ? {
     /** Target for the owning machine, or `undefined` when running as a root. */
     readonly parent: MachineTarget<Machine.EventInputOf<ParentEvents>> | undefined;
-}
+} : {});
 /**
  * Synchronous commands available while a machine transition is being
  * selected. Enqueuing only records statechart and machine operations; it never
@@ -446,6 +473,8 @@ type ExcludeCompatibleRuntime<Requirements, Events, Emits> = Requirements extend
 type IncompatibleRuntime<Requirements, Events, Emits> = Requirements extends Runtime.Requirement<infer RequiredEvents, infer RequiredEmits> ? IsAny<Requirements> extends true ? never : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements : Requirements : never;
 declare const InvokeTypeId: typeof internal.InvokeTypeId;
 declare const TransitionTypeId: typeof internal.TransitionTypeId;
+declare const TransitionBuilderTypeId: unique symbol;
+declare const InitialBuilderTypeId: unique symbol;
 type StateDefinitionError<Message extends string, Path extends PropertyKey = never, Details extends PropertyKey = never> = {
     readonly "~effect/Machine/DefinitionError": Message;
     readonly path: Path;
@@ -486,16 +515,21 @@ type ValidateStateNodeConfig<Node extends Machine.StateNodeConfig, Path extends
 type ValidateOutputSchema<Node> = "output" extends keyof Node ? Node extends {
     readonly output: Schema.Top;
 } ? unknown : StateDefinitionError<"State output must be a schema"> : unknown;
+type SelectorChildKey<Children extends Machine.StateSchemas> = ActiveStateKey<Children> | ChoiceStateKey<Children>;
+type ValidateInitialSelectorChild<Children extends Machine.StateSchemas, Path extends PropertyKey> = "initial" extends SelectorChildKey<Children> ? StateDefinitionError<"Active and choice child states cannot use the reserved target selector key \"initial\"", StateDefinitionPath<Extract<Path, string>, "initial">, "initial"> : unknown;
+type ValidateWithSelectorChild<Node extends Machine.StateNodeConfig, Children extends Machine.StateSchemas, Path extends PropertyKey> = Node extends {
+    readonly schema: Machine.TaggedSchema;
+} ? "with" extends SelectorChildKey<Children> ? StateDefinitionError<"Schema-backed compound child states cannot use the reserved local target selector key \"with\"", StateDefinitionPath<Extract<Path, string>, "with">, "with"> : unknown : unknown;
 type ValidateStateNodeWithChildren<Node extends Machine.StateNodeConfig, Children, Path extends PropertyKey> = Children extends Machine.StateSchemas ? Node extends {
     readonly type: "final";
 } ? StateDefinitionError<"Final states cannot declare child states"> : Node extends {
     readonly type: "parallel";
-} ? "initial" extends keyof Node ? StateDefinitionError<"Parallel states cannot declare an initial child"> : {
+} ? ValidateInitialSelectorChild<Children, Path> & ("initial" extends keyof Node ? StateDefinitionError<"Parallel states cannot declare an initial child"> : {
     readonly states: ValidateStateTree<Children, true, Extract<Path, string>>;
-} & ValidateOutputSchema<Node> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : ValidateCompoundStateNode<Node, Children, Path> : StateDefinitionError<"Child states must be a state tree">;
+} & ValidateOutputSchema<Node>) : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : ValidateCompoundStateNode<Node, Children, Path> : StateDefinitionError<"Child states must be a state tree">;
 type ValidateCompoundStateNode<Node extends Machine.StateNodeConfig, Children extends Machine.StateSchemas, Path extends PropertyKey> = Node extends {
     readonly initial: infer Initial;
-} ? Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> ? {
+} ? Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> ? ValidateInitialSelectorChild<Children, Path> & ValidateWithSelectorChild<Node, Children, Path> & {
     readonly states: ValidateStateTree<Children, true, Extract<Path, string>>;
 } : StateDefinitionError<"Compound initial must be one of its direct child keys", Path, Extract<Initial, PropertyKey>> : StateDefinitionError<"Compound states must declare an initial child", Path>;
 type ValidateStateNodeWithoutChildren<Node extends Machine.StateNodeConfig> = "initial" extends keyof Node ? StateDefinitionError<"Atomic states cannot declare an initial child"> : Node extends {
@@ -1407,6 +1441,20 @@ export declare namespace Machine {
         readonly inputEvents: InputEvents;
         readonly parentEvents: ParentEvents;
     }
+    /** @internal Carries parent availability without widening the event tuple. */
+    type ParentEventSchemas<Mode extends ParentMode, Events extends ReadonlyArray<TaggedSchema>> = Events & {
+        readonly [ParentModeTypeId]: Mode;
+    };
+    /** Extracts the parent availability encoded in a machine event tuple. */
+    type ParentModeOf<Events extends ReadonlyArray<TaggedSchema>> = Events extends {
+        readonly [ParentModeTypeId]: infer Mode extends ParentMode;
+    } ? Mode : Events extends readonly [] ? "none" : "optional";
+    /** Extracts the event schemas declared by an owning-machine protocol. */
+    type ParentEventsOf<Declaration extends Parent.Any | undefined> = Declaration extends Parent<infer Mode, infer Events> ? ParentEventSchemas<Mode, Events> : readonly [];
+    /** Extracts the owning-machine declaration carried by a machine. */
+    type ParentDeclarationOf<Events extends ReadonlyArray<TaggedSchema>> = ParentModeOf<Events> extends infer Mode ? Mode extends ParentMode ? Parent<Mode, Events> : undefined : never;
+    /** Constraint applied to APIs that create an independent root runtime. */
+    type RootCompatible<Events extends ReadonlyArray<TaggedSchema>> = ParentModeOf<Events> extends "required" ? never : unknown;
     /**
      * Any schema-first machine.
      *
@@ -1427,7 +1475,7 @@ export declare namespace Machine {
         readonly events: EventProtocol.Any<"public">;
         readonly internalEvents: EventProtocol.Any<"internal">;
         readonly emittedEvents: EventProtocol.Any<"emitted">;
-        readonly parentEvents: EventProtocol.Any<"public">;
+        readonly parent: Parent.Any | undefined;
         readonly input: Schema.Top | undefined;
         readonly id: string | undefined;
         /** @internal */
@@ -1437,8 +1485,6 @@ export declare namespace Machine {
         /** @internal */
         readonly handlers: any;
         /** @internal */
-        readonly invoke: any;
-        /** @internal */
         readonly initial: any;
         /** @internal */
         readonly initialDefinition: InitialDefinition;
@@ -1538,6 +1584,8 @@ export declare namespace Machine {
     type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"];
     /** Extracts the public input protocol required from an owning machine. */
     type ParentEvents<M extends Any> = M[typeof MachineTypeId]["parentEvents"];
+    /** Extracts whether a machine requires or optionally accepts an owner. */
+    type ParentAvailability<M extends Any> = ParentModeOf<M[typeof MachineTypeId]["parentEvents"]>;
     /** Extracts an internal event schema tuple from the complete and public protocols. */
     type InternalEventSchemas<Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>> = Events extends readonly [
         ...InputEvents,
@@ -2054,6 +2102,7 @@ export declare namespace Machine {
         readonly source: SourcePath;
         readonly trigger: TransitionTrigger<EventTag>;
         readonly reenter: boolean;
+        readonly acceptance: TransitionAcceptance;
         readonly branches: ReadonlyArray<TransitionBranch<TargetPath>>;
     }
     /**
@@ -2658,6 +2707,22 @@ export declare namespace Machine {
     interface NoTarget {
         readonly [Topology.NoTargetTypeId]: typeof Topology.NoTargetTypeId;
     }
+    /**
+     * Opaque result returned when a declinable transition does not accept the
+     * current event or lifecycle outcome.
+     *
+     * Declining selects no transition and discards operations enqueued by that
+     * resolver. Hierarchical event and eventless dispatch continues with the
+     * next eligible ancestor candidate.
+     *
+     * @category models
+     * @since 0.17.0
+     */
+    interface Declined {
+        readonly [Topology.DeclinedTypeId]: typeof Topology.DeclinedTypeId;
+    }
+    /** Static acceptance contract of one transition definition. */
+    type TransitionAcceptance = "required" | "declinable";
     /**
      * Transition instruction that restores a history pseudo-state's parent.
      *
@@ -2821,11 +2886,12 @@ export declare namespace Machine {
         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 SelectionValue<Builder, Path extends string, Kind extends Topology.TargetSelectionKind = "state"> = TargetSelection<Builder, Path, Kind>;
+    type SelectionMethod<Builder, Path extends string, Kind extends Topology.TargetSelectionKind = "state"> = () => SelectionValue<Builder, Path, Kind>;
     type InitialSelectionMethod<Builder, Path extends string> = Builder extends {
         readonly initial: infer Initial;
     } ? {
-        readonly initial: SelectionMethod<Initial, Path, "initial">;
+        readonly initial: SelectionValue<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]>;
@@ -2843,27 +2909,32 @@ export declare namespace Machine {
         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>;
+        readonly with: SelectionValue<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 [Key in Extract<HistoryContainingKey<States>, keyof Builder>]: States[Key] extends HistoryStateNodeConfig ? SelectionValue<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. */
+    /**
+     * Definition-time topology selector available to an ordinary transition.
+     * Topology-only instructions (`none`, declared `initial` and history
+     * selections, and `local.with`) are values. State and choice destinations
+     * remain callable selection methods.
+     */
     interface TargetSelector<States extends StateSchemas, Source extends StateNodeIdentifier<States>> {
-        readonly none: SelectionMethod<TargetBuilder<States, Source>["none"], never, "none">;
+        readonly none: SelectionValue<TargetBuilder<States, Source>["none"], never, "none">;
         readonly local: LocalTargetSelector<States, Source>;
         readonly branch: BranchTargetSelector<States, Source>;
         readonly full: FullTargetSelector<States>;
         readonly history: HistorySelectionTree<States, States, "", HistoryTargetBuilder<States>>;
     }
     /** Definition-time selector that can choose only a valid top-level initial entry. */
-    type InitialSelector<States extends StateSchemas> = {
+    type InitialTargetSelector<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">;
+            readonly initial: SelectionValue<InitialBuilder<States>[Key], Key, "initial">;
         } : SelectionMethod<InitialBuilder<States>[Key], Key>;
     };
     /**
@@ -2872,7 +2943,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
+    type HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
@@ -2886,38 +2957,38 @@ export declare namespace Machine {
          * @since 0.4.0
          */
         readonly target: TargetBuilder<States, StateId>;
-    }
+    };
     /**
      * Context passed to an entry or exit state handler.
      *
      * @category models
      * @since 0.4.0
      */
-    interface StateActionContext<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 []> extends MachineReferences<InputEvents, ParentEvents> {
+    type StateActionContext<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 []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
-    }
+    };
     /**
      * Context passed to a function-valued invocation source.
      *
      * @category models
      * @since 0.4.0
      */
-    interface InvokeContext<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 []> extends MachineReferences<InputEvents, ParentEvents> {
+    type InvokeContext<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 []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
-    }
+    };
     /**
      * Context passed to an invocation's active-snapshot transition.
      *
      * @category models
      * @since 0.4.0
      */
-    interface InvokeSnapshotContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, State, Error, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
+    type InvokeSnapshotContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, State, Error, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly id: string;
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
@@ -2926,14 +2997,14 @@ export declare namespace Machine {
         readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
             readonly status: "active";
         }>;
-    }
+    };
     /**
      * Context passed to an invocation's successful completion transition.
      *
      * @category models
      * @since 0.4.0
      */
-    interface InvokeDoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
+    type InvokeDoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly id: string;
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
@@ -2941,9 +3012,9 @@ export declare namespace Machine {
         readonly snapshot: Snapshot<States>;
         readonly target: TargetBuilder<States, StateId>;
         readonly output: Output;
-    }
+    };
     /** Context passed to a Stream invocation's element transition. */
-    interface InvokeElementContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Element, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
+    type InvokeElementContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Element, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly id: string;
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
@@ -2951,9 +3022,9 @@ export declare namespace Machine {
         readonly snapshot: Snapshot<States>;
         readonly target: TargetBuilder<States, StateId>;
         readonly element: Element;
-    }
+    };
     /** Context passed to an invocation typed-failure transition. */
-    interface InvokeFailureContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Error, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
+    type InvokeFailureContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Error, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly id: string;
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
@@ -2961,14 +3032,14 @@ export declare namespace Machine {
         readonly snapshot: Snapshot<States>;
         readonly target: TargetBuilder<States, StateId>;
         readonly error: Error;
-    }
+    };
     /**
      * Context passed to an eventless transition handler.
      *
      * @category models
      * @since 0.4.0
      */
-    interface AlwaysContext<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 []> extends MachineReferences<InputEvents, ParentEvents> {
+    type AlwaysContext<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 []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
@@ -2983,14 +3054,14 @@ export declare namespace Machine {
          * @since 0.4.0
          */
         readonly target: TargetBuilder<States, StateId>;
-    }
+    };
     /**
      * Context passed to a state completion transition handler.
      *
      * @category models
      * @since 0.4.0
      */
-    interface DoneContext<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 []> extends MachineReferences<InputEvents, ParentEvents> {
+    type DoneContext<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 []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
@@ -3006,16 +3077,16 @@ export declare namespace Machine {
          * @since 0.4.0
          */
         readonly target: TargetBuilder<States, StateId>;
-    }
+    };
     /** Context passed to a transient choice resolver. There is no `state` value. */
-    interface ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
+    type ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
         readonly containingState: StateByIdentifier<States, Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>>;
         readonly ancestors: {
             readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, ValuedStateIdentifier<States>>]: StateByIdentifier<States, Parent>;
         };
         readonly event: LifecycleEvent<Events>;
         readonly target: TargetBuilder<States, ChoiceId>;
-    }
+    };
     /**
      * Context passed to a final state output function.
      *
@@ -3144,7 +3215,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type EventTransitionReturn<Transition> = Transition extends {
+    type EventTransitionReturn<Transition> = Transition extends (...args: any) => infer Authored ? Authored extends TransitionBuilderEvidence<infer Result, any> ? Result : never : Transition extends {
         readonly resolve?: infer Resolve;
     } ? NonNullable<Resolve> extends (...args: any) => infer Ret ? Ret : never : never;
     /**
@@ -3310,32 +3381,15 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type ConfigServices<Config> = Effect.Services<EventHandlerReturn<Config>> | Effect.Services<AlwaysReturn<Config>> | Effect.Services<DoneReturn<Config>> | Effect.Services<StateActionReturn<Config, "entry">> | Effect.Services<StateActionReturn<Config, "exit">> | Effect.Services<HistoryDefaultReturn<Config>> | Effect.Services<ChoiceReturn<Config>> | InvokeRequirements<Config>;
-    /** Type evidence retained by {@link transition} without affecting runtime data. */
-    interface TransitionTyped<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean> {
+    /** Type evidence retained by an authored transition without affecting runtime data. */
+    interface TransitionTyped<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance = "required"> {
         readonly [TransitionTypeId]: {
             readonly owner: Types.Covariant<readonly [States, Events, Emits, StateId, Context]>;
-        };
-    }
-    /** Type evidence for a targetless transition reusable in every owning context. */
-    interface TargetlessTransitionTyped {
-        readonly [TransitionTypeId]: {
-            readonly targetless: true;
+            readonly acceptance: Types.Covariant<Acceptance>;
         };
     }
     /** The only transition value accepted by machine handler APIs. */
-    type TransitionConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean = false> = (TransitionTyped<States, Events, Emits, StateId, Context, Reenter> | TargetlessTransitionTyped | TargetlessTransitionInput<Events, Emits, Context>) & {
-        readonly reenter?: [Reenter] extends [true] ? boolean : never;
-    };
-    /** Direct shorthand for a non-reentering targetless transition. */
-    interface TargetlessTransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context> {
-        <ResolvedContext extends Omit<Context, "target">>(context: ResolvedContext, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>): undefined;
-    }
-    type TargetlessTransitionInput<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context> = {
-        readonly target: TargetlessSelector;
-        readonly resolve?: TargetlessTransitionResolver<Events, Emits, Context>;
-        readonly branches?: never;
-        readonly reenter?: never;
-    };
+    type TransitionConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean = false, Acceptance extends TransitionAcceptance = "required"> = TransitionBuilderInput<States, Events, Emits, StateId, Context, Reenter, Acceptance>;
     type SelectionBuilder<Selection> = Selection extends TargetSelection<infer Builder, any, any> ? Builder : never;
     type SelectionKind<Selection> = Selection extends TargetSelection<any, any, infer Kind> ? Kind : never;
     type SelectionPath<Selection> = Selection extends TargetSelection<any, infer Path, any> ? Path : never;
@@ -3343,16 +3397,18 @@ export declare namespace Machine {
         readonly from: (...args: any) => infer Result;
     } ? Result : never);
     type SelectedTargetResult<Selection> = SelectionBuilder<Selection> extends infer Builder ? TargetBuilderResult<Builder> : never;
+    type SelectionSupportsDefaultConstruction<Selection> = SelectionKind<Selection> extends "none" ? true : SelectionBuilder<Selection> extends {
+        readonly from: (...args: infer Args) => any;
+    } ? [] extends Args ? true : false : SelectionBuilder<Selection> extends (...args: infer Args) => any ? [] extends Args ? true : false : false;
     type TransitionResolveContext<Context, Selection> = Omit<Context, "target"> & (SelectionKind<Selection> extends "none" ? {} : {
         readonly target: SelectionBuilder<Selection>;
     });
+    /** Context capability available only to explicitly declinable resolvers. */
+    interface DeclineCapability {
+        readonly decline: () => Declined;
+    }
     type TransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined;
-    type TransitionDirectInput<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, any>> = {
-        readonly target: (to: TargetSelector<States, StateId>) => Selection;
-        readonly resolve?: TransitionResolver<Events, Emits, Context, Selection>;
-        readonly branches?: never;
-        readonly reenter?: Reenter;
-    };
+    type DeclinableTransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined;
     /** One named destination declared by a branching transition. */
     interface TransitionBranchInput<Selection extends TargetSelection<any, any, any> = TargetSelection<any, any, any>> {
         readonly target: Selection;
@@ -3387,24 +3443,82 @@ export declare namespace Machine {
         readonly select: BranchSelectors<Branches>;
     };
     type TransitionBranchesResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = (context: TransitionBranchesResolveContext<Context, Branches>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => BranchSelectionResult<Branches>;
-    type TransitionBranchesInput<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Branches extends Readonly<Record<string, TransitionBranchInput>>> = {
-        readonly target?: never;
-        /**
-         * Declares every possible destination under a stable semantic key.
-         *
-         * Branches are captured once in ECMAScript property order. Array-index
-         * keys are rejected so reordering ordinary named properties affects only
-         * presentation order; the key remains the testing and inspection identity.
-         */
-        readonly branches: (to: TargetSelector<States, StateId>) => Branches;
-        readonly resolve: TransitionBranchesResolver<Events, Emits, Context, Branches>;
-        readonly reenter?: Reenter;
+    type DeclinableTransitionBranchesResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = (context: TransitionBranchesResolveContext<Context, Branches> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => BranchSelectionResult<Branches> | Declined;
+    /** @internal Type evidence retained by a transition authored through its bound selector. */
+    interface TransitionBuilderEvidence<out Result, out Acceptance extends TransitionAcceptance> {
+        readonly [TransitionBuilderTypeId]: {
+            readonly result: Types.Covariant<Result>;
+            readonly acceptance: Types.Covariant<Acceptance>;
+        };
+    }
+    type TransitionReenterOption<Reenter extends boolean> = [Reenter] extends [true] ? {
+        readonly reenter?: boolean;
+    } : {
+        readonly reenter?: never;
+    };
+    type TransitionRequiredOptions<Reenter extends boolean> = TransitionReenterOption<Reenter> & {
+        readonly declinable?: false;
+    };
+    type TransitionDeclinableOptions<Reenter extends boolean> = TransitionReenterOption<Reenter> & {
+        readonly declinable: true;
+    };
+    type BuiltTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Result, Acceptance extends TransitionAcceptance> = TransitionTyped<States, Events, Emits, StateId, Context, Reenter, Acceptance> & TransitionBuilderEvidence<Result, Acceptance>;
+    interface TransitionResolveRequired<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>> {
+        (resolve: TransitionResolver<Events, Emits, Context, Selection>, options?: TransitionRequiredOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required">;
+    }
+    interface TransitionResolveDeclinable<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>> {
+        (resolve: DeclinableTransitionResolver<Events, Emits, Context, Selection>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined, "declinable">;
+    }
+    /** A selected transition target with target-specific resolver operations. */
+    type TransitionTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, any>> = Selection & (SelectionSupportsDefaultConstruction<Selection> extends true ? BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required"> : {}) & {
+        readonly resolve: TransitionResolveRequired<States, Events, Emits, StateId, Context, Reenter, Selection> & ("declinable" extends Acceptance ? TransitionResolveDeclinable<States, Events, Emits, StateId, Context, Reenter, Selection> : {});
+    } & ([Reenter] extends [true] ? SelectionSupportsDefaultConstruction<Selection> extends true ? {
+        readonly reenter: () => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required">;
+    } : {} : {});
+    /** @internal Type evidence retained by a machine initial-entry declaration. */
+    interface InitialBuilderEvidence<out Selection> {
+        readonly [InitialBuilderTypeId]: Types.Covariant<Selection>;
+    }
+    /** A selected machine initial entry with its exact resolver target. */
+    type InitialTransitionTarget<Input, Selection extends TargetSelection<any, any, any>> = Selection & (SelectionSupportsDefaultConstruction<Selection> extends true ? InitialBuilderEvidence<Selection> : {}) & {
+        readonly resolve: (resolve: (context: {
+            readonly input: Input;
+            readonly target: SelectionBuilder<Selection>;
+        }) => SelectedTargetResult<Selection>) => InitialBuilderEvidence<Selection>;
+    };
+    type InitialSelectorNode<Input, Node> = Node extends (...args: infer Args) => infer Selection ? Selection extends TargetSelection<any, any, any> ? ((...args: Args) => InitialTransitionTarget<Input, Selection>) & {
+        readonly [Key in keyof Node]: InitialSelectorNode<Input, Node[Key]>;
+    } : never : Node extends TargetSelection<any, any, any> ? InitialTransitionTarget<Input, Node> : {
+        readonly [Key in keyof Node]: InitialSelectorNode<Input, Node[Key]>;
+    };
+    /** Definition-time selector for a machine's top-level initial entry. */
+    type InitialSelector<States extends StateSchemas, Input = void> = InitialSelectorNode<Input, InitialTargetSelector<States>>;
+    /** Target-first initial-entry declaration accepted by {@link make}. */
+    type InitialBuilderInput<States extends StateSchemas, Input> = (to: InitialSelector<States, Input>) => InitialBuilderEvidence<TargetSelection<any, any, any>>;
+    type TransitionSelectorNode<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Node> = Node extends (...args: infer Args) => infer Selection ? Selection extends TargetSelection<any, any, any> ? ((...args: Args) => TransitionTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Selection>) & {
+        readonly [Key in keyof Node]: TransitionSelectorNode<States, Events, Emits, StateId, Context, Reenter, Acceptance, Node[Key]>;
+    } : never : Node extends TargetSelection<any, any, any> ? TransitionTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Node> : {
+        readonly [Key in keyof Node]: TransitionSelectorNode<States, Events, Emits, StateId, Context, Reenter, Acceptance, Node[Key]>;
+    };
+    interface TransitionBranchesResolveRequired<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Branches extends Readonly<Record<string, TransitionBranchInput>>> {
+        (resolve: TransitionBranchesResolver<Events, Emits, Context, Branches>, options?: TransitionRequiredOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, BranchSelectionResult<Branches>, "required">;
+    }
+    interface TransitionBranchesResolveDeclinable<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Branches extends Readonly<Record<string, TransitionBranchInput>>> {
+        (resolve: DeclinableTransitionBranchesResolver<Events, Emits, Context, Branches>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, BranchSelectionResult<Branches> | Declined, "declinable">;
+    }
+    /** Selector supplied to inline transition declarations. */
+    type TransitionSelector<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance> = TransitionSelectorNode<States, Events, Emits, StateId, Context, Reenter, Acceptance, TargetSelector<States, StateId>> & {
+        readonly branches: <const Branches extends Readonly<Record<string, TransitionBranchInput>>>(branches: Branches & ValidateTransitionBranchRecord<NoInfer<Branches>>) => {
+            readonly resolve: TransitionBranchesResolveRequired<States, Events, Emits, StateId, Context, Reenter, Branches> & ("declinable" extends Acceptance ? TransitionBranchesResolveDeclinable<States, Events, Emits, StateId, Context, Reenter, Branches> : {});
+        };
     };
-    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>;
+    /** Inline transition declaration accepted by state and invocation handlers. */
+    type TransitionBuilderInput<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance> = (to: TransitionSelector<States, Events, Emits, StateId, Context, Reenter, Acceptance>) => TransitionTyped<States, Events, Emits, StateId, Context, Reenter, Acceptance> & TransitionBuilderEvidence<any, Acceptance>;
+    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, TransitionAcceptance>;
     type InvokeSource<Value, Context> = Value | ((context: Context) => Value);
     /** Inline state-owned work that runs for the lifetime of its active state. */
-    interface InvokeOwned<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
-        readonly "~effect/Machine/InvokeOwner"?: Types.Covariant<readonly [States, Events, Emits, StateId]>;
+    interface InvokeOwned<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> {
+        readonly "~effect/Machine/InvokeOwner"?: Types.Covariant<readonly [States, Events, Emits, StateId, InputEvents, ParentEvents]>;
     }
     /** Type evidence retained by {@link invoke} without affecting runtime data. */
     interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never, ParentEvent = never> {
@@ -3417,7 +3531,7 @@ export declare namespace Machine {
             readonly parentEvents: Types.Covariant<ParentEvent>;
         };
     }
-    type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = InvokeOwned<States, Events, Emits, StateId> & ({
+    type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & ({
         readonly id: string;
         readonly effect: (context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<any, any, any>;
         readonly stream?: never;
@@ -3563,7 +3677,7 @@ export declare namespace Machine {
     type LogicServicesOf<Value> = Effect.Services<LogicInitialEffectOf<Value> | LogicRunEffectOf<Value>>;
     type LogicOutputOf<Value> = Effect.Success<LogicRunEffectOf<Value>>;
     type LogicInitialErrorOf<Value> = Effect.Error<LogicInitialEffectOf<Value>>;
-    type ContextualInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Raw> = Raw extends InvokeTyped<any, any, any, any, any> ? unknown : Raw extends {
+    type ContextualInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Raw> = Raw extends InvokeTyped<any, any, any, any, any> ? unknown : [Extract<keyof Raw, "onDone" | "onFailure" | "onElement" | "onSnapshot">] extends [never] ? unknown : Raw extends {
         readonly effect: infer Source;
     } ? InvokeFactoryResult<Source> extends infer Fx extends Effect.Effect<any, any, any> ? InvokeDoneRequirement<Effect.Success<Fx>, InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Effect.Error<Fx>, InvokeTransition<States, Events, Emits, StateId, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>>> & {
         readonly onSnapshot?: never;
@@ -3619,10 +3733,10 @@ export declare namespace Machine {
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
         readonly exit?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
         readonly invoke?: InvokeDefinition<States, Events, Emits, StateId, InputEvents, ParentEvents> | TypedInvokeDefinition;
-        readonly always?: 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 always?: TransitionConfig<States, Events, Emits, StateId, AlwaysContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, false, TransitionAcceptance>;
+        readonly onDone?: TransitionConfig<States, Events, Emits, StateId, DoneContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, false, TransitionAcceptance>;
         readonly on?: {
-            readonly [EventTag in TagOf<Events[number]>]?: TransitionConfig<States, Events, Emits, StateId, HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>, true>;
+            readonly [EventTag in TagOf<Events[number]>]?: TransitionConfig<States, Events, Emits, StateId, HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>, true, TransitionAcceptance>;
         };
         readonly initialize?: StateInitializeHandler<States, Events, Emits, StateId, InputEvents, ParentEvents>;
     } & ActiveOutputHandlerConfig<States, Events, StateId>;
@@ -3924,7 +4038,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    type EventHandlerMap<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, TransitionConfig<States, Events, Emits, StateId, HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, true>>>;
+    type EventHandlerMap<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, TransitionConfig<States, Events, Emits, StateId, HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, true, TransitionAcceptance>>>;
     /**
      * Runtime state config stored for a single state tag.
      *
@@ -3935,8 +4049,8 @@ export declare namespace Machine {
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<E, R>;
         readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<E, R>;
         readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>;
-        readonly always?: TransitionConfig<States, Events, Emits, StateId, AlwaysContext<States, Events, Emits, StateId>>;
-        readonly onDone?: TransitionConfig<States, Events, Emits, StateId, DoneContext<States, Events, Emits, StateId>>;
+        readonly always?: TransitionConfig<States, Events, Emits, StateId, AlwaysContext<States, Events, Emits, StateId>, false, TransitionAcceptance>;
+        readonly onDone?: TransitionConfig<States, Events, Emits, StateId, DoneContext<States, Events, Emits, StateId>, false, TransitionAcceptance>;
         readonly output?: ((context: FinalOutputContext<States, Events, StateId>) => unknown) | ((context: ParallelOutputContext<States, Events, StateId>) => unknown);
         readonly on?: EventHandlerMap<States, Events, Emits, StateId, EventTag, E, R>;
     }
@@ -4035,10 +4149,7 @@ export declare const state: StateConstructor;
  * Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.idle(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   initial: (to) => to.idle().resolve(({ target }) => target.from())
  * })
  * ```
  *
@@ -4046,31 +4157,22 @@ export declare const state: StateConstructor;
  * @since 0.4.0
  */
 export declare const states: StatesConstructor;
-type InitialDirectInput<States extends Machine.StateSchemas, Input, Selection extends Machine.TargetSelection<any, any, any>> = {
-    readonly target: (to: Machine.InitialSelector<States>) => Selection;
-    readonly resolve?: (context: {
-        readonly input: Input;
-        readonly target: Machine.SelectionBuilder<Selection>;
-    }) => Machine.SelectedTargetResult<Selection>;
-    readonly cases?: never;
-    readonly otherwise?: never;
-};
-type MakeConfig<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = {
+type MakeConfig<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentDeclaration extends Parent.Any | undefined> = {
     readonly id?: string;
     readonly states: States & DefineStateTreeInput<NoInfer<States>>;
     readonly events: Machine.EventProtocol<"public", InputEvents> & ValidateInputEventProtocol<NoInfer<InputEvents>>;
     readonly internalEvents?: Machine.EventProtocol<"internal", InternalEvents> & ValidateInternalEventProtocol<NoInfer<InputEvents>, NoInfer<InternalEvents>>;
     readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>;
-    readonly parentEvents?: Machine.EventProtocol<"public", ParentEvents>;
+    readonly parent?: ParentDeclaration;
     readonly input?: Input;
     readonly initial: unknown;
 };
-type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = Definition<States, readonly [...InputEvents, ...InternalEvents], Input, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, InputEvents, ParentEvents>;
+type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentDeclaration extends Parent.Any | undefined> = Definition<States, readonly [...InputEvents, ...InternalEvents], Input, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, InputEvents, Machine.ParentEventsOf<ParentDeclaration>>;
 interface Make {
-    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const InitialSelection extends Machine.TargetSelection<any, any, any> = Machine.TargetSelection<any, any, any>>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "initial"> & {
-        readonly initial: InitialDirectInput<States, Input["Type"], InitialSelection>;
-    }, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>;
-    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "states"> & {
+    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentDeclaration extends Parent.Any | undefined = undefined>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>, "initial"> & {
+        readonly initial: Machine.InitialBuilderInput<States, Input["Type"]>;
+    }, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>;
+    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentDeclaration extends Parent.Any | undefined = undefined>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>, "states"> & {
         readonly states: InvalidDefinedStateTreeInput<States>;
     }): never;
 }
@@ -4085,11 +4187,17 @@ interface Make {
  * `states` or is passed inline. Call `handle` on the returned definition
  * to implement state behavior with ordinary TypeScript control flow.
  *
+ * `initial` is a target-first callback. Its outer selector runs once while the
+ * definition is captured; an attached `.resolve(...)` callback remains lazy
+ * until initial planning. Return a bare selected state when its schema supports
+ * default construction.
+ *
  * `Machine.events` defines the public input protocol. `Machine.internalEvents`
  * adds raised events and other machine-local deliveries.
- * `Machine.emittedEvents` defines outward ephemeral notifications, while
- * `parentEvents` declares the inputs a child may explicitly send to its owning
- * machine. All descriptors expose deferred constructors while retaining their
+ * `Machine.emittedEvents` defines outward ephemeral notifications. The
+ * `parent` configuration accepts `Machine.parent(events)` for a required owner
+ * or `Machine.optionalParent(events)` for a root-capable machine. All
+ * descriptors expose deferred constructors while retaining their
  * schemas opaquely for runtime validation. Public and internal tags must be
  * disjoint.
  *
@@ -4113,18 +4221,13 @@ interface Make {
  * const counter = Machine.make({
  *   states: States.states,
  *   events: Events,
- *   initial: {
- *     target: (to) => to.Count(),
- *     resolve: ({ target }) => target(new Count({ value: 0 }))
- *   }
+ *   initial: (to) => to.Count().resolve(({ target }) => target(new Count({ value: 0 })))
  * }).handle({
  *   Count: {
  *     on: {
- *       Increment: Machine.transition({
- *         target: (to) => to.full.Count(),
- *         resolve: ({ event, state, target }) =>
- *           target(new Count({ value: state.value + event.by }))
- *       })
+ *       Increment: (to) =>
+ *         to.full.Count().resolve(({ event, state, target }) =>
+ *           target(new Count({ value: state.value + event.by })))
  *     }
  *   }
  * })
@@ -4171,6 +4274,27 @@ export declare const events: {
     <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(...schemas: Schemas & ValidateInputEventProtocol<NoInfer<Schemas>>): Machine.EventProtocol<"public", readonly [...Schemas]>;
     <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"public">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"public", Inputs>): Machine.EventProtocol<"public", Machine.EventProtocolInputSchemasOf<"public", Inputs>>;
 };
+/**
+ * Requires the machine to run as an owned child whose parent accepts the
+ * supplied public event protocol.
+ *
+ * Required-parent machines expose a non-optional `parent` target in behavior
+ * contexts and are rejected by root execution APIs.
+ *
+ * @category constructors
+ * @since 0.17.0
+ */
+export declare const parent: <const Events extends ReadonlyArray<Machine.TaggedSchema>>(events: Machine.EventProtocol<"public", Events>) => Parent<"required", Events>;
+/**
+ * Declares public events a machine may send to its owner while preserving the
+ * ability to run that machine as a root.
+ *
+ * Optional-parent machines expose `parent` as a possibly absent target.
+ *
+ * @category constructors
+ * @since 0.17.0
+ */
+export declare const optionalParent: <const Events extends ReadonlyArray<Machine.TaggedSchema>>(events: Machine.EventProtocol<"public", Events>) => Parent<"optional", Events>;
 /**
  * Defines an internal event protocol and returns deferred constructors for
  * every statically finite configured event tag.
@@ -4259,10 +4383,7 @@ export declare const emittedEvents: {
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
  * }).handle({ Idle: {} })
  *
  * const encoded = Effect.gen(function*() {
@@ -4306,10 +4427,7 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
  * }).handle({ Idle: {} })
  *
  * const roundTrip = Effect.gen(function*() {
@@ -4337,7 +4455,7 @@ type EffectInvokeSource<States extends Machine.StateSchemas, Events extends Read
 };
 type EffectDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
 type EffectFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
-type EffectInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never>;
+type EffectInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never>;
 type StreamInvokeSource<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<any>) => unknown> = {
     readonly id: InvokeLifecycleId;
     readonly stream: Source & ((context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown);
@@ -4352,180 +4470,14 @@ type StreamSourceResult<Source extends (...args: ReadonlyArray<any>) => unknown>
 type StreamElementHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<any>) => unknown> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeElementContext<States, Events, Emits, StateId, Stream.Success<StreamSourceResult<NoInfer<Source>>>, InputEvents, ParentEvents>>;
 type StreamDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
 type StreamFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<any>) => unknown> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Stream.Error<StreamSourceResult<NoInfer<Source>>>, InputEvents, ParentEvents>>;
-type StreamInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<any>) => unknown> = Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<void, Stream.Error<StreamSourceResult<Source>>, Stream.Services<StreamSourceResult<Source>>, never>;
+type StreamInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<any>) => unknown> = Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<void, Stream.Error<StreamSourceResult<Source>>, Stream.Services<StreamSourceResult<Source>>, never>;
 type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false;
-type BoundEffectInvokeSource<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<unknown, unknown, unknown>> = {
-    readonly id: InvokeLifecycleId;
-    readonly effect: Source;
-    readonly stream?: never;
-    readonly after?: never;
-    readonly logic?: never;
-    readonly child?: never;
-    readonly address?: never;
-    readonly onElement?: never;
-    readonly onSnapshot?: never;
-};
-type BoundEffectDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
-type BoundEffectFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
-type BoundEffectInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never>;
-/** Captures one exact named-branch topology while preserving handler inference. */
-type BranchingTransitionResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateNodeIdentifier<States>, Context, Reenter extends boolean, Branches extends Readonly<Record<string, Machine.TransitionBranchInput>>> = Machine.TransitionBranchesInput<States, Events, Emits, StateId, Context, Reenter, Branches> & Machine.TransitionTyped<States, Events, Emits, StateId, Context, Reenter>;
 type TransitionBranchRecordError<Message extends string, Key extends PropertyKey = never> = {
     readonly "~effect/Machine/TransitionBranchRecordError": Message;
     readonly key: Key;
 };
 type InvalidStaticTransitionBranchKey<Branches> = Extract<keyof Branches, "" | number | symbol>;
 type ValidateTransitionBranchRecord<Branches> = [keyof Branches] extends [never] ? TransitionBranchRecordError<"Branch records must contain at least one branch"> : [InvalidStaticTransitionBranchKey<Branches>] extends [never] ? unknown : TransitionBranchRecordError<"Branch keys must be non-empty, non-index strings", InvalidStaticTransitionBranchKey<Branches>>;
-/**
- * Contextually types direct and branching transition definitions.
- *
- * @category constructors
- * @since 0.14.0
- */
-export interface TransitionConstructor {
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateNodeIdentifier<States>, Context, const Selection extends Machine.TargetSelection<any, any, any>, Reenter extends boolean = never>(config: Machine.TransitionDirectInput<States, Events, Emits, StateId, Context, Reenter, Selection>): Machine.TransitionDirectInput<States, Events, Emits, StateId, Context, Reenter, Selection> & (Machine.SelectionKind<Selection> extends "none" ? Machine.TargetlessTransitionTyped : Machine.TransitionTyped<States, Events, Emits, StateId, Context, Reenter>);
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateNodeIdentifier<States>, Context, const Branches extends Readonly<Record<string, Machine.TransitionBranchInput>>, Reenter extends boolean = never>(config: Machine.TransitionBranchesInput<States, Events, Emits, StateId, Context, Reenter, Branches> & ValidateTransitionBranchRecord<NoInfer<Branches>>): BranchingTransitionResult<States, Events, Emits, StateId, Context, Reenter, Branches>;
-}
-/**
- * Defines a statically inspectable transition.
- *
- * It is required for every event, lifecycle, choice, and invocation transition
- * so the destination selected by `target` can contextually type the
- * corresponding resolver. Branching transitions declare every possible
- * destination up front, then select one through ordinary TypeScript control
- * flow in `resolve`.
- *
- * ```ts
- * Machine.transition({
- *   target: (to) => to.full.Ready(),
- *   resolve: ({ target }) => target.from()
- * })
- *
- * Machine.transition({
- *   branches: (to) => ({
- *     cached: { target: to.full.Ready() },
- *     loading: { target: to.full.Loading() }
- *   }),
- *   resolve: ({ event, select }) => event.cached
- *     ? select.cached.from({ data: event.cached })
- *     : select.loading.from()
- * })
- * ```
- *
- * @category constructors
- * @since 0.14.0
- */
-export declare const transition: TransitionConstructor;
-/**
- * Sentinel used by direct targetless transition shorthands.
- *
- * This is the concise form of `target: (to) => to.none()`.
- *
- * ```ts
- * onElement: {
- *   target: Machine.targetless,
- *   resolve: ({ element }, enqueue) => {
- *     enqueue.raise(new MeasurementReceived({ value: element }))
- *   }
- * }
- *
- * onDone: { target: Machine.targetless }
- * ```
- *
- * @category constructors
- * @since 0.16.0
- */
-export interface TargetlessSelector {
-    readonly "~effect/Machine/TargetlessSelector": true;
-    <const States extends Machine.StateSchemas, StateId extends Machine.StateNodeIdentifier<States>>(to: Machine.TargetSelector<States, StateId>): ReturnType<Machine.TargetSelector<States, StateId>["none"]>;
-}
-/**
- * Selects no transition target while keeping enqueue operations explicit.
- *
- * Use as the `target` of a direct handler object when the handler should keep
- * the current state configuration and only raise, emit, or send events.
- *
- * @category constructors
- * @since 0.16.0
- */
-export declare const targetless: TargetlessSelector;
-/**
- * Machine-bound invocation constructor that preserves the owning machine's
- * public input and parent protocols in every invocation callback.
- *
- * @category constructors
- * @since 0.11.0
- */
-export interface Invoker<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> {
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<unknown, unknown, unknown>>(config: BoundEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
-        readonly onDone: BoundEffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-        readonly onFailure: BoundEffectFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    }, ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
-        "onDone must be omitted when the Effect output is never"
-    ] : InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
-        "onFailure must be omitted when the Effect error is never"
-    ] : []): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<unknown, never, unknown>>(config: BoundEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
-        readonly onDone: BoundEffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-        readonly onFailure?: never;
-    }, ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
-        "onDone must be omitted when the Effect output is never"
-    ] : []): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<never, unknown, unknown>>(config: BoundEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
-        readonly onDone?: never;
-        readonly onFailure: BoundEffectFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    }, ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
-        "onFailure must be omitted when the Effect error is never"
-    ] : []): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<never, never, unknown>>(config: BoundEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
-        readonly onDone?: never;
-        readonly onFailure?: never;
-    }): BoundEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<unknown, unknown, any>>(config: StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
-        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>;
-        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    }, ..._validation: InvokeChannelIsNever<Stream.Success<ReturnType<Source>>> extends true ? [
-        "onElement must be omitted when the Stream element is never"
-    ] : InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
-        "onFailure must be omitted when the Stream error is never"
-    ] : []): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<never, unknown, any>>(config: StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
-        readonly onElement?: never;
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>;
-        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    }, ..._validation: InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
-        "onFailure must be omitted when the Stream error is never"
-    ] : []): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<never, never, any>>(config: StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
-        readonly onElement?: never;
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>;
-        readonly onFailure?: never;
-    }): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<unknown, never, any>>(config: StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
-        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>;
-        readonly onFailure?: never;
-    }): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <StateId extends Machine.StateIdentifier<States>, const Config extends object>(config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>;
-    <StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown, Address extends ChildAddress<never>>(config: {
-        readonly logic: Source;
-    } & Machine.LogicInvokeArgs<States, Events, Emits, StateId, Machine.LogicStateOf<ReturnType<Source>>, Machine.LogicEventOf<ReturnType<Source>>, Machine.LogicErrorOf<ReturnType<Source>>, Machine.LogicServicesOf<ReturnType<Source>>, Machine.LogicOutputOf<ReturnType<Source>>, Machine.LogicInitialErrorOf<ReturnType<Source>>, Address, Source, InputEvents, ParentEvents>, ..._validation: ReturnType<Source> extends {
-        readonly initial: unknown;
-        readonly run: unknown;
-    } ? [] : [
-        "logic factory must return Machine.Logic"
-    ]): Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Machine.LogicOutputOf<ReturnType<Source>>, Machine.LogicErrorOf<ReturnType<Source>>, Machine.LogicServicesOf<ReturnType<Source>>, Machine.LogicInitialErrorOf<ReturnType<Source>>>;
-    <StateId extends Machine.StateIdentifier<States>, const Source, Address extends ChildAddress<never>>(config: {
-        readonly logic: Source;
-    } & Machine.LogicInvokeArgs<States, Events, Emits, StateId, Machine.LogicStateOf<Source>, Machine.LogicEventOf<Source>, Machine.LogicErrorOf<Source>, Machine.LogicServicesOf<Source>, Machine.LogicOutputOf<Source>, Machine.LogicInitialErrorOf<Source>, Address, Source, InputEvents, ParentEvents>, ..._validation: Source extends {
-        readonly initial: unknown;
-        readonly run: unknown;
-    } ? [] : [
-        "logic must implement Machine.Logic"
-    ]): Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Machine.LogicOutputOf<Source>, Machine.LogicErrorOf<Source>, Machine.LogicServicesOf<Source>, Machine.LogicInitialErrorOf<Source>>;
-    <StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
-}
 /**
  * Preserves inference for a state-owned invocation configuration.
  *
@@ -4547,9 +4499,10 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
  * `address` must not be repeated.
  *
  * Inside `handle(...)`, the owning definition contextually supplies its public
- * input and `parentEvents` protocols. Invocation sources and lifecycle handlers
+ * input and declared parent protocols. Invocation sources and lifecycle handlers
  * can therefore send through `self` and `parent` without naming the definition.
- * The bound `definition.invoke(...)` constructor remains an equivalent form.
+ * The standard `Machine.invoke(...)` constructor preserves these contexts
+ * directly; no intermediate definition method is required.
  *
  * ```ts
  * invoke: Machine.invoke({
@@ -4559,14 +4512,12 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
  *       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 })
- *   }),
- *   onFailure: Machine.transition({
- *     target: (to) => to.full.Failed(),
- *     resolve: ({ error, target }) => target.from({ error })
- *   })
+ *   onDone: (to) =>
+ *     to.full.Ready().resolve(({ output, target }) =>
+ *       target.from({ data: output })),
+ *   onFailure: (to) =>
+ *     to.full.Failed().resolve(({ error, target }) =>
+ *       target.from({ error }))
  * })
  * ```
  *
@@ -4574,31 +4525,31 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
  * @since 0.9.0
  */
 export declare const invoke: {
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<unknown, unknown, unknown>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<unknown, unknown, unknown>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
         readonly onDone: EffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
         readonly onFailure: EffectFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
     }, ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
         "onDone must be omitted when the Effect output is never"
     ] : InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
         "onFailure must be omitted when the Effect error is never"
-    ] : []): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<unknown, never, unknown>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
+    ] : []): NoInfer<Config> & EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<unknown, never, unknown>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
         readonly onDone: EffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
         readonly onFailure?: never;
     }, ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
         "onDone must be omitted when the Effect output is never"
-    ] : []): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<never, unknown, unknown>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
+    ] : []): NoInfer<Config> & EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<never, unknown, unknown>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
         readonly onDone?: never;
         readonly onFailure: EffectFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
     }, ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
         "onFailure must be omitted when the Effect error is never"
-    ] : []): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<never, never, unknown>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
+    ] : []): NoInfer<Config> & EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<never, never, unknown>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
         readonly onDone?: never;
         readonly onFailure?: never;
-    }): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<unknown, unknown, any>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
+    }): NoInfer<Config> & EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<unknown, unknown, any>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
         readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
         readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>;
         readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
@@ -4606,28 +4557,42 @@ export declare const invoke: {
         "onElement must be omitted when the Stream element is never"
     ] : InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
         "onFailure must be omitted when the Stream error is never"
-    ] : []): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<never, unknown, any>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
+    ] : []): NoInfer<Config> & StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<never, unknown, any>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
         readonly onElement?: never;
         readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>;
         readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
     }, ..._validation: InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
         "onFailure must be omitted when the Stream error is never"
-    ] : []): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<never, never, any>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
+    ] : []): NoInfer<Config> & StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<never, never, any>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
         readonly onElement?: never;
         readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>;
         readonly onFailure?: never;
-    }): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<unknown, never, any>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
+    }): NoInfer<Config> & StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Stream.Stream<unknown, never, any>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source> & {
         readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
         readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>;
         readonly onFailure?: never;
-    }): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, InputEvents, ParentEvents>): Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
+    }): NoInfer<Config> & StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>): NoInfer<Config> & Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<void, never, never, never>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown, Address extends ChildAddress<never>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & {
+        readonly logic: Source;
+    } & Machine.LogicInvokeArgs<States, Events, Emits, StateId, Machine.LogicStateOf<ReturnType<Source>>, Machine.LogicEventOf<ReturnType<Source>>, Machine.LogicErrorOf<ReturnType<Source>>, Machine.LogicServicesOf<ReturnType<Source>>, Machine.LogicOutputOf<ReturnType<Source>>, Machine.LogicInitialErrorOf<ReturnType<Source>>, Address, Source, InputEvents, ParentEvents>, ..._validation: ReturnType<Source> extends {
+        readonly initial: unknown;
+        readonly run: unknown;
+    } ? [] : [
+        "logic factory must return Machine.Logic"
+    ]): NoInfer<Config> & Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Machine.LogicOutputOf<ReturnType<Source>>, Machine.LogicErrorOf<ReturnType<Source>>, Machine.LogicServicesOf<ReturnType<Source>>, Machine.LogicInitialErrorOf<ReturnType<Source>>>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source, Address extends ChildAddress<never>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & {
+        readonly logic: Source;
+    } & Machine.LogicInvokeArgs<States, Events, Emits, StateId, Machine.LogicStateOf<Source>, Machine.LogicEventOf<Source>, Machine.LogicErrorOf<Source>, Machine.LogicServicesOf<Source>, Machine.LogicOutputOf<Source>, Machine.LogicInitialErrorOf<Source>, Address, Source, InputEvents, ParentEvents>, ..._validation: Source extends {
+        readonly initial: unknown;
+        readonly run: unknown;
+    } ? [] : [
+        "logic must implement Machine.Logic"
+    ]): NoInfer<Config> & Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Machine.LogicOutputOf<Source>, Machine.LogicErrorOf<Source>, Machine.LogicServicesOf<Source>, Machine.LogicInitialErrorOf<Source>>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, InputEvents, ParentEvents>): Config & Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
 };
 /**
  * Plans the initial state for a machine without executing machine commands.
@@ -4658,10 +4623,7 @@ export declare const invoke: {
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
  * }).handle({ Idle: {} })
  *
  * const initialState = Effect.map(Machine.planInitial(machine), (plan) => plan.state)
@@ -4672,7 +4634,7 @@ export declare const invoke: {
  * @category constructors
  * @since 0.4.0
  */
-export declare const planInitial: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
+export declare const planInitial: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
     readonly startingState: Machine.Snapshot<States>;
     readonly initialEntryPaths: ReadonlyArray<Machine.StateIdentifier<States>>;
     readonly state: Machine.Snapshot<States>;
@@ -4730,7 +4692,8 @@ export declare const initialDefinition: <M extends Machine.Any>(machine: M) => M
  * Event handlers retain their handler-key order within each source state and
  * are followed by eventless and completion handlers. This function does not
  * execute resolvers. Every direct, named, and targetless branch exposes the
- * destination selected by its required static `target` declaration.
+ * destination selected by its required static `target` declaration, while
+ * `acceptance` reports whether the resolver may decline the transition.
  *
  * @category getters
  * @since 0.4.0
@@ -4763,7 +4726,12 @@ export declare const activityDefinitions: <M extends Machine.Any>(machine: M) =>
  */
 export declare const configuration: <M extends Machine.Any>(machine: M, state: Machine.Snapshot<Machine.States<M>>) => ReadonlyArray<Machine.ActiveStateNode<Machine.StateIdentifier<Machine.States<M>>, Machine.ChoiceIdentifier<Machine.States<M>>>>;
 /**
- * Returns the event tags handled by the current state snapshot.
+ * Returns event tags with at least one structurally eligible handler in the
+ * current state snapshot.
+ *
+ * A `declinable` handler may still reject a concrete event at planning time,
+ * so this is a static candidate query rather than a guarantee that every value
+ * with the returned tag will be handled.
  *
  * @category getters
  * @since 0.4.0
@@ -4799,17 +4767,12 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(Toggle),
- *   initial: {
- *     target: (to) => to.Off(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   initial: (to) => to.Off().resolve(({ target }) => target.from())
  * }).handle({
  *   Off: {
  *     on: {
- *       Toggle: Machine.transition({
- *         target: (to) => to.full.On(),
- *         resolve: ({ target }) => target.from()
- *       })
+ *       Toggle: (to) =>
+ *         to.full.On().resolve(({ target }) => target.from())
  *     }
  *   },
  *   On: {}
@@ -4826,7 +4789,7 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * @category combinators
  * @since 0.4.0
  */
-export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, state: Machine.Snapshot<States>, event: Machine.EventInputOf<InputEvents>) => Effect.Effect<{
+export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, state: Machine.Snapshot<States>, event: Machine.EventInputOf<InputEvents>) => Effect.Effect<{
     readonly next: Machine.Snapshot<States>;
     readonly commands: ReadonlyArray<Command>;
     readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
@@ -4972,7 +4935,7 @@ export declare const watch: <State, Event, Error = never, Output = never>(ref: M
  * @category constructors
  * @since 0.11.0
  */
-export declare const prepare: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<Prepared<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>>;
+export declare const prepare: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<Prepared<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>>;
 /**
  * Starts a machine.
  *
@@ -5006,10 +4969,7 @@ export declare const prepare: <const States extends Machine.StateSchemas, const
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
  * }).handle({ Idle: {} })
  *
  * const state = Effect.gen(function*() {
@@ -5023,7 +4983,7 @@ export declare const prepare: <const States extends Machine.StateSchemas, const
  * @category constructors
  * @since 0.4.0
  */
-export declare const start: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+export declare const start: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 /**
  * Starts a fresh managed runtime from a decoded logical snapshot.
  *
@@ -5059,10 +5019,7 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
+ *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
  * }).handle({ Idle: {} })
  *
  * const resumed = Effect.gen(function*() {
@@ -5078,5 +5035,5 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * @category constructors
  * @since 0.4.0
  */
-export declare const resume: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+export declare const resume: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 //# sourceMappingURL=Machine.d.ts.map