@typeonce/effect-machine 0.10.0 → 0.11.0

package/README.md

@@ -188,14 +188,24 @@ object to `send` or `Machine.plan` for those events.
 `ref.emissions` is a hot `Stream`: it publishes only notifications produced
 after subscription, replays nothing, and completes when the actor terminates.
 Snapshots remain separate and stateful: `ref.changes` begins with the current
-lifecycle snapshot and then follows later changes. Because `Machine.start`
-returns only after initialization, startup emissions are not observable from
-the returned ref; represent startup facts in state when they must be retained.
+lifecycle snapshot and then follows later changes. Use `Machine.prepare` when
+an observer must be installed before initial-entry actions run:
 
 ```ts
-const next = ref.emissions.pipe(Stream.take(1), Stream.runHead)
+const prepared = yield * Machine.prepare(machine)
+
+yield * prepared.emissions.pipe(
+  Stream.runForEach(handleEmission),
+  Effect.forkScoped({ startImmediately: true })
+)
+
+const ref = yield * prepared.start
 ```
 
+`Machine.start(machine)` remains the one-step convenience for callers that do
+not observe startup emissions. Preparation does not retain or replay an
+emission: the observer is simply subscribed before initialization begins.
+
 Invalid event and emission constructions fail the machine with a typed
 `MachineSchemaDecodeError`; they do not throw from the constructor call.
 
