@typeonce/effect-machine 0.7.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. */
@@ -383,48 +386,38 @@ type UnknownPseudoAnnotationProperty<Node> = Node extends {
 type ValidatePseudoStateAnnotations<Node, Path extends PropertyKey> = [UnknownPseudoAnnotationProperty<Node>] extends [
     never
 ] ? unknown : StateDefinitionError<"Pseudo-state annotations contain unknown properties", Path, Extract<UnknownPseudoAnnotationProperty<Node>, PropertyKey>>;
-type ValidateStateNode<Node, AllowHistory extends boolean, Path extends PropertyKey> = Node extends Machine.TaggedSchema ? unknown : Node extends Machine.HistoryStateNodeConfig ? ValidateExactStateNodeProperties<Node, "history", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateHistoryStateNode<Node> : StateDefinitionError<"History states must be declared below an active parent state", Path>) : Node extends Machine.ChoiceStateNodeConfig ? ValidateExactStateNodeProperties<Node, "choice", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateChoiceStateNode<Node> : StateDefinitionError<"Choice states must be declared below an active parent state", Path>) : Node extends {
-    readonly schema: Machine.TaggedSchema;
-} ? ValidateStateNodeConfig<Node, Path> : StateDefinitionError<"State nodes must be tagged schemas or state node configs", Path>;
+type ValidateStateNode<Node, AllowHistory extends boolean, Path extends PropertyKey> = Node extends Machine.TaggedSchema ? unknown : Node extends Machine.HistoryStateNodeConfig ? ValidateExactStateNodeProperties<Node, "history", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateHistoryStateNode<Node> : StateDefinitionError<"History states must be declared below an active parent state", Path>) : Node extends Machine.ChoiceStateNodeConfig ? ValidateExactStateNodeProperties<Node, "choice", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateChoiceStateNode<Node> : StateDefinitionError<"Choice states must be declared below an active parent state", Path>) : Node extends Machine.StateNodeConfig ? ValidateStateNodeConfig<Node, Path> : StateDefinitionError<"State nodes must be tagged schemas or state node configs", Path>;
 type ValidateHistoryStateNode<Node extends Machine.HistoryStateNodeConfig> = [
     Extract<keyof Node, "schema" | "states" | "initial" | "output" | "choice">
 ] extends [never] ? unknown : StateDefinitionError<"History states cannot declare schemas, children, initial states, or output">;
 type ValidateChoiceStateNode<Node extends Machine.ChoiceStateNodeConfig> = [
     Extract<keyof Node, "schema" | "states" | "initial" | "output" | "history">
 ] extends [never] ? unknown : StateDefinitionError<"Choice states cannot declare schemas, children, initial states, output, or history">;
-type ValidateStateNodeConfig<Node extends {
-    readonly schema: Machine.TaggedSchema;
-}, Path extends PropertyKey> = Node extends {
+type ValidateStateNodeConfig<Node extends Machine.StateNodeConfig, Path extends PropertyKey> = Node extends {
     readonly type: "parallel";
 } ? ValidateExactStateNodeProperties<Node, "parallel", Path> & ValidateStateNodeWithChildren<Node, Node extends {
     readonly states: infer Children;
-} ? Children : never, Path> : Node extends {
+} ? Children : never, Path> & ValidatePseudoStateAnnotations<Node, Path> : Node extends {
     readonly type: "final";
-} ? ValidateExactStateNodeProperties<Node, "final", Path> & ValidateStateNodeWithoutChildren<Node> : Node extends {
+} ? ValidateExactStateNodeProperties<Node, "final", Path> & ValidateStateNodeWithoutChildren<Node> & ValidatePseudoStateAnnotations<Node, Path> : Node extends {
     readonly states: infer Children;
-} ? ValidateExactStateNodeProperties<Node, "compound", Path> & ValidateStateNodeWithChildren<Node, Children, Path> : ValidateExactStateNodeProperties<Node, "atomic", Path> & ValidateStateNodeWithoutChildren<Node>;
+} ? ValidateExactStateNodeProperties<Node, "compound", Path> & ValidateStateNodeWithChildren<Node, Children, Path> & ValidatePseudoStateAnnotations<Node, Path> : ValidateExactStateNodeProperties<Node, "atomic", Path> & ValidateStateNodeWithoutChildren<Node> & ValidatePseudoStateAnnotations<Node, Path>;
 type ValidateOutputSchema<Node> = "output" extends keyof Node ? Node extends {
     readonly output: Schema.Top;
 } ? unknown : StateDefinitionError<"State output must be a schema"> : unknown;
