@typeonce/effect-machine 0.17.0 → 0.19.0

package/dist/Machine.d.ts

@@ -183,6 +183,20 @@ export interface Definition<States extends Machine.StateSchemas, Events extends
      * 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<States, Events, Emits, Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, FinalStates, Output, never, InputEvents, ParentEvents>;
@@ -384,8 +398,10 @@ export type MachineReferences<InputEvents extends ReadonlyArray<Machine.TaggedSc
 } : {});
 /**
  * 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
@@ -474,6 +490,7 @@ type IncompatibleRuntime<Requirements, Events, Emits> = Requirements extends Run
 declare const InvokeTypeId: typeof internal.InvokeTypeId;
 declare const TransitionTypeId: typeof internal.TransitionTypeId;
 declare const TransitionBuilderTypeId: unique symbol;
+declare const InvokeBuilderTypeId: unique symbol;
 declare const InitialBuilderTypeId: unique symbol;
 type StateDefinitionError<Message extends string, Path extends PropertyKey = never, Details extends PropertyKey = never> = {
     readonly "~effect/Machine/DefinitionError": Message;
@@ -924,6 +941,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
@@ -1198,7 +1218,7 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
     readonly childChanges: <Child extends ChildMachine.Any>(child: Child) => Stream.Stream<Option.Option<ChildMachine.Ref<Child>>>;
 }
 /**
- * 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
@@ -1504,12 +1524,22 @@ export declare namespace Machine {
      */
     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
+     */
+    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
      */
-    type Input<M extends Any> = M[typeof MachineTypeId]["input"];
+    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.
      *
@@ -1724,8 +1754,11 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     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;
     }
     /** Descriptive annotations accepted by schema-less active and pseudo-states. */
@@ -1733,31 +1766,41 @@ export declare namespace Machine {
     /** @deprecated Use {@link SchemaLessStateAnnotations}. */
     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
      */
     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;
     } | {
         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;
     };
     /**
@@ -1768,16 +1811,22 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     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;
     } | {
         readonly schema?: never;
         readonly type?: "active";
         readonly initial: string;
         readonly states: StateTree;
+        /** Descriptive metadata for a schema-less state. */
         readonly annotations?: SchemaLessStateAnnotations;
     };
     /**
@@ -1788,16 +1837,22 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     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;
     } | {
         readonly schema?: never;
         readonly type: "parallel";
         readonly output?: Schema.Top;
         readonly states: StateTree;
+        /** Descriptive metadata for a schema-less state. */
         readonly annotations?: SchemaLessStateAnnotations;
     };
     /**
@@ -1813,9 +1868,16 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     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;
     }
     /**
@@ -1829,7 +1891,9 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     interface ChoiceStateNodeConfig {
+        /** Selects transient choice pseudo-state semantics. */
         readonly type: "choice";
+        /** Descriptive metadata used by visualization and documentation tooling. */
         readonly annotations?: SchemaLessStateAnnotations;
     }
     /**
@@ -2456,33 +2520,36 @@ export declare namespace Machine {
      */
     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
      */
     interface EncodedSnapshotCompletion {
         readonly path: string;
-        readonly output?: unknown;
+        readonly output?: Schema.Json;
     }
     /** Encoded values and paths retained by one history pseudo-state. */
     interface EncodedSnapshotHistoryEntry {
         readonly mode: "shallow" | "deep";
         readonly active: ReadonlyArray<string>;
-        readonly values: Readonly<Record<string, unknown>>;
+        readonly values: Readonly<Record<string, Schema.Json>>;
     }
     /**
      * Normalized data representation of a machine snapshot.
      *
      * **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
@@ -2918,15 +2985,23 @@ 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.
      */
     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>>;
     }
     /** Definition-time selector that can choose only a valid top-level initial entry. */
