@typeonce/effect-machine 0.16.0 → 0.18.0

package/src/Machine.ts

@@ -53,6 +53,9 @@ 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
+
+const ParentTypeId = "~effect/Machine/Parent"
 
 const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId = internal.ChildMachineLogicTypeId
 
@@ -184,16 +187,16 @@ export interface Machine<
   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.
@@ -220,15 +223,6 @@ export interface Machine<
   /** @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 */
@@ -471,22 +465,61 @@ export interface MachineTarget<in Event> {
   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. */
+  export type Any = Parent<ParentMode, ReadonlyArray<Machine.TaggedSchema>>
+}
+
 /**
  * Machine targets available while evaluating machine behavior.
  *
  * @category models
  * @since 0.12.0
  */
-export interface MachineReferences<
+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>>
-
-  /** Target for the owning machine, or `undefined` when running as a root. */
-  readonly parent: MachineTarget<Machine.EventInputOf<ParentEvents>> | undefined
-}
+> =
+  & {
+    /** 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
@@ -600,6 +633,9 @@ type IncompatibleRuntime<Requirements, Events, Emits> = Requirements extends Run
 
 const InvokeTypeId: typeof internal.InvokeTypeId = internal.InvokeTypeId
 const TransitionTypeId: typeof internal.TransitionTypeId = internal.TransitionTypeId
+declare const TransitionBuilderTypeId: unique symbol
+declare const InvokeBuilderTypeId: unique symbol
+declare const InitialBuilderTypeId: unique symbol
 
 type StateDefinitionError<
   Message extends string,
@@ -725,6 +761,29 @@ type ValidateOutputSchema<Node> = "output" extends keyof Node ? Node extends { r
   : 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,
@@ -732,8 +791,9 @@ type ValidateStateNodeWithChildren<
 > = 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">
-    : { readonly states: ValidateStateTree<Children, true, Extract<Path, string>> } & ValidateOutputSchema<Node>
+      & 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">
@@ -743,9 +803,12 @@ type ValidateCompoundStateNode<
   Children extends Machine.StateSchemas,
   Path extends PropertyKey
 > = Node extends { readonly initial: infer Initial } ?
-  Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> ? {
-      readonly states: ValidateStateTree<Children, true, Extract<Path, string>>
-    }
+  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,
@@ -2130,7 +2193,7 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
 }
 
 /**
- * Machine-specific process logic used by `spawn` and `invoke`.
+ * Machine-specific process logic used by `spawn` and state-owned invocations.
  *
  * @category models
  * @since 0.4.0
@@ -2465,6 +2528,35 @@ export declare namespace Machine {
     readonly parentEvents: ParentEvents
   }
 
+  /** @internal Carries parent availability without widening the event tuple. */
+  export type ParentEventSchemas<
+    Mode extends ParentMode,
+    Events extends ReadonlyArray<TaggedSchema>
+  > = Events & { readonly [ParentModeTypeId]: Mode }
+
+  /** Extracts the parent availability encoded in a machine event tuple. */
+  export 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. */
+  export 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. */
+  export 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. */
+  export type RootCompatible<Events extends ReadonlyArray<TaggedSchema>> = ParentModeOf<Events> extends "required"
+    ? never
+    : unknown
+
   /**
    * Any schema-first machine.
    *
@@ -2485,7 +2577,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 */
@@ -2495,8 +2587,6 @@ export declare namespace Machine {
     /** @internal */
     readonly handlers: any
     /** @internal */
-    readonly invoke: any
-    /** @internal */
     readonly initial: any
     /** @internal */
     readonly initialDefinition: InitialDefinition
@@ -2519,12 +2609,26 @@ export declare namespace Machine {
   export type Events<M extends Any> = M[typeof MachineTypeId]["events"]
 
   /**
-   * Extracts the input schema carried by a machine definition.
+   * Extracts the startup input schema carried by a machine definition.
    *
    * @category utility types
-   * @since 0.4.0
+   * @since 0.18.0
+   */
+  export type InputSchema<M extends Any> = M[typeof MachineTypeId]["input"]
+
+  /**
+   * Extracts the decoded startup input accepted by a machine definition.
+   *
+   * Machines declared with `Schema.Void` do not accept a startup input, so
+   * their extracted input type is `never`.
+   *
+   * @category utility types
+   * @since 0.18.0
    */
-  export type Input<M extends Any> = M[typeof MachineTypeId]["input"]
+  export type Input<M extends Any> = InputSchema<M> extends infer Input extends Schema.Top
+    ? Input extends typeof Schema.Void ? never
+    : Input["Type"]
+    : never
 
   /**
    * Extracts state paths that do not yet have handlers.
@@ -2612,6 +2716,9 @@ export declare namespace Machine {
   /** Extracts the public input protocol required from an owning machine. */
   export type ParentEvents<M extends Any> = M[typeof MachineTypeId]["parentEvents"]
 
+  /** Extracts whether a machine requires or optionally accepts an owner. */
+  export type ParentAvailability<M extends Any> = ParentModeOf<M[typeof MachineTypeId]["parentEvents"]>
+
   /** Extracts an internal event schema tuple from the complete and public protocols. */
   export type InternalEventSchemas<
     Events extends ReadonlyArray<TaggedSchema>,
@@ -3306,6 +3413,7 @@ export declare namespace Machine {
     readonly source: SourcePath
     readonly trigger: TransitionTrigger<EventTag>
     readonly reenter: boolean
+    readonly acceptance: TransitionAcceptance
     readonly branches: ReadonlyArray<TransitionBranch<TargetPath>>
   }
 
@@ -4184,6 +4292,24 @@ export declare namespace Machine {
     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
+   */
+  export interface Declined {
+    readonly [Topology.DeclinedTypeId]: typeof Topology.DeclinedTypeId
+  }
+
+  /** Static acceptance contract of one transition definition. */
+  export type TransitionAcceptance = "required" | "declinable"
+
   /**
    * Transition instruction that restores a history pseudo-state's parent.
    *
@@ -4393,11 +4519,14 @@ export declare namespace Machine {
     readonly "~effect/Machine/TargetSelectionResult"?: Types.Covariant<Result>
   }
 
-  type SelectionMethod<Builder, Path extends string, Kind extends Topology.TargetSelectionKind = "state"> = () =>
+  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">
     }
     : {}
 
@@ -4477,7 +4606,7 @@ export declare namespace Machine {
       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>
             }
             : {})
       : {}
@@ -4491,7 +4620,7 @@ export declare namespace Machine {
     Builder
   > = {
     readonly [Key in Extract<HistoryContainingKey<States>, keyof Builder>]: States[Key] extends HistoryStateNodeConfig ?
-      SelectionMethod<
+      SelectionValue<
         Builder[Key],
         JoinPath<Prefix, Key>,
         "history"
@@ -4505,12 +4634,17 @@ export declare namespace Machine {
       : 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.
+   */
   export 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>
@@ -4518,10 +4652,10 @@ export declare namespace Machine {
   }
 
   /** Definition-time selector that can choose only a valid top-level initial entry. */
-  export 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>
   }
@@ -4532,7 +4666,7 @@ export declare namespace Machine {
    * @category models
    * @since 0.4.0
    */
-  export interface HandlerContext<
+  export type HandlerContext<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -4542,7 +4676,7 @@ export declare namespace Machine {
     R,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4565,14 +4699,14 @@ export declare namespace Machine {
    * @category models
    * @since 0.4.0
    */
-  export interface StateActionContext<
+  export 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 []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4585,14 +4719,14 @@ export declare namespace Machine {
    * @category models
    * @since 0.4.0
    */
-  export interface InvokeContext<
+  export 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 []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4605,7 +4739,7 @@ export declare namespace Machine {
    * @category models
    * @since 0.4.0
    */
-  export interface InvokeSnapshotContext<
+  export type InvokeSnapshotContext<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -4615,7 +4749,7 @@ export declare namespace Machine {
     Output,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4630,7 +4764,7 @@ export declare namespace Machine {
    * @category models
    * @since 0.4.0
    */
-  export interface InvokeDoneContext<
+  export type InvokeDoneContext<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -4638,7 +4772,7 @@ export declare namespace Machine {
     Output,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4649,7 +4783,7 @@ export declare namespace Machine {
   }
 
   /** Context passed to a Stream invocation's element transition. */
-  export interface InvokeElementContext<
+  export type InvokeElementContext<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -4657,7 +4791,7 @@ export declare namespace Machine {
     Element,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4668,7 +4802,7 @@ export declare namespace Machine {
   }
 
   /** Context passed to an invocation typed-failure transition. */
-  export interface InvokeFailureContext<
+  export type InvokeFailureContext<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -4676,7 +4810,7 @@ export declare namespace Machine {
     Error,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4692,14 +4826,14 @@ export declare namespace Machine {
    * @category models
    * @since 0.4.0
    */
-  export interface AlwaysContext<
+  export 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 []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4723,14 +4857,14 @@ export declare namespace Machine {
    * @category models
    * @since 0.4.0
    */
-  export interface DoneContext<
+  export 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 []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4750,14 +4884,14 @@ export declare namespace Machine {
   }
 
   /** Context passed to a transient choice resolver. There is no `state` value. */
-  export interface ChoiceContext<
+  export 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 []
-  > extends MachineReferences<InputEvents, ParentEvents> {
+  > = MachineReferences<InputEvents, ParentEvents> & {
     readonly containingState: StateByIdentifier<
       States,
       Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>
@@ -4947,8 +5081,10 @@ export declare namespace Machine {
    * @category utility types
    * @since 0.4.0
    */
-  export type EventTransitionReturn<Transition> = Transition extends { readonly resolve?: infer Resolve } ?
-    NonNullable<Resolve> extends (...args: any) => infer Ret ? Ret : never
+  export 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
   /**
    * Extracts the return value from a state's event handlers.
@@ -5092,11 +5228,19 @@ export declare namespace Machine {
     : never
   /** Extracts transition results returned by invocation lifecycle handlers. */
   export type InvokeOutcomeReturn<Invoke> = Invoke extends unknown ?
+      | (Invoke extends {
+        readonly [InvokeTypeId]: { readonly outcomes: Types.Covariant<infer Outcomes> }
+      } ? EventTransitionReturn<Outcomes> :
+        never)
       | (Invoke extends { readonly onDone?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
       | (Invoke extends { readonly onFailure?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
       | (Invoke extends { readonly onElement?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
       | (Invoke extends { readonly onSnapshot?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
     : never
+  type InvokeOutcomeError<Invoke> = IsAny<InvokeOutcomeReturn<Invoke>> extends true ? never
+    : Effect.Error<InvokeOutcomeReturn<Invoke>>
+  type InvokeOutcomeServices<Invoke> = IsAny<InvokeOutcomeReturn<Invoke>> extends true ? never
+    : Effect.Services<InvokeOutcomeReturn<Invoke>>
   /**
    * Extracts the parent transition error contribution from invoked children.
    *
@@ -5107,7 +5251,7 @@ export declare namespace Machine {
     :
       | ChildAlreadyExistsError
       | InvokeInitialError<InvokeReturn<Config>>
-      | Effect.Error<InvokeOutcomeReturn<InvokeReturn<Config>>>
+      | InvokeOutcomeError<InvokeReturn<Config>>
   /**
    * Extracts the parent service requirement contribution from invoked children.
    *
@@ -5118,9 +5262,7 @@ export declare namespace Machine {
     :
       | MachineRuntimeRequirement
       | InvokeServices<InvokeReturn<Config>>
-      | Effect.Services<
-        InvokeOutcomeReturn<InvokeReturn<Config>>
-      >
+      | InvokeOutcomeServices<InvokeReturn<Config>>
   /**
    * Extracts the return value from an eventless transition.
    *
@@ -5165,24 +5307,19 @@ export declare namespace Machine {
     | Effect.Services<ChoiceReturn<Config>>
     | InvokeRequirements<Config>
 
-  /** Type evidence retained by {@link transition} without affecting runtime data. */
+  /** Type evidence retained by an authored transition without affecting runtime data. */
   export interface TransitionTyped<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateNodeIdentifier<States>,
     Context,
-    Reenter extends boolean
+    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. */
-  export interface TargetlessTransitionTyped {
-    readonly [TransitionTypeId]: {
-      readonly targetless: true
+      readonly acceptance: Types.Covariant<Acceptance>
     }
   }
 
@@ -5193,41 +5330,9 @@ export declare namespace Machine {
     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. */
-  // Keep the context generic so omitting `target` is deferred until a resolver
-  // is actually authored instead of expanding every TransitionConfig eagerly.
-  interface TargetlessTransitionResolver<
-    Events extends ReadonlyArray<TaggedSchema>,
-    Emits extends ReadonlyArray<TaggedSchema>,
-    Context
-  > {
-    <ResolvedContext extends Omit<Context, "target">>(
-      context: ResolvedContext,
-      enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
-    ): undefined
-  }
-
-  export type TargetlessTransitionInput<
-    Events extends ReadonlyArray<TaggedSchema>,
-    Emits extends ReadonlyArray<TaggedSchema>,
-    Context
-  > = {
-    readonly target: TargetlessSelector
-    readonly resolve?: TargetlessTransitionResolver<Events, Emits, Context>
-    readonly branches?: never
-    readonly reenter?: never
-  }
+    Reenter extends boolean = false,
+    Acceptance extends TransitionAcceptance = "required"
+  > = TransitionBuilderInput<States, Events, Emits, StateId, Context, Reenter, Acceptance>
 
   export type SelectionBuilder<Selection> = Selection extends TargetSelection<infer Builder, any, any> ? Builder : never
   export type SelectionKind<Selection> = Selection extends TargetSelection<any, any, infer Kind> ? Kind : never
@@ -5239,6 +5344,13 @@ export declare namespace Machine {
     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
+
   export type TransitionResolveContext<
     Context,
     Selection
@@ -5246,6 +5358,11 @@ export declare namespace Machine {
     & Omit<Context, "target">
     & (SelectionKind<Selection> extends "none" ? {} : { readonly target: SelectionBuilder<Selection> })
 
+  /** Context capability available only to explicitly declinable resolvers. */
+  export interface DeclineCapability {
+    readonly decline: () => Declined
+  }
+
   export type TransitionResolver<
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -5256,20 +5373,17 @@ export declare namespace Machine {
     enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
   ) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined
 
-  export type TransitionDirectInput<
-    States extends StateSchemas,
+  export type DeclinableTransitionResolver<
     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
-  }
+    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. */
   export interface TransitionBranchInput<
@@ -5337,805 +5451,992 @@ export declare namespace Machine {
     enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
   ) => BranchSelectionResult<Branches>
 
-  export type TransitionBranchesInput<
-    States extends StateSchemas,
+  export type DeclinableTransitionBranchesResolver<
     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
+  > = (
+    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. */
+  export interface TransitionBuilderEvidence<out Result, out Acceptance extends TransitionAcceptance> {
+    readonly [TransitionBuilderTypeId]: {
+      readonly result: Types.Covariant<Result>
+      readonly acceptance: Types.Covariant<Acceptance>
+    }
   }
 
-  export type InvokeTransition<
+  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
-  > = TransitionConfig<States, Events, Emits, StateId, Context, true>
-
-  export type InvokeSource<Value, Context> = Value | ((context: Context) => Value)
+    Context,
+    Reenter extends boolean,
+    Result,
+    Acceptance extends TransitionAcceptance
+  > =
+    & TransitionTyped<States, Events, Emits, StateId, Context, Reenter, Acceptance>
+    & TransitionBuilderEvidence<Result, Acceptance>
 
-  /** Inline state-owned work that runs for the lifetime of its active state. */
-  export interface InvokeOwned<
+  interface TransitionResolveRequired<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateNodeIdentifier<States>,
+    Context,
+    Reenter extends boolean,
+    Selection extends TargetSelection<any, any, any>
   > {
-    readonly "~effect/Machine/InvokeOwner"?: Types.Covariant<readonly [States, Events, Emits, StateId]>
-  }
-
-  /** Type evidence retained by {@link invoke} without affecting runtime data. */
-  export interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never, ParentEvent = never> {
-    readonly [InvokeTypeId]: {
-      readonly output: Types.Covariant<Output>
-      readonly error: Types.Covariant<Error>
-      readonly requirements: Types.Covariant<Requirements>
-      readonly initialError: Types.Covariant<InitialError>
-      readonly emits: Types.Covariant<Emits>
-      readonly parentEvents: Types.Covariant<ParentEvent>
-    }
+    (
+      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"
+    >
   }
 
-  export type InvokeConfig<
+  interface TransitionResolveDeclinable<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
-    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
-    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > =
-    & InvokeOwned<States, Events, Emits, StateId>
-    & (
-      | {
-        readonly id: string
-        readonly effect: (
-          context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-        ) => Effect.Effect<any, any, any>
-        readonly stream?: never
-        readonly after?: never
-        readonly logic?: never
-        readonly child?: never
-        readonly address?: never
-        readonly onDone?: unknown
-        readonly onFailure?: unknown
-        readonly onElement?: never
-        readonly onSnapshot?: never
-      }
-      | {
-        readonly id: string
-        readonly stream: (
-          context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-        ) => Stream.Stream<any, any, any>
-        readonly effect?: never
-        readonly after?: never
-        readonly logic?: never
-        readonly child?: never
-        readonly address?: never
-        readonly onElement?: unknown
-        readonly onDone: unknown
-        readonly onFailure?: unknown
-        readonly onSnapshot?: never
-      }
-      | {
-        readonly id: string
-        readonly after: InvokeSource<
-          Duration.Input,
-          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-        >
-        readonly effect?: never
-        readonly stream?: never
-        readonly logic?: never
-        readonly child?: never
-        readonly address?: never
-        readonly onDone: unknown
-        readonly onFailure?: never
-        readonly onElement?: never
-        readonly onSnapshot?: never
-      }
-      | {
-        readonly id: string
-        readonly address: string
-        readonly logic: InvokeSource<
-          Logic<any, any, any, any, any, any>,
-          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-        >
-        readonly effect?: never
-        readonly stream?: never
-        readonly after?: never
-        readonly child?: never
-        readonly onDone?: unknown
-        readonly onFailure?: unknown
-        readonly onElement?: never
-        readonly onSnapshot?: unknown
-      }
-      | {
-        readonly child: ChildMachine.Any
-        readonly input?:
-          | {}
-          | null
-          | ((context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown)
-        readonly id?: never
-        readonly address?: never
-        readonly effect?: never
-        readonly stream?: never
-        readonly after?: never
-        readonly logic?: never
-        readonly onDone?: unknown
-        readonly onFailure?: unknown
-        readonly onElement?: never
-        readonly onSnapshot?: unknown
-      }
-    )
+    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"
+    >
+  }
 
-  /** State-bound inline invocation configuration. */
-  export type InvokeDefinition<
+  /** A selected transition target with target-specific resolver operations. */
+  export type TransitionTarget<
     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 []
+    StateId extends StateNodeIdentifier<States>,
+    Context,
+    Reenter extends boolean,
+    Acceptance extends TransitionAcceptance,
+    Selection extends TargetSelection<any, any, any>
   > =
-    | InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>
-
-  type TypedInvokeDefinition =
-    | InvokeTyped<any, any, any, any, any, any>
-    | ReadonlyArray<InvokeTyped<any, any, any, 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"
+          >
+        }
+      : {}
+      : {})
 
-  type InvokeHandlerRequirement<Value, Handler> = IsAny<Value> extends true ? { readonly handler: Handler }
-    : [Value] extends [never] ? { readonly handler?: never }
-    : { readonly handler: Handler }
+  /** @internal Type evidence retained by a machine initial-entry declaration. */
+  export interface InitialBuilderEvidence<out Selection> {
+    readonly [InitialBuilderTypeId]: Types.Covariant<Selection>
+  }
 
-  export type InvokeDoneRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
-    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onDone: Required }
-    : { readonly onDone?: never }
-    : never
+  /** A selected machine initial entry with its exact resolver target. */
+  export 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>
+    }
 
-  export type InvokeFailureRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
-    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onFailure: Required }
-    : { readonly onFailure?: never }
+  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]>
+    }
 
-  export type InvokeElementRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
-    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onElement: Required }
-    : { readonly onElement?: never }
-    : never
+  /** Definition-time selector for a machine's top-level initial entry. */
+  export type InitialSelector<States extends StateSchemas, Input = void> = InitialSelectorNode<
+    Input,
+    InitialTargetSelector<States>
+  >
 
-  export type TimerInvokeArgs<
-    States extends StateSchemas,
-    Events extends ReadonlyArray<TaggedSchema>,
-    Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
-    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
-    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > = {
-    readonly id: InvokeLifecycleId
-    readonly after: InvokeSource<
-      Duration.Input,
-      InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    >
-    readonly effect?: never
-    readonly stream?: never
-    readonly logic?: never
-    readonly child?: never
-    readonly address?: never
-    readonly onFailure?: never
-    readonly onElement?: never
-    readonly onSnapshot?: never
-    readonly onDone: InvokeTransition<
-      States,
-      Events,
-      Emits,
-      StateId,
-      InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
-    >
-  }
+  /** Target-first initial-entry declaration accepted by {@link make}. */
+  export type InitialBuilderInput<States extends StateSchemas, Input> = (
+    to: InitialSelector<States, Input>
+  ) => InitialBuilderEvidence<TargetSelection<any, any, any>>
 
-  export type LogicInvokeArgs<
+  type TransitionSelectorNode<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
-    ChildState,
-    ChildEvent,
-    ChildError,
-    ChildRequirements,
-    ChildOutput,
-    ChildInitialError,
-    Address extends ChildAddress<never>,
-    Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
-    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
-    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > =
-    & {
-      readonly id: InvokeLifecycleId
-      readonly address: Address & ChildAddress.Compatibility<Address, ChildEvent>
-      readonly logic: Source
-      readonly effect?: never
-      readonly stream?: never
-      readonly after?: never
-      readonly child?: never
-      readonly onElement?: never
-      readonly onSnapshot?: InvokeTransition<
-        States,
-        Events,
-        Emits,
-        StateId,
-        InvokeSnapshotContext<
+    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,
-          NoInfer<ChildState>,
-          NoInfer<ChildError>,
-          NoInfer<ChildOutput>,
-          InputEvents,
-          ParentEvents
-        >
-      >
-    }
-    & InvokeDoneRequirement<
-      NoInfer<ChildOutput>,
-      InvokeTransition<
+          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,
-        InvokeDoneContext<States, Events, Emits, StateId, NoInfer<ChildOutput>, InputEvents, ParentEvents>
+        Context,
+        Reenter,
+        Acceptance,
+        Node
       >
-    >
-    & InvokeFailureRequirement<
-      NoInfer<ChildError>,
-      InvokeTransition<
+    : {
+      readonly [Key in keyof Node]: TransitionSelectorNode<
         States,
         Events,
         Emits,
         StateId,
-        InvokeFailureContext<States, Events, Emits, StateId, NoInfer<ChildError>, InputEvents, ParentEvents>
+        Context,
+        Reenter,
+        Acceptance,
+        Node[Key]
       >
-    >
+    }
 
-  export type ChildInvokeArgs<
+  interface TransitionBranchesResolveRequired<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
-    ChildDefinition extends Machine.Any,
-    Child extends ChildMachine<string, ChildDefinition>,
-    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
-    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > =
-    & {
-      readonly child:
-        & Child
-        & (ChildDefinition extends EnsureExecutable<
-          Machine.States<ChildDefinition>,
-          Machine.UnhandledStates<ChildDefinition>,
-          Machine.OutputStates<ChildDefinition>
-        > ? unknown :
-          never)
-      readonly id?: never
-      readonly address?: never
-      readonly effect?: never
-      readonly stream?: never
-      readonly after?: never
-      readonly logic?: never
-      readonly onElement?: never
-      readonly onSnapshot?: InvokeTransition<
-        States,
-        Events,
-        Emits,
-        StateId,
-        InvokeSnapshotContext<
-          States,
-          Events,
-          Emits,
-          StateId,
-          Snapshot<Machine.States<ChildDefinition>>,
-          Error<ChildDefinition>,
-          Output<ChildDefinition>,
-          InputEvents,
-          ParentEvents
-        >
-      >
-    }
-    & (Input<ChildDefinition> extends typeof Schema.Void ? { readonly input?: never } : {
-      readonly input: InvokeSource<
-        Input<ChildDefinition>["Type"],
-        InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-      >
-    })
-    & InvokeDoneRequirement<
-      Output<ChildDefinition>,
-      InvokeTransition<
-        States,
-        Events,
-        Emits,
-        StateId,
-        InvokeDoneContext<
-          States,
-          Events,
-          Emits,
-          StateId,
-          Output<ChildDefinition>,
-          InputEvents,
-          ParentEvents
-        >
-      >
-    >
-    & InvokeFailureRequirement<
-      Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
-      InvokeTransition<
-        States,
-        Events,
-        Emits,
-        StateId,
-        InvokeFailureContext<
-          States,
-          Events,
-          Emits,
-          StateId,
-          Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
-          InputEvents,
-          ParentEvents
-        >
-      >
+    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"
     >
+  }
 
-  type LogicInitialEffectOf<Value> = Value extends { readonly initial: infer Initial } ?
-    Initial extends (...args: ReadonlyArray<any>) => infer Result ? Result : never
-    : never
-
-  type LogicRunEffectOf<Value> = Value extends { readonly run: infer Run } ?
-    Run extends (...args: ReadonlyArray<any>) => infer Result ? Result : never
-    : never
-
-  export type LogicStateOf<Value> = Effect.Success<LogicInitialEffectOf<Value>>
-  export type LogicEventOf<Value> = Value extends { readonly initial: infer Initial } ?
-    Initial extends (scope: infer LogicScope, ...args: ReadonlyArray<any>) => any ?
-      LogicScope extends Logic.Scope<infer Event> ? Event : never
-    : never
-    : never
-  export type LogicErrorOf<Value> = Effect.Error<LogicRunEffectOf<Value>>
-  export type LogicServicesOf<Value> = Effect.Services<LogicInitialEffectOf<Value> | LogicRunEffectOf<Value>>
-  export type LogicOutputOf<Value> = Effect.Success<LogicRunEffectOf<Value>>
-  export type LogicInitialErrorOf<Value> = Effect.Error<LogicInitialEffectOf<Value>>
+  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"
+    >
+  }
 
-  type ContextualInvokeConfig<
+  /** Selector supplied to inline transition declarations. */
+  export type TransitionSelector<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
-    InputEvents extends ReadonlyArray<TaggedSchema>,
-    ParentEvents extends ReadonlyArray<TaggedSchema>,
-    Raw
-  > = Raw extends InvokeTyped<any, any, any, any, any> ? unknown
-    : Raw extends { readonly effect: infer Source } ?
-      InvokeFactoryResult<Source> extends infer Fx extends Effect.Effect<any, any, any> ?
-          & InvokeDoneRequirement<
-            Effect.Success<Fx>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>, InputEvents, ParentEvents>
-            >
-          >
-          & InvokeFailureRequirement<
-            Effect.Error<Fx>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>
-            >
-          >
-          & { readonly onSnapshot?: never }
-      : never
-    : Raw extends { readonly stream: infer Source } ?
-      InvokeFactoryResult<Source> extends infer SourceStream extends Stream.Stream<any, any, any> ?
-          & InvokeElementRequirement<
-            Stream.Success<SourceStream>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeElementContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                Stream.Success<SourceStream>,
-                InputEvents,
-                ParentEvents
-              >
-            >
-          >
-          & {
-            readonly onDone: InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
-            >
-          }
-          & InvokeFailureRequirement<
-            Stream.Error<SourceStream>,
-            InvokeTransition<
+    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,
-              InvokeFailureContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                Stream.Error<SourceStream>,
-                InputEvents,
-                ParentEvents
-              >
+              Context,
+              Reenter,
+              Branches
             >
-          >
-          & { readonly onSnapshot?: never }
-      : never
-    : Raw extends { readonly after: unknown } ? {
-        readonly onDone: InvokeTransition<
-          States,
-          Events,
-          Emits,
-          StateId,
-          InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
-        >
-        readonly onFailure?: never
-        readonly onSnapshot?: never
+            : {})
       }
-    : Raw extends { readonly logic: infer Source; readonly address: infer Address } ?
-      InvokeResolvedSource<Source> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ?
-          & InvokeDoneRequirement<
-            InvokeOutput<Raw>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>, InputEvents, ParentEvents>
-            >
-          >
-          & InvokeFailureRequirement<
-            InvokeRuntimeError<Raw>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeFailureContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                InvokeRuntimeError<Raw>,
-                InputEvents,
-                ParentEvents
-              >
-            >
-          >
-          & {
-            readonly address:
-              & ChildAddress<never>
-              & ChildAddress.Compatibility<
-                Address,
-                ChildLogic extends Logic<any, infer ChildEvent, any, any, any, any> ? ChildEvent : never
-              >
-            readonly onSnapshot?: InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeSnapshotContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                ChildLogic extends Logic<infer ChildState, any, any, any, any, any> ? ChildState : never,
-                InvokeRuntimeError<Raw>,
-                InvokeOutput<Raw>,
-                InputEvents,
-                ParentEvents
-              >
-            >
-          }
-      : never
-    : Raw extends { readonly child: infer Child extends ChildMachine<string, infer ChildDefinition> } ?
-      ChildMachineLogic<Child> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ?
-          & InvokeDoneRequirement<
-            Output<ChildDefinition>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeDoneContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                Output<ChildDefinition>,
-                InputEvents,
-                ParentEvents
-              >
-            >
-          >
-          & InvokeFailureRequirement<
-            Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeFailureContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
-                InputEvents,
-                ParentEvents
-              >
-            >
-          >
-          & (Input<ChildDefinition> extends typeof Schema.Void ? { readonly input?: never } : {
-            readonly input: InvokeSource<
-              Input<ChildDefinition>["Type"],
-              InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-            >
-          })
-          & {
-            readonly onSnapshot?: InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeSnapshotContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                Snapshot<Machine.States<ChildDefinition>>,
-                Error<ChildDefinition>,
-                Output<ChildDefinition>,
-                InputEvents,
-                ParentEvents
-              >
-            >
-          }
-      : never
-    : never
+    }
 
-  type ContextualInvokeDefinition<
+  /** Inline transition declaration accepted by state and invocation handlers. */
+  export type TransitionBuilderInput<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
-    InputEvents extends ReadonlyArray<TaggedSchema>,
-    ParentEvents extends ReadonlyArray<TaggedSchema>,
-    Raw
-  > = Raw extends ReadonlyArray<any> ? {
-      readonly [Index in keyof Raw]: ContextualInvokeConfig<
-        States,
-        Events,
-        Emits,
-        StateId,
-        InputEvents,
-        ParentEvents,
-        Raw[Index]
-      >
-    }
-    : ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw>
+    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 OutputHandlerConfig<
+  export type InvokeTransition<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateNodeIdentifier<States>,
     Context
-  > = NodeByIdentifier<States, StateId> extends { readonly output: Schema.Top } ? {
-      readonly output: (context: Context) => OutputByIdentifier<States, StateId>
-    }
-    : {
-      readonly output?: never
-    }
+  > = TransitionConfig<States, Events, Emits, StateId, Context, true, TransitionAcceptance>
 
-  type ActiveOutputHandlerConfig<
-    States extends StateSchemas,
-    Events extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
-  > = NodeByIdentifier<States, StateId> extends { readonly type: "parallel" } ? OutputHandlerConfig<
-      States,
-      Events,
-      StateId,
-      ParallelOutputContext<States, Events, StateId>
-    >
-    : {
-      readonly output?: never
-    }
+  export type InvokeSource<Value, Context> = Value | ((context: Context) => Value)
 
-  /**
-   * Configuration accepted for a non-final state.
-   *
-   * @category models
-   * @since 0.4.0
-   */
-  export type ActiveStateConfig<
+  /** Inline state-owned work that runs for the lifetime of its active state. */
+  export interface InvokeOwned<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
-    E,
-    R,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > = {
-    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 "~effect/Machine/InvokeOwner"?: Types.Covariant<
+      readonly [States, Events, Emits, StateId, InputEvents, ParentEvents]
     >
-    readonly on?: {
-      readonly [EventTag in TagOf<Events[number]>]?: TransitionConfig<
-        States,
-        Events,
-        Emits,
-        StateId,
-        HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>,
-        true
-      >
+  }
+
+  /** Type evidence retained by a completed state-owned invocation. */
+  export interface InvokeTyped<
+    Output,
+    Error,
+    Requirements,
+    InitialError,
+    Emits = never,
+    ParentEvent = never,
+    Outcomes = never
+  > {
+    readonly [InvokeTypeId]: {
+      readonly output: Types.Covariant<Output>
+      readonly error: Types.Covariant<Error>
+      readonly requirements: Types.Covariant<Requirements>
+      readonly initialError: Types.Covariant<InitialError>
+      readonly emits: Types.Covariant<Emits>
+      readonly parentEvents: Types.Covariant<ParentEvent>
+      readonly outcomes: Types.Covariant<Outcomes>
     }
-    readonly initialize?: StateInitializeHandler<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  } & ActiveOutputHandlerConfig<States, Events, StateId>
+  }
 
-  /**
-   * Values constructed for a state's schema-valued direct initial children.
-   *
-   * @category utility types
-   * @since 0.13.0
-   */
-  export type StateInitializeValue<
+  type StoredInvokeConfig<
     States extends StateSchemas,
-    StateId extends StateIdentifier<States>
-  > = NodeByIdentifier<States, StateId> extends infer Node ?
-    Node extends { readonly type: "parallel"; readonly states: infer Children extends StateSchemas } ? {
-        readonly [Key in ActiveStateKey<Children> as NodeSchema<Children[Key]> extends never ? never : Key]: NodeValue<
-          Children[Key]
+    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
+        readonly after?: never
+        readonly logic?: never
+        readonly child?: never
+        readonly address?: never
+        readonly onDone?: unknown
+        readonly onFailure?: unknown
+        readonly onElement?: never
+        readonly onSnapshot?: never
+      }
+      | {
+        readonly id: string
+        readonly stream: (
+          context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        ) => Stream.Stream<any, any, any>
+        readonly effect?: never
+        readonly after?: never
+        readonly logic?: never
+        readonly child?: never
+        readonly address?: never
+        readonly onElement?: unknown
+        readonly onDone: unknown
+        readonly onFailure?: unknown
+        readonly onSnapshot?: never
+      }
+      | {
+        readonly id: string
+        readonly after: InvokeSource<
+          Duration.Input,
+          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
         >
+        readonly effect?: never
+        readonly stream?: never
+        readonly logic?: never
+        readonly child?: never
+        readonly address?: never
+        readonly onDone: unknown
+        readonly onFailure?: never
+        readonly onElement?: never
+        readonly onSnapshot?: never
       }
-    : Node extends { readonly states: infer Children extends StateSchemas; readonly initial: infer Initial } ?
-      Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never
-        : { readonly [Key in Initial]: NodeValue<Children[Initial]> }
-      : never
+      | {
+        readonly id: string
+        readonly address: string
+        readonly logic: InvokeSource<
+          Logic<any, any, any, any, any, any>,
+          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        >
+        readonly effect?: never
+        readonly stream?: never
+        readonly after?: never
+        readonly child?: never
+        readonly onDone?: unknown
+        readonly onFailure?: unknown
+        readonly onElement?: never
+        readonly onSnapshot?: unknown
+      }
+      | {
+        readonly child: ChildMachine.Any
+        readonly input?:
+          | {}
+          | null
+          | ((context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown)
+        readonly id?: never
+        readonly address?: never
+        readonly effect?: never
+        readonly stream?: never
+        readonly after?: never
+        readonly logic?: never
+        readonly onDone?: unknown
+        readonly onFailure?: unknown
+        readonly onElement?: never
+        readonly onSnapshot?: unknown
+      }
+    )
+
+  type StoredInvokeDefinition<
+    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 []
+  > =
+    | StoredInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    | ReadonlyArray<StoredInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>
+
+  type LogicInitialEffectOf<Value> = Value extends { readonly initial: infer Initial } ?
+    Initial extends (...args: ReadonlyArray<any>) => infer Result ? Result : never
     : never
+
+  type LogicRunEffectOf<Value> = Value extends { readonly run: infer Run } ?
+    Run extends (...args: ReadonlyArray<any>) => infer Result ? Result : never
     : never
 
-  type StateInitializeCompoundBuilder<Node, Initial extends PropertyKey> = Node extends {
-    readonly states: infer Children extends StateSchemas
-  } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never
-      : NodeBuilderMethod<
-        Children[Initial],
-        readonly [value: NodeValue<Children[Initial]>],
-        SnapshotBuilderComplete<{ readonly [Key in Initial]: NodeValue<Children[Initial]> }>,
-        readonly [input: NodeMakeInput<Children[Initial]>],
-        SnapshotBuilderComplete<{ readonly [Key in Initial]: NodeValue<Children[Initial]> }, true>
-      >
+  export type LogicStateOf<Value> = Effect.Success<LogicInitialEffectOf<Value>>
+  export type LogicEventOf<Value> = Value extends { readonly initial: infer Initial } ?
+    Initial extends (scope: infer LogicScope, ...args: ReadonlyArray<any>) => any ?
+      LogicScope extends Logic.Scope<infer Event> ? Event : never
     : never
     : never
+  export type LogicErrorOf<Value> = Effect.Error<LogicRunEffectOf<Value>>
+  export type LogicServicesOf<Value> = Effect.Services<LogicInitialEffectOf<Value> | LogicRunEffectOf<Value>>
+  export type LogicOutputOf<Value> = Effect.Success<LogicRunEffectOf<Value>>
+  export type LogicInitialErrorOf<Value> = Effect.Error<LogicInitialEffectOf<Value>>
 
-  type StateInitializeParallelBuilder<
-    Children extends StateSchemas,
-    Remaining extends ActiveStateKey<Children> = {
-      readonly [Key in ActiveStateKey<Children>]: NodeSchema<Children[Key]> extends never ? never : Key
-    }[ActiveStateKey<Children>],
-    Values = {},
-    Constructed extends boolean = false
+  type RequiredInvokeChannel<Value, Channel extends string> = IsAny<Value> extends true ? Channel
+    : [Value] extends [never] ? never
+    : Channel
+
+  type InvokeBuilderResult<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
+    Output,
+    Error,
+    Requirements,
+    InitialError,
+    ChildEmits,
+    ChildParentEvent,
+    Outcomes
   > =
-    & SnapshotBuilderComplete<Values, Constructed>
-    & {
-      readonly [Key in Remaining]: NodeBuilderMethod<
-        Children[Key],
-        readonly [value: NodeValue<Children[Key]>],
-        StateInitializeParallelBuilder<
-          Children,
-          Exclude<Remaining, Key>,
-          Values & { readonly [Region in Key]: NodeValue<Children[Key]> },
-          Constructed
-        >,
-        readonly [input: NodeMakeInput<Children[Key]>],
-        StateInitializeParallelBuilder<
-          Children,
-          Exclude<Remaining, Key>,
-          Values & { readonly [Region in Key]: NodeValue<Children[Key]> },
-          true
+    & InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    & InvokeTyped<Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Outcomes>
+    & { readonly [InvokeBuilderTypeId]: true }
+
+  type InvokeBuilder<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
+    Output,
+    Error,
+    Requirements,
+    InitialError,
+    ChildEmits,
+    ChildParentEvent,
+    Element,
+    Pending extends string,
+    SnapshotHandler,
+    Outcomes = never
+  > =
+    & ([Pending] extends [never] ? InvokeBuilderResult<
+        States,
+        Events,
+        Emits,
+        StateId,
+        InputEvents,
+        ParentEvents,
+        Output,
+        Error,
+        Requirements,
+        InitialError,
+        ChildEmits,
+        ChildParentEvent,
+        Outcomes
+      >
+      : {})
+    & ("done" extends Pending ? {
+        readonly onDone: <
+          const Handler extends InvokeTransition<
+            States,
+            Events,
+            Emits,
+            StateId,
+            InvokeDoneContext<States, Events, Emits, StateId, Output, InputEvents, ParentEvents>
+          >
+        >(
+          handler:
+            & Handler
+            & InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeDoneContext<States, Events, Emits, StateId, Output, InputEvents, ParentEvents>
+            >
+        ) => InvokeBuilder<
+          States,
+          Events,
+          Emits,
+          StateId,
+          InputEvents,
+          ParentEvents,
+          Output,
+          Error,
+          Requirements,
+          InitialError,
+          ChildEmits,
+          ChildParentEvent,
+          Element,
+          Exclude<Pending, "done">,
+          SnapshotHandler,
+          Outcomes | Handler
+        >
+      }
+      : {})
+    & ("failure" extends Pending ? {
+        readonly onFailure: <
+          const Handler extends InvokeTransition<
+            States,
+            Events,
+            Emits,
+            StateId,
+            InvokeFailureContext<States, Events, Emits, StateId, Error, InputEvents, ParentEvents>
+          >
+        >(
+          handler:
+            & Handler
+            & InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeFailureContext<States, Events, Emits, StateId, Error, InputEvents, ParentEvents>
+            >
+        ) => InvokeBuilder<
+          States,
+          Events,
+          Emits,
+          StateId,
+          InputEvents,
+          ParentEvents,
+          Output,
+          Error,
+          Requirements,
+          InitialError,
+          ChildEmits,
+          ChildParentEvent,
+          Element,
+          Exclude<Pending, "failure">,
+          SnapshotHandler,
+          Outcomes | Handler
+        >
+      }
+      : {})
+    & ("element" extends Pending ? {
+        readonly onElement: <
+          const Handler extends InvokeTransition<
+            States,
+            Events,
+            Emits,
+            StateId,
+            InvokeElementContext<States, Events, Emits, StateId, Element, InputEvents, ParentEvents>
+          >
+        >(
+          handler:
+            & Handler
+            & InvokeTransition<
+              States,
+              Events,
+              Emits,
+              StateId,
+              InvokeElementContext<States, Events, Emits, StateId, Element, InputEvents, ParentEvents>
+            >
+        ) => InvokeBuilder<
+          States,
+          Events,
+          Emits,
+          StateId,
+          InputEvents,
+          ParentEvents,
+          Output,
+          Error,
+          Requirements,
+          InitialError,
+          ChildEmits,
+          ChildParentEvent,
+          Element,
+          Exclude<Pending, "element">,
+          SnapshotHandler,
+          Outcomes | Handler
         >
+      }
+      : {})
+    & ([SnapshotHandler] extends [never] ? {} : {
+      readonly onSnapshot: <const Handler extends SnapshotHandler>(handler: Handler & SnapshotHandler) => InvokeBuilder<
+        States,
+        Events,
+        Emits,
+        StateId,
+        InputEvents,
+        ParentEvents,
+        Output,
+        Error,
+        Requirements,
+        InitialError,
+        ChildEmits,
+        ChildParentEvent,
+        Element,
+        Pending,
+        never,
+        Outcomes | Handler
       >
-    }
+    })
 
-  /**
-   * Builder bound to the direct initial child or regions owned by a state.
-   *
-   * @category utility types
-   * @since 0.13.0
-   */
-  export type StateInitializeBuilder<
+  type EffectInvokeBuilder<
     States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
-    Node = NodeByIdentifier<States, StateId>
-  > = Node extends { readonly type: "parallel"; readonly states: infer Children extends StateSchemas } ?
-    StateInitializeParallelBuilder<Children>
-    : Node extends { readonly initial: infer Initial } ? StateInitializeCompoundBuilder<Node, Initial & PropertyKey>
-    : never
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
+    Source extends (...args: ReadonlyArray<any>) => Effect.Effect<any, any, any>
+  > = InvokeBuilder<
+    States,
+    Events,
+    Emits,
+    StateId,
+    InputEvents,
+    ParentEvents,
+    Effect.Success<ReturnType<Source>>,
+    Effect.Error<ReturnType<Source>>,
+    Effect.Services<ReturnType<Source>>,
+    never,
+    never,
+    never,
+    never,
+    | RequiredInvokeChannel<Effect.Success<ReturnType<Source>>, "done">
+    | RequiredInvokeChannel<Effect.Error<ReturnType<Source>>, "failure">,
+    never
+  >
+
+  type StreamInvokeBuilder<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
+    Source extends (...args: ReadonlyArray<any>) => Stream.Stream<any, any, any>
+  > = InvokeBuilder<
+    States,
+    Events,
+    Emits,
+    StateId,
+    InputEvents,
+    ParentEvents,
+    void,
+    Stream.Error<ReturnType<Source>>,
+    Stream.Services<ReturnType<Source>>,
+    never,
+    never,
+    never,
+    Stream.Success<ReturnType<Source>>,
+    | "done"
+    | RequiredInvokeChannel<Stream.Success<ReturnType<Source>>, "element">
+    | RequiredInvokeChannel<Stream.Error<ReturnType<Source>>, "failure">,
+    never
+  >
+
+  type LogicInvokeBuilder<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
+    ChildLogic
+  > = InvokeBuilder<
+    States,
+    Events,
+    Emits,
+    StateId,
+    InputEvents,
+    ParentEvents,
+    LogicOutputOf<ChildLogic>,
+    LogicErrorOf<ChildLogic>,
+    LogicServicesOf<ChildLogic>,
+    LogicInitialErrorOf<ChildLogic>,
+    never,
+    never,
+    never,
+    | RequiredInvokeChannel<LogicOutputOf<ChildLogic>, "done">
+    | RequiredInvokeChannel<LogicErrorOf<ChildLogic>, "failure">,
+    InvokeTransition<
+      States,
+      Events,
+      Emits,
+      StateId,
+      InvokeSnapshotContext<
+        States,
+        Events,
+        Emits,
+        StateId,
+        LogicStateOf<ChildLogic>,
+        LogicErrorOf<ChildLogic>,
+        LogicOutputOf<ChildLogic>,
+        InputEvents,
+        ParentEvents
+      >
+    >
+  >
+
+  type ChildInvokeBuilder<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
+    Child extends ChildMachine.Any,
+    ChildDefinition extends Machine.Any = Child["machine"]
+  > = InvokeBuilder<
+    States,
+    Events,
+    Emits,
+    StateId,
+    InputEvents,
+    ParentEvents,
+    Output<ChildDefinition>,
+    Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
+    Services<ChildDefinition>,
+    InitialError<ChildDefinition>,
+    Emit<ChildDefinition>,
+    EventOf<Machine.ParentEvents<ChildDefinition>>,
+    never,
+    | RequiredInvokeChannel<Output<ChildDefinition>, "done">
+    | RequiredInvokeChannel<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, "failure">,
+    InvokeTransition<
+      States,
+      Events,
+      Emits,
+      StateId,
+      InvokeSnapshotContext<
+        States,
+        Events,
+        Emits,
+        StateId,
+        Snapshot<Machine.States<ChildDefinition>>,
+        Error<ChildDefinition>,
+        Output<ChildDefinition>,
+        InputEvents,
+        ParentEvents
+      >
+    >
+  >
 
   /**
-   * Context passed to an implicit child-state initializer.
+   * Selects state-owned work and begins its lifecycle-handler chain.
+   *
+   * Each source exposes exactly the lifecycle methods that it can produce. A
+   * chain becomes returnable from `invoke` only after every reachable required
+   * channel has been handled.
    *
    * @category models
-   * @since 0.13.0
+   * @since 0.18.0
    */
-  export type StateInitializeContext<
+  export interface InvokeSelector<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > = StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents> & {
-    readonly builder: StateInitializeBuilder<States, StateId>
+  > {
+    /** Starts a fresh Effect each time the owning state is entered. */
+    readonly effect: <
+      const Source extends (
+        context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+      ) => Effect.Effect<unknown, unknown, unknown>
+    >(
+      id: InvokeLifecycleId,
+      source: Source
+    ) => EffectInvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, Source>
+
+    /** Starts a fresh, backpressured Stream each time the owning state is entered. */
+    readonly stream: <
+      const Source extends (
+        context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+      ) => Stream.Stream<unknown, unknown, any>
+    >(
+      id: InvokeLifecycleId,
+      source: Source
+    ) => StreamInvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, Source>
+
+    /** Starts a cancellable state-scoped timer. */
+    readonly timer: (
+      id: InvokeLifecycleId,
+      duration: InvokeSource<
+        Duration.Input,
+        InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+      >
+    ) => InvokeBuilder<
+      States,
+      Events,
+      Emits,
+      StateId,
+      InputEvents,
+      ParentEvents,
+      void,
+      never,
+      never,
+      never,
+      never,
+      never,
+      never,
+      "done",
+      never
+    >
+
+    /** Starts reusable process logic at a typed parent-local address. */
+    readonly logic: {
+      <
+        const Source extends (
+          context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        ) => unknown,
+        Address extends ChildAddress<never>
+      >(
+        id: InvokeLifecycleId,
+        options: {
+          readonly address:
+            & Address
+            & ChildAddress.Compatibility<Address, LogicEventOf<ReturnType<NoInfer<Source>>>>
+          readonly logic: Source
+        },
+        ..._validation: ReturnType<Source> extends { readonly initial: unknown; readonly run: unknown } ? [] : [
+          "logic factory must return Machine.Logic"
+        ]
+      ): LogicInvokeBuilder<
+        States,
+        Events,
+        Emits,
+        StateId,
+        InputEvents,
+        ParentEvents,
+        ReturnType<Source>
+      >
+      <const Source, Address extends ChildAddress<never>>(
+        id: InvokeLifecycleId,
+        options: {
+          readonly address: Address & ChildAddress.Compatibility<Address, LogicEventOf<NoInfer<Source>>>
+          readonly logic: Source
+        },
+        ..._validation: Source extends { readonly initial: unknown; readonly run: unknown } ? [] : [
+          "logic must implement Machine.Logic"
+        ]
+      ): LogicInvokeBuilder<
+        States,
+        Events,
+        Emits,
+        StateId,
+        InputEvents,
+        ParentEvents,
+        Source
+      >
+    }
+
+    /** Starts a complete child statechart represented by a reusable descriptor. */
+    readonly child: <const Child extends ChildMachine.Any>(
+      child:
+        & Child
+        & (Child["machine"] extends EnsureExecutable<
+          Machine.States<Child["machine"]>,
+          Machine.UnhandledStates<Child["machine"]>,
+          Machine.OutputStates<Child["machine"]>
+        > ? unknown
+          : never),
+      ...options: InputSchema<Child["machine"]> extends typeof Schema.Void ? [options?: { readonly input?: never }]
+        : [options: {
+          readonly input: InvokeSource<
+            Input<Child["machine"]>,
+            InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+          >
+        }]
+    ) => ChildInvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, Child>
   }
 
   /**
-   * Initial child value implementation for a compound or parallel state.
+   * Inline invocation declaration accepted by an active state handler.
+   *
+   * Return one completed source chain or an array of completed chains. Source
+   * computations and child descriptors may be extracted, but the chain stays
+   * local to preserve the owning state and machine protocols.
    *
    * @category models
-   * @since 0.13.0
+   * @since 0.18.0
    */
-  export type StateInitializeHandler<
+  export type InvokeBuilderInput<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -6143,15 +6444,219 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = (
-    context: StateInitializeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
-    enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
-  ) => SnapshotBuilderComplete<StateInitializeValue<States, StateId>, boolean>
+    from: InvokeSelector<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  ) =>
+    | (InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & {
+      readonly [InvokeBuilderTypeId]: true
+    })
+    | ReadonlyArray<
+      InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & {
+        readonly [InvokeBuilderTypeId]: true
+      }
+    >
 
-  /** Context used only when a history node has no previously captured record. */
-  export interface HistoryDefaultContext<
+  type OutputHandlerConfig<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
-    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    Context
+  > = NodeByIdentifier<States, StateId> extends { readonly output: Schema.Top } ? {
+      readonly output: (context: Context) => OutputByIdentifier<States, StateId>
+    }
+    : {
+      readonly output?: never
+    }
+
+  type ActiveOutputHandlerConfig<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>
+  > = NodeByIdentifier<States, StateId> extends { readonly type: "parallel" } ? OutputHandlerConfig<
+      States,
+      Events,
+      StateId,
+      ParallelOutputContext<States, Events, StateId>
+    >
+    : {
+      readonly output?: never
+    }
+
+  /**
+   * Configuration accepted for a non-final state.
+   *
+   * @category models
+   * @since 0.4.0
+   */
+  export type ActiveStateConfig<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    E,
+    R,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > = {
+    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?: InvokeBuilderInput<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,
+        TransitionAcceptance
+      >
+    }
+    readonly initialize?: StateInitializeHandler<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  } & ActiveOutputHandlerConfig<States, Events, StateId>
+
+  /**
+   * Values constructed for a state's schema-valued direct initial children.
+   *
+   * @category utility types
+   * @since 0.13.0
+   */
+  export type StateInitializeValue<
+    States extends StateSchemas,
+    StateId extends StateIdentifier<States>
+  > = NodeByIdentifier<States, StateId> extends infer Node ?
+    Node extends { readonly type: "parallel"; readonly states: infer Children extends StateSchemas } ? {
+        readonly [Key in ActiveStateKey<Children> as NodeSchema<Children[Key]> extends never ? never : Key]: NodeValue<
+          Children[Key]
+        >
+      }
+    : Node extends { readonly states: infer Children extends StateSchemas; readonly initial: infer Initial } ?
+      Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never
+        : { readonly [Key in Initial]: NodeValue<Children[Initial]> }
+      : never
+    : never
+    : never
+
+  type StateInitializeCompoundBuilder<Node, Initial extends PropertyKey> = Node extends {
+    readonly states: infer Children extends StateSchemas
+  } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never
+      : NodeBuilderMethod<
+        Children[Initial],
+        readonly [value: NodeValue<Children[Initial]>],
+        SnapshotBuilderComplete<{ readonly [Key in Initial]: NodeValue<Children[Initial]> }>,
+        readonly [input: NodeMakeInput<Children[Initial]>],
+        SnapshotBuilderComplete<{ readonly [Key in Initial]: NodeValue<Children[Initial]> }, true>
+      >
+    : never
+    : never
+
+  type StateInitializeParallelBuilder<
+    Children extends StateSchemas,
+    Remaining extends ActiveStateKey<Children> = {
+      readonly [Key in ActiveStateKey<Children>]: NodeSchema<Children[Key]> extends never ? never : Key
+    }[ActiveStateKey<Children>],
+    Values = {},
+    Constructed extends boolean = false
+  > =
+    & SnapshotBuilderComplete<Values, Constructed>
+    & {
+      readonly [Key in Remaining]: NodeBuilderMethod<
+        Children[Key],
+        readonly [value: NodeValue<Children[Key]>],
+        StateInitializeParallelBuilder<
+          Children,
+          Exclude<Remaining, Key>,
+          Values & { readonly [Region in Key]: NodeValue<Children[Key]> },
+          Constructed
+        >,
+        readonly [input: NodeMakeInput<Children[Key]>],
+        StateInitializeParallelBuilder<
+          Children,
+          Exclude<Remaining, Key>,
+          Values & { readonly [Region in Key]: NodeValue<Children[Key]> },
+          true
+        >
+      >
+    }
+
+  /**
+   * Builder bound to the direct initial child or regions owned by a state.
+   *
+   * @category utility types
+   * @since 0.13.0
+   */
+  export type StateInitializeBuilder<
+    States extends StateSchemas,
+    StateId extends StateIdentifier<States>,
+    Node = NodeByIdentifier<States, StateId>
+  > = Node extends { readonly type: "parallel"; readonly states: infer Children extends StateSchemas } ?
+    StateInitializeParallelBuilder<Children>
+    : Node extends { readonly initial: infer Initial } ? StateInitializeCompoundBuilder<Node, Initial & PropertyKey>
+    : never
+
+  /**
+   * Context passed to an implicit child-state initializer.
+   *
+   * @category models
+   * @since 0.13.0
+   */
+  export type StateInitializeContext<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > = StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents> & {
+    readonly builder: StateInitializeBuilder<States, StateId>
+  }
+
+  /**
+   * Initial child value implementation for a compound or parallel state.
+   *
+   * @category models
+   * @since 0.13.0
+   */
+  export type StateInitializeHandler<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > = (
+    context: StateInitializeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
+    enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
+  ) => SnapshotBuilderComplete<StateInitializeValue<States, StateId>, boolean>
+
+  /** Context used only when a history node has no previously captured record. */
+  export interface HistoryDefaultContext<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
     ParentId extends StateIdentifier<States>
   > {
     readonly event: LifecycleEvent<Events>
@@ -6304,55 +6809,6 @@ export declare namespace Machine {
     : Path extends keyof Config ? Config[Path]
     : never
 
-  type HandlerInvokeContextAtPath<
-    AllStates extends StateSchemas,
-    Events extends ReadonlyArray<TaggedSchema>,
-    InputEvents extends ReadonlyArray<TaggedSchema>,
-    Emits extends ReadonlyArray<TaggedSchema>,
-    ParentEvents extends ReadonlyArray<TaggedSchema>,
-    Config,
-    StateId extends StateNodeIdentifier<AllStates>,
-    NodeConfig = HandlerConfigAtPath<Config, StateId>
-  > = StateId extends StateIdentifier<AllStates> ?
-    NodeConfig extends { readonly invoke: infer Invoke } ? HandlerValidationAtPath<
-        StateId,
-        {
-          readonly invoke: ContextualInvokeDefinition<
-            AllStates,
-            Events,
-            Emits,
-            StateId,
-            InputEvents,
-            ParentEvents,
-            Invoke
-          >
-        }
-      >
-    : unknown
-    : unknown
-
-  type HandlerInvokeContexts<
-    AllStates extends StateSchemas,
-    Events extends ReadonlyArray<TaggedSchema>,
-    InputEvents extends ReadonlyArray<TaggedSchema>,
-    Emits extends ReadonlyArray<TaggedSchema>,
-    ParentEvents extends ReadonlyArray<TaggedSchema>,
-    Config
-  > = Types.UnionToIntersection<
-    StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ?
-      StateId extends StateNodeIdentifier<AllStates> ? HandlerInvokeContextAtPath<
-          AllStates,
-          Events,
-          InputEvents,
-          Emits,
-          ParentEvents,
-          Config,
-          StateId
-        >
-      : never
-      : never
-  >
-
   // Rebuild the public nested handler shape so branded validation errors stay
   // attached to the exact property that introduced them.
   type HandlerValidationAtPath<Path extends string, Validation> = Path extends `${infer Head}.${infer Rest}` ? {
@@ -6952,7 +7408,6 @@ export declare namespace Machine {
     >(
       config:
         & Config
-        & HandlerInvokeContexts<States, Events, InputEvents, Emits, ParentEvents, NoInfer<Config>>
         & HandlerTreeValidation<
           States,
           Events,
@@ -7022,7 +7477,8 @@ export declare namespace Machine {
         Emits,
         StateId,
         HandlerContext<States, Events, Emits, StateId, EventTag, E, R>,
-        true
+        true,
+        TransitionAcceptance
       >
     >
   >
@@ -7050,20 +7506,24 @@ export declare namespace Machine {
       context: StateActionContext<States, Events, Emits, StateId>,
       enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
     ) => StateActionResult<E, R>
-    readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>
+    readonly invoke?: StoredInvokeDefinition<States, Events, Emits, StateId>
     readonly always?: TransitionConfig<
       States,
       Events,
       Emits,
       StateId,
-      AlwaysContext<States, Events, Emits, StateId>
+      AlwaysContext<States, Events, Emits, StateId>,
+      false,
+      TransitionAcceptance
     >
     readonly onDone?: TransitionConfig<
       States,
       Events,
       Emits,
       StateId,
-      DoneContext<States, Events, Emits, StateId>
+      DoneContext<States, Events, Emits, StateId>,
+      false,
+      TransitionAcceptance
     >
     readonly output?:
       | ((context: FinalOutputContext<States, Events, StateId>) => unknown)
@@ -7094,15 +7554,49 @@ export declare namespace Machine {
   >
 }
 
+type StateSource = Machine.DefinedStates<any> | Machine.Any
+
+type StateSchemasOf<Source extends StateSource> = Source extends Machine.DefinedStates<infer States> ? States
+  : Source extends Machine.Any ? Machine.States<Source>
+  : never
+
 /**
- * Extracts the complete logical snapshot represented by a state definition.
+ * Extracts the complete logical snapshot represented by a state definition or
+ * machine.
  *
  * @category utility types
  * @since 0.15.0
  */
-export type Snapshot<Defined extends Machine.DefinedStates<any>> = Defined extends Machine.DefinedStates<infer States>
-  ? Machine.Snapshot<States>
-  : never
+export type Snapshot<Source extends StateSource> = Machine.Snapshot<StateSchemasOf<Source>>
+
+/**
+ * Extracts the decoded value owned by a schema-backed state path.
+ *
+ * The source may be the object returned by {@link states} or a machine
+ * definition. Control-only state paths are intentionally excluded.
+ *
+ * @category utility types
+ * @since 0.18.0
+ */
+export type Value<
+  Source extends StateSource,
+  Path extends Machine.ValuedStateIdentifier<StateSchemasOf<Source>>
+> = Machine.StateByIdentifier<StateSchemasOf<Source>, Path>
+
+/**
+ * Extracts the logical snapshot rooted at a state path.
+ *
+ * The source may be the object returned by {@link states} or a machine
+ * definition. This is the type-level counterpart of
+ * `DefinedStates.getSnapshot`.
+ *
+ * @category utility types
+ * @since 0.18.0
+ */
+export type SnapshotAt<
+  Source extends StateSource,
+  Path extends Machine.StateIdentifier<StateSchemasOf<Source>>
+> = Machine.SnapshotByIdentifier<StateSchemasOf<Source>, Path>
 
 /**
  * Returns `true` if a value is a `Machine`.
@@ -7220,10 +7714,7 @@ export const state: StateConstructor = internal.state as 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())
  * })
  * ```
  *
@@ -7232,20 +7723,6 @@ export const state: StateConstructor = internal.state as StateConstructor
  */
 export const states: StatesConstructor = internal.states
 
-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>,
@@ -7254,7 +7731,7 @@ type MakeConfig<
   InitialE,
   InitialR,
   InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
+  ParentDeclaration extends Parent.Any | undefined
 > = {
   readonly id?: string
   readonly states: States & DefineStateTreeInput<NoInfer<States>>
@@ -7268,7 +7745,7 @@ type MakeConfig<
       NoInfer<InternalEvents>
     >
   readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>
-  readonly parentEvents?: Machine.EventProtocol<"public", ParentEvents>
+  readonly parent?: ParentDeclaration
   readonly input?: Input
   readonly initial: unknown
 }
@@ -7281,7 +7758,7 @@ type MakeResult<
   InitialE,
   InitialR,
   InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
+  ParentDeclaration extends Parent.Any | undefined
 > = Definition<
   States,
   readonly [...InputEvents, ...InternalEvents],
@@ -7292,7 +7769,7 @@ type MakeResult<
   Machine.TerminalOutput<States>,
   Emits,
   InputEvents,
-  ParentEvents
+  Machine.ParentEventsOf<ParentDeclaration>
 >
 
 interface Make {
@@ -7304,17 +7781,16 @@ interface Make {
     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>
+    const ParentDeclaration extends Parent.Any | undefined = undefined
   >(
     config:
       & Omit<
-        MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>,
+        MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>,
         "initial"
       >
-      & { readonly initial: InitialDirectInput<States, Input["Type"], InitialSelection> },
+      & { readonly initial: Machine.InitialBuilderInput<States, Input["Type"]> },
     ..._validation: ValidateDefinedStates<NoInfer<States>>
-  ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>
+  ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>
   <
     const States extends Machine.StateSchemas,
     const InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
@@ -7323,10 +7799,13 @@ interface Make {
     InitialE = never,
     InitialR = never,
     const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+    const ParentDeclaration extends Parent.Any | undefined = undefined
   >(
     config:
-      & Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "states">
+      & Omit<
+        MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>,
+        "states"
+      >
       & { readonly states: InvalidDefinedStateTreeInput<States> }
   ): never
 }
@@ -7342,11 +7821,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.
  *
@@ -7370,18 +7855,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 })))
  *     }
  *   }
  * })
@@ -7408,1336 +7888,310 @@ export type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventO
  * statically finite configured event tag.
  *
  * Constructor inputs retain their schema-derived required fields, defaults,
- * and transformations. Construction is deferred until delivery so failures
- * enter the machine's `MachineSchemaDecodeError` channel rather than throwing
- * at the call site.
- *
- * **Example**
- *
- * ```ts
- * export const Event = Machine.events(
- *   Schema.TaggedUnion({
- *     Increment: { by: Schema.Number },
- *     Reset: {}
- *   })
- * )
- * const machine = Machine.make({ events: Event, ... })
- * yield* ref.send(Event.Increment({ by: 1 }))
- * ```
- *
- * @category constructors
- * @since 0.10.0
- */
-export 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>>
-} = internal.events as any
-
-/**
- * Defines an internal event protocol and returns deferred constructors for
- * every statically finite configured event tag.
- *
- * Use these constructors for raised events and other machine-local deliveries.
- * Construction failures are reported through the
- * owning machine's `MachineSchemaDecodeError` channel.
- *
- * **Example**
- *
- * ```ts
- * const Internal = Machine.internalEvents(
- *   Schema.TaggedUnion({
- *     Loaded: { value: Schema.String },
- *     Failed: { message: Schema.String }
- *   })
- * )
- * const machine = Machine.make({ internalEvents: Internal, ... })
- *
- * // Inside a transition callback:
- * enqueue.raise(Internal.Loaded({ value }))
- * ```
- *
- * @category constructors
- * @since 0.10.0
- */
-export const internalEvents: {
-  <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(
-    ...schemas: Schemas & ValidateInternalEventProtocol<readonly [], NoInfer<Schemas>>
-  ): Machine.EventProtocol<"internal", readonly [...Schemas]>
-  <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"internal">>>(
-    ...inputs: Inputs & ValidateEventProtocolBuilder<"internal", Inputs>
-  ): Machine.EventProtocol<"internal", Machine.EventProtocolInputSchemasOf<"internal", Inputs>>
-} = internal.internalEvents as any
-
-/**
- * Defines the ephemeral notifications a machine may publish to external
- * observers. Emitted events are separate from machine input and are never sent
- * implicitly to a parent machine. Observe them through `MachineRef.emissions` or
- * the AtomMachine emission stream adapters.
- *
- * **Example**
- *
- * ```ts
- * const Emitted = Machine.emittedEvents(
- *   Schema.TaggedUnion({
- *     Saved: { id: Schema.String }
- *   })
- * )
- * const machine = Machine.make({ emittedEvents: Emitted, ... })
- * ```
- *
- * @category constructors
- * @since 0.10.0
- */
-export const emittedEvents: {
-  <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(
-    ...schemas: Schemas & ValidateEmittedEventProtocol<NoInfer<Schemas>>
-  ): Machine.EventProtocol<"emitted", readonly [...Schemas]>
-  <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"emitted">>>(
-    ...inputs: Inputs & ValidateEventProtocolBuilder<"emitted", Inputs>
-  ): Machine.EventProtocol<"emitted", Machine.EventProtocolInputSchemasOf<"emitted", Inputs>>
-} = internal.emittedEvents as any
-
-/**
- * Encodes a decoded machine snapshot into a normalized data representation.
- *
- * **When to use**
- *
- * Use when you need to store or transport a statechart snapshot independently
- * of its local machine runtime.
- *
- * **Details**
- *
- * Each active state value and completed output is encoded with the schema
- * declared for its state path. The result contains no process-local runtime
- * state.
- *
- * **Gotchas**
- *
- * The encoded snapshot does not contain the machine definition, machine
- * version, running children, invoked process state, services, or subscriptions.
- * Store machine identity and migration metadata alongside the result when the
- * snapshot crosses deployment versions. Schema encoding does not by itself
- * guarantee JSON-compatible values; schemas used with JSON-backed storage must
- * have JSON-compatible encoded representations.
- *
- * **Example**
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
- * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
- * }).handle({ Idle: {} })
- *
- * const encoded = Effect.gen(function*() {
- *   const initial = yield* Machine.planInitial(machine)
- *   return yield* Machine.encodeSnapshot(machine, initial.state)
- * })
- * ```
- *
- * @see {@link decodeSnapshot} for restoring an encoded snapshot.
- * @category encoding
- * @since 0.4.0
- */
-export const encodeSnapshot: <
-  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
-  >,
-  snapshot: Machine.Snapshot<States>
-) => Effect.Effect<
-  Machine.EncodedSnapshot,
-  MachineSchemaEncodeError,
-  Machine.SnapshotEncodingServices<States>
-> = internal.encodeSnapshot as any
-
-/**
- * Decodes a normalized data representation into a validated machine snapshot.
- *
- * **When to use**
- *
- * Use when you need to resume planning from a snapshot loaded from storage or
- * received over a transport boundary.
- *
- * **Details**
- *
- * Decoding resolves every path against the supplied machine, decodes values
- * with their state and output schemas, validates compound and parallel state
- * relationships, and rebuilds the recursive in-memory snapshot.
- *
- * **Gotchas**
- *
- * Decoding restores logical statechart data only. It does not restart invoked
- * processes, recreate spawned children, or restore a previous `MachineRef`.
- *
- * **Example**
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
- * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: {
- *     target: (to) => to.Idle(),
- *     resolve: ({ target }) => target.from()
- *   }
- * }).handle({ Idle: {} })
- *
- * const roundTrip = Effect.gen(function*() {
- *   const initial = yield* Machine.planInitial(machine)
- *   const encoded = yield* Machine.encodeSnapshot(machine, initial.state)
- *   return yield* Machine.decodeSnapshot(machine, encoded)
- * })
- * ```
- *
- * @see {@link encodeSnapshot} for creating the normalized representation.
- * @category decoding
- * @since 0.4.0
- */
-export const decodeSnapshot: <
-  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
-  >,
-  encoded: unknown
-) => Effect.Effect<
-  Machine.Snapshot<States>,
-  MachineSchemaDecodeError,
-  Machine.SnapshotDecodingServices<States>
-> = internal.decodeSnapshot as any
-
-type EffectInvokeSource<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (
-    context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  ) => Effect.Effect<unknown, unknown, unknown>
-> = {
-  readonly id: InvokeLifecycleId
-  readonly effect: Source
-  readonly stream?: never
-  readonly after?: never
-  readonly logic?: never
-  readonly child?: never
-  readonly address?: never
-  readonly onElement?: never
-  readonly onSnapshot?: never
-}
-
-type EffectDoneHandler<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
-> = Machine.InvokeTransition<
-  States,
-  Events,
-  Emits,
-  StateId,
-  Machine.InvokeDoneContext<
-    States,
-    Events,
-    Emits,
-    StateId,
-    Effect.Success<ReturnType<NoInfer<Source>>>,
-    InputEvents,
-    ParentEvents
-  >
->
-
-type EffectFailureHandler<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
-> = Machine.InvokeTransition<
-  States,
-  Events,
-  Emits,
-  StateId,
-  Machine.InvokeFailureContext<
-    States,
-    Events,
-    Emits,
-    StateId,
-    Effect.Error<ReturnType<NoInfer<Source>>>,
-    InputEvents,
-    ParentEvents
-  >
->
-
-type EffectInvokeResult<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
-> =
-  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  & Machine.InvokeTyped<
-    Effect.Success<ReturnType<Source>>,
-    Effect.Error<ReturnType<Source>>,
-    Effect.Services<ReturnType<Source>>,
-    never
-  >
-
-type StreamInvokeSource<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<any>) => unknown
-> = {
-  readonly id: InvokeLifecycleId
-  readonly stream:
-    & Source
-    & ((context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown)
-  readonly effect?: never
-  readonly after?: never
-  readonly logic?: never
-  readonly child?: never
-  readonly address?: never
-  readonly onSnapshot?: never
-}
-
-type StreamSourceResult<Source extends (...args: ReadonlyArray<any>) => unknown> = ReturnType<Source> extends
-  infer Result extends Stream.Stream<any, any, any> ? Result : never
-
-type StreamElementHandler<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<any>) => unknown
-> = Machine.InvokeTransition<
-  States,
-  Events,
-  Emits,
-  StateId,
-  Machine.InvokeElementContext<
-    States,
-    Events,
-    Emits,
-    StateId,
-    Stream.Success<StreamSourceResult<NoInfer<Source>>>,
-    InputEvents,
-    ParentEvents
-  >
->
-
-type StreamDoneHandler<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>
-> = Machine.InvokeTransition<
-  States,
-  Events,
-  Emits,
-  StateId,
-  Machine.InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
->
-
-type StreamFailureHandler<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<any>) => unknown
-> = Machine.InvokeTransition<
-  States,
-  Events,
-  Emits,
-  StateId,
-  Machine.InvokeFailureContext<
-    States,
-    Events,
-    Emits,
-    StateId,
-    Stream.Error<StreamSourceResult<NoInfer<Source>>>,
-    InputEvents,
-    ParentEvents
-  >
->
-
-type StreamInvokeResult<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<any>) => unknown
-> =
-  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  & Machine.InvokeTyped<
-    void,
-    Stream.Error<StreamSourceResult<Source>>,
-    Stream.Services<StreamSourceResult<Source>>,
-    never
-  >
-
-type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false
-
-type BoundEffectInvokeSource<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (
-    context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  ) => Effect.Effect<unknown, unknown, unknown>
-> = {
-  readonly id: InvokeLifecycleId
-  readonly effect: Source
-  readonly stream?: never
-  readonly after?: never
-  readonly logic?: never
-  readonly child?: never
-  readonly address?: never
-  readonly onElement?: never
-  readonly onSnapshot?: never
-}
-
-type BoundEffectDoneHandler<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
-> = Machine.InvokeTransition<
-  States,
-  Events,
-  Emits,
-  StateId,
-  Machine.InvokeDoneContext<
-    States,
-    Events,
-    Emits,
-    StateId,
-    Effect.Success<ReturnType<NoInfer<Source>>>,
-    InputEvents,
-    ParentEvents
-  >
->
-
-type BoundEffectFailureHandler<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
-> = Machine.InvokeTransition<
-  States,
-  Events,
-  Emits,
-  StateId,
-  Machine.InvokeFailureContext<
-    States,
-    Events,
-    Emits,
-    StateId,
-    Effect.Error<ReturnType<NoInfer<Source>>>,
-    InputEvents,
-    ParentEvents
-  >
->
-
-type BoundEffectInvokeResult<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
-> =
-  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  & Machine.InvokeTyped<
-    Effect.Success<ReturnType<Source>>,
-    Effect.Error<ReturnType<Source>>,
-    Effect.Services<ReturnType<Source>>,
-    never
-  >
-
-/** 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.
+ * and transformations. Construction is deferred until delivery so failures
+ * enter the machine's `MachineSchemaDecodeError` channel rather than throwing
+ * at the call site.
+ *
+ * **Example**
+ *
+ * ```ts
+ * export const Event = Machine.events(
+ *   Schema.TaggedUnion({
+ *     Increment: { by: Schema.Number },
+ *     Reset: {}
+ *   })
+ * )
+ * const machine = Machine.make({ events: Event, ... })
+ * yield* ref.send(Event.Increment({ by: 1 }))
+ * ```
  *
  * @category constructors
- * @since 0.14.0
+ * @since 0.10.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
-  >
-}
+export 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>>
+} = internal.events as any
 
 /**
- * Defines a statically inspectable transition.
+ * Requires the machine to run as an owned child whose parent accepts the
+ * supplied public event protocol.
  *
- * 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`.
+ * Required-parent machines expose a non-optional `parent` target in behavior
+ * contexts and are rejected by root execution APIs.
  *
- * ```ts
- * Machine.transition({
- *   target: (to) => to.full.Ready(),
- *   resolve: ({ target }) => target.from()
- * })
+ * @category constructors
+ * @since 0.17.0
+ */
+export const parent: <const Events extends ReadonlyArray<Machine.TaggedSchema>>(
+  events: Machine.EventProtocol<"public", Events>
+) => Parent<"required", Events> = internal.parent
+
+/**
+ * Declares public events a machine may send to its owner while preserving the
+ * ability to run that machine as a root.
  *
- * 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()
- * })
- * ```
+ * Optional-parent machines expose `parent` as a possibly absent target.
  *
  * @category constructors
- * @since 0.14.0
+ * @since 0.17.0
  */
-export const transition: TransitionConstructor = ((config: unknown) => config) as TransitionConstructor
+export const optionalParent: <const Events extends ReadonlyArray<Machine.TaggedSchema>>(
+  events: Machine.EventProtocol<"public", Events>
+) => Parent<"optional", Events> = internal.optionalParent
 
 /**
- * Sentinel used by direct targetless transition shorthands.
+ * Defines an internal event protocol and returns deferred constructors for
+ * every statically finite configured event tag.
+ *
+ * Use these constructors for raised events and other machine-local deliveries.
+ * Construction failures are reported through the
+ * owning machine's `MachineSchemaDecodeError` channel.
  *
- * This is the concise form of `target: (to) => to.none()`.
+ * **Example**
  *
  * ```ts
- * onElement: {
- *   target: Machine.targetless,
- *   resolve: ({ element }, enqueue) => {
- *     enqueue.raise(new MeasurementReceived({ value: element }))
- *   }
- * }
+ * const Internal = Machine.internalEvents(
+ *   Schema.TaggedUnion({
+ *     Loaded: { value: Schema.String },
+ *     Failed: { message: Schema.String }
+ *   })
+ * )
+ * const machine = Machine.make({ internalEvents: Internal, ... })
  *
- * onDone: { target: Machine.targetless }
+ * // Inside a transition callback:
+ * enqueue.raise(Internal.Loaded({ value }))
  * ```
  *
  * @category constructors
- * @since 0.16.0
+ * @since 0.10.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"]>
-}
+export const internalEvents: {
+  <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(
+    ...schemas: Schemas & ValidateInternalEventProtocol<readonly [], NoInfer<Schemas>>
+  ): Machine.EventProtocol<"internal", readonly [...Schemas]>
+  <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"internal">>>(
+    ...inputs: Inputs & ValidateEventProtocolBuilder<"internal", Inputs>
+  ): Machine.EventProtocol<"internal", Machine.EventProtocolInputSchemasOf<"internal", Inputs>>
+} = internal.internalEvents as any
 
 /**
- * Selects no transition target while keeping enqueue operations explicit.
+ * Defines the ephemeral notifications a machine may publish to external
+ * observers. Emitted events are separate from machine input and are never sent
+ * implicitly to a parent machine. Observe them through `MachineRef.emissions` or
+ * the AtomMachine emission stream adapters.
+ *
+ * **Example**
  *
- * 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.
+ * ```ts
+ * const Emitted = Machine.emittedEvents(
+ *   Schema.TaggedUnion({
+ *     Saved: { id: Schema.String }
+ *   })
+ * )
+ * const machine = Machine.make({ emittedEvents: Emitted, ... })
+ * ```
  *
  * @category constructors
- * @since 0.16.0
+ * @since 0.10.0
  */
-export const targetless: TargetlessSelector = Object.assign(
-  (to: Machine.TargetSelector<any, any>) => to.none(),
-  { "~effect/Machine/TargetlessSelector": true as const }
-)
+export const emittedEvents: {
+  <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(
+    ...schemas: Schemas & ValidateEmittedEventProtocol<NoInfer<Schemas>>
+  ): Machine.EventProtocol<"emitted", readonly [...Schemas]>
+  <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"emitted">>>(
+    ...inputs: Inputs & ValidateEventProtocolBuilder<"emitted", Inputs>
+  ): Machine.EventProtocol<"emitted", Machine.EventProtocolInputSchemasOf<"emitted", Inputs>>
+} = internal.emittedEvents as any
 
 /**
- * Machine-bound invocation constructor that preserves the owning machine's
- * public input and parent protocols in every invocation callback.
+ * Encodes a decoded machine snapshot into a normalized data representation.
  *
- * @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"]>>
-    >
-}
+ * **When to use**
+ *
+ * Use when you need to store or transport a statechart snapshot independently
+ * of its local machine runtime.
+ *
+ * **Details**
+ *
+ * Each active state value and completed output is encoded with the schema
+ * declared for its state path. The result contains no process-local runtime
+ * state.
+ *
+ * **Gotchas**
+ *
+ * The encoded snapshot does not contain the machine definition, machine
+ * version, running children, invoked process state, services, or subscriptions.
+ * Store machine identity and migration metadata alongside the result when the
+ * snapshot crosses deployment versions. Schema encoding does not by itself
+ * guarantee JSON-compatible values; schemas used with JSON-backed storage must
+ * have JSON-compatible encoded representations.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
+ * const States = Machine.states({ Idle })
+ * const machine = Machine.make({
+ *   states: States.states,
+ *   events: Machine.events(),
+ *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
+ * }).handle({ Idle: {} })
+ *
+ * const encoded = Effect.gen(function*() {
+ *   const initial = yield* Machine.planInitial(machine)
+ *   return yield* Machine.encodeSnapshot(machine, initial.state)
+ * })
+ * ```
+ *
+ * @see {@link decodeSnapshot} for restoring an encoded snapshot.
+ * @category encoding
+ * @since 0.4.0
+ */
+export const encodeSnapshot: <
+  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
+  >,
+  snapshot: Machine.Snapshot<States>
+) => Effect.Effect<
+  Machine.EncodedSnapshot,
+  MachineSchemaEncodeError,
+  Machine.SnapshotEncodingServices<States>
+> = internal.encodeSnapshot as any
 
 /**
- * Preserves inference for a state-owned invocation configuration.
- *
- * Use `effect` for one-shot work, `stream` for repeated values, `after` for a
- * cancellable timer, `logic` for reusable process logic, or `child` for a
- * complete child machine. Stream elements are handled by `onElement` before
- * the next element is pulled. `onDone` is required whenever the source can
- * complete, while `onFailure` is required only when the source has a typed
- * failure channel.
- *
- * This constructor is an identity at runtime, but preserves lifecycle callback
- * inference through published declarations. Effect and Stream factories run
- * when their owning state is entered and infer the owner context, value,
- * output, error, and service channels together without a return annotation.
- * Durations may be
- * supplied directly or derived from the owning state's entry context. Logic
- * invocations require both a lifecycle `id` and a typed communication
- * `address`. Child descriptors already own their identity, so `id` and
- * `address` must not be repeated.
- *
- * Inside `handle(...)`, the owning definition contextually supplies its public
- * input and `parentEvents` 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.
+ * Decodes a normalized data representation into a validated machine snapshot.
+ *
+ * **When to use**
+ *
+ * Use when you need to resume planning from a snapshot loaded from storage or
+ * received over a transport boundary.
+ *
+ * **Details**
+ *
+ * Decoding resolves every path against the supplied machine, decodes values
+ * with their state and output schemas, validates compound and parallel state
+ * relationships, and rebuilds the recursive in-memory snapshot.
+ *
+ * **Gotchas**
+ *
+ * Decoding restores logical statechart data only. It does not restart invoked
+ * processes, recreate spawned children, or restore a previous `MachineRef`.
+ *
+ * **Example**
  *
  * ```ts
- * invoke: Machine.invoke({
- *   id: "load",
- *   effect: () =>
- *     Effect.tryPromise({
- *       try: () => fetch("/api/data").then((response) => response.json()),
- *       catch: (cause) => new LoadError({ cause })
- *     }),
- *   onDone: Machine.transition({
- *     target: (to) => to.full.Ready(),
- *     resolve: ({ output, target }) => target.from({ data: output })
- *   }),
- *   onFailure: Machine.transition({
- *     target: (to) => to.full.Failed(),
- *     resolve: ({ error, target }) => target.from({ error })
- *   })
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
+ * const States = Machine.states({ Idle })
+ * const machine = Machine.make({
+ *   states: States.states,
+ *   events: Machine.events(),
+ *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
+ * }).handle({ Idle: {} })
+ *
+ * const roundTrip = Effect.gen(function*() {
+ *   const initial = yield* Machine.planInitial(machine)
+ *   const encoded = yield* Machine.encodeSnapshot(machine, initial.state)
+ *   return yield* Machine.decodeSnapshot(machine, encoded)
  * })
  * ```
  *
- * @category constructors
- * @since 0.9.0
+ * @see {@link encodeSnapshot} for creating the normalized representation.
+ * @category decoding
+ * @since 0.4.0
  */
-export 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>
-      & {
-        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>
-      & {
-        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>
-      & {
-        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>
-      & {
-        readonly onDone?: never
-        readonly onFailure?: never
-      }
-  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Stream.Stream<unknown, unknown, any>,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
-        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      },
-    ..._validation: InvokeChannelIsNever<Stream.Success<ReturnType<Source>>> extends true ? [
-        "onElement must be omitted when the Stream element is never"
-      ]
-      : InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
-          "onFailure must be omitted when the Stream error is never"
-        ]
-      : []
-  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Stream.Stream<never, unknown, any>,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onElement?: never
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
-        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      },
-    ..._validation: InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
-        "onFailure must be omitted when the Stream error is never"
-      ]
-      : []
-  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Stream.Stream<never, never, any>,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onElement?: never
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
-        readonly onFailure?: never
-      }
-  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Stream.Stream<unknown, never, any>,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
-        readonly onFailure?: never
-      }
-  ): StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    ChildState,
-    ChildEvent,
-    ChildError,
-    ChildRequirements,
-    ChildOutput,
-    ChildInitialError,
-    Address extends ChildAddress<never>,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config: Machine.LogicInvokeArgs<
-      States,
-      Events,
-      Emits,
-      StateId,
-      ChildState,
-      ChildEvent,
-      ChildError,
-      ChildRequirements,
-      ChildOutput,
-      ChildInitialError,
-      Address,
-      (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Logic<
-        ChildState,
-        ChildEvent,
-        ChildError,
-        ChildRequirements,
-        ChildOutput,
-        ChildInitialError
-      >,
-      InputEvents,
-      ParentEvents
-    >
-  ):
-    & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    & Machine.InvokeTyped<
-      ChildOutput,
-      ChildError,
-      ChildRequirements,
-      ChildInitialError
-    >
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    ChildState,
-    ChildEvent,
-    ChildError,
-    ChildRequirements,
-    ChildOutput,
-    ChildInitialError,
-    Address extends ChildAddress<never>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & Machine.LogicInvokeArgs<
-        States,
-        Events,
-        Emits,
-        StateId,
-        ChildState,
-        ChildEvent,
-        ChildError,
-        ChildRequirements,
-        ChildOutput,
-        ChildInitialError,
-        Address,
-        Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
-        InputEvents,
-        ParentEvents
-      >
-  ):
-    & Config
-    & Machine.InvokeOwned<States, Events, Emits, StateId>
-    & Machine.InvokeTyped<
-      ChildOutput,
-      ChildError,
-      ChildRequirements,
-      ChildInitialError
-    >
-  <
-    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"]>>
-    >
-} = ((config: unknown) => config) as any
+export const decodeSnapshot: <
+  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
+  >,
+  encoded: unknown
+) => Effect.Effect<
+  Machine.Snapshot<States>,
+  MachineSchemaDecodeError,
+  Machine.SnapshotDecodingServices<States>
+> = internal.decodeSnapshot as any
+
+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>
+  >
+
 /**
  * Plans the initial state for a machine without executing machine commands.
  *
@@ -8767,10 +8221,7 @@ export 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)
@@ -8814,7 +8265,8 @@ export const planInitial: <
       InputEvents,
       ParentEvents
     >
-    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+    & EnsureExecutable<States, UnhandledStates, OutputStates>
+    & Machine.RootCompatible<ParentEvents>,
   ...args: [...Machine.InputArgs<Input>]
 ) => Effect.Effect<
   & {
@@ -8899,7 +8351,8 @@ export const initialDefinition: <M extends Machine.Any>(machine: M) => Machine.I
  * Event handlers retain their handler-key order within each source state and
  * are followed by eventless and completion handlers. This function does not
  * execute 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
@@ -8952,7 +8405,12 @@ export const configuration: <M extends Machine.Any>(
 > = internal.configuration
 
 /**
- * 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
@@ -9022,17 +8480,12 @@ export const enabled: <
  * 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: {}
@@ -9082,7 +8535,8 @@ export const plan: <
       InputEvents,
       ParentEvents
     >
-    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+    & EnsureExecutable<States, UnhandledStates, OutputStates>
+    & Machine.RootCompatible<ParentEvents>,
   state: Machine.Snapshot<States>,
   event: Machine.EventInputOf<InputEvents>
 ) => Effect.Effect<
@@ -9185,7 +8639,7 @@ export const child: <const Id extends string, M extends Machine.Any>(id: Id, mac
  * Creates a typed parent-local address for lower-level child process logic.
  *
  * The default event protocol is `never`; provide an event type before using
- * the address with `spawn`, `invoke`, or `sendTo`.
+ * the address with `spawn`, a state-owned logic invocation, or `sendTo`.
  *
  * @category constructors
  * @since 0.4.0
@@ -9206,7 +8660,8 @@ export const childAddress: <Event = never>(id: string) => ChildAddress<Event> =
  * This Effect requires a managed process runtime. A named child id must be
  * unique for the current parent until that child stops.
  *
- * @see {@link invoke} for children that start and stop with a state.
+ * Use a state's `invoke: (from) => from.logic(...)` declaration for children
+ * that start and stop with that state.
  * @see {@link sendTo} for sending events to named children.
  * @category runtime
  * @since 0.4.0
@@ -9344,7 +8799,8 @@ export const prepare: <
       InputEvents,
       ParentEvents
     >
-    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+    & EnsureExecutable<States, UnhandledStates, OutputStates>
+    & Machine.RootCompatible<ParentEvents>,
   ...args: [...Machine.InputArgs<Input>]
 ) => Effect.Effect<
   Prepared<
@@ -9405,10 +8861,7 @@ export const prepare: <
  * 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*() {
@@ -9455,7 +8908,8 @@ export const start: <
       InputEvents,
       ParentEvents
     >
-    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+    & EnsureExecutable<States, UnhandledStates, OutputStates>
+    & Machine.RootCompatible<ParentEvents>,
   ...args: [...Machine.InputArgs<Input>]
 ) => Effect.Effect<
   MachineRef<
@@ -9518,10 +8972,7 @@ export const start: <
  * 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*() {
@@ -9570,7 +9021,8 @@ export const resume: <
       InputEvents,
       ParentEvents
     >
-    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+    & EnsureExecutable<States, UnhandledStates, OutputStates>
+    & Machine.RootCompatible<ParentEvents>,
   snapshot: Machine.Snapshot<States>
 ) => Effect.Effect<
   MachineRef<