-type ValidateStateNodeWithChildren<Node extends {
-    readonly schema: Machine.TaggedSchema;
-}, Children, Path extends PropertyKey> = Children extends Machine.StateSchemas ? Node extends {
+type ValidateStateNodeWithChildren<Node extends Machine.StateNodeConfig, Children, Path extends PropertyKey> = Children extends Machine.StateSchemas ? Node extends {
     readonly type: "final";
 } ? StateDefinitionError<"Final states cannot declare child states"> : Node extends {
     readonly type: "parallel";
 } ? "initial" extends keyof Node ? StateDefinitionError<"Parallel states cannot declare an initial child"> : {
     readonly states: ValidateStateTree<Children, true, Extract<Path, string>>;
 } & ValidateOutputSchema<Node> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : ValidateCompoundStateNode<Node, Children, Path> : StateDefinitionError<"Child states must be a state tree">;
-type ValidateCompoundStateNode<Node extends {
-    readonly schema: Machine.TaggedSchema;
-}, Children extends Machine.StateSchemas, Path extends PropertyKey> = Node extends {
+type ValidateCompoundStateNode<Node extends Machine.StateNodeConfig, Children extends Machine.StateSchemas, Path extends PropertyKey> = Node extends {
     readonly initial: infer Initial;
 } ? Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> ? {
     readonly states: ValidateStateTree<Children, true, Extract<Path, string>>;
 } : StateDefinitionError<"Compound initial must be one of its direct child keys"> : StateDefinitionError<"Compound states must declare an initial child">;
-type ValidateStateNodeWithoutChildren<Node extends {
-    readonly schema: Machine.TaggedSchema;
-}> = "initial" extends keyof Node ? StateDefinitionError<"Atomic states cannot declare an initial child"> : Node extends {
+type ValidateStateNodeWithoutChildren<Node extends Machine.StateNodeConfig> = "initial" extends keyof Node ? StateDefinitionError<"Atomic states cannot declare an initial child"> : Node extends {
     readonly type: infer Type;
 } ? Type extends "final" ? ValidateOutputSchema<Node> : Type extends "active" | undefined ? "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown : StateDefinitionError<"State node type must be active, final, or parallel"> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown;
 type DefineStateTreeInput<States extends Machine.StateSchemas> = {
@@ -483,6 +476,24 @@ type FromMethod<Arguments extends ReadonlyArray<unknown>, Result> = {
 };
 type ConstructionResult<Result> = Result | Machine.StateConstruction<Result>;
 type UnwrapConstruction<Result> = Result extends Machine.StateConstruction<infer Value> ? Value : Result;
+type NodeValue<Node> = [Machine.NodeSchema<Node>] extends [never] ? undefined : Machine.NodeSchema<Node>["Type"];
+type NodeMakeInput<Node> = [Machine.NodeSchema<Node>] extends [never] ? never : Machine.NodeSchema<Node>["~type.make.in"];
+type WithNodeValue<Node, Rest extends ReadonlyArray<unknown>> = Machine.NodeSchema<Node> extends never ? Rest : readonly [value: NodeValue<Node>, ...Rest];
+type WithNodeInput<Node, Rest extends ReadonlyArray<unknown>> = Machine.NodeSchema<Node> extends never ? Rest : readonly [input: NodeMakeInput<Node>, ...Rest];
+type NodeBuilderMethod<Node, Arguments extends ReadonlyArray<unknown>, Result, FromArguments extends ReadonlyArray<unknown>, FromResult> = Machine.NodeSchema<Node> extends never ? {
+    readonly from: FromCallable<FromArguments, FromResult>;
+} : ((...args: Arguments) => Result) & {
+    readonly from: FromCallable<FromArguments, FromResult>;
+};
+type NodeMethod<Node, Arguments extends ReadonlyArray<unknown>, Result, FromArguments extends ReadonlyArray<unknown>> = Machine.NodeSchema<Node> extends never ? FromMethod<FromArguments, Result> : ((...args: Arguments) => Result) & FromMethod<FromArguments, Result>;
+type NodeConstructionSelectorFromCallable<Node, Builder, Result> = Machine.NodeSchema<Node> extends never ? {
+    <Selected extends ConstructionResult<Result>>(state: (builder: Builder) => Selected): Machine.StateConstruction<UnwrapConstruction<Selected>>;
+} : ConstructionSelectorFromCallable<NodeMakeInput<Node>, Builder, Result>;
+type NestedTargetMethod<Node, Builder, Result> = Machine.NodeSchema<Node> extends never ? {
+    readonly from: NodeConstructionSelectorFromCallable<Node, Builder, Result>;
+} : (<Selected extends ConstructionResult<Result>>(value: NodeValue<Node>, state: (builder: Builder) => Selected) => Selected) & {
+    readonly from: NodeConstructionSelectorFromCallable<Node, Builder, Result>;
+};
 type ConstructionSelectorFromCallable<Input, Builder, Result> = {} extends Input ? {
     <Selected extends ConstructionResult<Result>>(state: (builder: Builder) => Selected): Machine.StateConstruction<UnwrapConstruction<Selected>>;
     <Selected extends ConstructionResult<Result>>(input: Input, state: (builder: Builder) => Selected): Machine.StateConstruction<UnwrapConstruction<Selected>>;
@@ -492,127 +503,111 @@ type InitialSnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Prefi
 } & {
     readonly [Key in ChoiceStateKey<States>]: () => Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, Key>>;
 };
-type InitialSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = ((...args: InitialSnapshotArguments<States, StateId, Prefix>) => InitialSnapshotResult<States, StateId, Prefix>) & FromMethod<InitialSnapshotFromArguments<States, StateId, Prefix>, InitialSnapshotResult<States, StateId, Prefix>>;
+type InitialSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = Machine.NodeSchema<States[StateId]> extends never ? FromMethod<InitialSnapshotFromArguments<States, StateId, Prefix>, InitialSnapshotResult<States, StateId, Prefix>> : ((...args: InitialSnapshotArguments<States, StateId, Prefix>) => InitialSnapshotResult<States, StateId, Prefix>) & FromMethod<InitialSnapshotFromArguments<States, StateId, Prefix>, InitialSnapshotResult<States, StateId, Prefix>>;
 type InitialSnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     states: (builder: InitialParallelBuilder<Children, Path>) => SnapshotBuilderComplete<InitialSnapshotRegionsWithPrefix<Children, Path>>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
     readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => InitialSelectableResult<Children, Initial, Path>
-] : never : [value: Machine.NodeSchema<Node>["Type"]] : never;
+]> : never : WithNodeValue<Node, []> : never;
 type InitialSnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     states: (builder: InitialParallelBuilder<Children, Path>) => SnapshotBuilderComplete<InitialSnapshotRegionsWithPrefix<Children, Path>, boolean>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
     readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => ConstructionResult<InitialSelectableResult<Children, Initial, Path>>
-] : never : [input: Machine.NodeSchema<Node>["~type.make.in"]] : never;
+]> : never : WithNodeInput<Node, []> : never;
 type InitialSnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Machine.ParallelSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSnapshotRegionsWithPrefix<Children, Path>> : Node extends {
+} ? Machine.ParallelSnapshot<Path, NodeValue<Node>, InitialSnapshotRegionsWithPrefix<Children, Path>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
     readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
