@typeonce/effect-machine 0.7.0 → 0.9.0

package/src/Machine.ts

@@ -49,6 +49,9 @@ export const TypeId: TypeId = "~effect/Machine"
 
 declare const MachineOutputStatesTypeId: unique symbol
 declare const MachineTypeId: unique symbol
+declare const EventConstructionTypeId: unique symbol
+
+const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId = internal.ChildMachineLogicTypeId
 
 /**
  * Type identifier used for the synthetic event passed to startup lifecycle
@@ -158,7 +161,8 @@ export interface Machine<
   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
    */
@@ -350,7 +354,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.
@@ -370,7 +374,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
@@ -558,7 +562,7 @@ type ValidateStateNode<Node, AllowHistory extends boolean, Path extends Property
       & 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>
+  : 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> = [
@@ -572,27 +576,31 @@ type ValidateChoiceStateNode<Node extends Machine.ChoiceStateNodeConfig> = [
   : StateDefinitionError<"Choice states cannot declare schemas, children, initial states, output, or history">
 
 type ValidateStateNodeConfig<
-  Node extends { readonly schema: Machine.TaggedSchema },
+  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>
+    & ValidatePseudoStateAnnotations<Node, Path>
   : Node extends { readonly type: "final" } ?
       & ValidateExactStateNodeProperties<Node, "final", Path>
       & ValidateStateNodeWithoutChildren<Node>
+      & ValidatePseudoStateAnnotations<Node, Path>
   : Node extends { readonly states: infer Children } ?
       & 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 },
+  Node extends Machine.StateNodeConfig,
   Children,
   Path extends PropertyKey
 > = Children extends Machine.StateSchemas ?
@@ -605,7 +613,7 @@ type ValidateStateNodeWithChildren<
   : StateDefinitionError<"Child states must be a state tree">
 
 type ValidateCompoundStateNode<
-  Node extends { readonly schema: Machine.TaggedSchema },
+  Node extends Machine.StateNodeConfig,
   Children extends Machine.StateSchemas,
   Path extends PropertyKey
 > = Node extends { readonly initial: infer Initial } ?
@@ -615,8 +623,8 @@ type ValidateCompoundStateNode<
   : 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">
+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">
@@ -722,6 +730,56 @@ 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
@@ -751,14 +809,18 @@ type InitialSnapshotMethod<
   States extends Machine.StateSchemas,
   StateId extends ActiveStateKey<States>,
   Prefix extends string
-> =
-  & ((
-    ...args: InitialSnapshotArguments<States, StateId, Prefix>
-  ) => InitialSnapshotResult<States, StateId, Prefix>)
-  & FromMethod<
+> = 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,
@@ -766,21 +828,21 @@ type InitialSnapshotArguments<
   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"],
+  Node extends { readonly type: "parallel"; readonly states: infer Children extends Machine.StateSchemas } ?
+    WithNodeValue<Node, [
       states: (
         builder: InitialParallelBuilder<Children, Path>
       ) => SnapshotBuilderComplete<InitialSnapshotRegionsWithPrefix<Children, Path>>
-    ]
+    ]>
   : 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"],
+    Node extends { readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> } ?
+      WithNodeValue<Node, [
         state: (
           builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>
         ) => InitialSelectableResult<Children, Initial, Path>
-      ]
+      ]>
     : never
-  : [value: Machine.NodeSchema<Node>["Type"]]
+  : WithNodeValue<Node, []>
   : never
 
 type InitialSnapshotFromArguments<
@@ -789,21 +851,21 @@ type InitialSnapshotFromArguments<
   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"],
+  Node extends { readonly type: "parallel"; readonly states: infer Children extends Machine.StateSchemas } ?
+    WithNodeInput<Node, [
       states: (
         builder: InitialParallelBuilder<Children, Path>
       ) => SnapshotBuilderComplete<InitialSnapshotRegionsWithPrefix<Children, Path>, boolean>
-    ]
+    ]>
   : 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"],
+    Node extends { readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> } ?
+      WithNodeInput<Node, [
         state: (
           builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>
         ) => ConstructionResult<InitialSelectableResult<Children, Initial, Path>>
-      ]
+      ]>
     : never
-  : [input: Machine.NodeSchema<Node>["~type.make.in"]]
+  : WithNodeInput<Node, []>
   : never
 
 type InitialSnapshotResult<
@@ -815,18 +877,18 @@ type InitialSnapshotResult<
   Node extends { readonly type: "parallel"; readonly states: infer Children extends Machine.StateSchemas } ?
     Machine.ParallelSnapshot<
       Path,
-      Machine.NodeSchema<Node>["Type"],
+      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"],
+        NodeValue<Node>,
         InitialSelectableResult<Children, Initial, Path>
       >
     : never