@@ -2944,11 +3019,15 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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>;
         /**
          * Provides typed builders for choosing the next active state from this
@@ -2965,9 +3044,13 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type StateActionContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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>;
     };
     /**
@@ -2977,9 +3060,13 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InvokeContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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>;
     };
     /**
@@ -2989,11 +3076,17 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InvokeSnapshotContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, State, Error, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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";
         }>;
@@ -3005,32 +3098,53 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InvokeDoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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;
     };
     /** Context passed to a Stream invocation's element transition. */
     type InvokeElementContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Element, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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;
     };
     /** Context passed to an invocation typed-failure transition. */
     type InvokeFailureContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Error, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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;
     };
     /**
@@ -3040,11 +3154,15 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type AlwaysContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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>;
         /**
          * Provides typed builders for choosing the next active state from this
@@ -3062,12 +3180,17 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type DoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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>;
         /**
          * Provides typed builders for choosing the next active state after this
@@ -3080,11 +3203,15 @@ export declare namespace Machine {
     };
     /** Context passed to a transient choice resolver. There is no `state` value. */
     type ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = MachineReferences<InputEvents, ParentEvents> & {
+        /** 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>;
     };
     /**
@@ -3094,9 +3221,13 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     interface FinalOutputContext<States extends StateSchemas, 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>;
     }
     /**
@@ -3118,10 +3249,15 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     interface ParallelOutputContext<States extends StateSchemas, 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>;
     }
     /**
@@ -3325,6 +3461,10 @@ export declare namespace Machine {
     } ? EventOf<ParentEvents<M>> : never;
     /** Extracts transition results returned by invocation lifecycle handlers. */
     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;
@@ -3333,20 +3473,22 @@ export declare namespace Machine {
     } ? 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.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type InvokeError<Config> = [InvokeReturn<Config>] extends [never] ? never : ChildAlreadyExistsError | InvokeInitialError<InvokeReturn<Config>> | Effect.Error<InvokeOutcomeReturn<InvokeReturn<Config>>>;
+    type InvokeError<Config> = [InvokeReturn<Config>] extends [never] ? never : ChildAlreadyExistsError | InvokeInitialError<InvokeReturn<Config>> | InvokeOutcomeError<InvokeReturn<Config>>;
     /**
      * Extracts the parent service requirement contribution from invoked children.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type InvokeRequirements<Config> = [InvokeReturn<Config>] extends [never] ? never : MachineRuntimeRequirement | InvokeServices<InvokeReturn<Config>> | Effect.Services<InvokeOutcomeReturn<InvokeReturn<Config>>>;
+    type InvokeRequirements<Config> = [InvokeReturn<Config>] extends [never] ? never : MachineRuntimeRequirement | InvokeServices<InvokeReturn<Config>> | InvokeOutcomeServices<InvokeReturn<Config>>;
     /**
      * Extracts the return value from an eventless transition.
      *
@@ -3405,13 +3547,16 @@ export declare namespace Machine {
     });
     /** Context capability available only to explicitly declinable resolvers. */
     interface DeclineCapability {
+        /** Declines this candidate and continues hierarchical transition selection. */
         readonly decline: () => Declined;
     }
     type TransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined;
     type DeclinableTransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined;
     /** One named destination declared by a branching transition. */
     interface TransitionBranchInput<Selection extends TargetSelection<any, any, any> = TargetSelection<any, any, any>> {
+        /** Exact topology destination available to the branching resolver. */
         readonly target: Selection;
+        /** Optional human-readable branch label used by visualization tooling. */
         readonly title?: string;
     }
     /** Opaque evidence that a branching resolver selected one declared branch. */
@@ -3452,14 +3597,17 @@ export declare namespace Machine {
         };
     }
     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> & {
+        /** Keeps the transition required. The resolver cannot return `decline()`. */
         readonly declinable?: false;
     };
     type TransitionDeclinableOptions<Reenter extends boolean> = TransitionReenterOption<Reenter> & {
+        /** Adds `decline()` to the resolver context and permits declining this candidate. */
         readonly declinable: true;
     };
     type BuiltTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Result, Acceptance extends TransitionAcceptance> = TransitionTyped<States, Events, Emits, StateId, Context, Reenter, Acceptance> & TransitionBuilderEvidence<Result, Acceptance>;