-} ? Machine.CompoundSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSelectableResult<Children, Initial, Path>> : never : Machine.AtomicSnapshot<Path, Machine.NodeSchema<Node>["Type"]> : never;
+} ? Machine.CompoundSnapshot<Path, NodeValue<Node>, InitialSelectableResult<Children, Initial, Path>> : never : Machine.AtomicSnapshot<Path, NodeValue<Node>> : never;
 type InitialSelectableResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States> | ChoiceStateKey<States>, Prefix extends string> = StateId extends ChoiceStateKey<States> ? Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, StateId>> : StateId extends ActiveStateKey<States> ? InitialSnapshotResult<States, StateId, Prefix> : never;
 type InitialSnapshotRegionsWithPrefix<States extends Machine.StateSchemas, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: InitialSnapshotResult<States, Key, Prefix>;
 };
 type InitialParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
-    readonly [Key in Remaining]: ((...args: InitialSnapshotArguments<States, Key, Prefix>) => InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+    readonly [Key in Remaining]: NodeBuilderMethod<States[Key], InitialSnapshotArguments<States, Key, Prefix>, InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
-    }, Constructed>) & {
-        readonly from: FromCallable<InitialSnapshotFromArguments<States, Key, Prefix>, InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
-            readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
-        }, true>>;
-    };
+    }, Constructed>, InitialSnapshotFromArguments<States, Key, Prefix>, InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
+    }, true>>;
 };
 type FullSnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Prefix extends string = ""> = {
     readonly [Key in ActiveStateKey<States>]: FullSnapshotMethod<States, Key, Prefix>;
 } & {
     readonly [Key in ChoiceStateKey<States>]: () => Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, Key>>;
 };
-type FullSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = ((...args: FullSnapshotArguments<States, StateId, Prefix>) => FullSnapshotResult<States, StateId, Prefix>) & FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>>;
+type FullSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = Machine.NodeSchema<States[StateId]> extends never ? FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>> : ((...args: FullSnapshotArguments<States, StateId, Prefix>) => FullSnapshotResult<States, StateId, Prefix>) & FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>>;
 type FullSnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => Machine.SnapshotWithPrefix<Children, Path> | Machine.ChoiceTargetInstruction<Machine.ChoiceIdentifierWithPrefix<Children, Path>>