-  : Machine.AtomicSnapshot<Path, Machine.NodeSchema<Node>["Type"]>
+  : Machine.AtomicSnapshot<Path, NodeValue<Node>>
   : never
 
 type InitialSelectableResult<
@@ -853,28 +915,25 @@ type InitialParallelBuilder<
 > =
   & SnapshotBuilderComplete<Regions, Constructed>
   & {
-    readonly [Key in Remaining]:
-      & ((
-        ...args: InitialSnapshotArguments<States, Key, Prefix>
-      ) => InitialParallelBuilder<
+    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
-          >
-        >
-      }
+      >,
+      InitialSnapshotFromArguments<States, Key, Prefix>,
+      InitialParallelBuilder<
+        States,
+        Prefix,
+        Exclude<Remaining, Key>,
+        Regions & { readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix> },
+        true
+      >
+    >
   }
 
 type FullSnapshotBuilderWithPrefix<
@@ -892,14 +951,18 @@ type FullSnapshotMethod<
   States extends Machine.StateSchemas,
   StateId extends ActiveStateKey<States>,
   Prefix extends string
-> =
-  & ((
-    ...args: FullSnapshotArguments<States, StateId, Prefix>
-  ) => FullSnapshotResult<States, StateId, Prefix>)
-  & FromMethod<
+> = 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,
@@ -907,21 +970,20 @@ type FullSnapshotArguments<
   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"],
+  Node extends { readonly type: "parallel"; readonly states: infer Children extends Machine.StateSchemas } ?
+    WithNodeValue<Node, [
       states: (
         builder: FullParallelBuilder<Children, Path>
       ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
-    ]
-  : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? [
-      value: Machine.NodeSchema<Node>["Type"],
+    ]>
+  : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? WithNodeValue<Node, [
       state: (
         builder: FullSnapshotBuilderWithPrefix<Children, Path>
       ) =>
         | Machine.SnapshotWithPrefix<Children, Path>
         | Machine.ChoiceTargetInstruction<Machine.ChoiceIdentifierWithPrefix<Children, Path>>
-    ]
-  : [value: Machine.NodeSchema<Node>["Type"]]
+    ]>
+  : WithNodeValue<Node, []>
   : never
 
 type FullSnapshotFromArguments<
@@ -930,22 +992,21 @@ type FullSnapshotFromArguments<
   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"],
+  Node extends { readonly type: "parallel"; readonly states: infer Children extends Machine.StateSchemas } ?
+    WithNodeInput<Node, [
       states: (
         builder: FullParallelBuilder<Children, Path>
       ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-    ]
-  : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? [
-      input: Machine.NodeSchema<Node>["~type.make.in"],
+    ]>
+  : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? 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"]]
+    ]>
+  : WithNodeInput<Node, []>
   : never
 
 type FullSnapshotResult<
@@ -964,28 +1025,25 @@ type FullParallelBuilder<
 > =
   & SnapshotBuilderComplete<Regions, Constructed>
   & {
-    readonly [Key in Remaining]:
-      & ((
-        ...args: FullSnapshotArguments<States, Key, Prefix>
-      ) => FullParallelBuilder<
+    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
-          >
-        >
-      }
+      >,
+      FullSnapshotFromArguments<States, Key, Prefix>,
+      FullParallelBuilder<
+        States,
+        Prefix,
+        Exclude<Remaining, Key>,
+        Regions & { readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix> },
+        true
+      >
+    >
   }
 
 type HistorySnapshotArguments<
@@ -996,18 +1054,17 @@ type HistorySnapshotArguments<
   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"],
+    Node extends { readonly type: "parallel"; readonly states: infer Children extends Machine.StateSchemas } ?
+      WithNodeValue<Node, [
         states: (
           builder: HistoryParallelBuilder<Children, Path, Owner>
         ) => SnapshotBuilderComplete<HistorySnapshotRegions<Children, Path, Owner>>
-      ]
-    : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? [
-        value: Machine.NodeSchema<Node>["Type"],
+      ]>
+    : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? WithNodeValue<Node, [
         state: (
           builder: HistorySnapshotBuilderWithPrefix<Children, Owner, Path>
         ) => ConstructionResult<HistorySnapshotWithPrefix<Children, Owner, Path>>
-      ]
+      ]>
     : never
   : never
 
@@ -1019,18 +1076,17 @@ type HistorySnapshotFromArguments<
   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"],
