@typeonce/effect-machine 0.10.0 → 0.12.0

package/src/Machine.ts

@@ -175,18 +175,18 @@ export interface Machine<
   >
 
   /**
-   * Ephemeral outward notifications published to this actor's observers.
-   * Emissions are never delivered implicitly to an owning actor.
+   * Ephemeral outward notifications published to this machine's observers.
+   * Emissions are never delivered implicitly to an owning machine.
    *
    * @since 0.4.0
    */
   readonly emittedEvents: Machine.EventProtocol<"emitted", Emits>
 
   /**
-   * Public input events accepted by an owning actor when this machine is
+   * Public input events accepted by an owning machine when this machine is
    * running as a child.
    *
-   * The protocol types the optional `parent` actor reference exposed to
+   * The protocol types the optional `parent` machine target exposed to
    * handlers and is checked against a concrete parent's public events at
    * composition boundaries.
    *
@@ -246,6 +246,15 @@ export interface Machine<
     ParentEvents
   >
 
+  /**
+   * Preserves invocation inference with this machine's public input and parent
+   * protocols. Prefer this bound constructor when an invocation source or
+   * lifecycle handler uses `self` or `parent`.
+   *
+   * @since 0.11.0
+   */
+  readonly invoke: Invoker<States, Events, Emits, InputEvents, ParentEvents>
+
   /** @internal */
   readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
 }