-] : [value: Machine.NodeSchema<Node>["Type"]] : never;
+]> : WithNodeValue<Node, []> : never;
 type FullSnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => ConstructionResult<Machine.SnapshotWithPrefix<Children, Path> | Machine.ChoiceTargetInstruction<Machine.ChoiceIdentifierWithPrefix<Children, Path>>>
-] : [input: Machine.NodeSchema<Node>["~type.make.in"]] : never;
+]> : WithNodeInput<Node, []> : never;
 type FullSnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Machine.SnapshotByIdentifierWithPath<States, StateId, Path>;
 type FullParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
-    readonly [Key in Remaining]: ((...args: FullSnapshotArguments<States, Key, Prefix>) => FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+    readonly [Key in Remaining]: NodeBuilderMethod<States[Key], FullSnapshotArguments<States, Key, Prefix>, FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-    }, Constructed>) & {
-        readonly from: FromCallable<FullSnapshotFromArguments<States, Key, Prefix>, FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
-            readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-        }, true>>;
-    };
+    }, Constructed>, FullSnapshotFromArguments<States, Key, Prefix>, FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
+    }, true>>;
 };
 type HistorySnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotArguments<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     states: (builder: HistoryParallelBuilder<Children, Path, Owner>) => SnapshotBuilderComplete<HistorySnapshotRegions<Children, Path, Owner>>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     state: (builder: HistorySnapshotBuilderWithPrefix<Children, Owner, Path>) => ConstructionResult<HistorySnapshotWithPrefix<Children, Owner, Path>>
-] : never : never;
+]> : never : never;
 type HistorySnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotFromArguments<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     states: (builder: HistoryParallelBuilder<Children, Path, Owner>) => SnapshotBuilderComplete<HistorySnapshotRegions<Children, Path, Owner>, boolean>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     state: (builder: HistorySnapshotBuilderWithPrefix<Children, Owner, Path>) => ConstructionResult<HistorySnapshotWithPrefix<Children, Owner, Path>>
-] : never : never;
+]> : never : never;
 type HistorySnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotResult<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Machine.ParallelSnapshot<Path, Machine.NodeSchema<Node>["Type"], HistorySnapshotRegions<Children, Path, Owner>> : Node extends {
+} ? Machine.ParallelSnapshot<Path, NodeValue<Node>, HistorySnapshotRegions<Children, Path, Owner>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Machine.CompoundSnapshot<Path, Machine.NodeSchema<Node>["Type"], HistorySnapshotWithPrefix<Children, Owner, Path>> : never : never;
-type HistorySnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string> = ((...args: HistorySnapshotArguments<States, StateId, Prefix, Owner>) => HistorySnapshotResult<States, StateId, Prefix, Owner>) & FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>>;
+} ? Machine.CompoundSnapshot<Path, NodeValue<Node>, HistorySnapshotWithPrefix<Children, Owner, Path>> : never : never;
+type HistorySnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string> = Machine.NodeSchema<States[StateId]> extends never ? FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>> : ((...args: HistorySnapshotArguments<States, StateId, Prefix, Owner>) => HistorySnapshotResult<States, StateId, Prefix, Owner>) & FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>>;
 type HistorySnapshotWithPrefix<States extends Machine.StateSchemas, Owner extends string, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? HistorySnapshotResult<States, Key, Prefix, Owner> : never;
 }[ActiveStateKey<States>];
@@ -623,19 +618,15 @@ type HistorySnapshotRegions<States extends Machine.StateSchemas, Prefix extends
     readonly [Key in ActiveStateKey<States>]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? HistorySnapshotResult<States, Key, Prefix, Owner> : FullSnapshotResult<States, Key, Prefix>;
 };
 type HistoryParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Owner extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