+    Node extends { readonly type: "parallel"; readonly states: infer Children extends Machine.StateSchemas } ?
+      WithNodeInput<Node, [
         states: (
           builder: HistoryParallelBuilder<Children, Path, Owner>
         ) => SnapshotBuilderComplete<HistorySnapshotRegions<Children, Path, Owner>, boolean>
-      ]
-    : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? [
-        input: Machine.NodeSchema<Node>["~type.make.in"],
+      ]>
+    : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? WithNodeInput<Node, [
         state: (
           builder: HistorySnapshotBuilderWithPrefix<Children, Owner, Path>
         ) => ConstructionResult<HistorySnapshotWithPrefix<Children, Owner, Path>>
-      ]
+      ]>
     : never
   : never
 
@@ -1045,12 +1101,12 @@ type HistorySnapshotResult<
     Node extends { readonly type: "parallel"; readonly states: infer Children extends Machine.StateSchemas } ?
       Machine.ParallelSnapshot<
         Path,
-        Machine.NodeSchema<Node>["Type"],
+        NodeValue<Node>,
         HistorySnapshotRegions<Children, Path, Owner>
       >
     : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? Machine.CompoundSnapshot<
         Path,
-        Machine.NodeSchema<Node>["Type"],
+        NodeValue<Node>,
         HistorySnapshotWithPrefix<Children, Owner, Path>
       >
     : never
@@ -1061,14 +1117,18 @@ type HistorySnapshotMethod<
   StateId extends ActiveStateKey<States>,
   Prefix extends string,
   Owner extends string
