@typeonce/effect-machine 0.17.0 → 0.19.0

package/src/Machine.ts

@@ -278,6 +278,20 @@ export interface Definition<
    * captured by value, so later mutation of the supplied objects cannot alter
    * the resulting machine.
    *
+   * **Example**
+   *
+   * ```ts
+   * const counter = definition.handle({
+   *   Count: {
+   *     on: {
+   *       Increment: (to) =>
+   *         to.full.Count().resolve(({ event, state, target }) =>
+   *           target(new Count({ value: state.value + event.by })))
+   *     }
+   *   }
+   * })
+   * ```
+   *
    * @since 0.4.0
    */
   readonly handle: Machine.Handler<
@@ -523,8 +537,10 @@ export type MachineReferences<
 
 /**
  * Synchronous commands available while a machine transition is being
- * selected. Enqueuing only records statechart and machine operations; it never
- * executes an Effect.
+ * selected.
+ *
+ * Enqueuing records statechart and machine operations for the selected
+ * transition. It never executes an Effect while the transition is evaluated.
  *
  * @category models
  * @since 0.4.0
@@ -634,6 +650,7 @@ 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<
@@ -1877,6 +1894,9 @@ export type RuntimeSnapshot<State, Error = never, Output = never> =
  * one stream may contain unrelated root, child-machine, and `Logic` protocols.
  * The record structure remains a closed discriminated union, while typed
  * application observation continues through `changes` and `emissions`.
+ * Records retain decoded local events and snapshots and are not themselves a
+ * stable JSON export format. Telemetry exporters must project process-local
+ * values into an explicit portable representation.
  *
  * @category models
  * @since 0.13.0
@@ -2192,7 +2212,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
@@ -2608,12 +2628,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.
@@ -2897,8 +2931,11 @@ export declare namespace Machine {
    * @since 0.4.0
    */
   export interface StateNodeAnnotations extends Schema.Annotations.Annotations {
+    /** Human-readable label used by visualization and documentation tooling. */
     readonly title?: string | undefined
+    /** Short explanation of the state node's domain meaning. */
     readonly description?: string | undefined
+    /** Longer documentation text associated with the state node. */
     readonly documentation?: string | undefined
   }
 