-    readonly [Key in Remaining]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? ((...args: HistorySnapshotArguments<States, Key, Prefix, Owner>) => HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+    readonly [Key in Remaining]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? NodeBuilderMethod<States[Key], HistorySnapshotArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
+    }, Constructed>, HistorySnapshotFromArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
-    }, Constructed>) & {
-        readonly from: FromCallable<HistorySnapshotFromArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
-            readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
-        }, true>>;
-    } : ((...args: FullSnapshotArguments<States, Key, Prefix>) => HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+    }, true>> : NodeBuilderMethod<States[Key], FullSnapshotArguments<States, Key, Prefix>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-    }, Constructed>) & {
-        readonly from: FromCallable<FullSnapshotFromArguments<States, Key, Prefix>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
-            readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-        }, true>>;
-    };
+    }, Constructed>, FullSnapshotFromArguments<States, Key, Prefix>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
+    }, true>>;
 };
 type ParentPath<Path extends string> = Path extends `${infer Parent}.${infer Child}` ? Child extends `${string}.${string}` ? `${Parent}.${ParentPath<Child>}` : Parent : never;
 type IsCompoundNode<Node> = Node extends {
@@ -664,19 +655,14 @@ type LocalTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States
 type LocalTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateNodeIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Source extends Path | `${Path}.${string}` ? (<Result extends ConstructionResult<LocalTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
-    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>>;
-} : ((value: Machine.NodeSchema<Node>["Type"], states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? Source extends Path | `${Path}.${string}` ? NestedTargetMethod<Node, LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>> : NodeMethod<Node, WithNodeValue<Node, [
+    states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
+]>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : Node extends {
+]>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? (<Result extends ConstructionResult<LocalTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
-    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>>;
-} : ((value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
-    input: Machine.NodeSchema<Node>["~type.make.in"]
-], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : never;
-type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope extends Machine.StateIdentifier<States>, Source extends Machine.StateNodeIdentifier<States>> = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ? LocalTargetBuilderWithPrefix<States, Children, Scope, Source> & {
+} ? NestedTargetMethod<Node, LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>> : NodeMethod<Node, WithNodeValue<Node, []>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, []>> : never;
+type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope extends Machine.StateIdentifier<States>, Source extends Machine.StateNodeIdentifier<States>> = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ? LocalTargetBuilderWithPrefix<States, Children, Scope, Source> & (Scope extends Machine.ValuedStateIdentifier<States> ? {
     /**
      * Updates the value of the state containing the local group and moves to
      * one of the states inside it. Values in other active branches are kept.
@@ -686,7 +672,7 @@ type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope exten
     readonly with: (<Result extends ConstructionResult<LocalTargetResultWithPrefix<States, Children, Scope>>>(value: Machine.StateByIdentifier<States, Scope>, state: (builder: LocalTargetBuilderWithPrefix<States, Children, Scope, Source>) => Result) => Result) & {
         readonly from: ConstructionSelectorFromCallable<Machine.SchemaByIdentifier<States, Scope>["~type.make.in"], LocalTargetBuilderWithPrefix<States, Children, Scope, Source>, LocalTargetResultWithPrefix<States, Children, Scope>>;
     };
-} : {};
+} : {}) : {};
 type BranchTargetResult<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? States[StateId] extends {
@@ -703,18 +689,13 @@ type BranchTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, State
 type BranchTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateNodeIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Source extends Path | `${Path}.${string}` ? (<Result extends ConstructionResult<BranchTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
-    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>>;
-} & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : ((value: Machine.NodeSchema<Node>["Type"], states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? Source extends Path | `${Path}.${string}` ? NestedTargetMethod<Node, BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>> & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : NodeMethod<Node, WithNodeValue<Node, [
+    states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
+]>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : Node extends {
+]>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? (<Result extends ConstructionResult<BranchTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
-    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>>;
-} & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : ((value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
-    input: Machine.NodeSchema<Node>["~type.make.in"]
-], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : never;
+} ? NestedTargetMethod<Node, BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>> & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : NodeMethod<Node, WithNodeValue<Node, []>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, []>> : never;
 type BranchTargetBuilderForRoot<States extends Machine.StateSchemas, Root extends ActiveStateKey<States>, Source extends Machine.StateNodeIdentifier<States>> = {
     readonly [Key in Root]: BranchTargetMethod<States, States, Key, "", Source>;
 };
@@ -735,13 +716,16 @@ type HasDirectShallowHistory<States extends Machine.StateSchemas> = {
         readonly history: "deep";
     } ? never : Key;
 }[HistoryStateKey<States>] extends never ? false : true;
+type HasValuedActiveChild<States extends Machine.StateSchemas> = {
+    readonly [Key in ActiveStateKey<States>]: Machine.NodeSchema<States[Key]> extends never ? never : Key;
+}[ActiveStateKey<States>] extends never ? false : true;
 type InitializerClosureForNode<AllStates extends Machine.StateSchemas, Node, Path extends string> = Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Extract<Path, Machine.StateIdentifier<AllStates>> | InitializerClosuresForChildren<AllStates, Children, Path> : Node extends {
+} ? (HasValuedActiveChild<Children> extends true ? Extract<Path, Machine.StateIdentifier<AllStates>> : never) | InitializerClosuresForChildren<AllStates, Children, Path> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
     readonly initial: infer Initial;
-} ? Extract<Path, Machine.StateIdentifier<AllStates>> | (Initial extends ActiveStateKey<Children> ? InitializerClosureForNode<AllStates, Children[Initial], Machine.JoinPath<Path, Initial>> : never) : never;
+} ? (Initial extends ActiveStateKey<Children> ? Machine.NodeSchema<Children[Initial]> extends never ? never : Extract<Path, Machine.StateIdentifier<AllStates>> : never) | (Initial extends ActiveStateKey<Children> ? InitializerClosureForNode<AllStates, Children[Initial], Machine.JoinPath<Path, Initial>> : never) : never;
 type InitializerClosuresForChildren<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: InitializerClosureForNode<AllStates, States[Key], Machine.JoinPath<Prefix, Key>>;
 }[ActiveStateKey<States>];
@@ -923,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
@@ -971,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
@@ -983,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`.
@@ -1004,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.
      *
@@ -1240,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.
      *
@@ -1254,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.
      *
@@ -1280,8 +1307,9 @@ export declare namespace Machine {
      * Descriptive annotations exposed for compiled state nodes.
      *
      * Schema-backed states resolve their complete Effect Schema annotation map.
-     * Pseudo-states accept only the descriptive fields below. Annotations never
-     * affect state identity, targeting, or runtime behavior.
+     * Schema-less active states and pseudo-states accept only the descriptive
+     * fields below. Annotations never affect state identity, targeting, or
+     * runtime behavior.
      *
      * @category models
      * @since 0.4.0
@@ -1291,10 +1319,13 @@ export declare namespace Machine {
         readonly description?: string | undefined;
         readonly documentation?: string | undefined;
     }
-    /** Descriptive annotations accepted by schema-less pseudo-states. */
-    type PseudoStateAnnotations = Pick<StateNodeAnnotations, "title" | "description" | "documentation">;
+    /** Descriptive annotations accepted by schema-less active and pseudo-states. */
+    type SchemaLessStateAnnotations = Pick<StateNodeAnnotations, "title" | "description" | "documentation">;
+    /** @deprecated Use {@link SchemaLessStateAnnotations}. */
+    type PseudoStateAnnotations = SchemaLessStateAnnotations;
     /**
-     * Configuration accepted for an atomic object state node.
+     * 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
@@ -1303,35 +1334,63 @@ export declare namespace Machine {
         readonly schema: TaggedSchema;
         readonly type?: "active";
         readonly output?: never;
+        readonly annotations?: never;
     } | {
         readonly schema: TaggedSchema;
         readonly type: "final";
         readonly output?: Schema.Top;
+        readonly annotations?: never;
+    } | {
+        readonly schema?: never;
+        readonly type?: "active";
+        readonly output?: never;
+        readonly annotations?: SchemaLessStateAnnotations;
+    } | {
+        readonly schema?: never;
+        readonly type: "final";
+        readonly output?: Schema.Top;
+        readonly annotations?: SchemaLessStateAnnotations;
     };
     /**
-     * Configuration accepted for a compound object state node.
+     * Configuration accepted for a compound object state node. Omit `schema`
+     * when the compound state exists only to own control topology.
      *
      * @category models
      * @since 0.4.0
      */
-    interface CompoundStateNodeConfig {
+    type CompoundStateNodeConfig = {
         readonly schema: TaggedSchema;
         readonly type?: "active";
         readonly initial: string;
         readonly states: StateTree;
-    }
+        readonly annotations?: never;
+    } | {
+        readonly schema?: never;
+        readonly type?: "active";
+        readonly initial: string;
+        readonly states: StateTree;
+        readonly annotations?: SchemaLessStateAnnotations;
+    };
     /**
-     * Configuration accepted for a parallel object state node.
+     * Configuration accepted for a parallel object state node. Omit `schema`
+     * when the parallel state exists only to own its regions.
      *
      * @category models
      * @since 0.4.0
      */
-    interface ParallelStateNodeConfig {
+    type ParallelStateNodeConfig = {
         readonly schema: TaggedSchema;
         readonly type: "parallel";
         readonly output?: Schema.Top;
         readonly states: StateTree;
-    }
+        readonly annotations?: never;
+    } | {
+        readonly schema?: never;
+        readonly type: "parallel";
+        readonly output?: Schema.Top;
+        readonly states: StateTree;
+        readonly annotations?: SchemaLessStateAnnotations;
+    };
     /**
      * Pseudo-state that restores the last active configuration of its parent.
      *
@@ -1348,7 +1407,7 @@ export declare namespace Machine {
         readonly type: "history";
         /** Defaults to shallow history. */
         readonly history?: "shallow" | "deep";
-        readonly annotations?: PseudoStateAnnotations;
+        readonly annotations?: SchemaLessStateAnnotations;
     }
     /**
      * Transient decision pseudo-state resolved immediately when targeted.
@@ -1362,7 +1421,7 @@ export declare namespace Machine {
      */
     interface ChoiceStateNodeConfig {
         readonly type: "choice";
-        readonly annotations?: PseudoStateAnnotations;
+        readonly annotations?: SchemaLessStateAnnotations;
     }
     /**
      * Configuration accepted for an object state node.
@@ -1431,8 +1490,8 @@ export declare namespace Machine {
          * @since 0.4.0
          */
         readonly get: {
-            <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path): Option.Option<StateByIdentifier<States, Path>>;
-            <const From extends StateIdentifier<States>, const Path extends StateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)): Option.Option<StateByIdentifier<States, Path>>;
+            <Path extends ValuedStateIdentifier<States>>(snapshot: Snapshot<States>, path: Path): Option.Option<StateByIdentifier<States, Path>>;
+            <const From extends StateIdentifier<States>, const Path extends ValuedStateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)): Option.Option<StateByIdentifier<States, Path>>;
         };
         /**
          * Returns the decoded value for an active state path together with all of
@@ -1444,7 +1503,7 @@ export declare namespace Machine {
          *
          * @since 0.4.0
          */