@@ -3469,10 +3617,31 @@ export declare namespace Machine {
     interface TransitionResolveDeclinable<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, any>> {
         (resolve: DeclinableTransitionResolver<Events, Emits, Context, Selection>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined, "declinable">;
     }
-    /** A selected transition target with target-specific resolver operations. */
+    /**
+     * 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
+     */
     type TransitionTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, any>> = Selection & (SelectionSupportsDefaultConstruction<Selection> extends true ? BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required"> : {}) & {
+        /**
+         * 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<States, Events, Emits, StateId, Context, Reenter, Selection> : {});
     } & ([Reenter] extends [true] ? SelectionSupportsDefaultConstruction<Selection> extends true ? {
+        /** Reenters the source using the selected target's default construction. */
         readonly reenter: () => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required">;
     } : {} : {});
     /** @internal Type evidence retained by a machine initial-entry declaration. */
@@ -3481,8 +3650,11 @@ export declare namespace Machine {
     }
     /** A selected machine initial entry with its exact resolver target. */
     type InitialTransitionTarget<Input, Selection extends TargetSelection<any, any, any>> = Selection & (SelectionSupportsDefaultConstruction<Selection> extends true ? InitialBuilderEvidence<Selection> : {}) & {
+        /** 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>;
     };
@@ -3508,7 +3680,9 @@ export declare namespace Machine {
     }
     /** Selector supplied to inline transition declarations. */
     type TransitionSelector<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance> = TransitionSelectorNode<States, Events, Emits, StateId, Context, Reenter, Acceptance, TargetSelector<States, StateId>> & {
+        /** 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<States, Events, Emits, StateId, Context, Reenter, Branches> : {});
         };
     };
@@ -3520,8 +3694,8 @@ export declare namespace Machine {
     interface InvokeOwned<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> {
         readonly "~effect/Machine/InvokeOwner"?: Types.Covariant<readonly [States, Events, Emits, StateId, InputEvents, ParentEvents]>;
     }
-    /** Type evidence retained by {@link invoke} without affecting runtime data. */
-    interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never, ParentEvent = never> {
+    /** Type evidence retained by a completed state-owned invocation. */
+    interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never, ParentEvent = never, Outcomes = never> {
         readonly [InvokeTypeId]: {
             readonly output: Types.Covariant<Output>;
             readonly error: Types.Covariant<Error>;
@@ -3529,9 +3703,10 @@ export declare namespace Machine {
             readonly initialError: Types.Covariant<InitialError>;
             readonly emits: Types.Covariant<Emits>;
             readonly parentEvents: Types.Covariant<ParentEvent>;
+            readonly outcomes: Types.Covariant<Outcomes>;
         };
     }
-    type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & ({
+    type StoredInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & ({
         readonly id: string;
         readonly effect: (context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<any, any, any>;
         readonly stream?: never;
@@ -3593,76 +3768,7 @@ export declare namespace Machine {
         readonly onElement?: never;
         readonly onSnapshot?: unknown;
     });
-    /** State-bound inline invocation configuration. */
-    type InvokeDefinition<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 []> = InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
-    type TypedInvokeDefinition = InvokeTyped<any, any, any, any, any, any> | ReadonlyArray<InvokeTyped<any, any, any, any, any, any>>;
-    type InvokeHandlerRequirement<Value, Handler> = IsAny<Value> extends true ? {
-        readonly handler: Handler;
-    } : [Value] extends [never] ? {
-        readonly handler?: never;
-    } : {
-        readonly handler: Handler;
-    };
-    type InvokeDoneRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends infer Requirement ? Requirement extends {
-        readonly handler: infer Required;
-    } ? {
-        readonly onDone: Required;
-    } : {
-        readonly onDone?: never;
-    } : never;
-    type InvokeFailureRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends infer Requirement ? Requirement extends {
-        readonly handler: infer Required;
-    } ? {
-        readonly onFailure: Required;
-    } : {
-        readonly onFailure?: never;
-    } : never;
-    type InvokeElementRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends infer Requirement ? Requirement extends {
-        readonly handler: infer Required;
-    } ? {
-        readonly onElement: Required;
-    } : {
-        readonly onElement?: never;
-    } : never;
-    type TimerInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
-        readonly id: InvokeLifecycleId;
-        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
-        readonly effect?: never;
-        readonly stream?: never;
-        readonly logic?: never;
-        readonly child?: never;
-        readonly address?: never;
-        readonly onFailure?: never;
-        readonly onElement?: never;
-        readonly onSnapshot?: never;
-        readonly onDone: InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
-    };
-    type LogicInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
-        readonly id: InvokeLifecycleId;
-        readonly address: Address & ChildAddress.Compatibility<Address, ChildEvent>;
-        readonly logic: Source;
-        readonly effect?: never;
-        readonly stream?: never;
-        readonly after?: never;
-        readonly child?: never;
-        readonly onElement?: never;
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, NoInfer<ChildState>, NoInfer<ChildError>, NoInfer<ChildOutput>, InputEvents, ParentEvents>>;
-    } & InvokeDoneRequirement<NoInfer<ChildOutput>, InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, NoInfer<ChildOutput>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<NoInfer<ChildError>, InvokeTransition<States, Events, Emits, StateId, InvokeFailureContext<States, Events, Emits, StateId, NoInfer<ChildError>, InputEvents, ParentEvents>>>;
-    type ChildInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildDefinition extends Machine.Any, Child extends ChildMachine<string, ChildDefinition>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
-        readonly child: Child & (ChildDefinition extends EnsureExecutable<Machine.States<ChildDefinition>, Machine.UnhandledStates<ChildDefinition>, Machine.OutputStates<ChildDefinition>> ? unknown : never);
-        readonly id?: never;
-        readonly address?: never;
-        readonly effect?: never;
-        readonly stream?: never;
-        readonly after?: never;
-        readonly logic?: never;
-        readonly onElement?: never;
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>;
-    } & (Input<ChildDefinition> extends typeof Schema.Void ? {
-        readonly input?: never;
-    } : {
-        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
-    }) & InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, StateId, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, StateId, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InputEvents, ParentEvents>>>;
+    type StoredInvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = StoredInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> | ReadonlyArray<StoredInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
     type LogicInitialEffectOf<Value> = Value extends {
         readonly initial: infer Initial;
     } ? Initial extends (...args: ReadonlyArray<any>) => infer Result ? Result : never : never;
@@ -3677,43 +3783,142 @@ export declare namespace Machine {
     type LogicServicesOf<Value> = Effect.Services<LogicInitialEffectOf<Value> | LogicRunEffectOf<Value>>;
     type LogicOutputOf<Value> = Effect.Success<LogicRunEffectOf<Value>>;
     type LogicInitialErrorOf<Value> = Effect.Error<LogicInitialEffectOf<Value>>;
-    type ContextualInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Raw> = Raw extends InvokeTyped<any, any, any, any, any> ? unknown : [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;
-    type ContextualInvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Raw> = Raw extends ReadonlyArray<any> ? {
-        readonly [Index in keyof Raw]: ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw[Index]>;
-    } : ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw>;
+    type RequiredInvokeChannel<Value, Channel extends string> = IsAny<Value> extends true ? Channel : [Value] extends [never] ? never : Channel;
+    type InvokeBuilderResult<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Outcomes> = InvokeOwned<States, Events, Emits, StateId, InputEvents, ParentEvents> & InvokeTyped<Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Outcomes> & {
+        readonly [InvokeBuilderTypeId]: true;
+    };
+    /** 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>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Element, Pending extends string, SnapshotHandler, Outcomes = never> = ([Pending] extends [never] ? InvokeBuilderResult<States, Events, Emits, StateId, InputEvents, ParentEvents, Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Outcomes> : {}) & ("done" extends Pending ? {
+        /** 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, InputEvents, ParentEvents, Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Element, Exclude<Pending, "done">, SnapshotHandler, Outcomes | Handler>;
+    } : {}) & ("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, InputEvents, ParentEvents, Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Element, Exclude<Pending, "failure">, SnapshotHandler, Outcomes | Handler>;
+    } : {}) & ("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, InputEvents, ParentEvents, Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Element, Exclude<Pending, "element">, SnapshotHandler, Outcomes | Handler>;
+    } : {}) & ([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, InputEvents, ParentEvents, Output, Error, Requirements, InitialError, ChildEmits, ChildParentEvent, Element, Pending, never, Outcomes | Handler>;
+    });
+    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 StreamInvokeBuilder<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Source extends (...args: ReadonlyArray<any>) => Stream.Stream<any, any, any>> = InvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, void, Stream.Error<ReturnType<Source>>, Stream.Services<ReturnType<Source>>, never, never, never, Stream.Success<ReturnType<Source>>, "done" | RequiredInvokeChannel<Stream.Success<ReturnType<Source>>, "element"> | RequiredInvokeChannel<Stream.Error<ReturnType<Source>>, "failure">, never>;
+    type LogicInvokeBuilder<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, ChildLogic> = InvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, LogicOutputOf<ChildLogic>, LogicErrorOf<ChildLogic>, LogicServicesOf<ChildLogic>, LogicInitialErrorOf<ChildLogic>, never, never, never, RequiredInvokeChannel<LogicOutputOf<ChildLogic>, "done"> | RequiredInvokeChannel<LogicErrorOf<ChildLogic>, "failure">, InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, LogicStateOf<ChildLogic>, LogicErrorOf<ChildLogic>, LogicOutputOf<ChildLogic>, InputEvents, ParentEvents>>>;
+    type ChildInvokeBuilder<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Child extends ChildMachine.Any, ChildDefinition extends Machine.Any = Child["machine"]> = InvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, Output<ChildDefinition>, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, Services<ChildDefinition>, InitialError<ChildDefinition>, Emit<ChildDefinition>, EventOf<Machine.ParentEvents<ChildDefinition>>, never, RequiredInvokeChannel<Output<ChildDefinition>, "done"> | RequiredInvokeChannel<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, "failure">, InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>>;
+    /**
+     * 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
+     */
+    interface InvokeSelector<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> {
+        /**
+         * 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, 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>;
+        };
+        /**
+         * 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
+     */
+    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>;
     } : {
         readonly output?: never;
@@ -3726,18 +3931,41 @@ 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
      */
     type ActiveStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
+        /** 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, Emits, StateId, AlwaysContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, false, TransitionAcceptance>;
+        /** Transition evaluated after this compound or parallel state completes. */
         readonly onDone?: TransitionConfig<States, Events, Emits, StateId, DoneContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, 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, Events, Emits, StateId, HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>, true, 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>;
     /**
@@ -3803,8 +4031,11 @@ export declare namespace Machine {
     type StateInitializeHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = (context: StateInitializeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => SnapshotBuilderComplete<StateInitializeValue<States, StateId>, boolean>;
     /** Context used only when a history node has no previously captured record. */
     interface HistoryDefaultContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, 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;
     }
     /**
@@ -3815,14 +4046,26 @@ export declare namespace Machine {
      * and provides every inactive ancestor and required parallel region.
      */
     type HistoryDefaultHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>> = (context: HistoryDefaultContext<States, Events, Emits, ParentId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => 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
+     */
     type HistoryDefaultConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, 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. */
     interface ChoiceStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> {
+        /** Required transition that resolves this transient choice to a concrete destination. */
         readonly choice: TransitionConfig<States, Events, Emits, ChoiceId, ChoiceContext<States, Events, Emits, ChoiceId, InputEvents, ParentEvents>>;
         readonly entry?: never;
         readonly exit?: never;
@@ -3836,10 +4079,13 @@ export declare namespace Machine {
     /**
      * Configuration accepted for a final state.
      *
+     * @inlineType OutputHandlerConfig
+     *
      * @category models
      * @since 0.4.0
      */
     type FinalStateConfig<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 []> = {
+        /** 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>>) => StateActionResult<any, any>;
         readonly exit?: never;
         readonly always?: never;
@@ -3870,12 +4116,6 @@ export declare namespace Machine {
         readonly states: infer Children extends StateSchemas;
     } ? HandlerNodeByPath<Children, Rest> : never : never : Path extends keyof States ? States[Path] : never;
     type HandlerConfigAtPath<Config, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Config ? HandlerConfigAtPath<HandlerNodeChildrenConfig<Config[Head]>, Rest> : never : 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>;
     type HandlerValidationAtPath<Path extends string, Validation> = Path extends `${infer Head}.${infer Rest}` ? {
         readonly [Key in Head]?: {
             readonly states: HandlerValidationAtPath<Rest, Validation>;
@@ -3883,6 +4123,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, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>> = HandlerNodeConfig<AllStates, Events, Emits, StateId, E, R, InputEvents, ParentEvents> & (StateId extends ChoiceIdentifier<AllStates> ? {
         readonly states?: never;
         readonly history?: never;
@@ -3890,7 +4131,9 @@ export declare namespace Machine {
         readonly states?: never;
         readonly history?: never;
     } : {
+        /** Child-state handlers nested according to the declared state topology. */
         readonly states?: HandlerTree<AllStates, Children, Events, Emits, E, R, InputEvents, ParentEvents, Extract<StateId, StateIdentifier<AllStates>>>;
+        /** First-use defaults keyed by direct history pseudo-state. */
         readonly history?: HistoryDefaultConfig<AllStates, Events, Emits, Extract<StateId, StateIdentifier<AllStates>>, Children>;
     } : {
         readonly states?: never;
@@ -4023,7 +4266,7 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     interface Handler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<States>, Output, OutputStates extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>> {
-        <const Config extends HandlerTree<States, States, Events, Emits, E, R, InputEvents, ParentEvents, "">>(config: Config & HandlerInvokeContexts<States, Events, InputEvents, Emits, ParentEvents, NoInfer<Config>> & HandlerTreeValidation<States, Events, InputEvents, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>> & ([StateIdentifier<States>] extends [UnhandledStates] ? HandlerInitialTargetValidation<States, NoInfer<Config>> : unknown)): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents, Config>;
+        <const Config extends HandlerTree<States, States, Events, Emits, E, R, InputEvents, ParentEvents, "">>(config: Config & HandlerTreeValidation<States, Events, InputEvents, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>> & ([StateIdentifier<States>] extends [UnhandledStates] ? HandlerInitialTargetValidation<States, NoInfer<Config>> : unknown)): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents, Config>;
     }
     /**
      * Any state config.
@@ -4048,7 +4291,7 @@ export declare namespace Machine {
     interface StateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> {
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<E, R>;
         readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<E, R>;
-        readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>;
+        readonly invoke?: StoredInvokeDefinition<States, Events, Emits, StateId>;
         readonly always?: TransitionConfig<States, Events, Emits, StateId, AlwaysContext<States, Events, Emits, StateId>, false, TransitionAcceptance>;
         readonly onDone?: TransitionConfig<States, Events, Emits, StateId, DoneContext<States, Events, Emits, StateId>, false, TransitionAcceptance>;
         readonly output?: ((context: FinalOutputContext<States, Events, StateId>) => unknown) | ((context: ParallelOutputContext<States, Events, StateId>) => unknown);
@@ -4062,13 +4305,37 @@ export declare namespace Machine {
      */
     type StateConfigs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, StateConfig<States, Events, Emits, StateId, EventTag, E, R> | ChoiceStateConfig<States, Events, Emits, ChoiceIdentifier<States>>>>;
 }
+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`.
  *
@@ -4158,20 +4425,31 @@ export declare const state: StateConstructor;
  */
 export declare const states: StatesConstructor;
 type MakeConfig<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentDeclaration extends Parent.Any | undefined> = {
+    /** 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;
 };
 type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentDeclaration extends Parent.Any | undefined> = Definition<States, readonly [...InputEvents, ...InternalEvents], Input, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, InputEvents, Machine.ParentEventsOf<ParentDeclaration>>;
+/** @inline */
 interface Make {
+    /** @param config Complete schema-first machine definition. */
     <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentDeclaration extends Parent.Any | undefined = undefined>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>, "initial"> & {
         readonly initial: Machine.InitialBuilderInput<States, Input["Type"]>;
     }, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>;
+    /** @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>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentDeclaration extends Parent.Any | undefined = undefined>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>, "states"> & {
         readonly states: InvalidDefinedStateTreeInput<States>;
     }): never;
@@ -4234,6 +4512,7 @@ interface Make {
  * ```
  *
  * @see {@link states} for typed state-tree helpers.
+ * @inlineType MakeConfig
  * @category constructors
  * @since 0.4.0
  */
@@ -4359,18 +4638,21 @@ export declare 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**
  *
@@ -4442,158 +4724,12 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * @since 0.4.0
  */
 export declare const decodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
-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;
 };
 type InvalidStaticTransitionBranchKey<Branches> = Extract<keyof Branches, "" | number | symbol>;
 type ValidateTransitionBranchRecord<Branches> = [keyof Branches] extends [never] ? TransitionBranchRecordError<"Branch records must contain at least one branch"> : [InvalidStaticTransitionBranchKey<Branches>] extends [never] ? unknown : TransitionBranchRecordError<"Branch keys must be non-empty, non-index strings", InvalidStaticTransitionBranchKey<Branches>>;
-/**
- * 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 declare const invoke: {
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Effect.Effect<unknown, unknown, unknown>, const 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"]>>>;
-};
 /**
  * Plans the initial state for a machine without executing machine commands.
  *
@@ -4857,7 +4993,7 @@ export declare const child: <const Id extends string, M extends Machine.Any>(id:
  * 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
@@ -4877,7 +5013,8 @@ export declare const childAddress: <Event = never>(id: string) => ChildAddress<E
  * 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