@@ -2912,22 +2949,29 @@ export declare namespace Machine {
   export type PseudoStateAnnotations = SchemaLessStateAnnotations
 
   /**
-   * Configuration accepted for an atomic object state node. Omit `schema` when
-   * the state owns no value; a schema-less final may still declare `output`.
+   * Configuration accepted for an atomic object state node.
+   *
+   * Omit `schema` when the state owns no value. A schema-less final may still
+   * declare `output`.
    *
    * @category models
    * @since 0.4.0
    */
   export type AtomicStateNodeConfig =
     | {
+      /** Tagged schema that owns the state's decoded value. */
       readonly schema: TaggedSchema
+      /** Declares an ordinary active state. Omitted values default to `"active"`. */
       readonly type?: "active"
+      /** Atomic active states cannot declare terminal output. */
       readonly output?: never
+      /** Schema-backed states take their annotations from the schema. */
       readonly annotations?: never
     }
     | {
       readonly schema: TaggedSchema
       readonly type: "final"
+      /** Optional schema describing the terminal value produced by this final state. */
       readonly output?: Schema.Top
       readonly annotations?: never
     }
@@ -2935,12 +2979,15 @@ export declare namespace Machine {
       readonly schema?: never
       readonly type?: "active"
       readonly output?: never
+      /** Descriptive metadata for a schema-less state. */
       readonly annotations?: SchemaLessStateAnnotations
     }
     | {
       readonly schema?: never
       readonly type: "final"
+      /** Optional schema describing the terminal value produced by this final state. */
       readonly output?: Schema.Top
+      /** Descriptive metadata for a schema-less state. */
       readonly annotations?: SchemaLessStateAnnotations
     }
 
@@ -2953,10 +3000,15 @@ export declare namespace Machine {
    */
   export type CompoundStateNodeConfig =
     | {
+      /** Tagged schema that owns the compound state's decoded value. */
       readonly schema: TaggedSchema
+      /** Compound states are ordinary active states. */
       readonly type?: "active"
+      /** Direct child selected when the compound state is entered initially. */
       readonly initial: string
+      /** Nested state nodes owned by this compound state. */
       readonly states: StateTree
+      /** Schema-backed states take their annotations from the schema. */
       readonly annotations?: never
     }
     | {
@@ -2964,6 +3016,7 @@ export declare namespace Machine {
       readonly type?: "active"
       readonly initial: string
       readonly states: StateTree
+      /** Descriptive metadata for a schema-less state. */
       readonly annotations?: SchemaLessStateAnnotations
     }
 
@@ -2976,10 +3029,15 @@ export declare namespace Machine {
    */
   export type ParallelStateNodeConfig =
     | {
+      /** Tagged schema that owns the parallel state's decoded value. */
       readonly schema: TaggedSchema
+      /** Selects parallel-region semantics for the node. */
       readonly type: "parallel"
+      /** Optional schema describing the value produced after every region completes. */
       readonly output?: Schema.Top
+      /** Child regions that are entered and remain active simultaneously. */
       readonly states: StateTree
+      /** Schema-backed states take their annotations from the schema. */
       readonly annotations?: never
     }
     | {
@@ -2987,6 +3045,7 @@ export declare namespace Machine {
       readonly type: "parallel"
       readonly output?: Schema.Top
       readonly states: StateTree
+      /** Descriptive metadata for a schema-less state. */
       readonly annotations?: SchemaLessStateAnnotations
     }
 
@@ -3003,9 +3062,16 @@ export declare namespace Machine {
    * @since 0.4.0
    */
   export interface HistoryStateNodeConfig {
+    /** Selects history pseudo-state semantics. */
     readonly type: "history"
-    /** Defaults to shallow history. */
+    /**
+     * Restores only the direct child for shallow history or the complete
+     * descendant configuration for deep history.
+     *
+     * @defaultValue `"shallow"`
+     */
     readonly history?: "shallow" | "deep"
+    /** Descriptive metadata used by visualization and documentation tooling. */
     readonly annotations?: SchemaLessStateAnnotations
   }
 
@@ -3020,7 +3086,9 @@ export declare namespace Machine {
    * @since 0.4.0
    */
   export interface ChoiceStateNodeConfig {
+    /** Selects transient choice pseudo-state semantics. */
     readonly type: "choice"
+    /** Descriptive metadata used by visualization and documentation tooling. */
     readonly annotations?: SchemaLessStateAnnotations
   }
 
@@ -3948,26 +4016,28 @@ export declare namespace Machine {
    */
   export interface EncodedSnapshotState {
     readonly path: string
-    readonly value?: unknown
+    readonly value?: Schema.Json
   }
 
   /**
    * Encoded output for one completed state path in a normalized machine
-   * snapshot. An omitted output represents `undefined`.
+   * snapshot. An omitted output means the final state declares no output
+   * schema; a declared `Schema.Void` or `Schema.Undefined` output encodes as
+   * canonical JSON `null`.
    *
    * @category models
    * @since 0.4.0
    */
   export interface EncodedSnapshotCompletion {
     readonly path: string
-    readonly output?: unknown
+    readonly output?: Schema.Json
   }
 
   /** Encoded values and paths retained by one history pseudo-state. */
   export interface EncodedSnapshotHistoryEntry {
     readonly mode: "shallow" | "deep"
     readonly active: ReadonlyArray<string>
-    readonly values: Readonly<Record<string, unknown>>
+    readonly values: Readonly<Record<string, Schema.Json>>
   }
 
   /**
@@ -3975,9 +4045,10 @@ export declare namespace Machine {
    *
    * **Details**
    *
-   * Active state and completion values use the encoded representations of
-   * their declared schemas. Runtime process state such as children, fibers,
-   * scopes, queues, and subscriptions is not included.
+   * Active state and completion values use the canonical JSON representations
+   * derived from their declared schemas. A successfully encoded snapshot is
+   * safe to pass to JSON-backed persistence and transport. Runtime process state
+   * such as children, fibers, scopes, queues, and subscriptions is not included.
    *
    * @category models
    * @since 0.4.0
@@ -4621,18 +4692,26 @@ export declare namespace Machine {
 
   /**
    * 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.
+   * selections, and `local.with`) are values.
+   *
+   * State and choice destinations remain callable selection methods so their
+   * target-specific resolver APIs retain exact inference.
    */
   export interface TargetSelector<
     States extends StateSchemas,
     Source extends StateNodeIdentifier<States>
   > {
+    /** Handles the trigger without selecting a destination. */
     readonly none: SelectionValue<TargetBuilder<States, Source>["none"], never, "none">
+    /** Selects a destination inside the nearest active compound scope. */
     readonly local: LocalTargetSelector<States, Source>
+    /** Selects a destination elsewhere under the currently active root. */
     readonly branch: BranchTargetSelector<States, Source>
+    /** Selects a complete destination under any top-level state. */
     readonly full: FullTargetSelector<States>
+    /** Restores a shallow or deep history pseudo-state. */
     readonly history: HistorySelectionTree<States, States, "", HistoryTargetBuilder<States>>
   }
 
@@ -4662,11 +4741,15 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Value owned by the state whose handler is running. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
     /** Complete logical configuration captured at the start of this microstep. */
     readonly snapshot: Snapshot<States>
+    /** Event that selected this handler, narrowed by its `_tag`. */
     readonly event: EventByTag<Events, EventTag>
 
     /**
@@ -4692,9 +4775,13 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Value owned by the state entering or exiting. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
+    /** Event or initial-entry marker responsible for the lifecycle action. */
     readonly event: LifecycleEvent<Events>
   }
 
@@ -4712,9 +4799,13 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Value owned by the state that owns this invocation. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
+    /** Event or initial-entry marker responsible for starting the invocation. */
     readonly event: LifecycleEvent<Events>
   }
 
@@ -4735,11 +4826,17 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Parent-local invocation identifier. */
     readonly id: string
+    /** Current value of the state that owns the invocation. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
+    /** Builders for selecting the owning machine's next state. */
     readonly target: TargetBuilder<States, StateId>
+    /** Latest active lifecycle snapshot published by the invoked logic or child. */
     readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, { readonly status: "active" }>
   }
 
@@ -4758,12 +4855,19 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Parent-local invocation identifier. */
     readonly id: string
+    /** Current value of the state that owns the invocation. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
+    /** Complete owning-machine configuration captured for this transition. */
     readonly snapshot: Snapshot<States>
+    /** Builders for selecting the owning machine's next state. */
     readonly target: TargetBuilder<States, StateId>
+    /** Successful output produced by the invocation. */
     readonly output: Output
   }
 
@@ -4777,12 +4881,19 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Parent-local invocation identifier. */
     readonly id: string
+    /** Current value of the state that owns the Stream invocation. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
+    /** Complete owning-machine configuration captured for this transition. */
     readonly snapshot: Snapshot<States>
+    /** Builders for selecting the owning machine's next state. */
     readonly target: TargetBuilder<States, StateId>
+    /** Next element emitted by the invoked Stream. */
     readonly element: Element
   }
 
@@ -4796,12 +4907,19 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Parent-local invocation identifier. */
     readonly id: string
+    /** Current value of the state that owns the invocation. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
+    /** Complete owning-machine configuration captured for this transition. */
     readonly snapshot: Snapshot<States>
+    /** Builders for selecting the owning machine's next state. */
     readonly target: TargetBuilder<States, StateId>
+    /** Typed failure produced by the invocation. */
     readonly error: Error
   }
 
@@ -4819,11 +4937,15 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Current value of the state evaluating the eventless transition. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
     /** Complete logical configuration captured at the start of this microstep. */
     readonly snapshot: Snapshot<States>
+    /** Lifecycle event retained while the eventless transition is evaluated. */
     readonly event: LifecycleEvent<Events>
 
     /**
@@ -4850,12 +4972,17 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Current value of the state whose child configuration completed. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
     /** Complete logical configuration captured at the start of this microstep. */
     readonly snapshot: Snapshot<States>
+    /** Lifecycle event retained while state completion is processed. */
     readonly event: LifecycleEvent<Events>
+    /** Output produced by the completed final child or parallel regions. */
     readonly output: CompletionOutputByIdentifier<States, StateId>
 
     /**
@@ -4877,17 +5004,21 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = MachineReferences<InputEvents, ParentEvents> & {
+    /** Value owned by the choice node's immediate schema-backed parent. */
     readonly containingState: StateByIdentifier<
       States,
       Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>
     >
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: {
       readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, ValuedStateIdentifier<States>>]: StateByIdentifier<
         States,
         Parent
       >
     }
+    /** Lifecycle event that led to the transient choice. */
     readonly event: LifecycleEvent<Events>
+    /** Builders for selecting the concrete destination of this choice. */
     readonly target: TargetBuilder<States, ChoiceId>
   }
 