-        readonly getWithParents: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<StateWithParents<States, Path>>;
+        readonly getWithParents: <Path extends ValuedStateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<StateWithParents<States, Path>>;
         /**
          * Returns the snapshot for an active state path. The supplied snapshot may
          * be a complete root snapshot or a snapshot previously extracted from this
@@ -1481,14 +1540,14 @@ export declare namespace Machine {
     interface StateNodeBase<Path extends string = string> {
         readonly path: Path;
         readonly key: string;
-        /** Resolved Effect Schema annotations, or descriptive pseudo-state annotations. */
+        /** Resolved schema annotations, or descriptive schema-less-state annotations. */
         readonly annotations: Readonly<StateNodeAnnotations> | undefined;
         readonly order: number;
     }
     /** Runtime metadata for a compiled atomic state. */
     interface AtomicStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
         readonly type: "atomic";
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: undefined;
         readonly history: undefined;
         readonly parent: ActivePath | undefined;
@@ -1498,7 +1557,7 @@ export declare namespace Machine {
     /** Runtime metadata for a compiled compound state. */
     interface CompoundStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath, ChoicePath extends string = ActivePath> extends StateNodeBase<OwnPath> {
         readonly type: "compound";
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: undefined;
         readonly history: undefined;
         readonly parent: ActivePath | undefined;
@@ -1509,7 +1568,7 @@ export declare namespace Machine {
     /** Runtime metadata for a compiled parallel state. */
     interface ParallelStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
         readonly type: "parallel";
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: Schema.Top | undefined;
         readonly history: undefined;
         readonly parent: ActivePath | undefined;
@@ -1520,7 +1579,7 @@ export declare namespace Machine {
     /** Runtime metadata for a compiled final state. */
     interface FinalStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
         readonly type: "final";
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: Schema.Top | undefined;
         readonly history: undefined;
         readonly parent: ActivePath | undefined;
@@ -1583,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.
@@ -1602,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
@@ -1619,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
@@ -1680,6 +1743,10 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type StateIdentifier<States extends StateSchemas> = StateIdentifierWithPrefix<States>;
+    /** Extracts active state paths whose definitions declare a state value schema. */
+    type ValuedStateIdentifier<States extends StateSchemas> = StateIdentifier<States> extends infer StateId ? StateId extends StateIdentifier<States> ? NodeSchema<NodeByIdentifier<States, StateId>> extends never ? never : StateId : never : never;
+    /** Extracts active state paths whose definitions intentionally omit a state value schema. */
+    type StructuralStateIdentifier<States extends StateSchemas> = Exclude<StateIdentifier<States>, ValuedStateIdentifier<States>>;
     /**
      * Extracts the state path values represented by a state definition under a
      * parent path prefix.
@@ -1807,7 +1874,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type StateByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = Extract<StateOf<States>, SchemaByIdentifier<States, StateId>["Type"]>;
+    type StateByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends ValuedStateIdentifier<States> ? SchemaByIdentifier<States, StateId>["Type"] : undefined;
     /**
      * Extracts every parent state path from a state identifier.
      *
@@ -1829,7 +1896,7 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type ParentStateValues<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? {
-        readonly [Parent in Extract<ParentStateIdentifier<StateId>, StateIdentifier<States>>]: StateByIdentifier<States, Parent>;
+        readonly [Parent in Extract<ParentStateIdentifier<StateId>, ValuedStateIdentifier<States>>]: StateByIdentifier<States, Parent>;
     } : never;
     /**
      * Extracts the nearest parent value, or `undefined` for a root state.
@@ -1837,7 +1904,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type ParentStateValue<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? Extract<ImmediateParentStateIdentifier<StateId>, StateIdentifier<States>> extends infer Parent ? [Parent] extends [never] ? undefined : Parent extends StateIdentifier<States> ? StateByIdentifier<States, Parent> : undefined : undefined : never;
+    type ParentStateValue<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? Extract<ImmediateParentStateIdentifier<StateId>, StateIdentifier<States>> extends infer Parent ? [Parent] extends [never] ? undefined : Parent extends ValuedStateIdentifier<States> ? StateByIdentifier<States, Parent> : undefined : undefined : never;
     /**
      * Represents a decoded state value together with all of its parent values.
      *
@@ -1954,7 +2021,7 @@ export declare namespace Machine {
      */
     interface EncodedSnapshotState {
         readonly path: string;
-        readonly value: unknown;
+        readonly value?: unknown;
     }
     /**
      * Encoded output for one completed state path in a normalized machine
@@ -2103,9 +2170,9 @@ export declare namespace Machine {
     type SnapshotByIdentifierWithPath<States extends StateSchemas, StateId extends ActiveStateKey<States>, Path extends string> = States[StateId] extends {
         readonly type: "parallel";
         readonly states: infer Children;
-    } ? Children extends StateSchemas ? ParallelSnapshot<Path, NodeSchema<States[StateId]>["Type"], SnapshotRegionsWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]> : States[StateId] extends {
+    } ? Children extends StateSchemas ? ParallelSnapshot<Path, NodeValue<States[StateId]>, SnapshotRegionsWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeValue<States[StateId]>> : States[StateId] extends {
         readonly states: infer Children;
-    } ? Children extends StateSchemas ? CompoundSnapshot<Path, NodeSchema<States[StateId]>["Type"], SnapshotWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]>;
+    } ? Children extends StateSchemas ? CompoundSnapshot<Path, NodeValue<States[StateId]>, SnapshotWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeValue<States[StateId]>> : AtomicSnapshot<Path, NodeValue<States[StateId]>>;
     /**
      * Extracts a complete root snapshot whose selected configuration contains a
      * particular active state.
@@ -2190,7 +2257,7 @@ export declare namespace Machine {
         readonly path: StateId;
         readonly value: StateByIdentifier<States, StateId>;
         readonly values?: Partial<{
-            readonly [AncestorStateId in StateIdentifier<States>]: StateByIdentifier<States, AncestorStateId>;
+            readonly [AncestorStateId in ValuedStateIdentifier<States>]: StateByIdentifier<States, AncestorStateId>;
         }>;
     }
     /**
@@ -2349,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
@@ -2361,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.
      *
@@ -2431,7 +2517,7 @@ export declare namespace Machine {
     interface ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>> {
         readonly parent: StateByIdentifier<States, Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>>;
         readonly parents: {
-            readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, StateIdentifier<States>>]: StateByIdentifier<States, Parent>;
+            readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, ValuedStateIdentifier<States>>]: StateByIdentifier<States, Parent>;
         };
         readonly event: LifecycleEvent<Events>;
         readonly target: TargetBuilder<States, ChoiceId>;
@@ -2594,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.
      *
@@ -2649,34 +2743,33 @@ export declare namespace Machine {
      */
     type InvokeEmits<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
-            readonly emits: Types.Covariant<infer Emits>;
+            readonly emits: Types.Covariant<infer Emitted>;
         };
-    } ? 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>;
-        };
-    } ? 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.
      *