@@ -322,6 +332,35 @@ invoke: Machine.invoke({
 })
 ```
 
+The standalone `Machine.invoke(...)` constructor does not know the owning
+definition, so its `self` and `parent` references are non-sendable. When an
+invocation callback sends through either reference, construct it through the
+owning definition so those references use its exact public input and
+`parentEvents` protocols:
+
+```ts
+const definition = Machine.make({
+  events: Commands,
+  internalEvents: InternalEvents,
+  parentEvents: ParentEvents
+  // ...
+})
+
+const machine = definition.handle({
+  Saving: {
+    invoke: definition.invoke({
+      id: "notify-parent",
+      effect: ({ parent }) =>
+        parent === undefined
+          ? Effect.void
+          : parent.send(ParentEvents.SaveStarted()),
+      onDone: ({ target }) => target.none(),
+      onFailure: ({ target }) => target.none()
+    })
+  }
+})
+```
+
 A direct `invoke: { ... }` object is also supported when its lifecycle handlers
 do not need source-derived context. Reuse one exported
 `Machine.child(id, machine)` descriptor for invocation, `sendTo`, and child

package/dist/Machine.d.ts

@@ -165,6 +165,14 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
      * @since 0.4.0
      */
     readonly handle: Machine.Handler<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, 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>;
 }
@@ -851,6 +859,28 @@ export type RuntimeOutcome<State, Error = never, Output = never> = {
         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.
@@ -1176,6 +1206,8 @@ export declare namespace Machine {
         /** @internal */
         readonly handle: any;
         /** @internal */
+        readonly invoke: any;
+        /** @internal */
         readonly initial: any;
     }
     /**
@@ -2961,9 +2993,9 @@ export declare namespace Machine {
             readonly parentEvents: Types.Covariant<ParentEvent>;
         };
     }
-    type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeOwned<States, Events, Emits, StateId> & ({
+    type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = InvokeOwned<States, Events, Emits, StateId> & ({
         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;
@@ -2973,7 +3005,7 @@ export declare namespace Machine {
         readonly onSnapshot?: never;
     } | {
         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;
@@ -2984,7 +3016,7 @@ 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;
@@ -2993,7 +3025,7 @@ export declare namespace Machine {
         readonly onSnapshot?: unknown;
     } | {
         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;
@@ -3004,7 +3036,8 @@ export declare namespace Machine {
         readonly onSnapshot?: unknown;
     });
     /** State-bound inline invocation configuration. */
-    type InvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeConfig<States, Events, Emits, StateId> | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId>>;
+    type InvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
+    type TypedInvokeDefinition = InvokeTyped<any, any, any, any, any, any> | ReadonlyArray<InvokeTyped<any, any, any, any, any, any>>;
     type InvokeHandlerRequirement<Value, Handler> = IsAny<Value> extends true ? {
         readonly handler: Handler;
     } : [Value] extends [never] ? {
@@ -3026,7 +3059,7 @@ export declare namespace Machine {
     } : {
         readonly onFailure?: never;
     } : never;
-    type EffectInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Fx extends Effect.Effect<any, any, any>, Source = Fx> = {
+    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, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         readonly id: InvokeLifecycleId;
         readonly effect: Source;
         readonly after?: never;
@@ -3034,74 +3067,74 @@ export declare namespace Machine {
         readonly child?: never;
         readonly address?: never;
         readonly onSnapshot?: never;
-    } & InvokeDoneRequirement<Effect.Success<NoInfer<Fx>>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<NoInfer<Fx>>>>> & InvokeFailureRequirement<Effect.Error<NoInfer<Fx>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<NoInfer<Fx>>>>>;
-    type TimerInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = {
+    } & InvokeDoneRequirement<Effect.Success<NoInfer<Fx>>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<NoInfer<Fx>>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Effect.Error<NoInfer<Fx>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<NoInfer<Fx>>, InputEvents, ParentEvents>>>;
+    type TimerInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         readonly id: InvokeLifecycleId;
-        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>;
+        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
         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>>;
+        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
     };
-    type LogicInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>> = {
+    type LogicInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         readonly id: InvokeLifecycleId;
         readonly address: Address & ChildAddress.Compatibility<Address, ChildEvent>;
         readonly logic: Source;
         readonly effect?: never;
         readonly after?: never;
         readonly child?: never;
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, ChildState, ChildError, ChildOutput>>;
-    } & InvokeDoneRequirement<ChildOutput, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, ChildOutput>>> & InvokeFailureRequirement<ChildError, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, ChildError>>>;
-    type ChildInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildDefinition extends Machine.Any, Child extends ChildMachine<string, ChildDefinition>> = {
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, ChildState, ChildError, ChildOutput, InputEvents, ParentEvents>>;
+    } & InvokeDoneRequirement<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, InputEvents, ParentEvents>>>;
+    type ChildInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildDefinition extends Machine.Any, Child extends ChildMachine<string, ChildDefinition>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         readonly child: Child & (ChildDefinition extends EnsureExecutable<Machine.States<ChildDefinition>, Machine.UnhandledStates<ChildDefinition>, Machine.OutputStates<ChildDefinition>> ? unknown : never);
         readonly id?: never;
         readonly address?: never;
         readonly effect?: never;
         readonly after?: never;
         readonly logic?: never;
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>>>;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>;
     } & (Input<ChildDefinition> extends typeof Schema.Void ? {
         readonly input?: never;
     } : {
-        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>;
-    }) & 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>>>>>;
+        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
+    }) & InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InputEvents, ParentEvents>>>;
     type LogicStateOf<Value> = Value extends Logic<infer State, any, any, any, any, any> ? State : never;
     type LogicEventOf<Value> = Value extends Logic<any, infer Event, any, any, any, any> ? Event : never;
     type LogicErrorOf<Value> = Value extends Logic<any, any, infer Error, any, any, any> ? Error : never;
     type LogicServicesOf<Value> = Value extends Logic<any, any, any, infer Services, any, any> ? Services : never;
     type LogicOutputOf<Value> = Value extends Logic<any, any, any, any, infer Output, any> ? Output : never;
     type LogicInitialErrorOf<Value> = Value extends Logic<any, any, any, any, any, infer Error> ? Error : never;
-    type ContextualInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Raw> = Raw extends InvokeTyped<any, any, any, any, any> ? unknown : Raw extends {
+    type ContextualInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Raw> = Raw extends InvokeTyped<any, any, any, any, any> ? unknown : 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>>>> & {
+    } ? 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>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Effect.Error<Fx>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>>> & {
         readonly onSnapshot?: never;
     } : never : Raw extends {
         readonly after: unknown;
     } ? {
-        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void>>;
+        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>>;
         readonly onFailure?: never;
         readonly onSnapshot?: never;
     } : Raw extends {
         readonly logic: infer Source;
         readonly address: infer Address;
-    } ? InvokeResolvedSource<Source> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ? InvokeDoneRequirement<InvokeOutput<Raw>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>>>> & InvokeFailureRequirement<InvokeRuntimeError<Raw>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, InvokeRuntimeError<Raw>>>> & {
+    } ? 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>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<InvokeRuntimeError<Raw>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, InvokeRuntimeError<Raw>, InputEvents, ParentEvents>>> & {
         readonly address: ChildAddress<never> & ChildAddress.Compatibility<Address, ChildLogic extends Logic<any, infer ChildEvent, any, any, any, any> ? ChildEvent : never>;
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, ChildLogic extends Logic<infer ChildState, any, any, any, any, any> ? ChildState : never, InvokeRuntimeError<Raw>, InvokeOutput<Raw>>>;
+        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>, InputEvents, ParentEvents>>;
     } : never : Raw extends {
         readonly child: infer Child extends ChildMachine<string, infer ChildDefinition>;
-    } ? ChildMachineLogic<Child> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ? InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, 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 ? {
+    } ? 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>, InputEvents, ParentEvents>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InputEvents, ParentEvents>>> & (Input<ChildDefinition> extends typeof Schema.Void ? {
         readonly input?: never;
     } : {
-        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>;
+        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>>;
     }) & {
-        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>>>;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>;
     } : never : never;
-    type ContextualInvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Raw> = Raw extends ReadonlyArray<any> ? {
-        readonly [Index in keyof Raw]: ContextualInvokeConfig<States, Events, Emits, StateId, Raw[Index]>;
-    } : ContextualInvokeConfig<States, Events, Emits, StateId, Raw>;
+    type ContextualInvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Raw> = Raw extends ReadonlyArray<any> ? {
+        readonly [Index in keyof Raw]: ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw[Index]>;
+    } : ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw>;
     type OutputHandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Context> = NodeByIdentifier<States, StateId> extends {
         readonly output: Schema.Top;
     } ? {
@@ -3123,7 +3156,7 @@ export declare namespace Machine {
     type ActiveStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
         readonly exit?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
-        readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>;
+        readonly invoke?: InvokeDefinition<States, Events, Emits, StateId, InputEvents, ParentEvents> | TypedInvokeDefinition;
         readonly always?: ((context: AlwaysContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
             /** Statically declared upper bound of possible target paths. */
             readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
@@ -3235,12 +3268,12 @@ export declare namespace Machine {
         readonly states: infer Children extends StateSchemas;
     } ? HandlerNodeByPath<Children, Rest> : never : never : Path extends keyof States ? States[Path] : never;
     type HandlerConfigAtPath<Config, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Config ? HandlerConfigAtPath<HandlerNodeChildrenConfig<Config[Head]>, Rest> : never : Path extends keyof Config ? Config[Path] : never;
-    type HandlerInvokeContextAtPath<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, StateId extends StateNodeIdentifier<AllStates>, NodeConfig = HandlerConfigAtPath<Config, StateId>> = StateId extends StateIdentifier<AllStates> ? NodeConfig extends {
+    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;
-    type HandlerInvokeContexts<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config> = Types.UnionToIntersection<StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerInvokeContextAtPath<AllStates, Events, Emits, Config, StateId> : never : never>;
+    type HandlerInvokeContexts<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Config> = Types.UnionToIntersection<StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerInvokeContextAtPath<AllStates, Events, InputEvents, Emits, ParentEvents, Config, StateId> : never : never>;
     type HandlerValidationAtPath<Path extends string, Validation> = Path extends `${infer Head}.${infer Rest}` ? {
         readonly [Key in Head]?: {
             readonly states: HandlerValidationAtPath<Rest, Validation>;
@@ -3391,7 +3424,7 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     interface Handler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<States>, Output, OutputStates extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>> {
-        <const Config extends HandlerTree<States, States, Events, Emits, E, R, InputEvents, ParentEvents, "">>(config: Config & HandlerInvokeContexts<States, Events, Emits, NoInfer<Config>> & HandlerTreeValidation<States, Events, InputEvents, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents, Config>;
+        <const Config extends HandlerTree<States, States, Events, Emits, E, R, InputEvents, ParentEvents, "">>(config: Config & HandlerInvokeContexts<States, Events, InputEvents, Emits, ParentEvents, NoInfer<Config>> & HandlerTreeValidation<States, Events, InputEvents, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents, Config>;
     }
     /**
      * Any state config.
@@ -3726,7 +3759,7 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * @since 0.4.0
  */
 export declare const decodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
-type 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>> = {
+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, readonly [], readonly []>) => Effect.Effect<unknown, unknown, unknown>> = {
     readonly id: InvokeLifecycleId;
     readonly effect: Source;
     readonly after?: never;
@@ -3735,10 +3768,60 @@ type DynamicEffectInvokeSource<States extends Machine.StateSchemas, Events exten
     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 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>>>, readonly [], readonly []>>;
+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>>>, readonly [], readonly []>>;
+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, readonly [], readonly []> & 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;
+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.
  *
@@ -3755,6 +3838,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",
@@ -3771,7 +3860,7 @@ type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] e
  * @since 0.9.0
  */
 export declare const invoke: {
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Effect.Effect<unknown, unknown, unknown>>(config: DynamicEffectInvokeSource<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, readonly [], readonly []>) => 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 ? [
@@ -3779,27 +3868,27 @@ export declare const invoke: {
     ] : 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> & {
+    <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, readonly [], readonly []>) => 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> & {
+    <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, readonly [], readonly []>) => 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> & {
+    <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, readonly [], readonly []>) => Effect.Effect<never, never, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
         readonly onDone?: never;
         readonly onFailure?: never;
     }): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Fx extends Effect.Effect<any, any, any>, const Config extends object>(config: Config & Machine.EffectInvokeArgs<States, Events, Emits, StateId, Fx>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Effect.Success<Fx>, Effect.Error<Fx>, Effect.Services<Fx>, never>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Config extends object>(config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>>(config: Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>>): Machine.InvokeConfig<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object>(config: Config & Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
+    <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, Fx, readonly [], readonly []>): 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, readonly [], readonly []>): 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, readonly [], readonly []>) => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, readonly [], readonly []>): Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []> & 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, Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, readonly [], readonly []>): 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, readonly [], readonly []>): 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"]>>>;
 };
 /**
  * Plans the initial state for a machine without executing actor commands.
@@ -4127,6 +4216,29 @@ export declare const stopChild: {
  * @since 0.4.0
  */
 export declare const watch: <State, Event, Error = never, Output = never>(ref: MachineRef<State, Event, Error, Output>) => Stream.Stream<RuntimeOutcome<State, Error, Output>>;
+/**
+ * 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 declare 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>>>>;
 /**
  * Starts a machine.
  *