@@ -378,7 +387,7 @@ export interface Runtime<in Events, in Emits> {
   readonly raise: (event: Machine.EventInput<Events>) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>
 
   /**
-   * Publishes an ephemeral notification to the running actor's observers.
+   * Publishes an ephemeral notification to the running machine's observers.
    *
    * @since 0.4.0
    */
@@ -388,37 +397,37 @@ export interface Runtime<in Events, in Emits> {
 }
 
 /**
- * Minimal typed reference accepted by targeted actor commands.
+ * Minimal typed target accepted by inter-machine send commands.
  *
  * @category models
- * @since 0.10.0
+ * @since 0.12.0
  */
-export interface ActorRef<in Event> {
+export interface MachineTarget<in Event> {
   readonly id: string
   readonly sessionId: string
   readonly send: (event: Event) => Effect.Effect<void, StoppedError>
 }
 
 /**
- * Actor references available while evaluating machine behavior.
+ * Machine targets available while evaluating machine behavior.
  *
  * @category models
- * @since 0.10.0
+ * @since 0.12.0
  */
-export interface ActorContext<
+export interface MachineReferences<
   InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
   ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
 > {
-  /** Reference to the current actor. Sending queues a later mailbox event. */
-  readonly self: ActorRef<Machine.EventInputOf<InputEvents>>
+  /** Target for the current machine. Sending queues a later mailbox event. */
+  readonly self: MachineTarget<Machine.EventInputOf<InputEvents>>
 
-  /** Reference to the owning actor, or `undefined` when running as a root. */
-  readonly parent: ActorRef<Machine.EventInputOf<ParentEvents>> | undefined
+  /** Target for the owning machine, or `undefined` when running as a root. */
+  readonly parent: MachineTarget<Machine.EventInputOf<ParentEvents>> | undefined
 }
 
 /**
  * Synchronous commands available while a machine transition is being
- * selected. Enqueuing only records statechart and actor operations; it never
+ * selected. Enqueuing only records statechart and machine operations; it never
  * executes an Effect.
  *
  * @category models
@@ -428,12 +437,12 @@ export interface Enqueue<in Events, in Emits> {
   /** Raises an event inside the current macrostep. */
   readonly raise: (event: Machine.EventInput<Events>) => void
 
-  /** Publishes an ephemeral notification to this actor's observers. */
+  /** Publishes an ephemeral notification to this machine's observers. */
   readonly emit: (event: Machine.EmittedEventInput<Emits>) => void
 
   /** Sends an event to an invoked child after the transition is selected. */
   readonly sendTo: {
-    <Event>(target: ActorRef<Event>, event: Event): void
+    <Event>(target: MachineTarget<Event>, event: Event): void
     <Child extends ChildMachine.Any>(child: Child, event: ChildMachine.Event<Child>): void
     <Address extends ChildAddress<never>>(child: Address, event: ChildAddress.Event<Address>): void
   }
@@ -446,7 +455,7 @@ export interface Enqueue<in Events, in Emits> {
 }
 
 /**
- * A closed actor command recorded by a synchronous machine transition.
+ * A closed machine command recorded by a synchronous transition.
  *
  * @category models
  * @since 0.4.0
@@ -454,7 +463,7 @@ export interface Enqueue<in Events, in Emits> {
 export type Command =
   | {
     readonly _tag: "SendTo"
-    readonly target: ActorRef<unknown> | ChildMachine.Any | ChildAddress<never>
+    readonly target: MachineTarget<unknown> | ChildMachine.Any | ChildAddress<never>
     readonly event: unknown
   }
   | {
@@ -1694,6 +1703,33 @@ export type RuntimeOutcome<State, Error = never, Output = never> =
     readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, { readonly status: "stopped" }>
   }
 
+/**
+ * A fresh machine whose observable streams exist before initialization.
+ *
+ * Subscribe to `emissions` before evaluating `start` when initial-entry
+ * emissions must be observed. `start` is one-shot: concurrent and repeated
+ * evaluations share the same initialization and running reference.
+ *
+ * @category models
+ * @since 0.11.0
+ */
+export interface Prepared<out State, in Event, out Error, out Output, out Emitted, out StartError, StartRequirements> {
+  /** Stable machine definition id, or a generated fallback when none was declared. */
+  readonly id: string
+
+  /** Unique identity reserved for this prepared machine instance. */
+  readonly sessionId: string
+
+  /** Waits for startup, then streams the initial lifecycle snapshot and later changes. */
+  readonly changes: Stream.Stream<RuntimeSnapshot<State, Error, Output>, StartError>
+
+  /** Streams ephemeral notifications published after subscription. */
+  readonly emissions: Stream.Stream<Emitted>
+
+  /** Initializes this machine once and returns its running reference. */
+  readonly start: Effect.Effect<MachineRef<State, Event, Error, Output, Emitted>, StartError, StartRequirements>
+}
+
 /**
  * Provides access to a running machine's state, lifecycle, event input, and
  * termination operations.
@@ -1709,7 +1745,7 @@ export type RuntimeOutcome<State, Error = never, Output = never> =
  * @since 0.4.0
  */
 export interface MachineRef<out State, in Event, out Error = never, out Output = never, out Emitted = never>
-  extends ActorRef<Event>
+  extends MachineTarget<Event>
 {
   /** Stable machine definition id, or a generated fallback when none was declared. */
   readonly id: string
@@ -1728,7 +1764,7 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
 
   /**
    * Streams ephemeral notifications published after subscription. Emissions
-   * are not retained or replayed; the stream completes when the actor stops.
+   * are not retained or replayed; the stream completes when the machine stops.
    */
   readonly emissions: Stream.Stream<Emitted>
 
@@ -1856,9 +1892,9 @@ export declare namespace Logic {
     /** Starts a child process owned by this scope. */
     readonly spawn: Spawn
 
-    /** Sends an event to an actor reference or typed parent-local child address. */
+    /** Sends an event to a machine target or typed parent-local child address. */
     readonly sendTo: {
-      <TargetEvent>(target: ActorRef<TargetEvent>, event: TargetEvent): Effect.Effect<void, StoppedError>
+      <TargetEvent>(target: MachineTarget<TargetEvent>, event: TargetEvent): Effect.Effect<void, StoppedError>
       <Address extends ChildAddress<never>>(
         id: Address,
         event: ChildAddress.Event<Address>
@@ -2128,6 +2164,8 @@ export declare namespace Machine {
     /** @internal */
     readonly handle: any
     /** @internal */
+    readonly invoke: any
+    /** @internal */
     readonly initial: any
   }
 
@@ -2238,7 +2276,7 @@ export declare namespace Machine {
    */
   export type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"]
 
-  /** Extracts the public input protocol required from an owning actor. */
+  /** Extracts the public input protocol required from an owning machine. */
   export type ParentEvents<M extends Any> = M[typeof MachineTypeId]["parentEvents"]
 
   /** Extracts an internal event schema tuple from the complete and public protocols. */
@@ -3973,7 +4011,7 @@ export declare namespace Machine {
     R,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4003,7 +4041,7 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4023,7 +4061,7 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4046,7 +4084,7 @@ export declare namespace Machine {
     Output,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4069,7 +4107,7 @@ export declare namespace Machine {
     Output,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4088,7 +4126,7 @@ export declare namespace Machine {
     Error,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4111,7 +4149,7 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4142,7 +4180,7 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4169,7 +4207,7 @@ export declare namespace Machine {
     ChoiceId extends ChoiceIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly containingState: StateByIdentifier<
       States,
       Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>
@@ -4616,13 +4654,18 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
     & InvokeOwned<States, Events, Emits, StateId>
     & (
       | {
         readonly id: string
-        readonly effect: InvokeSource<Effect.Effect<any, any, any>, InvokeContext<States, Events, Emits, StateId>>
+        readonly effect: InvokeSource<
+          Effect.Effect<any, any, any>,
+          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        >
         readonly after?: never
         readonly logic?: never
         readonly child?: never
@@ -4633,7 +4676,10 @@ export declare namespace Machine {
       }
       | {
         readonly id: string
-        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>
+        readonly after: InvokeSource<
+          Duration.Input,
+          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        >
         readonly effect?: never
         readonly logic?: never
         readonly child?: never
@@ -4645,7 +4691,10 @@ export declare namespace Machine {
       | {
         readonly id: string
         readonly address: string
-        readonly logic: InvokeSource<AnyLogicSource, InvokeContext<States, Events, Emits, StateId>>
+        readonly logic: InvokeSource<
+          AnyLogicSource,
+          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        >
         readonly effect?: never
         readonly after?: never
         readonly child?: never
@@ -4655,7 +4704,10 @@ export declare namespace Machine {
       }
       | {
         readonly child: ChildMachine.Any
-        readonly input?: {} | null | ((context: InvokeContext<States, Events, Emits, StateId>) => unknown)
+        readonly input?:
+          | {}
+          | null
+          | ((context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown)
         readonly id?: never
         readonly address?: never
         readonly effect?: never
@@ -4672,10 +4724,16 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
-    | InvokeConfig<States, Events, Emits, StateId>
-    | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId>>
+    | InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>
+
+  type TypedInvokeDefinition =
+    | InvokeTyped<any, any, any, any, any, any>
+    | ReadonlyArray<InvokeTyped<any, any, any, any, any, any>>
 
   type InvokeHandlerRequirement<Value, Handler> = IsAny<Value> extends true ? { readonly handler: Handler }
     : [Value] extends [never] ? { readonly handler?: never }
@@ -4697,7 +4755,9 @@ export declare namespace Machine {
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     Fx extends Effect.Effect<any, any, any>,
-    Source = Fx
+    Source = Fx,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
     & {
       readonly id: InvokeLifecycleId
@@ -4714,7 +4774,15 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
-        InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<NoInfer<Fx>>>
+        InvokeDoneContext<
+          States,
+          Events,
+          Emits,
+          StateId,
+          Effect.Success<NoInfer<Fx>>,
+          InputEvents,
+          ParentEvents
+        >
       >
     >
     & InvokeFailureRequirement<
@@ -4723,7 +4791,15 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
-        InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<NoInfer<Fx>>>
+        InvokeFailureContext<
+          States,
+          Events,
+          Emits,
+          StateId,
+          Effect.Error<NoInfer<Fx>>,
+          InputEvents,
+          ParentEvents
+        >
       >
     >
 
@@ -4731,10 +4807,15 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = {
     readonly id: InvokeLifecycleId
-    readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>
+    readonly after: InvokeSource<
+      Duration.Input,
+      InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    >
     readonly effect?: never
     readonly logic?: never
     readonly child?: never
@@ -4745,7 +4826,7 @@ export declare namespace Machine {
       States,
       Events,
       Emits,
-      InvokeDoneContext<States, Events, Emits, StateId, void>
+      InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
     >
   }
 
@@ -4761,7 +4842,9 @@ export declare namespace Machine {
     ChildOutput,
     ChildInitialError,
     Address extends ChildAddress<never>,
-    Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>
+    Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
     & {
       readonly id: InvokeLifecycleId
@@ -4774,16 +4857,36 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
-        InvokeSnapshotContext<States, Events, Emits, StateId, ChildState, ChildError, ChildOutput>
+        InvokeSnapshotContext<
+          States,
+          Events,
+          Emits,
+          StateId,
+          ChildState,
+          ChildError,
+          ChildOutput,
+          InputEvents,
+          ParentEvents
+        >
       >
     }
     & InvokeDoneRequirement<
       ChildOutput,
-      InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, ChildOutput>>
+      InvokeTransition<
+        States,
+        Events,
+        Emits,
+        InvokeDoneContext<States, Events, Emits, StateId, ChildOutput, InputEvents, ParentEvents>
+      >
     >
     & InvokeFailureRequirement<
       ChildError,
-      InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, ChildError>>
+      InvokeTransition<
+        States,
+        Events,
+        Emits,
+        InvokeFailureContext<States, Events, Emits, StateId, ChildError, InputEvents, ParentEvents>
+      >
     >
 
   export type ChildInvokeArgs<
@@ -4792,7 +4895,9 @@ export declare namespace Machine {
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     ChildDefinition extends Machine.Any,
-    Child extends ChildMachine<string, ChildDefinition>
+    Child extends ChildMachine<string, ChildDefinition>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
     & {
       readonly child:
@@ -4819,12 +4924,17 @@ export declare namespace Machine {
           StateId,
           Snapshot<Machine.States<ChildDefinition>>,
           Error<ChildDefinition>,
-          Output<ChildDefinition>
+          Output<ChildDefinition>,
+          InputEvents,
+          ParentEvents
         >
       >
     }
     & (Input<ChildDefinition> extends typeof Schema.Void ? { readonly input?: never } : {
-      readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>
+      readonly input: InvokeSource<
+        Input<ChildDefinition>["Type"],
+        InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+      >
     })
     & InvokeDoneRequirement<
       Output<ChildDefinition>,
@@ -4832,7 +4942,15 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
-        InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>>
+        InvokeDoneContext<
+          States,
+          Events,
+          Emits,
+          StateId,
+          Output<ChildDefinition>,
+          InputEvents,
+          ParentEvents
+        >
       >
     >
     & InvokeFailureRequirement<
@@ -4846,7 +4964,9 @@ export declare namespace Machine {
           Events,
           Emits,
           StateId,
-          Error<ChildDefinition> | ActionError<Services<ChildDefinition>>
+          Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
+          InputEvents,
+          ParentEvents
         >
       >
     >
@@ -4863,6 +4983,8 @@ export declare namespace Machine {
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Raw
   > = Raw extends InvokeTyped<any, any, any, any, any> ? unknown
     : Raw extends { readonly effect: infer Source } ?
@@ -4873,7 +4995,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>>
+              InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>, InputEvents, ParentEvents>
             >
           >
           & InvokeFailureRequirement<
@@ -4882,7 +5004,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>>
+              InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>
             >
           >
           & { readonly onSnapshot?: never }
@@ -4892,7 +5014,7 @@ export declare namespace Machine {
           States,
           Events,
           Emits,
-          InvokeDoneContext<States, Events, Emits, StateId, void>
+          InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
         >
         readonly onFailure?: never
         readonly onSnapshot?: never
@@ -4905,7 +5027,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>>
+              InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>, InputEvents, ParentEvents>
             >
           >
           & InvokeFailureRequirement<
@@ -4914,7 +5036,15 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeFailureContext<States, Events, Emits, StateId, InvokeRuntimeError<Raw>>
+              InvokeFailureContext<
+                States,
+                Events,
+                Emits,
+                StateId,
+                InvokeRuntimeError<Raw>,
+                InputEvents,
+                ParentEvents
+              >
             >
           >
           & {
@@ -4935,7 +5065,9 @@ export declare namespace Machine {
                 StateId,
                 ChildLogic extends Logic<infer ChildState, any, any, any, any, any> ? ChildState : never,
                 InvokeRuntimeError<Raw>,
-                InvokeOutput<Raw>
+                InvokeOutput<Raw>,
+                InputEvents,
+                ParentEvents
               >
             >
           }
@@ -4948,7 +5080,15 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>>
+              InvokeDoneContext<
+                States,
+                Events,
+                Emits,
+                StateId,
+                Output<ChildDefinition>,
+                InputEvents,
+                ParentEvents
+              >
             >
           >
           & InvokeFailureRequirement<
@@ -4962,12 +5102,17 @@ export declare namespace Machine {
                 Events,
                 Emits,
                 StateId,
-                Error<ChildDefinition> | ActionError<Services<ChildDefinition>>
+                Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
+                InputEvents,
+                ParentEvents
               >
             >
           >
           & (Input<ChildDefinition> extends typeof Schema.Void ? { readonly input?: never } : {
-            readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>
+            readonly input: InvokeSource<
+              Input<ChildDefinition>["Type"],
+              InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+            >
           })
           & {
             readonly onSnapshot?: InvokeTransition<
@@ -4981,7 +5126,9 @@ export declare namespace Machine {
                 StateId,
                 Snapshot<Machine.States<ChildDefinition>>,
                 Error<ChildDefinition>,
-                Output<ChildDefinition>
+                Output<ChildDefinition>,
+                InputEvents,
+                ParentEvents
               >
             >
           }
@@ -4993,11 +5140,21 @@ export declare namespace Machine {
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Raw
   > = Raw extends ReadonlyArray<any> ? {
-      readonly [Index in keyof Raw]: ContextualInvokeConfig<States, Events, Emits, StateId, Raw[Index]>
+      readonly [Index in keyof Raw]: ContextualInvokeConfig<
+        States,
+        Events,
+        Emits,
+        StateId,
+        InputEvents,
+        ParentEvents,
+        Raw[Index]
+      >
     }
-    : ContextualInvokeConfig<States, Events, Emits, StateId, Raw>
+    : ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw>
 
   type OutputHandlerConfig<
     States extends StateSchemas,
@@ -5049,7 +5206,9 @@ export declare namespace Machine {
       context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
       enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
     ) => StateActionResult<any, any>
-    readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>
+    readonly invoke?:
+      | InvokeDefinition<States, Events, Emits, StateId, InputEvents, ParentEvents>
+      | TypedInvokeDefinition
     readonly always?:
       | ((
         context: AlwaysContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
@@ -5300,14 +5459,26 @@ export declare namespace Machine {
   type HandlerInvokeContextAtPath<
     AllStates extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Config,
     StateId extends StateNodeIdentifier<AllStates>,
     NodeConfig = HandlerConfigAtPath<Config, StateId>
   > = StateId extends StateIdentifier<AllStates> ?
     NodeConfig extends { readonly invoke: infer Invoke } ? HandlerValidationAtPath<
         StateId,
-        { readonly invoke: ContextualInvokeDefinition<AllStates, Events, Emits, StateId, Invoke> }
+        {
+          readonly invoke: ContextualInvokeDefinition<
+            AllStates,
+            Events,
+            Emits,
+            StateId,
+            InputEvents,
+            ParentEvents,
+            Invoke
+          >
+        }
       >
     : unknown
     : unknown
@@ -5315,14 +5486,18 @@ export declare namespace Machine {
   type HandlerInvokeContexts<
     AllStates extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Config
   > = Types.UnionToIntersection<
     StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ?
       StateId extends StateNodeIdentifier<AllStates> ? HandlerInvokeContextAtPath<
           AllStates,
           Events,
+          InputEvents,
           Emits,
+          ParentEvents,
           Config,
           StateId
         >
@@ -5919,7 +6094,7 @@ export declare namespace Machine {
     >(
       config:
         & Config
-        & HandlerInvokeContexts<States, Events, Emits, NoInfer<Config>>
+        & HandlerInvokeContexts<States, Events, InputEvents, Emits, ParentEvents, NoInfer<Config>>
         & HandlerTreeValidation<
           States,
           Events,
@@ -6256,7 +6431,7 @@ interface Make {
  * adds raised events and other machine-local deliveries.
  * `Machine.emittedEvents` defines outward ephemeral notifications, while
  * `parentEvents` declares the inputs a child may explicitly send to its owning
- * actor. All descriptors expose deferred constructors while retaining their
+ * machine. All descriptors expose deferred constructors while retaining their
  * schemas opaquely for runtime validation. Public and internal tags must be
  * disjoint.
  *
@@ -6368,8 +6543,8 @@ export const internalEvents: {
 
 /**
  * Defines the ephemeral notifications a machine may publish to external
- * observers. Emitted events are separate from actor input and are never sent
- * implicitly to a parent actor. Observe them through `MachineRef.emissions` or
+ * observers. Emitted events are separate from machine input and are never sent
+ * implicitly to a parent machine. Observe them through `MachineRef.emissions` or
  * the AtomMachine emission stream adapters.
  *
  * @category constructors
@@ -6559,7 +6734,7 @@ type DynamicEffectInvokeSource<
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
   StateId extends Machine.StateIdentifier<States>,
   Source extends (
-    context: Machine.InvokeContext<States, Events, Emits, StateId>
+    context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
   ) => Effect.Effect<unknown, unknown, unknown>
 > = {
   readonly id: InvokeLifecycleId
@@ -6581,7 +6756,15 @@ type DynamicEffectDoneHandler<
   States,
   Events,
   Emits,
-  Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>>
+  Machine.InvokeDoneContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Effect.Success<ReturnType<NoInfer<Source>>>,
+    readonly [],
+    readonly []
+  >
 >
 
 type DynamicEffectFailureHandler<
@@ -6594,7 +6777,15 @@ type DynamicEffectFailureHandler<
   States,
   Events,
   Emits,
-  Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>>
+  Machine.InvokeFailureContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Effect.Error<ReturnType<NoInfer<Source>>>,
+    readonly [],
+    readonly []
+  >
 >
 
 type DynamicEffectInvokeResult<
@@ -6604,7 +6795,7 @@ type DynamicEffectInvokeResult<
   StateId extends Machine.StateIdentifier<States>,
   Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
 > =
-  & Machine.InvokeConfig<States, Events, Emits, StateId>
+  & Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []>
   & Machine.InvokeTyped<
     Effect.Success<ReturnType<Source>>,
     Effect.Error<ReturnType<Source>>,
@@ -6614,6 +6805,325 @@ type DynamicEffectInvokeResult<
 
 type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false
 
+type BoundDynamicEffectInvokeSource<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (
+    context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  ) => Effect.Effect<unknown, unknown, unknown>
+> = {
+  readonly id: InvokeLifecycleId
+  readonly effect: Source
+  readonly after?: never
+  readonly logic?: never
+  readonly child?: never
+  readonly address?: never
+  readonly onSnapshot?: never
+}
+
+type BoundDynamicEffectDoneHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  Machine.InvokeDoneContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Effect.Success<ReturnType<NoInfer<Source>>>,
+    InputEvents,
+    ParentEvents
+  >
+>
+
+type BoundDynamicEffectFailureHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  Machine.InvokeFailureContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Effect.Error<ReturnType<NoInfer<Source>>>,
+    InputEvents,
+    ParentEvents
+  >
+>
+
+type BoundDynamicEffectInvokeResult<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
+> =
+  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  & Machine.InvokeTyped<
+    Effect.Success<ReturnType<Source>>,
+    Effect.Error<ReturnType<Source>>,
+    Effect.Services<ReturnType<Source>>,
+    never
+  >
+
+/**
+ * Machine-bound invocation constructor that preserves the owning machine's
+ * public input and parent protocols in every invocation callback.
+ *
+ * @category constructors
+ * @since 0.11.0
+ */
+export interface Invoker<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
+> {
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<unknown, unknown, unknown>
+  >(
+    config:
+      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onDone: BoundDynamicEffectDoneHandler<
+          States,
+          Events,
+          Emits,
+          InputEvents,
+          ParentEvents,
+          StateId,
+          Source
+        >
+        readonly onFailure: BoundDynamicEffectFailureHandler<
+          States,
+          Events,
+          Emits,
+          InputEvents,
+          ParentEvents,
+          StateId,
+          Source
+        >
+      },
+    ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
+        "onDone must be omitted when the Effect output is never"
+      ]
+      : InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
+          "onFailure must be omitted when the Effect error is never"
+        ]
+      : []
+  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<unknown, never, unknown>
+  >(
+    config:
+      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onDone: BoundDynamicEffectDoneHandler<
+          States,
+          Events,
+          Emits,
+          InputEvents,
+          ParentEvents,
+          StateId,
+          Source
+        >
+        readonly onFailure?: never
+      },
+    ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
+        "onDone must be omitted when the Effect output is never"
+      ]
+      : []
+  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<never, unknown, unknown>
+  >(
+    config:
+      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onDone?: never
+        readonly onFailure: BoundDynamicEffectFailureHandler<
+          States,
+          Events,
+          Emits,
+          InputEvents,
+          ParentEvents,
+          StateId,
+          Source
+        >
+      },
+    ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
+        "onFailure must be omitted when the Effect error is never"
+      ]
+      : []
+  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<never, never, unknown>
+  >(
+    config:
+      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onDone?: never
+        readonly onFailure?: never
+      }
+  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    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,
+        Fx,
+        InputEvents,
+        ParentEvents
+      >
+  ):
+    & Config
+    & Machine.InvokeOwned<States, Events, Emits, StateId>
+    & Machine.InvokeTyped<Effect.Success<Fx>, Effect.Error<Fx>, Effect.Services<Fx>, never>
+  <StateId extends Machine.StateIdentifier<States>, const Config extends object>(
+    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
+  <
+    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, InputEvents, ParentEvents>) => Logic<
+        ChildState,
+        ChildEvent,
+        ChildError,
+        ChildRequirements,
+        ChildOutput,
+        ChildInitialError
+      >,
+      InputEvents,
+      ParentEvents
+    >
+  ):
+    & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>
+  <
+    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,
+        Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
+        InputEvents,
+        ParentEvents
+      >
+  ):
+    & Config
+    & Machine.InvokeOwned<States, Events, Emits, StateId>
+    & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>
+  <
+    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,
+        InputEvents,
+        ParentEvents
+      >
+  ):
+    & 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"]>,
+      Machine.EventOf<Machine.ParentEvents<Child["machine"]>>
+    >
+}
+
 /**
  * Preserves inference for a state-owned invocation configuration.
  *
@@ -6630,6 +7140,12 @@ type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] e
  * lifecycle `id` and a typed communication `address`. Child descriptors already
  * own their identity, so `id` and `address` must not be repeated.
  *
+ * Owner references are intentionally non-sendable here because this standalone
+ * constructor does not know the owning definition. When a callback sends to
+ * `self` or `parent`, use the bound constructor on the owning definition
+ * (`definition.invoke(...)`) so the exact public input and `parentEvents`
+ * protocols are available.
+ *
  * ```ts
  * invoke: Machine.invoke({
  *   id: "load",
@@ -6652,7 +7168,7 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
     ) => Effect.Effect<unknown, unknown, unknown>
   >(
     config:
@@ -6675,7 +7191,7 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
     ) => Effect.Effect<unknown, never, unknown>
   >(
     config:
@@ -6695,7 +7211,7 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
     ) => Effect.Effect<never, unknown, unknown>
   >(
     config:
@@ -6715,7 +7231,7 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
     ) => Effect.Effect<never, never, unknown>
   >(
     config:
@@ -6733,7 +7249,9 @@ export const invoke: {
     const Fx extends Effect.Effect<any, any, any>,
     const Config extends object
   >(
-    config: Config & Machine.EffectInvokeArgs<States, Events, Emits, StateId, Fx>
+    config:
+      & Config
+      & Machine.EffectInvokeArgs<States, Events, Emits, StateId, Fx, Fx, readonly [], readonly []>
   ):
     & Config
     & Machine.InvokeOwned<States, Events, Emits, StateId>
@@ -6750,7 +7268,7 @@ export const invoke: {
     StateId extends Machine.StateIdentifier<States>,
     const Config extends object
   >(
-    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId>
+    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, readonly [], readonly []>
   ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
   <
     const States extends Machine.StateSchemas,
@@ -6777,17 +7295,19 @@ export const invoke: {
       ChildOutput,
       ChildInitialError,
       Address,
-      (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Logic<
+      (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Logic<
         ChildState,
         ChildEvent,
         ChildError,
         ChildRequirements,
         ChildOutput,
         ChildInitialError
-      >
+      >,
+      readonly [],
+      readonly []
     >
   ):
-    & Machine.InvokeConfig<States, Events, Emits, StateId>
+    & Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []>
     & Machine.InvokeTyped<
       ChildOutput,
       ChildError,
@@ -6821,7 +7341,10 @@ export const invoke: {
         ChildRequirements,
         ChildOutput,
         ChildInitialError,
-        Address
+        Address,
+        Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
+        readonly [],
+        readonly []
       >
   ):
     & Config
@@ -6840,7 +7363,9 @@ export const invoke: {
     const Child extends ChildMachine.Any,
     const Config extends object
   >(
-    config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child>
+    config:
+      & Config
+      & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, readonly [], readonly []>
   ):
     & Config
     & Machine.InvokeOwned<States, Events, Emits, StateId>
@@ -6854,11 +7379,11 @@ export const invoke: {
     >
 } = ((config: unknown) => config) as any
 /**
- * Plans the initial state for a machine without executing actor commands.
+ * Plans the initial state for a machine without executing machine commands.
  *
  * **Details**
  *
- * The returned plan contains the settled initial snapshot, actor commands,
+ * The returned plan contains the settled initial snapshot, machine commands,
  * emitted events, optional final output, and every startup microstep. Planning
  * may evaluate transition logic and follow completion, eventless, and
  * raised-event steps. Transition callbacks are evaluated synchronously.
@@ -6867,8 +7392,8 @@ export const invoke: {
  *
  * **Gotchas**
  *
- * `start` executes the closed command list as part of the managed actor commit
- * protocol. Manual planners may inspect commands but need a running actor scope
+ * `start` executes the closed command list as part of the managed machine commit
+ * protocol. Manual planners may inspect commands but need running machine targets
  * to execute child-addressed operations.
  *
  * **Example**
@@ -7103,7 +7628,7 @@ export const enabled: <
  *
  * **Gotchas**
  *
- * `plan` returns data; it does not implement the actor commit protocol.
+ * `plan` returns data; it does not implement the managed machine commit protocol.
  * `start` executes child commands, publishes `next`, and then delivers
  * `emittedEvents`. Events with no enabled transition are ignored and produce
  * an unchanged plan.
@@ -7410,6 +7935,89 @@ export const watch: <State, Event, Error = never, Output = never>(
   ref: MachineRef<State, Event, Error, Output>
 ) => Stream.Stream<RuntimeOutcome<State, Error, Output>> = internal.watch
 
+/**
+ * Prepares a fresh machine without initializing it.
+ *
+ * Use this constructor when observation must be composed before initial-entry
+ * actions run. Subscribe to `prepared.emissions`, then evaluate
+ * `prepared.start`. Ordinary callers can continue to use {@link start}, which
+ * starts directly and does not allocate the prepared lifecycle boundary.
+ *
+ * ```ts
+ * const prepared = yield* Machine.prepare(machine)
+ *
+ * yield* prepared.emissions.pipe(
+ *   Stream.runForEach(handleEmission),
+ *   Effect.forkScoped({ startImmediately: true })
+ * )
+ *
+ * const ref = yield* prepared.start
+ * ```
+ *
+ * @category constructors
+ * @since 0.11.0
+ */
+export const prepare: <
+  const States extends Machine.StateSchemas,
+  const Events extends ReadonlyArray<Machine.TaggedSchema>,
+  const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+  const Input extends Schema.Top = typeof Schema.Void,
+  UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>,
+  E = never,
+  R = never,
+  InitialE = never,
+  InitialR = never,
+  FinalStates extends Machine.StateIdentifier<States> = never,
+  Output = never,
+  OutputStates extends Machine.StateIdentifier<States> = never,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+>(
+  machine:
+    & Machine<
+      States,
+      Events,
+      Input,
+      UnhandledStates,
+      E,
+      R,
+      InitialE,
+      InitialR,
+      FinalStates,
+      Output,
+      Emits,
+      OutputStates,
+      InputEvents,
+      ParentEvents
+    >
+    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+  ...args: [...Machine.InputArgs<Input>]
+) => Effect.Effect<
+  Prepared<
+    Machine.Snapshot<States>,
+    Machine.EventInputOf<InputEvents>,
+    | E
+    | ActionError<R>
+    | InfiniteTransitionError
+    | MachineSchemaDecodeError
+    | StoppedError,
+    Output,
+    Machine.EmittedEventOf<Emits>,
+    | InitialE
+    | E
+    | ActionError<InitialR | R>
+    | InfiniteTransitionError
+    | MachineSchemaDecodeError
+    | StartupError
+    | StoppedError,
+    ExcludeCompatibleRuntime<
+      ExecutionServices<InitialR | R>,
+      Machine.EventOf<Events>,
+      Machine.EmitOf<Emits>
+    >
+  >
+> = internal.prepare as any
+
 /**
  * Starts a machine.
  *
@@ -7421,7 +8029,7 @@ export const watch: <State, Event, Error = never, Output = never>(
  * **Details**
  *
  * For each accepted event the runtime plans the complete synchronous
- * macrostep, executes closed actor commands, stops invokes for exited states,
+ * macrostep, executes closed machine commands, stops invokes for exited states,
  * publishes the new state, delivers emitted events, and then starts invokes
  * for entered states.
  *