@@ -2711,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;
     } ? {
@@ -2819,11 +3020,11 @@ export declare namespace Machine {
         readonly type: "parallel";
         readonly states: infer Children extends StateSchemas;
     } ? {
-        readonly [Key in ActiveStateKey<Children>]: NodeSchema<Children[Key]>["Type"];
+        readonly [Key in ActiveStateKey<Children> as NodeSchema<Children[Key]> extends never ? never : Key]: NodeValue<Children[Key]>;
     } : Node extends {
         readonly states: infer Children extends StateSchemas;
         readonly initial: infer Initial;
-    } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]>["Type"] : never : never : never;
+    } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never : NodeValue<Children[Initial]> : never : never : never;
     /** Context passed to an implicit child-state initializer. */
     type StateInitialContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = StateActionContext<States, Events, Emits, StateId>;
     /** Initial child value implementation for a compound or parallel state. */
@@ -2901,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>;
@@ -3003,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>;
     };
@@ -3012,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>;
@@ -3057,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.
@@ -3133,7 +3334,9 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *
  * The returned `states` property is the same object passed to `defineStates`.
  * The returned `initial` builder creates snapshots without user-authored path
- * strings and enforces compound and parallel initial-state rules.
+ * strings and enforces compound and parallel initial-state rules. Active nodes
+ * may omit `schema` when they own no value; those builders expose `.from(...)`
+ * and still participate fully in targeting, matching, and snapshots.
  *
  * **Example** (Atomic initial snapshot)
  *
@@ -3184,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)
@@ -3237,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`.
@@ -3266,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.
  *
@@ -3359,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.
+ * Preserves inference for a state-owned invocation configuration.
  *
- * **Details**
- *
- * 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
- */
-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
+ * @since 0.9.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;
@@ -3518,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.
  *
@@ -3659,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
@@ -3732,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>>;
@@ -3754,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.
@@ -3818,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
@@ -3854,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
@@ -3977,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.
  *
@@ -3988,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
@@ -4029,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