@@ -4902,9 +5033,13 @@ export declare namespace Machine {
     Events extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>
   > {
+    /** Decoded value owned by the final state. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
+    /** Lifecycle event responsible for entering the final state. */
     readonly event: LifecycleEvent<Events>
   }
 
@@ -4937,10 +5072,15 @@ export declare namespace Machine {
     Events extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>
   > {
+    /** Decoded value owned by the completed parallel state. */
     readonly state: StateByIdentifier<States, StateId>
+    /** Value owned by the nearest schema-backed ancestor, when one exists. */
     readonly containingState: ParentStateValue<States, StateId>
+    /** Schema-backed ancestor values keyed by their complete state paths. */
     readonly ancestors: ParentStateValues<States, StateId>
+    /** Lifecycle event retained while parallel completion is processed. */
     readonly event: LifecycleEvent<Events>
+    /** Completion output from every direct parallel region. */
     readonly outputs: ParallelOutputRegions<States, StateId>
   }
 
@@ -5213,11 +5353,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.
    *
@@ -5228,7 +5376,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.
    *
@@ -5239,9 +5387,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.
    *
@@ -5339,6 +5485,7 @@ export declare namespace Machine {
 
   /** Context capability available only to explicitly declinable resolvers. */
   export interface DeclineCapability {
+    /** Declines this candidate and continues hierarchical transition selection. */
     readonly decline: () => Declined
   }
 
@@ -5368,7 +5515,9 @@ export declare namespace Machine {
   export interface TransitionBranchInput<
     Selection extends TargetSelection<any, any, any> = TargetSelection<any, any, any>
   > {
+    /** Exact topology destination available to the branching resolver. */
     readonly target: Selection
+    /** Optional human-readable branch label used by visualization tooling. */
     readonly title?: string
   }
 
@@ -5448,16 +5597,25 @@ export declare namespace Machine {
     }
   }
 
-  type TransitionReenterOption<Reenter extends boolean> = [Reenter] extends [true] ? { readonly reenter?: boolean }
+  type TransitionReenterOption<Reenter extends boolean> = [Reenter] extends [true] ? {
+      /** Forces the source state to exit and enter even when active paths remain unchanged. */
+      readonly reenter?: boolean
+    }
     : { readonly reenter?: never }
 
   type TransitionRequiredOptions<Reenter extends boolean> =
     & TransitionReenterOption<Reenter>
-    & { readonly declinable?: false }
+    & {
+      /** Keeps the transition required. The resolver cannot return `decline()`. */
+      readonly declinable?: false
+    }
 
   type TransitionDeclinableOptions<Reenter extends boolean> =
     & TransitionReenterOption<Reenter>
-    & { readonly declinable: true }
+    & {
+      /** Adds `decline()` to the resolver context and permits declining this candidate. */
+      readonly declinable: true
+    }
 
   type BuiltTransition<
     States extends StateSchemas,
@@ -5521,7 +5679,23 @@ export declare namespace Machine {
     >
   }
 
-  /** A selected transition target with target-specific resolver operations. */
+  /**
+   * A selected transition target with target-specific resolver operations.
+   *
+   * **Example** (Updating state while reentering)
+   *
+   * ```ts
+   * Reset: (to) =>
+   *   to.full.Ready().resolve(
+   *     ({ target }) => target.from(),
+   *     { reenter: true }
+   *   )
+   * ```
+   *
+   * @inlineType TransitionRequiredOptions
+   * @inlineType TransitionDeclinableOptions
+   * @inlineType TransitionReenterOption
+   */
   export type TransitionTarget<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
@@ -5545,6 +5719,10 @@ export declare namespace Machine {
       >
       : {})
     & {
+      /**
+       * Evaluates state construction and queued commands only after this
+       * transition has been selected.
+       */
       readonly resolve:
         & TransitionResolveRequired<States, Events, Emits, StateId, Context, Reenter, Selection>
         & ("declinable" extends Acceptance ? TransitionResolveDeclinable<
@@ -5559,6 +5737,7 @@ export declare namespace Machine {
           : {})
     }
     & ([Reenter] extends [true] ? SelectionSupportsDefaultConstruction<Selection> extends true ? {
+          /** Reenters the source using the selected target's default construction. */
           readonly reenter: () => BuiltTransition<
             States,
             Events,
@@ -5583,9 +5762,12 @@ export declare namespace Machine {
     & Selection
     & (SelectionSupportsDefaultConstruction<Selection> extends true ? InitialBuilderEvidence<Selection> : {})
     & {
+      /** Lazily constructs the selected initial state from decoded machine input. */
       readonly resolve: (
         resolve: (context: {
+          /** Decoded value supplied when the machine is started. */
           readonly input: Input
+          /** Builder specialized to the selected initial destination. */
           readonly target: SelectionBuilder<Selection>
         }) => SelectedTargetResult<Selection>
       ) => InitialBuilderEvidence<Selection>
@@ -5739,9 +5921,11 @@ export declare namespace Machine {
       TargetSelector<States, StateId>
     >
     & {
+      /** Declares a closed set of named destinations for one resolver. */
       readonly branches: <const Branches extends Readonly<Record<string, TransitionBranchInput>>>(
         branches: Branches & ValidateTransitionBranchRecord<NoInfer<Branches>>
       ) => {
+        /** Resolves exactly one declared branch after this transition is selected. */
         readonly resolve:
           & TransitionBranchesResolveRequired<States, Events, Emits, StateId, Context, Reenter, Branches>
           & ("declinable" extends Acceptance ? TransitionBranchesResolveDeclinable<
@@ -5796,8 +5980,16 @@ export declare namespace Machine {
     >
   }
 
-  /** Type evidence retained by {@link invoke} without affecting runtime data. */
-  export interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never, ParentEvent = never> {
+  /** 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>
@@ -5805,10 +5997,11 @@ export declare namespace Machine {
       readonly initialError: Types.Covariant<InitialError>
       readonly emits: Types.Covariant<Emits>
       readonly parentEvents: Types.Covariant<ParentEvent>
+      readonly outcomes: Types.Covariant<Outcomes>
     }
   }
 
-  export type InvokeConfig<
+  type StoredInvokeConfig<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -5899,8 +6092,7 @@ export declare namespace Machine {
       }
     )
 
-  /** State-bound inline invocation configuration. */
-  export type InvokeDefinition<
+  type StoredInvokeDefinition<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
@@ -5908,475 +6100,584 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
-    | InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>
+    | StoredInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    | ReadonlyArray<StoredInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>
 
-  type TypedInvokeDefinition =
-    | InvokeTyped<any, any, any, any, any, any>
-    | ReadonlyArray<InvokeTyped<any, any, any, any, any, any>>
-
-  type InvokeHandlerRequirement<Value, Handler> = IsAny<Value> extends true ? { readonly handler: Handler }
-    : [Value] extends [never] ? { readonly handler?: never }
-    : { readonly handler: Handler }
-
-  export type InvokeDoneRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
-    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onDone: Required }
-    : { readonly onDone?: never }
+  type LogicInitialEffectOf<Value> = Value extends { readonly initial: infer Initial } ?
+    Initial extends (...args: ReadonlyArray<any>) => infer Result ? Result : never
     : never
 
-  export type InvokeFailureRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
-    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onFailure: Required }
-    : { readonly onFailure?: never }
+  type LogicRunEffectOf<Value> = Value extends { readonly run: infer Run } ?
+    Run extends (...args: ReadonlyArray<any>) => infer Result ? Result : never
     : never
 
-  export type InvokeElementRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
-    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onElement: Required }
-    : { readonly onElement?: never }
+  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 RequiredInvokeChannel<Value, Channel extends string> = IsAny<Value> extends true ? Channel
+    : [Value] extends [never] ? never
+    : Channel
 
-  export type TimerInvokeArgs<
+  type InvokeBuilderResult<
     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>
-    >
-  }
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
+    Output,
+    Error,
+    Requirements,
+    InitialError,
+    ChildEmits,
+    ChildParentEvent,
+    Outcomes
+  > =
+    & InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    & InvokeTyped<Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Outcomes>
+    & { readonly [InvokeBuilderTypeId]: true }
 
-  export type LogicInvokeArgs<
+  /** Lifecycle handlers exposed according to the selected invocation source. */
+  type InvokeBuilder<
     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 []
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
+    Output,
+    Error,
+    Requirements,
+    InitialError,
+    ChildEmits,
+    ChildParentEvent,
+    Element,
+    Pending extends string,
+    SnapshotHandler,
+    Outcomes = never
   > =
-    & {
-      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<
+    & ([Pending] extends [never] ? InvokeBuilderResult<
         States,
         Events,
         Emits,
         StateId,
-        InvokeSnapshotContext<
+        InputEvents,
+        ParentEvents,
+        Output,
+        Error,
+        Requirements,
+        InitialError,
+        ChildEmits,
+        ChildParentEvent,
+        Outcomes
+      >
+      : {})
+    & ("done" extends Pending ? {
+        /** Handles successful completion and exposes the invocation output. */
+        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,
-          NoInfer<ChildState>,
-          NoInfer<ChildError>,
-          NoInfer<ChildOutput>,
           InputEvents,
-          ParentEvents
+          ParentEvents,
+          Output,
+          Error,
+          Requirements,
+          InitialError,
+          ChildEmits,
+          ChildParentEvent,
+          Element,
+          Exclude<Pending, "done">,
+          SnapshotHandler,
+          Outcomes | Handler
         >
-      >
-    }
-    & InvokeDoneRequirement<
-      NoInfer<ChildOutput>,
-      InvokeTransition<
-        States,
-        Events,
-        Emits,
-        StateId,
-        InvokeDoneContext<States, Events, Emits, StateId, NoInfer<ChildOutput>, InputEvents, ParentEvents>
-      >
-    >
-    & InvokeFailureRequirement<
-      NoInfer<ChildError>,
-      InvokeTransition<
-        States,
-        Events,
-        Emits,
-        StateId,
-        InvokeFailureContext<States, Events, Emits, StateId, NoInfer<ChildError>, InputEvents, ParentEvents>
-      >
-    >
-
-  export type ChildInvokeArgs<
-    States extends StateSchemas,
-    Events extends ReadonlyArray<TaggedSchema>,
-    Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>,
-    ChildDefinition extends Machine.Any,
-    Child extends ChildMachine<string, ChildDefinition>,
-    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
-    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > =
-    & {
-      readonly child:
-        & Child
-        & (ChildDefinition extends EnsureExecutable<
-          Machine.States<ChildDefinition>,
-          Machine.UnhandledStates<ChildDefinition>,
-          Machine.OutputStates<ChildDefinition>
-        > ? unknown :
-          never)
-      readonly id?: never
-      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<
+      }
+      : {})
+    & ("failure" extends Pending ? {
+        /** Handles typed failure and exposes the invocation error. */
+        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,
-          Snapshot<Machine.States<ChildDefinition>>,
-          Error<ChildDefinition>,
-          Output<ChildDefinition>,
           InputEvents,
-          ParentEvents
+          ParentEvents,
+          Output,
+          Error,
+          Requirements,
+          InitialError,
+          ChildEmits,
+          ChildParentEvent,
+          Element,
+          Exclude<Pending, "failure">,
+          SnapshotHandler,
+          Outcomes | Handler
         >
-      >
-    }
-    & (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<
+      }
+      : {})
+    & ("element" extends Pending ? {
+        /** Handles each backpressured element emitted by an invoked Stream. */
+        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,
-          Output<ChildDefinition>,
           InputEvents,
-          ParentEvents
+          ParentEvents,
+          Output,
+          Error,
+          Requirements,
+          InitialError,
+          ChildEmits,
+          ChildParentEvent,
+          Element,
+          Exclude<Pending, "element">,
+          SnapshotHandler,
+          Outcomes | Handler
         >
-      >
-    >
-    & InvokeFailureRequirement<
-      Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
-      InvokeTransition<
+      }
+      : {})
+    & ([SnapshotHandler] extends [never] ? {} : {
+      /** Handles each active snapshot published by invoked logic or a child machine. */
+      readonly onSnapshot: <const Handler extends SnapshotHandler>(handler: Handler & SnapshotHandler) => InvokeBuilder<
         States,
         Events,
         Emits,
         StateId,
-        InvokeFailureContext<
-          States,
-          Events,
-          Emits,
-          StateId,
-          Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
-          InputEvents,
-          ParentEvents
-        >
+        InputEvents,
+        ParentEvents,
+        Output,
+        Error,
+        Requirements,
+        InitialError,
+        ChildEmits,
+        ChildParentEvent,
+        Element,
+        Pending,
+        never,
+        Outcomes | Handler
       >
-    >
+    })
 
-  type LogicInitialEffectOf<Value> = Value extends { readonly initial: infer Initial } ?
-    Initial extends (...args: ReadonlyArray<any>) => infer Result ? Result : never
-    : never
+  type EffectInvokeBuilder<
+    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>) => 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 LogicRunEffectOf<Value> = Value extends { readonly run: infer Run } ?
-    Run extends (...args: ReadonlyArray<any>) => infer Result ? Result : never
-    : 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
+  >
 
-  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 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 ContextualInvokeConfig<
+  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>,
-    Raw
-  > = Raw extends InvokeTyped<any, any, any, any, any> ? unknown
-    : [Extract<keyof Raw, "onDone" | "onFailure" | "onElement" | "onSnapshot">] extends [never] ? unknown
-    : Raw extends { readonly effect: infer Source } ?
-      InvokeFactoryResult<Source> extends infer Fx extends Effect.Effect<any, any, any> ?
-          & InvokeDoneRequirement<
-            Effect.Success<Fx>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>, InputEvents, ParentEvents>
-            >
-          >
-          & InvokeFailureRequirement<
-            Effect.Error<Fx>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>
-            >
-          >
-          & { readonly onSnapshot?: never }
-      : never
-    : Raw extends { readonly stream: infer Source } ?
-      InvokeFactoryResult<Source> extends infer SourceStream extends Stream.Stream<any, any, any> ?
-          & InvokeElementRequirement<
-            Stream.Success<SourceStream>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeElementContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                Stream.Success<SourceStream>,
-                InputEvents,
-                ParentEvents
-              >
-            >
-          >
-          & {
-            readonly onDone: InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
-            >
-          }
-          & InvokeFailureRequirement<
-            Stream.Error<SourceStream>,
-            InvokeTransition<
-              States,
-              Events,
-              Emits,
-              StateId,
-              InvokeFailureContext<
-                States,
-                Events,
-                Emits,
-                StateId,
-                Stream.Error<SourceStream>,
-                InputEvents,
-                ParentEvents
-              >
-            >
-          >
-          & { readonly onSnapshot?: never }
-      : never
-    : Raw extends { readonly after: unknown } ? {
-        readonly onDone: InvokeTransition<
-          States,
-          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
+    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
+      >
+    >
+  >
 
-  type ContextualInvokeDefinition<
+  /**
+   * 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.
+   *
+   * **Example** (Invoking an Effect)
+   *
+   * ```ts
+   * invoke: (from) =>
+   *   from.effect("load-user", () => loadUser).onDone((to) =>
+   *     to.full.Ready().resolve(({ output, target }) => target.from({ user: output }))
+   *   ).onFailure((to) =>
+   *     to.full.Failed().resolve(({ error, target }) => target.from({ error }))
+   *   )
+   * ```
+   *
+   * @inlineType EffectInvokeBuilder
+   * @inlineType StreamInvokeBuilder
+   * @inlineType LogicInvokeBuilder
+   * @inlineType ChildInvokeBuilder
+   * @inlineType InvokeBuilder
+   *
+   * @category models
+   * @since 0.18.0
+   */
+  export interface InvokeSelector<
     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<
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > {
+    /**
+     * Starts a fresh Effect each time the owning state is entered.
+     *
+     * @param id Parent-local lifecycle identifier.
+     * @param source Lazy Effect factory evaluated on every entry.
+     */
+    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.
+     *
+     * @param id Parent-local lifecycle identifier.
+     * @param source Lazy Stream factory evaluated on every entry.
+     */
+    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.
+     *
+     * @param id Parent-local lifecycle identifier.
+     * @param duration Duration input or context-dependent duration factory.
+     */
+    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.
+     *
+     * @param id Parent-local lifecycle identifier.
+     * @param options Address and reusable logic value or factory.
+     */
+    readonly logic: {
+      <
+        const Source extends (
+          context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        ) => unknown,
+        Address extends ChildAddress<never>
+      >(
+        id: InvokeLifecycleId,
+        options: {
+          /** Typed parent-local address used to send events to this logic. */
+          readonly address:
+            & Address
+            & ChildAddress.Compatibility<Address, LogicEventOf<ReturnType<NoInfer<Source>>>>
+          /** Context-dependent factory that returns reusable process logic. */
+          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,
-        Raw[Index]
+        ReturnType<Source>
+      >
+      <const Source, Address extends ChildAddress<never>>(
+        id: InvokeLifecycleId,
+        options: {
+          /** Typed parent-local address used to send events to this logic. */
+          readonly address: Address & ChildAddress.Compatibility<Address, LogicEventOf<NoInfer<Source>>>
+          /** Reusable process logic started when the owning state enters. */
+          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
       >
     }
-    : ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw>
 
+    /**
+     * Starts a complete child statechart represented by a reusable descriptor.
+     *
+     * @param child Reusable descriptor created with `Machine.child`.
+     * @param options Input construction for a child with a non-void input schema.
+     */
+    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: {
+          /** Child input value or factory evaluated from the owning state context. */
+          readonly input: InvokeSource<
+            Input<Child["machine"]>,
+            InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+          >
+        }]
+    ) => ChildInvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, Child>
+  }
+
+  /**
+   * 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.18.0
+   */
+  export type InvokeBuilderInput<
+    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 []
+  > = (
+    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
+      }
+    >
+
+  /** Output construction available to final and output-producing parallel states. */
   type OutputHandlerConfig<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     Context
   > = NodeByIdentifier<States, StateId> extends { readonly output: Schema.Top } ? {
+      /** Constructs the decoded output declared by the state's `output` schema. */
       readonly output: (context: Context) => OutputByIdentifier<States, StateId>
     }
     : {
@@ -6400,6 +6701,22 @@ export declare namespace Machine {
   /**
    * Configuration accepted for a non-final state.
    *
+   * **Example** (State actions, events, and invocation)
+   *
+   * ```ts
+   * machine.handle({
+   *   Loading: {
+   *     entry: (_, enqueue) => enqueue.emit({ _tag: "Started" }),
+   *     invoke: (from) =>
+   *       from.effect("load", () => load).onDone((to) => to.full.Ready()),
+   *     on: { Cancel: (to) => to.full.Idle() }
+   *   }
+   * })
+   * ```
+   *
+   * @inlineType ActiveOutputHandlerConfig
+   * @inlineType OutputHandlerConfig
+   *
    * @category models
    * @since 0.4.0
    */
@@ -6413,17 +6730,19 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = {
+    /** Runs synchronously when the state is entered and may enqueue commands. */
     readonly entry?: (
       context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
       enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
     ) => StateActionResult<any, any>
+    /** Runs synchronously before the state is exited and may enqueue commands. */
     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
+    /** Starts state-owned Effect, Stream, timer, logic, or child lifecycles. */
+    readonly invoke?: InvokeBuilderInput<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    /** Eventless transition evaluated after the state becomes stable. */
     readonly always?: TransitionConfig<
       States,
       Events,
@@ -6433,6 +6752,7 @@ export declare namespace Machine {
       false,
       TransitionAcceptance
     >
+    /** Transition evaluated after this compound or parallel state completes. */
     readonly onDone?: TransitionConfig<
       States,
       Events,
@@ -6442,6 +6762,7 @@ export declare namespace Machine {
       false,
       TransitionAcceptance
     >
+    /** Event handlers keyed by the `_tag` of the machine's public or internal events. */
     readonly on?: {
       readonly [EventTag in TagOf<Events[number]>]?: TransitionConfig<
         States,
@@ -6453,6 +6774,7 @@ export declare namespace Machine {
         TransitionAcceptance
       >
     }
+    /** Supplies missing direct initial-child values required by implicit entry and shallow history. */
     readonly initialize?: StateInitializeHandler<States, Events, Emits, StateId, InputEvents, ParentEvents>
   } & ActiveOutputHandlerConfig<States, Events, StateId>
 
@@ -6577,8 +6899,11 @@ export declare namespace Machine {
     Emits extends ReadonlyArray<TaggedSchema>,
     ParentId extends StateIdentifier<States>
   > {
+    /** Lifecycle event that attempted to restore this history node. */
     readonly event: LifecycleEvent<Events>
+    /** Complete target builder rooted at the history owner. */
     readonly target: HistoryDefaultTargetBuilder<States, ParentId>
+    /** State path whose child configuration is restored by this history node. */
     readonly owner: ParentId
   }
 
@@ -6601,7 +6926,26 @@ export declare namespace Machine {
     | CompleteSnapshotContaining<States, ParentId>
     | StateConstruction<CompleteSnapshotContaining<States, ParentId>>
 
-  /** Default implementations keyed by direct history child. */
+  /**
+   * Fallback implementation for one direct history pseudo-state.
+   *
+   * @inline
+   */
+  interface HistoryDefaultEntry<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    ParentId extends StateIdentifier<States>
+  > {
+    /** Builds the complete fallback configuration used before history is first captured. */
+    readonly default: HistoryDefaultHandler<States, Events, Emits, ParentId>
+  }
+
+  /**
+   * Default implementations keyed by direct history child.
+   *
+   * @inlineType HistoryDefaultEntry
+   */
   export type HistoryDefaultConfig<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
@@ -6609,9 +6953,7 @@ export declare namespace Machine {
     ParentId extends StateIdentifier<States>,
     Children extends StateSchemas
   > = {
-    readonly [Key in HistoryStateKey<Children>]?: {
-      readonly default: HistoryDefaultHandler<States, Events, Emits, ParentId>
-    }
+    readonly [Key in HistoryStateKey<Children>]?: HistoryDefaultEntry<States, Events, Emits, ParentId>
   }
 
   /** Required implementation for a choice pseudo-state. */
@@ -6623,6 +6965,7 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > {
+    /** Required transition that resolves this transient choice to a concrete destination. */
     readonly choice: TransitionConfig<
       States,
       Events,
@@ -6643,6 +6986,8 @@ export declare namespace Machine {
   /**
    * Configuration accepted for a final state.
    *
+   * @inlineType OutputHandlerConfig
+   *
    * @category models
    * @since 0.4.0
    */
@@ -6654,6 +6999,7 @@ export declare namespace Machine {
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = {
+    /** Runs synchronously when the final state is entered and may enqueue commands. */
     readonly entry?: (
       context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
       enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
@@ -6727,55 +7073,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}` ? {
@@ -6785,6 +7082,7 @@ export declare namespace Machine {
     }
     : { readonly [Key in Path]?: Validation }
 
+  /** Nested handler-tree structure shared by active and final state configs. */
   type HandlerNode<
     AllStates extends StateSchemas,
     Node,
@@ -6806,6 +7104,7 @@ export declare namespace Machine {
             readonly history?: never
           }
         : {
+          /** Child-state handlers nested according to the declared state topology. */
           readonly states?: HandlerTree<
             AllStates,
             Children,
@@ -6817,6 +7116,7 @@ export declare namespace Machine {
             ParentEvents,
             Extract<StateId, StateIdentifier<AllStates>>
           >
+          /** First-use defaults keyed by direct history pseudo-state. */
           readonly history?: HistoryDefaultConfig<
             AllStates,
             Events,
@@ -7375,7 +7675,6 @@ export declare namespace Machine {
     >(
       config:
         & Config
-        & HandlerInvokeContexts<States, Events, InputEvents, Emits, ParentEvents, NoInfer<Config>>
         & HandlerTreeValidation<
           States,
           Events,
@@ -7474,7 +7773,7 @@ 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,
@@ -7522,15 +7821,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`.
@@ -7667,20 +8000,28 @@ type MakeConfig<
   InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
   ParentDeclaration extends Parent.Any | undefined
 > = {
+  /** Stable definition identifier used by inspection and visualization. */
   readonly id?: string
+  /** State topology and value schemas, normally supplied by `Machine.states`. */
   readonly states: States & DefineStateTreeInput<NoInfer<States>>
+  /** Public events accepted by independently running machine references. */
   readonly events:
     & Machine.EventProtocol<"public", InputEvents>
     & ValidateInputEventProtocol<NoInfer<InputEvents>>
+  /** Machine-local events used by raised events and other internal deliveries. */
   readonly internalEvents?:
     & Machine.EventProtocol<"internal", InternalEvents>
     & ValidateInternalEventProtocol<
       NoInfer<InputEvents>,
       NoInfer<InternalEvents>
     >
+  /** Ephemeral notifications that handlers may publish to observers. */
   readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>
+  /** Required or optional owning-machine protocol for this definition. */
   readonly parent?: ParentDeclaration
+  /** Schema used to decode input before initial-state construction. */
   readonly input?: Input
+  /** Target-first declaration that constructs the initial active configuration. */
   readonly initial: unknown
 }
 
@@ -7706,7 +8047,9 @@ type MakeResult<
   Machine.ParentEventsOf<ParentDeclaration>
 >
 
+/** @inline */
 interface Make {
+  /** @param config Complete schema-first machine definition. */
   <
     const States extends Machine.StateSchemas,
     const InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
@@ -7725,6 +8068,7 @@ interface Make {
       & { readonly initial: Machine.InitialBuilderInput<States, Input["Type"]> },
     ..._validation: ValidateDefinedStates<NoInfer<States>>
   ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>
+  /** @param config Invalid state tree retained only to report its validation error at the call site. */
   <
     const States extends Machine.StateSchemas,
     const InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
@@ -7802,6 +8146,7 @@ interface Make {
  * ```
  *
  * @see {@link states} for typed state-tree helpers.
+ * @inlineType MakeConfig
  * @category constructors
  * @since 0.4.0
  */
@@ -7952,18 +8297,21 @@ export const emittedEvents: {
  *
  * **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.
+ * Each active state value and completed output is encoded with the canonical
+ * JSON codec derived from the schema declared for its state path. Success
+ * guarantees that every state, output, and history value is `Schema.Json`.
+ * Non-JSON values, including cyclic process-local capabilities, fail with
+ * {@link MachineSchemaEncodeError} at their declared boundary.
  *
  * **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.
+ * snapshot crosses deployment versions. Opaque declarations without a JSON
+ * codec can encode only when their current value is already JSON-compatible.
+ * Define an explicit JSON codec or keep process-local capabilities outside the
+ * logical snapshot.
  *
  * **Example**
  *
@@ -8111,199 +8459,6 @@ export const decodeSnapshot: <
   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.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  & Machine.InvokeTyped<
-    Effect.Success<ReturnType<Source>>,
-    Effect.Error<ReturnType<Source>>,
-    Effect.Services<ReturnType<Source>>,
-    never
-  >
-
-type StreamInvokeSource<
-  States extends Machine.StateSchemas,
-  Events extends ReadonlyArray<Machine.TaggedSchema>,
-  Emits extends ReadonlyArray<Machine.TaggedSchema>,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
-  StateId extends Machine.StateIdentifier<States>,
-  Source extends (...args: ReadonlyArray<any>) => unknown
-> = {
-  readonly id: InvokeLifecycleId
-  readonly stream:
-    & Source
-    & ((context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown)
-  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.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  & Machine.InvokeTyped<
-    void,
-    Stream.Error<StreamSourceResult<Source>>,
-    Stream.Services<StreamSourceResult<Source>>,
-    never
-  >
-
-type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false
-
 type TransitionBranchRecordError<Message extends string, Key extends PropertyKey = never> = {
   readonly "~effect/Machine/TransitionBranchRecordError": Message
   readonly key: Key
@@ -8319,368 +8474,6 @@ type ValidateTransitionBranchRecord<Branches> = [keyof Branches] extends [never]
     InvalidStaticTransitionBranchKey<Branches>
   >
 
-/**
- * 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 declared parent protocols. Invocation sources and lifecycle handlers
- * can therefore send through `self` and `parent` without naming the definition.
- * The standard `Machine.invoke(...)` constructor preserves these contexts
- * directly; no intermediate definition method is required.
- *
- * ```ts
- * invoke: Machine.invoke({
- *   id: "load",
- *   effect: () =>
- *     Effect.tryPromise({
- *       try: () => fetch("/api/data").then((response) => response.json()),
- *       catch: (cause) => new LoadError({ cause })
- *     }),
- *   onDone: (to) =>
- *     to.full.Ready().resolve(({ output, target }) =>
- *       target.from({ data: output })),
- *   onFailure: (to) =>
- *     to.full.Failed().resolve(({ error, target }) =>
- *       target.from({ error }))
- * })
- * ```
- *
- * @category constructors
- * @since 0.9.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 Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onDone: EffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-        readonly onFailure: EffectFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      },
-    ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
-        "onDone must be omitted when the Effect output is never"
-      ]
-      : InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
-          "onFailure must be omitted when the Effect error is never"
-        ]
-      : []
-  ): NoInfer<Config> & EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Effect.Effect<unknown, never, unknown>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onDone: EffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-        readonly onFailure?: never
-      },
-    ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
-        "onDone must be omitted when the Effect output is never"
-      ]
-      : []
-  ): NoInfer<Config> & EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Effect.Effect<never, unknown, unknown>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onDone?: never
-        readonly onFailure: EffectFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      },
-    ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
-        "onFailure must be omitted when the Effect error is never"
-      ]
-      : []
-  ): NoInfer<Config> & EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Effect.Effect<never, never, unknown>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onDone?: never
-        readonly onFailure?: never
-      }
-  ): NoInfer<Config> & EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Stream.Stream<unknown, unknown, any>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
-        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      },
-    ..._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"
-        ]
-      : []
-  ): NoInfer<Config> & StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Stream.Stream<never, unknown, any>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onElement?: never
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
-        readonly onFailure: StreamFailureHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      },
-    ..._validation: InvokeChannelIsNever<Stream.Error<ReturnType<Source>>> extends true ? [
-        "onFailure must be omitted when the Stream error is never"
-      ]
-      : []
-  ): NoInfer<Config> & StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Stream.Stream<never, never, any>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onElement?: never
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
-        readonly onFailure?: never
-      }
-  ): NoInfer<Config> & StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => Stream.Stream<unknown, never, any>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & StreamInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-      & {
-        readonly onElement: StreamElementHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-        readonly onDone: StreamDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId>
-        readonly onFailure?: never
-      }
-  ): NoInfer<Config> & StreamInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>
-  ):
-    & NoInfer<Config>
-    & Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    & Machine.InvokeTyped<void, never, never, never>
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    ) => unknown,
-    Address extends ChildAddress<never>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & { readonly logic: Source }
-      & Machine.LogicInvokeArgs<
-        States,
-        Events,
-        Emits,
-        StateId,
-        Machine.LogicStateOf<ReturnType<Source>>,
-        Machine.LogicEventOf<ReturnType<Source>>,
-        Machine.LogicErrorOf<ReturnType<Source>>,
-        Machine.LogicServicesOf<ReturnType<Source>>,
-        Machine.LogicOutputOf<ReturnType<Source>>,
-        Machine.LogicInitialErrorOf<ReturnType<Source>>,
-        Address,
-        Source,
-        InputEvents,
-        ParentEvents
-      >,
-    ..._validation: ReturnType<Source> extends { readonly initial: unknown; readonly run: unknown } ? [] : [
-      "logic factory must return Machine.Logic"
-    ]
-  ):
-    & NoInfer<Config>
-    & Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    & Machine.InvokeTyped<
-      Machine.LogicOutputOf<ReturnType<Source>>,
-      Machine.LogicErrorOf<ReturnType<Source>>,
-      Machine.LogicServicesOf<ReturnType<Source>>,
-      Machine.LogicInitialErrorOf<ReturnType<Source>>
-    >
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Source,
-    Address extends ChildAddress<never>,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & { readonly logic: Source }
-      & Machine.LogicInvokeArgs<
-        States,
-        Events,
-        Emits,
-        StateId,
-        Machine.LogicStateOf<Source>,
-        Machine.LogicEventOf<Source>,
-        Machine.LogicErrorOf<Source>,
-        Machine.LogicServicesOf<Source>,
-        Machine.LogicOutputOf<Source>,
-        Machine.LogicInitialErrorOf<Source>,
-        Address,
-        Source,
-        InputEvents,
-        ParentEvents
-      >,
-    ..._validation: Source extends { readonly initial: unknown; readonly run: unknown } ? [] : [
-      "logic must implement Machine.Logic"
-    ]
-  ):
-    & NoInfer<Config>
-    & Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    & Machine.InvokeTyped<
-      Machine.LogicOutputOf<Source>,
-      Machine.LogicErrorOf<Source>,
-      Machine.LogicServicesOf<Source>,
-      Machine.LogicInitialErrorOf<Source>
-    >
-  <
-    const States extends Machine.StateSchemas,
-    const Events extends ReadonlyArray<Machine.TaggedSchema>,
-    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
-    StateId extends Machine.StateIdentifier<States>,
-    const Child extends ChildMachine.Any,
-    const Config extends object,
-    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
-    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
-  >(
-    config:
-      & Config
-      & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, InputEvents, ParentEvents>
-  ):
-    & Config
-    & Machine.InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents>
-    & Machine.InvokeTyped<
-      Machine.Output<Child["machine"]>,
-      Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>,
-      Machine.Services<Child["machine"]>,
-      Machine.InitialError<Child["machine"]>,
-      Machine.Emit<Child["machine"]>,
-      Machine.EventOf<Machine.ParentEvents<Child["machine"]>>
-    >
-} = ((config: unknown) => config) as any
 /**
  * Plans the initial state for a machine without executing machine commands.
  *
@@ -9128,7 +8921,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
@@ -9149,7 +8942,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