-> =
-  & ((
-    ...args: HistorySnapshotArguments<States, StateId, Prefix, Owner>
-  ) => HistorySnapshotResult<States, StateId, Prefix, Owner>)
-  & FromMethod<
+> = 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,
@@ -1117,50 +1177,48 @@ type HistoryParallelBuilder<
   & {
     readonly [Key in Remaining]: Owner extends
       | Machine.JoinPath<Prefix, Key>
-      | `${Machine.JoinPath<Prefix, Key>}.${string}` ?
-        & ((...args: HistorySnapshotArguments<States, Key, Prefix, Owner>) => HistoryParallelBuilder<
+      | `${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
-        >)
-        & {
-          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<
+        >,
+        HistorySnapshotFromArguments<States, Key, Prefix, Owner>,
+        HistoryParallelBuilder<
+          States,
+          Prefix,
+          Owner,
+          Exclude<Remaining, Key>,
+          Regions & { readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner> },
+          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
-            >
-          >
-        }
+        >,
+        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}`
@@ -1245,59 +1303,36 @@ type LocalTargetMethod<
   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"],
+    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>>)
-      & FromMethod<
-        [
-          input: Machine.NodeSchema<Node>["~type.make.in"],
-          states: (
-            builder: FullParallelBuilder<Children, Path>
-          ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-        ],
-        Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>
-      >
-  : 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>>
+      ]>,
+      Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>,
+      WithNodeInput<Node, [
+        states: (
+          builder: FullParallelBuilder<Children, Path>
+        ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
+      ]>
     >
+  : Node extends { readonly states: infer Children extends Machine.StateSchemas } ? 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<
@@ -1306,28 +1341,29 @@ type LocalTargetBuilderForScope<
   Source extends Machine.StateNodeIdentifier<States>
 > = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ?
     & LocalTargetBuilderWithPrefix<States, Children, Scope, Source>
-    & {
-      /**
-       * 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.
-       *
-       * @since 0.4.0
-       */
-      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>
-          >
-        }
-    }
+    & (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.
+         *
+         * @since 0.4.0
+         */
+        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<
@@ -1381,60 +1417,39 @@ type BranchTargetMethod<
 > = 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>
-          >
-        }
+        & NestedTargetMethod<
+          Node,
+          BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>,
+          BranchTargetResultWithPrefix<AllStates, Children, Path>
+        >
         & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>
-    :
-      & ((
-        value: Machine.NodeSchema<Node>["Type"],
+    : NodeMethod<
+      Node,
+      WithNodeValue<Node, [
         states: (
           builder: FullParallelBuilder<Children, Path>
         ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
-      ) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>)
-      & FromMethod<
-        [
-          input: Machine.NodeSchema<Node>["~type.make.in"],
-          states: (
-            builder: FullParallelBuilder<Children, Path>
-          ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-        ],
-        Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>
-      >
+      ]>,
+      Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>,
+      WithNodeInput<Node, [
+        states: (
+          builder: FullParallelBuilder<Children, Path>
+        ) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
+      ]>
+    >
   : 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>
-        >
-      }
+      & NestedTargetMethod<
+        Node,
+        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>>
-    >
+  : NodeMethod<
+    Node,
+    WithNodeValue<Node, []>,
+    Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>,
+    WithNodeInput<Node, []>
+  >
   : never
 
 type BranchTargetBuilderForRoot<
@@ -1471,15 +1486,21 @@ type HasDirectShallowHistory<States extends Machine.StateSchemas> = {
   readonly [Key in HistoryStateKey<States>]: States[Key] extends { 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>>
+    | (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> ? Machine.NodeSchema<Children[Initial]> extends never ? never
+        : Extract<Path, Machine.StateIdentifier<AllStates>>
+        : never)
       | (Initial extends ActiveStateKey<Children> ? InitializerClosureForNode<
           AllStates,
           Children[Initial],
@@ -1750,7 +1771,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
@@ -1812,8 +1834,9 @@ type InvokeLifecycleId = string & { readonly [ChildAddressTypeId]?: never }
  * **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
@@ -1826,6 +1849,9 @@ export interface ChildMachine<Id extends string, M extends Machine.Any> {
 
   /** Complete machine definition carried by this descriptor. */
   readonly machine: M
+
+  /** @internal */
+  readonly [ChildMachineLogicTypeId]: (input?: unknown) => Logic<any, any, any, any, any, any>
 }
 
 /**
@@ -1851,7 +1877,7 @@ export declare namespace ChildMachine {
    */
   export type Ref<Child> = Child extends ChildMachine<string, infer M> ? MachineRef<
       Machine.Snapshot<Machine.States<M>>,
-      Machine.InputEvent<M>,
+      Machine.EventInput<Machine.InputEvent<M>>,
       | Machine.Error<M>
       | ActionError<Machine.Services<M>>
       | InfiniteTransitionError
@@ -2135,6 +2161,13 @@ export declare namespace Machine {
    */
   export type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"]
 
+  /** Extracts the internal event schema tuple carried by a machine definition. */
+  export 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.
    *
@@ -2151,6 +2184,53 @@ export declare namespace Machine {
    */
   export 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.
+   */
+  export 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. */
+  export type EventInput<Event> =
+    | Event
+    | (Event extends { readonly _tag: PropertyKey } ? EventConstruction<Event> : never)
+
+  /** Event inputs accepted for a schema tuple at machine delivery boundaries. */
+  export 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. */
+  export 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.
    *
@@ -2175,8 +2255,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
@@ -2187,14 +2268,18 @@ export declare namespace Machine {
     readonly documentation?: string | undefined
   }
 
-  /** Descriptive annotations accepted by schema-less pseudo-states. */
-  export type PseudoStateAnnotations = Pick<
+  /** Descriptive annotations accepted by schema-less active and pseudo-states. */
+  export type SchemaLessStateAnnotations = Pick<
     StateNodeAnnotations,
     "title" | "description" | "documentation"
   >
 
+  /** @deprecated Use {@link SchemaLessStateAnnotations}. */
+  export 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
@@ -2204,38 +2289,72 @@ 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
    */
-  export interface CompoundStateNodeConfig {
-    readonly schema: TaggedSchema
-    readonly type?: "active"
-    readonly initial: string
-    readonly states: StateTree
-  }
+  export 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
    */
-  export interface ParallelStateNodeConfig {
-    readonly schema: TaggedSchema
-    readonly type: "parallel"
-    readonly output?: Schema.Top
-    readonly states: StateTree
-  }
+  export 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.
@@ -2253,7 +2372,7 @@ export declare namespace Machine {
     readonly type: "history"
     /** Defaults to shallow history. */
     readonly history?: "shallow" | "deep"
-    readonly annotations?: PseudoStateAnnotations
+    readonly annotations?: SchemaLessStateAnnotations
   }
 
   /**
@@ -2268,7 +2387,7 @@ export declare namespace Machine {
    */
   export interface ChoiceStateNodeConfig {
     readonly type: "choice"
-    readonly annotations?: PseudoStateAnnotations
+    readonly annotations?: SchemaLessStateAnnotations
   }
 
   /**
@@ -2349,13 +2468,13 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     readonly get: {
-      <Path extends StateIdentifier<States>>(
+      <Path extends ValuedStateIdentifier<States>>(
         snapshot: Snapshot<States>,
         path: Path
       ): Option.Option<StateByIdentifier<States, Path>>
       <
         const From extends StateIdentifier<States>,
-        const Path extends StateIdentifier<States>
+        const Path extends ValuedStateIdentifier<States>
       >(
         snapshot: SnapshotByIdentifier<States, From>,
         path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)
@@ -2372,7 +2491,7 @@ export declare namespace Machine {
      *
      * @since 0.4.0
      */
-    readonly getWithParents: <Path extends StateIdentifier<States>>(
+    readonly getWithParents: <Path extends ValuedStateIdentifier<States>>(
       snapshot: Snapshot<States>,
       path: Path
     ) => Option.Option<StateWithParents<States, Path>>
@@ -2434,7 +2553,7 @@ export declare namespace Machine {
   export 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
   }
@@ -2444,7 +2563,7 @@ export declare namespace Machine {
     extends StateNodeBase<OwnPath>
   {
     readonly type: "atomic"
-    readonly schema: TaggedSchema
+    readonly schema: TaggedSchema | undefined
     readonly output: undefined
     readonly history: undefined
     readonly parent: ActivePath | undefined
@@ -2459,7 +2578,7 @@ export declare namespace Machine {
     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
@@ -2473,7 +2592,7 @@ export declare namespace Machine {
     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
@@ -2487,7 +2606,7 @@ export declare namespace Machine {
     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
@@ -2580,6 +2699,11 @@ export declare namespace Machine {
     | {
       readonly type: "choice"
     }
+    | {
+      readonly type: "invoke"
+      readonly id: string
+      readonly outcome: "done" | "failure" | "snapshot"
+    }
 
   /**
    * Statically inspectable destination paths for a transition handler.
@@ -2602,10 +2726,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
@@ -2624,9 +2748,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
@@ -2697,6 +2821,19 @@ export declare namespace Machine {
    */
   export type StateIdentifier<States extends StateSchemas> = StateIdentifierWithPrefix<States>
 
+  /** Extracts active state paths whose definitions declare a state value schema. */
+  export 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. */
+  export 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.
@@ -2907,7 +3044,7 @@ export declare namespace Machine {
   export type StateByIdentifier<
     States extends StateSchemas,
     StateId extends StateIdentifier<States>
-  > = Extract<StateOf<States>, SchemaByIdentifier<States, StateId>["Type"]>
+  > = StateId extends ValuedStateIdentifier<States> ? SchemaByIdentifier<States, StateId>["Type"] : undefined
 
   /**
    * Extracts every parent state path from a state identifier.
@@ -2940,7 +3077,7 @@ export declare namespace Machine {
     States extends StateSchemas,
     StateId extends StateIdentifier<States>
   > = StateId extends StateIdentifier<States> ? {
-      readonly [Parent in Extract<ParentStateIdentifier<StateId>, StateIdentifier<States>>]: StateByIdentifier<
+      readonly [Parent in Extract<ParentStateIdentifier<StateId>, ValuedStateIdentifier<States>>]: StateByIdentifier<
         States,
         Parent
       >
@@ -2959,7 +3096,7 @@ export declare namespace Machine {
   > = StateId extends StateIdentifier<States> ?
     Extract<ImmediateParentStateIdentifier<StateId>, StateIdentifier<States>> extends infer Parent
       ? [Parent] extends [never] ? undefined
-      : Parent extends StateIdentifier<States> ? StateByIdentifier<States, Parent>
+      : Parent extends ValuedStateIdentifier<States> ? StateByIdentifier<States, Parent>
       : undefined
     : undefined
     : never
@@ -3144,7 +3281,7 @@ export declare namespace Machine {
    */
   export interface EncodedSnapshotState {
     readonly path: string
-    readonly value: unknown
+    readonly value?: unknown
   }
 
   /**
@@ -3329,17 +3466,17 @@ export declare namespace Machine {
   > = States[StateId] extends { readonly type: "parallel"; readonly states: infer Children }
     ? Children extends StateSchemas ? ParallelSnapshot<
         Path,
-        NodeSchema<States[StateId]>["Type"],
+        NodeValue<States[StateId]>,
         SnapshotRegionsWithPrefix<Children, Path>
       >
-    : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]>
+    : AtomicSnapshot<Path, NodeValue<States[StateId]>>
     : States[StateId] extends { readonly states: infer Children } ? Children extends StateSchemas ? CompoundSnapshot<
           Path,
-          NodeSchema<States[StateId]>["Type"],
+          NodeValue<States[StateId]>,
           SnapshotWithPrefix<Children, Path>
         >
-      : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]>
-    : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]>
+      : AtomicSnapshot<Path, NodeValue<States[StateId]>>
+    : AtomicSnapshot<Path, NodeValue<States[StateId]>>
 
   /**
    * Extracts a complete root snapshot whose selected configuration contains a
@@ -3455,7 +3592,7 @@ export declare namespace Machine {
     readonly value: StateByIdentifier<States, StateId>
     readonly values?: Partial<
       {
-        readonly [AncestorStateId in StateIdentifier<States>]: StateByIdentifier<States, AncestorStateId>
+        readonly [AncestorStateId in ValuedStateIdentifier<States>]: StateByIdentifier<States, AncestorStateId>
       }
     >
   }
@@ -3669,7 +3806,7 @@ export declare namespace Machine {
   }
 
   /**
-   * Context passed to an invoked child process source.
+   * Context passed to a function-valued invocation source.
    *
    * @category models
    * @since 0.4.0
@@ -3687,27 +3824,67 @@ export declare namespace Machine {
   }
 
   /**
-   * 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
    */
-  export interface InvokeSnapshotContext<State, Error, Output> {
+  export 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
    */
-  export interface InvokeDoneContext<Output> {
+  export 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. */
+  export 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.
    *
@@ -3779,7 +3956,7 @@ export declare namespace Machine {
       Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>
     >
     readonly parents: {
-      readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, StateIdentifier<States>>]: StateByIdentifier<
+      readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, ValuedStateIdentifier<States>>]: StateByIdentifier<
         States,
         Parent
       >
@@ -3997,7 +4174,41 @@ export declare namespace Machine {
    * @category utility types
    * @since 0.4.0
    */
-  export type InvokeLogic<Invoke> = Invoke extends { readonly src: (...args: any) => infer Logic } ? Logic : never
+  export 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
+
+  export type InvokeLogic<Invoke> = Invoke extends { 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.
    *
@@ -4049,35 +4260,40 @@ export declare namespace Machine {
    * @since 0.4.0
    */
   export type InvokeEmits<Invoke> = Invoke extends {
-    readonly [InvokeTypeId]: { readonly emits: Types.Covariant<infer Emits> }
-  } ? Emits :
-    never
+    readonly [InvokeTypeId]: { readonly emits: Types.Covariant<infer Emitted> }
+  } ? Emitted
+    : Invoke extends { readonly child: ChildMachine<string, infer M> } ? Emit<M>
+    : never
+  /** Extracts transition results returned by invocation lifecycle handlers. */
+  export 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 events returned by an invoked child snapshot mapper.
+   * Extracts the parent transition error contribution from invoked children.
    *
    * @category utility types
    * @since 0.4.0
    */
-  export type InvokeSnapshotEvent<Invoke> = Invoke extends {
-    readonly [InvokeTypeId]: { readonly snapshotEvent: Types.Covariant<infer Event> }
-  } ? Event :
-    never
+  export type InvokeError<Config> = [InvokeReturn<Config>] extends [never] ? never
+    :
+      | ChildAlreadyExistsError
+      | InvokeInitialError<InvokeReturn<Config>>
+      | Effect.Error<InvokeOutcomeReturn<InvokeReturn<Config>>>
   /**
-   * Extracts the parent transition error contribution from invoked children.
-   *
-   * @category utility types
-   * @since 0.4.0
-   */
-  export type InvokeError<Config> = [InvokeReturn<Config>] extends [never] ? never
-    : ChildAlreadyExistsError | InvokeInitialError<InvokeReturn<Config>> | InvokeRuntimeError<InvokeReturn<Config>>
-  /**
-   * Extracts the parent service requirement contribution from invoked children.
+   * Extracts the parent service requirement contribution from invoked children.
    *
    * @category utility types
    * @since 0.4.0
    */
   export type InvokeRequirements<Config> = [InvokeReturn<Config>] extends [never] ? never
-    : MachineRuntimeRequirement | InvokeServices<InvokeReturn<Config>>
+    :
+      | MachineRuntimeRequirement
+      | InvokeServices<InvokeReturn<Config>>
+      | Effect.Services<
+        InvokeOutcomeReturn<InvokeReturn<Config>>
+      >
   /**
    * Extracts the return value from an eventless transition.
    *
@@ -4123,106 +4339,436 @@ export declare namespace Machine {
     | Effect.Services<ChoiceReturn<Config>>
     | InvokeRequirements<Config>
 
-  /**
-   * Configuration for invoking a child process while a state is active.
-   *
-   * @category models
-   * @since 0.4.0
-   */
-  export interface InvokeConfig<
+  export type InvokeTransition<
     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>
+    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>
     }
-    /** @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
+
+  export 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 */
-  export 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. */
+  export 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. */
+  export 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
-  }
+  export 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 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
-   */
+  /** State-bound inline invocation configuration. */
   export 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>)
+    | 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 }
+
+  export type InvokeDoneRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
+    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onDone: Required }
+    : { readonly onDone?: never }
+    : never
+
+  export type InvokeFailureRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends
+    infer Requirement ? Requirement extends { readonly handler: infer Required } ? { readonly onFailure: Required }
+    : { readonly onFailure?: never }
+    : never
+
+  export 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>>>
+      >
+    >
+
+  export 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>
+    >
+  }
+
+  export 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>>
+    >
+
+  export type ChildInvokeArgs<
+    States extends StateSchemas,
+    Events extends ReadonlyArray<TaggedSchema>,
+    Emits extends ReadonlyArray<TaggedSchema>,
+    StateId extends StateIdentifier<States>,
+    ChildDefinition extends Machine.Any,
+    Child extends ChildMachine<string, ChildDefinition>
+  > =
+    & {
+      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>>
+        >
+      >
+    >
+
+  export type LogicStateOf<Value> = Value extends Logic<infer State, any, any, any, any, any> ? State : never
+  export type LogicEventOf<Value> = Value extends Logic<any, infer Event, any, any, any, any> ? Event : never
+  export type LogicErrorOf<Value> = Value extends Logic<any, any, infer Error, any, any, any> ? Error : never
+  export type LogicServicesOf<Value> = Value extends Logic<any, any, any, infer Services, any, any> ? Services : never
+  export type LogicOutputOf<Value> = Value extends Logic<any, any, any, any, infer Output, any> ? Output : never
+  export 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,
@@ -4328,10 +4874,14 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>
   > = NodeByIdentifier<States, StateId> extends infer Node ?
     Node extends { readonly type: "parallel"; readonly states: infer Children extends StateSchemas } ? {
-        readonly [Key in ActiveStateKey<Children>]: 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
+      Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never
+        : NodeValue<Children[Initial]>
+      : never
     : never
     : never
 
@@ -4504,6 +5054,39 @@ export declare namespace Machine {
     : 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
+  >
+
   // Rebuild the public nested handler shape so branded validation errors stay
   // attached to the exact property that introduced them.
   type HandlerValidationAtPath<Path extends string, Validation> = Path extends `${infer Head}.${infer Rest}` ? {
@@ -4818,9 +5401,7 @@ export declare namespace Machine {
         & 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>
@@ -4849,20 +5430,6 @@ export declare namespace Machine {
     }
     : 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,
@@ -4877,21 +5444,6 @@ export declare namespace Machine {
       >
     }
 
-  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>,
@@ -5095,6 +5647,7 @@ export declare namespace Machine {
     <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(
       config:
         & Config
+        & HandlerInvokeContexts<States, Events, Emits, NoInfer<Config>>
         & HandlerTreeValidation<
           States,
           Events,
@@ -5303,7 +5856,9 @@ export const isFinal: <
  *
  * 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)
  *
@@ -5414,8 +5969,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)
@@ -5469,6 +6024,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`.
@@ -5504,12 +6062,49 @@ export const event: <const M extends Machine.Any, const EventSchema extends Mach
 ) => EventSchema["Type"] = internal.event
 
 /**
- * Encodes a decoded machine snapshot into a normalized data representation.
+ * Returns deferred constructors for every public event in a machine protocol.
  *
- * **When to use**
+ * 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.
  *
- * Use when you need to store or transport a statechart snapshot independently
- * of its local machine runtime.
+ * **Example**
+ *
+ * ```ts
+ * const Event = Machine.events(counter)
+ * yield* ref.send(Event.Increment({ by: 1 }))
+ * ```
+ *
+ * @category constructors
+ * @since 0.9.0
+ */
+export const events: <const M extends Machine.Any>(
+  machine: M
+) => Machine.EventConstructors<Machine.InputEvents<M>> = internal.events
+
+/**
+ * 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 const internalEvents: <const M extends Machine.Any>(
+  machine: M
+) => Machine.EventConstructors<Machine.InternalEvents<M>> = internal.internalEvents
+
+/**
+ * Encodes a decoded machine snapshot into a normalized data representation.
+ *
+ * **When to use**
+ *
+ * Use when you need to store or transport a statechart snapshot independently
+ * of its local machine runtime.
  *
  * **Details**
  *
@@ -5668,63 +6263,231 @@ export const decodeSnapshot: <
   Machine.SnapshotDecodingServices<States>
 > = internal.decodeSnapshot
 
+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 effect: Source
+  readonly after?: never
+  readonly logic?: never
+  readonly child?: never
+  readonly address?: never
+  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
+
 /**
- * Creates an invoked child process configuration for an active state.
+ * Preserves inference for a state-owned invocation configuration.
  *
- * **When to use**
+ * 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.
  *
- * 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)
+ * 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.invoke({
+ * invoke: Machine.invoke({
  *   id: "load",
- *   src: () => Machine.effect(Effect.succeed(new Loaded({ value: "ready" })))
+ *   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 effect} for one-shot child effects.
- * @see {@link spawn} for children whose lifetime is controlled by actions.
  * @category constructors
- * @since 0.4.0
+ * @since 0.9.0
  */
-export const invoke: <
-  ChildState,
-  ChildEvent,
-  ChildError = never,
-  ChildRequirements = never,
-  ChildOutput = never,
-  ChildInitialError = never,
-  Event = never,
-  Address extends ChildAddress<never> | undefined = undefined
->(
-  config:
-    & {
-      readonly id: InvokeLifecycleId
-      readonly src: () => Logic<
+export const invoke: {
+  <
+    const States extends Machine.StateSchemas,
+    const Events extends ReadonlyArray<Machine.TaggedSchema>,
+    const Emits extends ReadonlyArray<Machine.TaggedSchema>,
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId>
+    ) => 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,
@@ -5732,136 +6495,73 @@ export const invoke: <
         ChildOutput,
         ChildInitialError
       >
-      readonly snapshot?: (
-        context: Machine.InvokeSnapshotContext<ChildState, ChildError, ChildOutput>
-      ) => Event | undefined
-    }
-    & ([Address] extends [undefined] ? {
-        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
-> = internal.invoke
-
-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
-      }
-  )
-
-/**
- * Invokes one Effect and maps its typed outcome into machine-local events.
- *
- * **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.
- *
- * Declare mapped outcomes in `internalEvents` unless they are also legitimate
- * public commands.
- *
- * **Example**
- *
- * ```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({
- *   id: "load",
- *   effect: Effect.succeed("ready"),
- *   onSuccess: (value) => new Loaded({ value })
- * })
- * ```
- *
- * @see {@link invoke} for arbitrary child process logic.
- * @see {@link after} for a state-scoped delayed event.
- * @category constructors
- * @since 0.4.0
- */
-export 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)
-> = internal.invokeEffect
-
-/**
- * Creates a cancellable state-scoped delayed event.
- *
- * The timer starts when its owning state is entered and is interrupted when
- * that state exits. The delayed value should normally be declared in
- * `internalEvents`.
- *
- * **Example**
- *
- * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class TimedOut extends Schema.TaggedClass<TimedOut>("TimedOut")("TimedOut", {}) {}
- *
- * const timeout = Machine.after("5 seconds", new TimedOut({}))
- * ```
- *
- * @category constructors
- * @since 0.4.0
- */
-export const after: <Event extends { readonly _tag: PropertyKey }>(
-  duration: Duration.Input,
-  event: Event,
-  options?: { readonly id?: InvokeLifecycleId }
-) => InvokeEffectResult<never, Event> = internal.after
-
+    >
+  ):
+    & 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"]>
+    >
+} = ((config: unknown) => config) as any
 type RetagFields<Target extends Machine.TaggedSchema> = Omit<Target["~type.make.in"], "_tag">
 
 type RetagTargetCompatibility<Target extends Machine.TaggedSchema> = Target extends {
@@ -5913,195 +6613,6 @@ export const retag: <const Target extends Machine.TaggedSchema, const Source ext
   ...args: RetagArgs<Target, Source>
 ) => Target["Type"] = internal.retag
 
-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 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>
-  >
-} = internal.invokeMachine
-
 /**
  * Plans the initial state for a machine without executing actor commands.
  *
@@ -6263,10 +6774,9 @@ export const transitionDefinitions: <M extends Machine.Any>(machine: M) => Reado
  *
  * **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
@@ -6414,7 +6924,7 @@ export const plan: <
     >
     & EnsureExecutable<States, UnhandledStates, OutputStates>,
   state: Machine.Snapshot<States>,
-  event: Machine.EventOf<InputEvents>
+  event: Machine.EventInputOf<InputEvents>
 ) => Effect.Effect<
   & {
     readonly next: Machine.Snapshot<States>
@@ -6452,52 +6962,6 @@ export const plan: <
   never
 > = internal.plan
 
-/**
- * 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 const effect: <Output, Error = never, Requirements = never>(
-  effect: Effect.Effect<Output, Error, Requirements>
-) => Logic<void, never, Error, Requirements, Output> = internal.effect
-
 /**
  * Creates advanced stateful process logic from explicit initialization and
  * execution methods.
@@ -6519,9 +6983,9 @@ export const effect: <Output, Error = never, Requirements = never>(
  * 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
@@ -6570,7 +7034,7 @@ export const logic: <
  * )
  * ```
  *
- * @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
@@ -6783,7 +7247,7 @@ export const start: <
 ) => Effect.Effect<
   MachineRef<
     Machine.Snapshot<States>,
-    Machine.EventOf<InputEvents>,
+    Machine.EventInputOf<InputEvents>,
     | E
     | ActionError<R>
     | InfiniteTransitionError
@@ -6815,8 +7279,8 @@ export const start: <
  * 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
@@ -6892,7 +7356,7 @@ export const resume: <
 ) => Effect.Effect<
   MachineRef<
     Machine.Snapshot<States>,
-    Machine.EventOf<InputEvents>,
+    Machine.EventInputOf<InputEvents>,
     | E
     | ActionError<R>
     | InfiniteTransitionError