@typeonce/effect-machine 0.8.0 → 0.9.0

package/dist/Machine.d.ts

@@ -37,6 +37,8 @@ export type TypeId = "~effect/Machine";
 export declare const TypeId: TypeId;
 declare const MachineOutputStatesTypeId: unique symbol;
 declare const MachineTypeId: unique symbol;
+declare const EventConstructionTypeId: unique symbol;
+declare const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId;
 /**
  * Type identifier used for the synthetic event passed to startup lifecycle
  * actions.
@@ -109,7 +111,8 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
      */
     readonly events: InputEvents;
     /**
-     * Events reserved for invokes, child emissions, and other machine-local work.
+     * Events reserved for raised events, child emissions, and other machine-local
+     * work.
      *
      * @since 0.4.0
      */
@@ -265,7 +268,7 @@ export interface Runtime<in Events, in Emits> {
      *
      * @since 0.4.0
      */
-    readonly raise: (event: Events) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
+    readonly raise: (event: Machine.EventInput<Events>) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
     /**
      * Emits an event through the running machine's parent boundary.
      *
@@ -283,7 +286,7 @@ export interface Runtime<in Events, in Emits> {
  */
 export interface Enqueue<in Events, in Emits> {
     /** Raises an event inside the current macrostep. */
-    readonly raise: (event: Events) => void;
+    readonly raise: (event: Machine.EventInput<Events>) => void;
     /** Emits an event through the machine's parent boundary. */
     readonly emit: (event: Emits) => void;
     /** Sends an event to an invoked child after the transition is selected. */
@@ -904,7 +907,8 @@ export declare namespace Logic {
      *
      * `sendParent` accepts `unknown` because process logic is independent from
      * the parent that eventually owns it. Prefer typed process output or an
-     * invoke snapshot mapper when either can represent the communication.
+     * invocation lifecycle transition when either can represent the
+     * communication.
      *
      * @category models
      * @since 0.4.0
@@ -952,8 +956,9 @@ type InvokeLifecycleId = string & {
  * **Details**
  *
  * The descriptor carries the child's address and complete machine type. Pass
- * the same value to `invokeMachine`, `sendTo`, and child lookup APIs so state,
- * event, error, and output types are inferred without separate annotations.
+ * a descriptor for the same id and machine to inline `invoke`, `sendTo`, and
+ * child lookup APIs so state, event, error, and output types are inferred
+ * without separate annotations.
  *
  * @category models
  * @since 0.4.0
@@ -964,6 +969,8 @@ export interface ChildMachine<Id extends string, M extends Machine.Any> {
     readonly id: Id;
     /** Complete machine definition carried by this descriptor. */
     readonly machine: M;
+    /** @internal */
+    readonly [ChildMachineLogicTypeId]: (input?: unknown) => Logic<any, any, any, any, any, any>;
 }
 /**
  * Namespace containing type-level members associated with `ChildMachine`.
@@ -985,7 +992,7 @@ export declare namespace ChildMachine {
      * @category utility types
      * @since 0.4.0
      */
-    type Ref<Child> = Child extends ChildMachine<string, infer M> ? MachineRef<Machine.Snapshot<Machine.States<M>>, Machine.InputEvent<M>, Machine.Error<M> | ActionError<Machine.Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Machine.Output<M>> : never;
+    type Ref<Child> = Child extends ChildMachine<string, infer M> ? MachineRef<Machine.Snapshot<Machine.States<M>>, Machine.EventInput<Machine.InputEvent<M>>, Machine.Error<M> | ActionError<Machine.Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Machine.Output<M>> : never;
     /**
      * Event accepted by the child selected by a descriptor.
      *
@@ -1221,6 +1228,11 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"];
+    /** Extracts the internal event schema tuple carried by a machine definition. */
+    type InternalEvents<M extends Any> = Events<M> extends readonly [
+        ...InputEvents<M>,
+        ...infer Internal extends ReadonlyArray<TaggedSchema>
+    ] ? Internal : readonly [];
     /**
      * Extracts the complete event protocol handled inside a machine.
      *
@@ -1235,6 +1247,40 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InputEvent<M extends Any> = EventOf<InputEvents<M>>;
+    /**
+     * Opaque event construction returned by {@link events} and
+     * {@link internalEvents}.
+     *
+     * The machine resolves the instruction through its event schema when it is
+     * delivered. Only the discriminator is available before decoding succeeds.
+     */
+    interface EventConstruction<out Event extends {
+        readonly _tag: PropertyKey;
+    }> {
+        readonly [EventConstructionTypeId]: Event;
+        readonly _tag: Event["_tag"];
+    }
+    /** A decoded event or a deferred machine-bound construction of that event. */
+    type EventInput<Event> = Event | (Event extends {
+        readonly _tag: PropertyKey;
+    } ? EventConstruction<Event> : never);
+    /** Event inputs accepted for a schema tuple at machine delivery boundaries. */
+    type EventInputOf<Events extends ReadonlyArray<TaggedSchema>> = EventInput<EventOf<Events>>;
+    type EventConstructorInput<EventSchema extends TaggedSchema> = Omit<EventSchema["~type.make.in"], "_tag">;
+    type EventConstructor<EventSchema extends TaggedSchema, Tag extends EventSchema["Type"]["_tag"]> = {} extends EventConstructorInput<EventSchema> ? (input?: EventConstructorInput<EventSchema>) => EventConstruction<EventByTag<readonly [EventSchema], Tag>> : (input: EventConstructorInput<EventSchema>) => EventConstruction<EventByTag<readonly [EventSchema], Tag>>;
+    type EventConstructorsForSchema<EventSchema extends TaggedSchema> = EventSchema extends {
+        readonly cases: infer Cases extends Readonly<Record<PropertyKey, TaggedSchema>>;
+    } ? {
+        readonly [Tag in keyof Cases]: Tag extends Cases[Tag]["Type"]["_tag"] ? EventConstructor<Cases[Tag], Tag> : never;
+    } : EventSchema extends {
+        readonly members: infer Members extends ReadonlyArray<TaggedSchema>;
+    } ? Types.UnionToIntersection<EventConstructorsForSchema<Members[number]>> : {
+        readonly [Tag in EventSchema["Type"]["_tag"]]: EventConstructor<EventSchema, Tag>;
+    };
+    /** Protocol-bound constructors keyed by each configured event tag. */
+    type EventConstructors<Events extends ReadonlyArray<TaggedSchema>> = {
+        readonly [Tag in keyof Types.UnionToIntersection<EventConstructorsForSchema<Events[number]>>]: Types.UnionToIntersection<EventConstructorsForSchema<Events[number]>>[Tag];
+    };
     /**
      * Extracts the event protocol emitted by a machine.
      *
@@ -1596,6 +1642,10 @@ export declare namespace Machine {
         readonly type: "done";
     } | {
         readonly type: "choice";
+    } | {
+        readonly type: "invoke";
+        readonly id: string;
+        readonly outcome: "done" | "failure" | "snapshot";
     };
     /**
      * Statically inspectable destination paths for a transition handler.
@@ -1615,10 +1665,10 @@ export declare namespace Machine {
      *
      * **Details**
      *
-     * Event, eventless, and completion handlers may declare an upper bound of
-     * possible target paths. A handler without that declaration is explicitly
-     * reported as dynamic. The source, trigger, and reentry behavior are
-     * available without executing the handler.
+     * Event, eventless, completion, and invocation lifecycle handlers may
+     * declare an upper bound of possible target paths. A handler without that
+     * declaration is explicitly reported as dynamic. The source, trigger, and
+     * reentry behavior are available without executing the handler.
      *
      * @category models
      * @since 0.4.0
@@ -1632,9 +1682,9 @@ export declare namespace Machine {
     /**
      * Serializable description of state-owned work.
      *
-     * Static invoke descriptors expose their lifecycle id and kind without
-     * retaining Effects, closures, services, or child runtimes. A function-valued
-     * invoke factory is reported as dynamic and is never evaluated by inspection.
+     * Static invoke definitions expose their lifecycle id and kind without
+     * retaining Effects, closures, services, or child runtimes. Function-valued
+     * sources are reported as dynamic and are never evaluated by inspection.
      *
      * @category models
      * @since 0.4.0
@@ -2366,7 +2416,7 @@ export declare namespace Machine {
         readonly event: LifecycleEvent<Events>;
     }
     /**
-     * Context passed to an invoked child process source.
+     * Context passed to a function-valued invocation source.
      *
      * @category models
      * @since 0.4.0
@@ -2378,27 +2428,46 @@ export declare namespace Machine {
         readonly event: LifecycleEvent<Events>;
     }
     /**
-     * Context passed to an invoked child process active snapshot mapper.
+     * Context passed to an invocation's active-snapshot transition.
      *
      * @category models
      * @since 0.4.0
      */
-    interface InvokeSnapshotContext<State, Error, Output> {
+    interface InvokeSnapshotContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, State, Error, Output> {
         readonly id: string;
+        readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
+        readonly parents: ParentStateValues<States, StateId>;
+        readonly target: TargetBuilder<States, StateId>;
         readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
             readonly status: "active";
         }>;
     }
     /**
-     * Context passed to an invoked machine terminal output mapper.
+     * Context passed to an invocation's successful completion transition.
      *
      * @category models
      * @since 0.4.0
      */
-    interface InvokeDoneContext<Output> {
+    interface InvokeDoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Output> {
         readonly id: string;
+        readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
+        readonly parents: ParentStateValues<States, StateId>;
+        readonly snapshot: Snapshot<States>;
+        readonly target: TargetBuilder<States, StateId>;
         readonly output: Output;
     }
+    /** Context passed to an invocation typed-failure transition. */
+    interface InvokeFailureContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Error> {
+        readonly id: string;
+        readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
+        readonly parents: ParentStateValues<States, StateId>;
+        readonly snapshot: Snapshot<States>;
+        readonly target: TargetBuilder<States, StateId>;
+        readonly error: Error;
+    }
     /**
      * Context passed to an eventless transition handler.
      *
@@ -2611,9 +2680,17 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
+    type InvokeResolvedSource<Source> = Source extends (...args: any) => infer Resolved ? Resolved : Source;
+    type ChildMachineLogic<Child> = Child extends ChildMachine<string, infer M> ? Logic<Snapshot<States<M>>, EventInput<InputEvent<M>>, Error<M> | ActionError<Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialServices<M> | Services<M>>, internalRuntime.MachineRuntime>, Event<M>, Emit<M>>, Output<M>, InitialError<M> | Error<M> | ActionError<InitialServices<M> | Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError> : never;
     type InvokeLogic<Invoke> = Invoke extends {
-        readonly src: (...args: any) => infer Logic;
-    } ? Logic : never;
+        readonly effect: infer Source;
+    } ? InvokeResolvedSource<Source> extends infer Fx extends Effect.Effect<any, any, any> ? Logic<void, never, Effect.Error<Fx>, Effect.Services<Fx>, Effect.Success<Fx>> : never : Invoke extends {
+        readonly after: unknown;
+    } ? Logic<void, never, never, never, void> : Invoke extends {
+        readonly logic: infer Source;
+    } ? InvokeResolvedSource<Source> : Invoke extends {
+        readonly child: infer Child;
+    } ? ChildMachineLogic<Child> : never;
     /**
      * Extracts the startup error from an invoke source child process logic.
      *
@@ -2666,34 +2743,33 @@ export declare namespace Machine {
      */
     type InvokeEmits<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
-            readonly emits: Types.Covariant<infer Emits>;
-        };
-    } ? Emits : never;
-    /**
-     * Extracts events returned by an invoked child snapshot mapper.
-     *
-     * @category utility types
-     * @since 0.4.0
-     */
-    type InvokeSnapshotEvent<Invoke> = Invoke extends {
-        readonly [InvokeTypeId]: {
-            readonly snapshotEvent: Types.Covariant<infer Event>;
+            readonly emits: Types.Covariant<infer Emitted>;
         };
-    } ? Event : never;
+    } ? Emitted : Invoke extends {
+        readonly child: ChildMachine<string, infer M>;
+    } ? Emit<M> : never;
+    /** Extracts transition results returned by invocation lifecycle handlers. */
+    type InvokeOutcomeReturn<Invoke> = Invoke extends unknown ? (Invoke extends {
+        readonly onDone?: infer Handler;
+    } ? EventTransitionReturn<NonNullable<Handler>> : never) | (Invoke extends {
+        readonly onFailure?: infer Handler;
+    } ? EventTransitionReturn<NonNullable<Handler>> : never) | (Invoke extends {
+        readonly onSnapshot?: infer Handler;
+    } ? EventTransitionReturn<NonNullable<Handler>> : never) : never;
     /**
      * 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>> | InvokeRuntimeError<InvokeReturn<Config>>;
+    type InvokeError<Config> = [InvokeReturn<Config>] extends [never] ? never : ChildAlreadyExistsError | InvokeInitialError<InvokeReturn<Config>> | Effect.Error<InvokeOutcomeReturn<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>>;
+    type InvokeRequirements<Config> = [InvokeReturn<Config>] extends [never] ? never : MachineRuntimeRequirement | InvokeServices<InvokeReturn<Config>> | Effect.Services<InvokeOutcomeReturn<InvokeReturn<Config>>>;
     /**
      * Extracts the return value from an eventless transition.
      *
@@ -2728,63 +2804,171 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type ConfigServices<Config> = Effect.Services<EventHandlerReturn<Config>> | Effect.Services<AlwaysReturn<Config>> | Effect.Services<DoneReturn<Config>> | Effect.Services<StateActionReturn<Config, "entry">> | Effect.Services<StateActionReturn<Config, "exit">> | Effect.Services<StateInitialReturn<Config>> | Effect.Services<HistoryDefaultReturn<Config>> | Effect.Services<ChoiceReturn<Config>> | InvokeRequirements<Config>;
-    /**
-     * Configuration for invoking a child process while a state is active.
-     *
-     * @category models
-     * @since 0.4.0
-     */
-    interface InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Event, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, ChildEmits = never, DeliveredOutput = ChildOutput> {
-        readonly [InvokeTypeId]: {
-            readonly output: Types.Covariant<DeliveredOutput>;
-            readonly emits: Types.Covariant<ChildEmits>;
-            readonly snapshotEvent: Types.Covariant<Event>;
-            readonly error: Types.Covariant<ChildError>;
-            readonly requirements: Types.Covariant<ChildRequirements>;
-            readonly initialError: Types.Covariant<ChildInitialError>;
-        };
-        /** @internal Serializable descriptor metadata used by inspection. */
-        readonly [Activities.ActivityMetadataTypeId]?: Activities.StaticActivityMetadata;
-        readonly id: string;
-        /**
-         * Optional parent-local address for sending events to this invocation.
-         *
-         * The invocation `id` is only its state-local lifecycle key. Use an
-         * explicit typed address when the parent must communicate with it.
-         */
-        readonly address?: string;
-        /** @internal */
-        readonly descriptor?: ChildMachine.Any;
-        src(): Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
-        snapshot?(context: InvokeSnapshotContext<ChildState, ChildError, ChildOutput>): Event | undefined;
-        onDone?(context: InvokeDoneContext<ChildOutput>): DeliveredOutput | undefined;
+    type InvokeTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context> = ((context: Context, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
+        readonly reenter?: boolean;
+        readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
+        readonly transition: (context: Context, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
+    };
+    type InvokeSource<Value, Context> = Value | ((context: Context) => Value);
+    interface AnyLogicSource {
+        initial(...args: ReadonlyArray<any>): Effect.Effect<any, any, any>;
+        run(...args: ReadonlyArray<any>): Effect.Effect<any, any, any>;
     }
-    /** @internal */
-    interface AnyInvokeConfig<Output = unknown, Error = unknown, Requirements = unknown, InitialError = unknown, Emits = never, SnapshotEvent = never> {
+    /** Inline state-owned work that runs for the lifetime of its active state. */
+    interface InvokeOwned<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
+        readonly "~effect/Machine/InvokeOwner"?: Types.Covariant<readonly [States, Events, Emits, StateId]>;
+    }
+    /** Type evidence retained by {@link invoke} without affecting runtime data. */
+    interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never> {
         readonly [InvokeTypeId]: {
             readonly output: Types.Covariant<Output>;
-            readonly emits: Types.Covariant<Emits>;
-            readonly snapshotEvent: Types.Covariant<SnapshotEvent>;
             readonly error: Types.Covariant<Error>;
             readonly requirements: Types.Covariant<Requirements>;
             readonly initialError: Types.Covariant<InitialError>;
+            readonly emits: Types.Covariant<Emits>;
         };
     }
-    interface InvokeDefinitionValue {
-        readonly [InvokeTypeId]: unknown;
-    }
-    /**
-     * State-bound configuration for invoked child processes.
-     *
-     * **Details**
-     *
-     * A function form receives the owning state's typed value and lifecycle
-     * event before constructing one or more invoke configurations.
-     *
-     * @category models
-     * @since 0.4.0
-     */
-    type InvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeDefinitionValue | ReadonlyArray<InvokeDefinitionValue> | ((context: InvokeContext<States, Events, Emits, StateId>) => InvokeDefinitionValue | ReadonlyArray<InvokeDefinitionValue>);
+    type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeOwned<States, Events, Emits, StateId> & ({
+        readonly id: string;
+        readonly effect: InvokeSource<Effect.Effect<any, any, any>, InvokeContext<States, Events, Emits, StateId>>;
+        readonly after?: never;
+        readonly logic?: never;
+        readonly child?: never;
+        readonly address?: never;
+        readonly onDone?: unknown;
+        readonly onFailure?: unknown;
+        readonly onSnapshot?: never;
+    } | {
+        readonly id: string;
+        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>;
+        readonly effect?: never;
+        readonly logic?: never;
+        readonly child?: never;
+        readonly address?: never;
+        readonly onDone: unknown;
+        readonly onFailure?: never;
+        readonly onSnapshot?: never;
+    } | {
+        readonly id: string;
+        readonly address: string;
+        readonly logic: InvokeSource<AnyLogicSource, InvokeContext<States, Events, Emits, StateId>>;
+        readonly effect?: never;
+        readonly after?: never;
+        readonly child?: never;
+        readonly onDone?: unknown;
+        readonly onFailure?: unknown;
+        readonly onSnapshot?: unknown;
+    } | {
+        readonly child: ChildMachine.Any;
+        readonly input?: {} | null | ((context: InvokeContext<States, Events, Emits, StateId>) => unknown);
+        readonly id?: never;
+        readonly address?: never;
+        readonly effect?: never;
+        readonly after?: never;
+        readonly logic?: never;
+        readonly onDone?: unknown;
+        readonly onFailure?: unknown;
+        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>> = InvokeConfig<States, Events, Emits, StateId> | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId>>;
+    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 EffectInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Fx extends Effect.Effect<any, any, any>, Source = Fx> = {
+        readonly id: InvokeLifecycleId;
+        readonly effect: Source;
+        readonly after?: never;
+        readonly logic?: never;
+        readonly child?: never;
+        readonly address?: never;
+        readonly onSnapshot?: never;
+    } & InvokeDoneRequirement<Effect.Success<NoInfer<Fx>>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<NoInfer<Fx>>>>> & InvokeFailureRequirement<Effect.Error<NoInfer<Fx>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<NoInfer<Fx>>>>>;
+    type TimerInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = {
+        readonly id: InvokeLifecycleId;
+        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>;
+        readonly effect?: never;
+        readonly logic?: never;
+        readonly child?: never;
+        readonly address?: never;
+        readonly onFailure?: never;
+        readonly onSnapshot?: never;
+        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void>>;
+    };
+    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>> = {
+        readonly id: InvokeLifecycleId;
+        readonly address: Address & ChildAddress.Compatibility<Address, ChildEvent>;
+        readonly logic: Source;
+        readonly effect?: never;
+        readonly after?: never;
+        readonly child?: never;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, ChildState, ChildError, ChildOutput>>;
+    } & InvokeDoneRequirement<ChildOutput, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, ChildOutput>>> & InvokeFailureRequirement<ChildError, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, ChildError>>>;
+    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>> = {
+        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 after?: never;
+        readonly logic?: never;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>>>;
+    } & (Input<ChildDefinition> extends typeof Schema.Void ? {
+        readonly input?: never;
+    } : {
+        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>;
+    }) & InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>>>>;
+    type LogicStateOf<Value> = Value extends Logic<infer State, any, any, any, any, any> ? State : never;
+    type LogicEventOf<Value> = Value extends Logic<any, infer Event, any, any, any, any> ? Event : never;
+    type LogicErrorOf<Value> = Value extends Logic<any, any, infer Error, any, any, any> ? Error : never;
+    type LogicServicesOf<Value> = Value extends Logic<any, any, any, infer Services, any, any> ? Services : never;
+    type LogicOutputOf<Value> = Value extends Logic<any, any, any, any, infer Output, any> ? Output : never;
+    type LogicInitialErrorOf<Value> = Value extends Logic<any, any, any, any, any, infer Error> ? Error : never;
+    type ContextualInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Raw> = Raw extends InvokeTyped<any, any, any, any, any> ? unknown : Raw extends {
+        readonly effect: infer Source;
+    } ? InvokeResolvedSource<Source> extends infer Fx extends Effect.Effect<any, any, any> ? InvokeDoneRequirement<Effect.Success<Fx>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>>>> & InvokeFailureRequirement<Effect.Error<Fx>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>>>> & {
+        readonly onSnapshot?: never;
+    } : never : Raw extends {
+        readonly after: unknown;
+    } ? {
+        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void>>;
+        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, InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>>>> & InvokeFailureRequirement<InvokeRuntimeError<Raw>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, InvokeRuntimeError<Raw>>>> & {
+        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, InvokeSnapshotContext<States, Events, Emits, StateId, ChildLogic extends Logic<infer ChildState, any, any, any, any, any> ? ChildState : never, InvokeRuntimeError<Raw>, InvokeOutput<Raw>>>;
+    } : 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, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>>>> & (Input<ChildDefinition> extends typeof Schema.Void ? {
+        readonly input?: never;
+    } : {
+        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>;
+    }) & {
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>>>;
+    } : never : never;
+    type ContextualInvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Raw> = Raw extends ReadonlyArray<any> ? {
+        readonly [Index in keyof Raw]: ContextualInvokeConfig<States, Events, Emits, StateId, Raw[Index]>;
+    } : ContextualInvokeConfig<States, Events, Emits, StateId, Raw>;
     type OutputHandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Context> = NodeByIdentifier<States, StateId> extends {
         readonly output: Schema.Top;
     } ? {
@@ -2918,6 +3102,12 @@ 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>, Emits 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, Invoke>;
+    }> : unknown : unknown;
+    type HandlerInvokeContexts<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config> = Types.UnionToIntersection<StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerInvokeContextAtPath<AllStates, Events, Emits, 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>;
@@ -3020,7 +3210,7 @@ export declare namespace Machine {
     ] extends [never] ? unknown : {
         readonly output: HandlerValidationError<"Handler config is missing a region output implementation required by parallel output", StateId, Exclude<RequiredParallelOutputStates<AllStates, StateId>, AvailableOutputStates>>;
     } : unknown : unknown);
-    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = StateId extends ChoiceIdentifier<AllStates> ? HandlerChoiceUnknownConfigKeyValidation<StateId, Config> & HandlerChoiceTargetValidation<StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : StateId extends StateIdentifier<AllStates> ? HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerOnTargetValidation<StateId, Config> & HandlerDirectTargetValidation<StateId, Config, "always"> & HandlerDirectTargetValidation<StateId, Config, "onDone"> & HandlerInvokeOutputValidation<Events, StateId, Config> & HandlerInvokeEmitsValidation<Events, StateId, Config> & HandlerInvokeSnapshotValidation<Events, StateId, Config> & HandlerChildrenValidation<Node, StateId, Config> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : unknown;
+    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = StateId extends ChoiceIdentifier<AllStates> ? HandlerChoiceUnknownConfigKeyValidation<StateId, Config> & HandlerChoiceTargetValidation<StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : StateId extends StateIdentifier<AllStates> ? HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerOnTargetValidation<StateId, Config> & HandlerDirectTargetValidation<StateId, Config, "always"> & HandlerDirectTargetValidation<StateId, Config, "onDone"> & HandlerInvokeEmitsValidation<Events, StateId, Config> & HandlerChildrenValidation<Node, StateId, Config> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : unknown;
     type HandlerChoiceUnknownConfigKeyValidation<StateId extends string, Config, UnknownKeys extends string = Exclude<Extract<keyof Config, string>, "choice">> = [UnknownKeys] extends [never] ? unknown : {
         readonly [Key in UnknownKeys]: HandlerValidationError<"Choice handler config contains an invalid key", StateId, Key>;
     };
@@ -3029,15 +3219,9 @@ export declare namespace Machine {
     } ? [UndeclaredTransitionTarget<Choice>] extends [never] ? unknown : {
         readonly choice: HandlerValidationError<"Choice resolver returns a target not listed in targets", StateId, UndeclaredTransitionTarget<Choice>>;
     } : unknown;
-    type HandlerInvokeOutputValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>] extends [never] ? unknown : {
-        readonly invoke: HandlerValidationError<"Invoked child output must be a machine event or void", StateId, Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>>;
-    };
     type HandlerInvokeEmitsValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown : {
         readonly invoke: HandlerValidationError<"Invoked child emits events not accepted by the parent machine", StateId, Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>>;
     };
-    type HandlerInvokeSnapshotValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : IsAny<InvokeSnapshotEvent<InvokeReturn<Config>>> extends true ? unknown : [Exclude<InvokeSnapshotEvent<InvokeReturn<Config>>, EventOf<Events> | undefined>] extends [never] ? unknown : {
-        readonly invoke: HandlerValidationError<"Invoked child snapshot mapper must return a machine event or undefined", StateId, Exclude<InvokeSnapshotEvent<InvokeReturn<Config>>, EventOf<Events> | undefined>>;
-    };
     type HandlerRuntimeValidation<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends string, Config, Incompatible = IncompatibleRuntime<ConfigServices<HandlerConfigPart<Config>>, EventOf<Events>, EmitOf<Emits>>> = [Incompatible] extends [never] ? unknown : HandlerValidationError<"Handler config requires an incompatible machine runtime", StateId, Incompatible>;
     type HandlerNodeValidationAtPath<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>, StateId extends StateNodeIdentifier<AllStates>, NodeConfig = HandlerConfigAtPath<Config, StateId>> = [NodeConfig] extends [never] ? never : HandlerNodeValidation<AllStates, HandlerNodeByPath<AllStates, StateId>, Events, Emits, StateId, NodeConfig, AvailableOutputStates> extends infer Validation ? unknown extends Validation ? never : HandlerValidationAtPath<StateId, Validation> : never;
     type HandlerTreeNodeValidations<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = Types.UnionToIntersection<StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerNodeValidationAtPath<AllStates, Events, Emits, Config, AvailableOutputStates, StateId> : never : never>;
@@ -3074,7 +3258,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>> {
-        <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(config: Config & HandlerTreeValidation<States, Events, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, Config>;
+        <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(config: Config & HandlerInvokeContexts<States, Events, Emits, NoInfer<Config>> & HandlerTreeValidation<States, Events, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, Config>;
     }
     /**
      * Any state config.
@@ -3203,8 +3387,8 @@ interface Make {
  * to implement state behavior with ordinary TypeScript control flow.
  *
  * Schemas in `events` define the public input protocol. Schemas in
- * `internalEvents` are added to the complete handler protocol for invoke
- * results, child emissions, and other machine-local deliveries. Their tags
+ * `internalEvents` are added to the complete handler protocol for raised
+ * events, child emissions, and other machine-local deliveries. Their tags
  * must be disjoint.
  *
  * **Example** (Typed counter machine)
@@ -3256,6 +3440,9 @@ type EventConstructorArgs<EventSchema extends Machine.TaggedSchema> = {} extends
  * Events supplied through ordinary `send` and `plan` calls remain untrusted
  * and continue through full runtime schema validation.
  * Treat the returned event as immutable after construction.
+ * This eager low-level constructor throws `MachineSchemaDecodeError` when
+ * construction fails. Prefer {@link events} and {@link internalEvents} for
+ * ordinary delivery so construction remains inside the machine error channel.
  *
  * The schema must be one of the machine's configured public or internal event
  * schemas, or a case schema belonging to a configured `Schema.TaggedUnion`.
@@ -3285,6 +3472,37 @@ type EventConstructorArgs<EventSchema extends Machine.TaggedSchema> = {} extends
  * @since 0.4.0
  */
 export declare const event: <const M extends Machine.Any, const EventSchema extends Machine.TaggedSchema>(machine: M, schema: EventSchema & ([EventSchema["Type"]] extends [Machine.Event<M>] ? unknown : never), ...args: EventConstructorArgs<EventSchema>) => EventSchema["Type"];
+/**
+ * Returns deferred constructors for every public event in a machine protocol.
+ *
+ * Constructor inputs retain their schema-derived required fields, defaults,
+ * and transformations. Construction is deferred until delivery so failures
+ * enter the machine's `MachineSchemaDecodeError` channel rather than throwing
+ * at the call site.
+ *
+ * **Example**
+ *
+ * ```ts
+ * const Event = Machine.events(counter)
+ * yield* ref.send(Event.Increment({ by: 1 }))
+ * ```
+ *
+ * @category constructors
+ * @since 0.9.0
+ */
+export declare const events: <const M extends Machine.Any>(machine: M) => Machine.EventConstructors<Machine.InputEvents<M>>;
+/**
+ * Returns deferred constructors for every internal event in a machine
+ * protocol.
+ *
+ * Use these constructors for raised events and other machine-local deliveries.
+ * Construction failures are reported through the
+ * owning machine's `MachineSchemaDecodeError` channel.
+ *
+ * @category constructors
+ * @since 0.9.0
+ */
+export declare const internalEvents: <const M extends Machine.Any>(machine: M) => Machine.EventConstructors<Machine.InternalEvents<M>>;
 /**
  * Encodes a decoded machine snapshot into a normalized data representation.
  *
@@ -3378,131 +3596,81 @@ 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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
-/**
- * Creates an invoked child process configuration for an active state.
- *
- * **When to use**
- *
- * Use to run a child process while a machine remains in a state. Successful
- * outputs are sent directly to the parent machine as events; `void` sends
- * nothing. Unrecovered child failures fail the owning machine. Active
- * snapshots can optionally be mapped to progress events.
- *
- * **Gotchas**
- *
- * Invoked child processes run while their owning state is active and are
- * stopped before the state exits. An unrecovered child failure fails the owning
- * machine; recover inside the child Effect when failure should become an event.
- * The `id` is a state-local lifecycle key, not a communication address. To
- * send events to the invocation, pass a typed `childAddress` as `address`.
- * The `src` callback is intentionally independent from its parent state. When
- * construction depends on the typed state, lifecycle event, or runtime, use
- * the state config factory form `invoke: (context) => Machine.invoke(...)` and
- * close over that context from `src`.
- *
- * **Example** (Effect output as a parent event)
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
- *   value: Schema.String
- * }) {}
- *
- * const load = Machine.invoke({
- *   id: "load",
- *   src: () => Machine.effect(Effect.succeed(new Loaded({ value: "ready" })))
- * })
- * ```
- *
- * @see {@link effect} for one-shot child effects.
- * @see {@link spawn} for children whose lifetime is controlled by actions.
- * @category constructors
- * @since 0.4.0
- */
-export declare const invoke: <ChildState, ChildEvent, ChildError = never, ChildRequirements = never, ChildOutput = never, ChildInitialError = never, Event = never, Address extends ChildAddress<never> | undefined = undefined>(config: {
+type DynamicEffectInvokeSource<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Effect.Effect<unknown, unknown, unknown>> = {
     readonly id: InvokeLifecycleId;
-    readonly src: () => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
-    readonly snapshot?: (context: Machine.InvokeSnapshotContext<ChildState, ChildError, ChildOutput>) => Event | undefined;
-} & ([Address] extends [undefined] ? {
+    readonly effect: Source;
+    readonly after?: never;
+    readonly logic?: never;
+    readonly child?: never;
     readonly address?: never;
-} : {
-    readonly address: Exclude<Address, undefined>;
-} & ChildAddress.Compatibility<Exclude<Address, undefined>, NoInfer<ChildEvent>>)) => Machine.InvokeConfig<any, any, any, any, Event, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
-type InvokeEffectResult<Requirements, Event> = Machine.InvokeConfig<any, any, any, any, never, void, never, never, Requirements, Event | void, never>;
-type InvokeEffectIsInfallible<Fx extends Effect.Effect<any, any, any>> = IsAny<Effect.Error<Fx>> extends true ? false : [Effect.Error<Fx>] extends [never] ? true : false;
-type InvokeEffectConfig<Fx extends Effect.Effect<any, any, any>, SuccessEvent, FailureEvent> = {
-    readonly id: InvokeLifecycleId;
-    readonly effect: Fx;
-    readonly onSuccess: (value: NoInfer<Effect.Success<Fx>>) => SuccessEvent | void;
-} & (InvokeEffectIsInfallible<Fx> extends true ? {
-    readonly onFailure?: never;
-} : {
-    readonly onFailure: (error: NoInfer<Effect.Error<Fx>>) => FailureEvent | void;
-});
+    readonly onSnapshot?: never;
+};
+type DynamicEffectDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>>>;
+type DynamicEffectFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>>>;
+type DynamicEffectInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeConfig<States, Events, Emits, StateId> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never>;
+type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false;
 /**
- * Invokes one Effect and maps its typed outcome into machine-local events.
- *
- * **Details**
+ * Preserves inference for a state-owned invocation configuration.
  *
- * This is the high-level one-shot counterpart to `invoke`. Success and typed
- * failure values are mapped independently, so callers do not need to recover
- * an Effect into a common event union by hand. Defects and interruption remain
- * failures of the owning machine.
+ * Use `effect` for one-shot work, `after` for a cancellable timer, `logic` for
+ * reusable process logic, or `child` for a complete child machine. `onDone` is
+ * required whenever the source can complete with an output, while `onFailure`
+ * is required only when the source has a typed failure channel.
  *
- * Declare mapped outcomes in `internalEvents` unless they are also legitimate
- * public commands.
- *
- * **Example**
+ * This constructor is an identity at runtime, but preserves lifecycle callback
+ * inference through published declarations. Effects and durations may be
+ * supplied directly or derived from the owning state's entry context. Dynamic
+ * Effect sources infer the owner context, output, error, and service channels
+ * together without a return annotation. Logic invocations require both a
+ * lifecycle `id` and a typed communication `address`. Child descriptors already
+ * own their identity, so `id` and `address` must not be repeated.
  *
  * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
- *   value: Schema.String
- * }) {}
- *
- * const load = Machine.invokeEffect({
+ * invoke: Machine.invoke({
  *   id: "load",
- *   effect: Effect.succeed("ready"),
- *   onSuccess: (value) => new Loaded({ value })
+ *   effect: Effect.tryPromise({
+ *     try: () => fetch("/api/data").then((response) => response.json()),
+ *     catch: (cause) => new LoadError({ cause })
+ *   }),
+ *   onDone: ({ output, target }) => target.full.Ready({ data: output }),
+ *   onFailure: ({ error, target }) => target.full.Failed({ error })
  * })
  * ```
  *
- * @see {@link invoke} for arbitrary child process logic.
- * @see {@link after} for a state-scoped delayed event.
  * @category constructors
- * @since 0.4.0
+ * @since 0.9.0
  */
-export declare const invokeEffect: <const Fx extends Effect.Effect<any, any, any>, SuccessEvent, FailureEvent = never>(config: InvokeEffectConfig<Fx, SuccessEvent, FailureEvent>) => InvokeEffectResult<Effect.Services<Fx>, SuccessEvent | (InvokeEffectIsInfallible<Fx> extends true ? never : FailureEvent)>;
-/**
- * Creates a cancellable state-scoped delayed event.
- *
- * The timer starts when its owning state is entered and is interrupted when
- * that state exits. The delayed value should normally be declared in
- * `internalEvents`.
- *
- * **Example**
- *
- * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class TimedOut extends Schema.TaggedClass<TimedOut>("TimedOut")("TimedOut", {}) {}
- *
- * const timeout = Machine.after("5 seconds", new TimedOut({}))
- * ```
- *
- * @category constructors
- * @since 0.4.0
- */
-export declare const after: <Event extends {
-    readonly _tag: PropertyKey;
-}>(duration: Duration.Input, event: Event, options?: {
-    readonly id?: InvokeLifecycleId;
-}) => InvokeEffectResult<never, Event>;
+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>) => Effect.Effect<unknown, unknown, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
+        readonly onDone: DynamicEffectDoneHandler<States, Events, Emits, StateId, Source>;
+        readonly onFailure: DynamicEffectFailureHandler<States, Events, Emits, 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"
+    ] : []): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Effect.Effect<unknown, never, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
+        readonly onDone: DynamicEffectDoneHandler<States, Events, Emits, StateId, Source>;
+        readonly onFailure?: never;
+    }, ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
+        "onDone must be omitted when the Effect output is never"
+    ] : []): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>;
+    <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>) => Effect.Effect<never, unknown, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
+        readonly onDone?: never;
+        readonly onFailure: DynamicEffectFailureHandler<States, Events, Emits, StateId, Source>;
+    }, ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
+        "onFailure must be omitted when the Effect error is never"
+    ] : []): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>;
+    <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>) => Effect.Effect<never, never, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
+        readonly onDone?: never;
+        readonly onFailure?: never;
+    }): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Fx extends Effect.Effect<any, any, any>, const Config extends object>(config: Config & Machine.EffectInvokeArgs<States, Events, Emits, StateId, Fx>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Effect.Success<Fx>, Effect.Error<Fx>, Effect.Services<Fx>, never>;
+    <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>(config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>>(config: Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>>): Machine.InvokeConfig<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object>(config: Config & Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>>;
+};
 type RetagFields<Target extends Machine.TaggedSchema> = Omit<Target["~type.make.in"], "_tag">;
 type RetagTargetCompatibility<Target extends Machine.TaggedSchema> = Target extends {
     readonly fields: Schema.Struct.Fields;
@@ -3537,48 +3705,6 @@ type RetagArgs<Target extends Machine.TaggedSchema, Source> = [
 export declare const retag: <const Target extends Machine.TaggedSchema, const Source extends {
     readonly _tag: PropertyKey;
 }>(target: Target & RetagTargetCompatibility<Target>, source: Source, ...args: RetagArgs<Target, Source>) => Target["Type"];
-type InvokeMachineInput<Input extends Schema.Top> = Input extends typeof Schema.Void ? {
-    readonly input?: never;
-} : {
-    readonly input: Input["Type"];
-};
-/**
- * Creates an invoked child process from a complete statechart machine.
- *
- * **When to use**
- *
- * Use when a state should own another statechart machine and communicate with
- * it through typed child events, emissions, snapshots, or terminal output.
- *
- * **Details**
- *
- * Child emissions are delivered directly to the parent as events. Active
- * snapshots and terminal output can be mapped to parent events. The owning
- * state controls the child lifetime.
- *
- * **Gotchas**
- *
- * Active invoked machines must have unique child addresses. A machine starts
- * after its owning state's entry actions, so those actions cannot send events
- * to a newly entered child. Unrecovered child failures fail the parent.
- *
- * @see {@link invoke} for invoking lower-level process logic.
- * @see {@link sendTo} for sending events to the invoked machine.
- * @category constructors
- * @since 0.4.0
- */
-export declare const invokeMachine: {
-    <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, SnapshotEvent = never, DoneEvent = never, Id extends string = string, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(config: {
-        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>>;
-        readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
-        readonly onDone: (context: Machine.InvokeDoneContext<Output>) => DoneEvent | undefined;
-    } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>, DoneEvent>;
-    <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, SnapshotEvent = never, Id extends string = string, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(config: {
-        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>>;
-        readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
-        readonly onDone?: never;
-    } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>>;
-};
 /**
  * Plans the initial state for a machine without executing actor commands.
  *
@@ -3678,10 +3804,9 @@ export declare const transitionDefinitions: <M extends Machine.Any>(machine: M)
  *
  * **Details**
  *
- * Static `invoke`, `invokeEffect`, `after`, and `invokeMachine` descriptors
- * expose stable ownership and lifecycle metadata without serializing runtime
- * values. Function-valued invoke factories are represented as dynamic and are
- * never evaluated during inspection.
+ * Static inline invocation definitions expose stable ownership and lifecycle
+ * metadata without serializing runtime values. Function-valued sources are
+ * represented as dynamic and are never evaluated during inspection.
  *
  * @category getters
  * @since 0.4.0
@@ -3751,7 +3876,7 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * @category combinators
  * @since 0.4.0
  */
-export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, state: Machine.Snapshot<States>, event: Machine.EventOf<InputEvents>) => Effect.Effect<{
+export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, state: Machine.Snapshot<States>, event: Machine.EventInputOf<InputEvents>) => Effect.Effect<{
     readonly next: Machine.Snapshot<States>;
     readonly commands: ReadonlyArray<Command>;
     readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
@@ -3773,49 +3898,6 @@ export declare const plan: <const States extends Machine.StateSchemas, const Eve
     readonly done: false;
     readonly output: undefined;
 }), E | InfiniteTransitionError | MachineSchemaDecodeError, never>;
-/**
- * Creates a one-shot child process from an Effect.
- *
- * **When to use**
- *
- * Use when you need side effects that produce one typed output or error.
- *
- * **Details**
- *
- * The Effect may run arbitrary side effects. Its success value is the process
- * output, its typed error is preserved, and its services are inferred. When
- * invoked, the output is sent to the owning machine as an event unless it is
- * `void`.
- *
- * **Gotchas**
- *
- * This process has no incoming event protocol. Its Effect runs once. Use
- * `transition` for a process that receives events over time and `logic` for
- * direct machine-local communication or intermediate snapshots.
- *
- * **Example** (Recover a child failure as output)
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class LoadFailed extends Schema.TaggedClass<LoadFailed>("LoadFailed")("LoadFailed", {
- *   reason: Schema.String
- * }) {}
- *
- * const load = Machine.effect(
- *   Effect.fail("unavailable").pipe(
- *     Effect.catch((reason) => Effect.succeed(new LoadFailed({ reason })))
- *   )
- * )
- * ```
- *
- * @see {@link transition} for event-driven state.
- * @see {@link logic} for direct control over intermediate snapshots.
- * @category constructors
- * @since 0.4.0
- */
-export declare const effect: <Output, Error = never, Requirements = never>(effect: Effect.Effect<Output, Error, Requirements>) => Logic<void, never, Error, Requirements, Output>;
 /**
  * Creates advanced stateful process logic from explicit initialization and
  * execution methods.
@@ -3837,9 +3919,9 @@ export declare const effect: <Output, Error = never, Requirements = never>(effec
  * This is the low-level process constructor. Parent messages sent directly
  * through its scope are intentionally `unknown` because the logic does not know
  * which machine will eventually own it. Prefer typed output, typed child
- * addresses, or invoke snapshot mapping when possible.
+ * addresses, or invocation lifecycle transitions when possible.
  *
- * @see {@link effect} for one-shot work.
+ * Use an inline `invoke` with an `effect` source for one-shot work.
  * @see {@link transition} for event-driven state.
  * @category constructors
  * @since 0.4.0
@@ -3873,7 +3955,7 @@ export declare const logic: <State, Event = never, Output = void, Error = never,
  * )
  * ```
  *
- * @see {@link effect} for one-shot work.
+ * Use an inline `invoke` with an `effect` source for one-shot work.
  * @see {@link logic} for direct process lifecycle control.
  * @category constructors
  * @since 0.4.0
@@ -3996,7 +4078,7 @@ export declare const watch: <State, Event, Error = never, Output = never>(ref: M
  * @category constructors
  * @since 0.4.0
  */
-export declare const start: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+export declare const start: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 /**
  * Starts a fresh managed runtime from a decoded logical snapshot.
  *
@@ -4007,8 +4089,8 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * entry or transition actions, re-deliver raised or emitted events, or
  * re-evaluate historical completion and eventless transitions. Active-state
  * invokes start once in ancestor and document order with {@link InitialEvent};
- * delayed invokes restart their complete duration and invoked machines start
- * from their own initial state.
+ * timer invocations restart their complete duration and child-machine
+ * invocations start from their own initial state.
  *
  * Only logical state, completion, and history metadata are resumed. Queues,
  * scopes, subscriptions, fibers, spawned children, invoke progress, and prior
@@ -4048,5 +4130,5 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * @category constructors
  * @since 0.4.0
  */
-export declare const resume: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+export declare const resume: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 //# sourceMappingURL=Machine.d.ts.map