@typeonce/effect-machine 0.8.0 → 0.10.0

package/dist/Machine.d.ts

@@ -37,6 +37,10 @@ export type TypeId = "~effect/Machine";
 export declare const TypeId: TypeId;
 declare const MachineOutputStatesTypeId: unique symbol;
 declare const MachineTypeId: unique symbol;
+declare const EventConstructionTypeId: unique symbol;
+declare const EmittedEventConstructionTypeId: unique symbol;
+declare const EventProtocolTypeId: unique symbol;
+declare const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId;
 /**
  * Type identifier used for the synthetic event passed to startup lifecycle
  * actions.
@@ -90,10 +94,10 @@ type IsAny<A> = 0 extends (1 & A) ? true : false;
  * @category models
  * @since 0.4.0
  */
-export interface Machine<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, 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, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events> extends Pipeable {
+export interface Machine<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, 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, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []> extends Pipeable {
     readonly [TypeId]: TypeId;
     /** @internal Stable type-level carrier for machine protocol extraction. */
-    readonly [MachineTypeId]: Machine.TypeCarrier<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>;
+    readonly [MachineTypeId]: Machine.TypeCarrier<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>;
     /** @internal Prevents output implementation evidence from being widened. */
     readonly [MachineOutputStatesTypeId]: Readonly<Record<OutputStates, true>>;
     /**
@@ -107,19 +111,31 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
      *
      * @since 0.4.0
      */
-    readonly events: InputEvents;
+    readonly events: Machine.EventProtocol<"public", InputEvents>;
     /**
-     * Events reserved for invokes, child emissions, and other machine-local work.
+     * Events reserved for raised events and other machine-local work.
      *
      * @since 0.4.0
      */
-    readonly internalEvents: ReadonlyArray<Machine.TaggedSchema>;
+    readonly internalEvents: Machine.EventProtocol<"internal", Machine.InternalEventSchemas<Events, InputEvents>>;
     /**
-     * Events that the machine may emit to its parent or external adapter.
+     * Ephemeral outward notifications published to this actor's observers.
+     * Emissions are never delivered implicitly to an owning actor.
      *
      * @since 0.4.0
      */
-    readonly emits: Emits;
+    readonly emittedEvents: Machine.EventProtocol<"emitted", Emits>;
+    /**
+     * Public input events accepted by an owning actor when this machine is
+     * running as a child.
+     *
+     * The protocol types the optional `parent` actor reference exposed to
+     * handlers and is checked against a concrete parent's public events at
+     * composition boundaries.
+     *
+     * @since 0.10.0
+     */
+    readonly parentEvents: Machine.EventProtocol<"public", ParentEvents>;
     /**
      * Optional schema used to decode the machine input before initialization.
      *
@@ -148,7 +164,7 @@ 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>;
+    readonly handle: Machine.Handler<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents>;
     /** @internal */
     readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>;
 }
@@ -254,7 +270,8 @@ export type PlanningServices<Requirements> = Exclude<Requirements, ActionRequire
  */
 export type ExecutionServices<Requirements> = Exclude<PlanningServices<Requirements>, MachineRuntimeRequirement> | Exclude<ActionServices<Requirements>, MachineRuntimeRequirement>;
 /**
- * Managed runtime capability used to deliver raised and emitted events.
+ * Managed runtime capability used to deliver raised events and publish
+ * emitted notifications.
  *
  * @category models
  * @since 0.4.0
@@ -265,13 +282,36 @@ export interface Runtime<in Events, in Emits> {
      *
      * @since 0.4.0
      */
-    readonly raise: (event: Events) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
+    readonly raise: (event: Machine.EventInput<Events>) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
     /**
-     * Emits an event through the running machine's parent boundary.
+     * Publishes an ephemeral notification to the running actor's observers.
      *
      * @since 0.4.0
      */
-    readonly sendParent: (event: Emits) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
+    readonly emit: (event: Machine.EmittedEventInput<Emits>) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
+}
+/**
+ * Minimal typed reference accepted by targeted actor commands.
+ *
+ * @category models
+ * @since 0.10.0
+ */
+export interface ActorRef<in Event> {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly send: (event: Event) => Effect.Effect<void, StoppedError>;
+}
+/**
+ * Actor references available while evaluating machine behavior.
+ *
+ * @category models
+ * @since 0.10.0
+ */
+export interface ActorContext<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>>;
+    /** Reference to the owning actor, or `undefined` when running as a root. */
+    readonly parent: ActorRef<Machine.EventInputOf<ParentEvents>> | undefined;
 }
 /**
  * Synchronous commands available while a machine transition is being
@@ -283,11 +323,12 @@ export interface Runtime<in Events, in Emits> {
  */
 export interface Enqueue<in Events, in Emits> {
     /** Raises an event inside the current macrostep. */
-    readonly raise: (event: Events) => void;
-    /** Emits an event through the machine's parent boundary. */
-    readonly emit: (event: Emits) => void;
+    readonly raise: (event: Machine.EventInput<Events>) => void;
+    /** Publishes an ephemeral notification to this actor'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;
         <Child extends ChildMachine.Any>(child: Child, event: ChildMachine.Event<Child>): void;
         <Address extends ChildAddress<never>>(child: Address, event: ChildAddress.Event<Address>): void;
     };
@@ -305,7 +346,7 @@ export interface Enqueue<in Events, in Emits> {
  */
 export type Command = {
     readonly _tag: "SendTo";
-    readonly child: ChildMachine.Any | ChildAddress<never>;
+    readonly target: ActorRef<unknown> | ChildMachine.Any | ChildAddress<never>;
     readonly event: unknown;
 } | {
     readonly _tag: "Stop";
@@ -448,9 +489,11 @@ type EventProtocolError<Message extends string, Tag extends PropertyKey = never>
 type DuplicateEventTag<Events extends ReadonlyArray<Machine.TaggedSchema>, Seen extends PropertyKey = never> = number extends Events["length"] ? never : Events extends readonly [
     infer Head extends Machine.TaggedSchema,
     ...infer Tail extends ReadonlyArray<Machine.TaggedSchema>
-] ? Machine.TagOf<Head> extends infer Tag extends PropertyKey ? Tag extends Seen ? Tag | DuplicateEventTag<Tail, Seen> : DuplicateEventTag<Tail, Seen | Tag> : never : never;
+] ? Machine.TagOf<Head> extends infer Tag extends PropertyKey ? Extract<Tag, Seen> | DuplicateEventTag<Tail, Seen | Tag> : never : never;
 type ValidateInputEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, DuplicateInput extends PropertyKey = DuplicateEventTag<InputEvents>> = [DuplicateInput] extends [never] ? unknown : EventProtocolError<"Public event tags must be unique", DuplicateInput>;
+type ValidateEmittedEventProtocol<EmittedEvents extends ReadonlyArray<Machine.TaggedSchema>, DuplicateEmitted extends PropertyKey = DuplicateEventTag<EmittedEvents>> = [DuplicateEmitted] extends [never] ? unknown : EventProtocolError<"Emitted event tags must be unique", DuplicateEmitted>;
 type ValidateInternalEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, DuplicateInternal extends PropertyKey = DuplicateEventTag<InternalEvents>, Overlap extends PropertyKey = Extract<Machine.TagOf<InputEvents[number]>, Machine.TagOf<InternalEvents[number]>>> = [DuplicateInternal] extends [never] ? [Overlap] extends [never] ? unknown : EventProtocolError<"Public and internal event tags must be disjoint", Overlap> : EventProtocolError<"Internal event tags must be unique", DuplicateInternal>;
+type ValidateEventProtocolBuilder<Kind extends Machine.EventProtocolKind, Inputs extends ReadonlyArray<Machine.EventProtocolInput<Kind>>, Schemas extends ReadonlyArray<Machine.TaggedSchema> = Machine.EventProtocolInputSchemasOf<Kind, Inputs>, Duplicate extends PropertyKey = DuplicateEventTag<Schemas>> = [Duplicate] extends [never] ? unknown : EventProtocolError<"Event protocol tags must be unique", Duplicate>;
 declare const SnapshotBuilderStateTypeId: typeof internal.SnapshotBuilderStateTypeId;
 declare const SnapshotBuilderConstructionTypeId: unique symbol;
 type SnapshotBuilderComplete<Regions, Constructed extends boolean = false> = {
@@ -822,7 +865,7 @@ export type RuntimeOutcome<State, Error = never, Output = never> = {
  * @category models
  * @since 0.4.0
  */
-export interface MachineRef<out State, in Event, out Error = never, out Output = never> {
+export interface MachineRef<out State, in Event, out Error = never, out Output = never, out Emitted = never> extends ActorRef<Event> {
     /** Stable machine definition id, or a generated fallback when none was declared. */
     readonly id: string;
     /** Unique identity for this running machine instance. */
@@ -831,8 +874,13 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
     readonly state: Effect.Effect<State>;
     /** Reads the latest lifecycle snapshot. */
     readonly snapshot: Effect.Effect<RuntimeSnapshot<State, Error, Output>>;
-    /** Streams lifecycle snapshots published after subscription. */
+    /** Streams the current lifecycle snapshot followed by later changes. */
     readonly changes: Stream.Stream<RuntimeSnapshot<State, Error, Output>>;
+    /**
+     * Streams ephemeral notifications published after subscription. Emissions
+     * are not retained or replayed; the stream completes when the actor stops.
+     */
+    readonly emissions: Stream.Stream<Emitted>;
     /** Waits for machine output or fails when execution fails or is stopped. */
     readonly join: Effect.Effect<Output, Error | StoppedError>;
     /** Stops this machine instance and its owned child processes. */
@@ -900,12 +948,6 @@ export declare namespace Logic {
     /**
      * Machine-local capabilities available while process logic initializes.
      *
-     * **Gotchas**
-     *
-     * `sendParent` accepts `unknown` because process logic is independent from
-     * the parent that eventually owns it. Prefer typed process output or an
-     * invoke snapshot mapper when either can represent the communication.
-     *
      * @category models
      * @since 0.4.0
      */
@@ -916,10 +958,11 @@ export declare namespace Logic {
         readonly parent: Address<unknown> | undefined;
         /** Starts a child process owned by this scope. */
         readonly spawn: Spawn;
-        /** Sends an untyped event to the owning process. */
-        readonly sendParent: (event: unknown) => Effect.Effect<void, StoppedError>;
-        /** Sends an event through a typed parent-local child address. */
-        readonly sendTo: <Address extends ChildAddress<never>>(id: Address, event: ChildAddress.Event<Address>) => Effect.Effect<void, StoppedError>;
+        /** Sends an event to an actor reference or typed parent-local child address. */
+        readonly sendTo: {
+            <TargetEvent>(target: ActorRef<TargetEvent>, event: TargetEvent): Effect.Effect<void, StoppedError>;
+            <Address extends ChildAddress<never>>(id: Address, event: ChildAddress.Event<Address>): Effect.Effect<void, StoppedError>;
+        };
         /** Stops a child process selected by its parent-local address. */
         readonly stopChild: <Event>(id: ChildAddress<Event>) => Effect.Effect<void>;
     }
@@ -952,8 +995,9 @@ type InvokeLifecycleId = string & {
  * **Details**
  *
  * The descriptor carries the child's address and complete machine type. Pass
- * the same value to `invokeMachine`, `sendTo`, and child lookup APIs so state,
- * event, error, and output types are inferred without separate annotations.
+ * a descriptor for the same id and machine to inline `invoke`, `sendTo`, and
+ * child lookup APIs so state, event, error, and output types are inferred
+ * without separate annotations.
  *
  * @category models
  * @since 0.4.0
@@ -964,6 +1008,8 @@ export interface ChildMachine<Id extends string, M extends Machine.Any> {
     readonly id: Id;
     /** Complete machine definition carried by this descriptor. */
     readonly machine: M;
+    /** @internal */
+    readonly [ChildMachineLogicTypeId]: (input?: unknown) => Logic<any, any, any, any, any, any>;
 }
 /**
  * Namespace containing type-level members associated with `ChildMachine`.
@@ -985,14 +1031,14 @@ export declare namespace ChildMachine {
      * @category utility types
      * @since 0.4.0
      */
-    type Ref<Child> = Child extends ChildMachine<string, infer M> ? MachineRef<Machine.Snapshot<Machine.States<M>>, Machine.InputEvent<M>, Machine.Error<M> | ActionError<Machine.Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Machine.Output<M>> : never;
+    type Ref<Child> = Child extends ChildMachine<string, infer M> ? MachineRef<Machine.Snapshot<Machine.States<M>>, Machine.EventInput<Machine.InputEvent<M>>, Machine.Error<M> | ActionError<Machine.Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Machine.Output<M>, Machine.EmittedEvent<M>> : never;
     /**
      * Event accepted by the child selected by a descriptor.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type Event<Child> = Ref<Child> extends MachineRef<any, infer Event, any, any> ? Event : never;
+    type Event<Child> = Child extends ChildMachine<string, infer M> ? Machine.EventInput<Machine.InputEvent<M>> : never;
 }
 /**
  * Parent-local address for a child process that can receive events.
@@ -1082,7 +1128,7 @@ export declare namespace Machine {
      *
      * @internal
      */
-    interface TypeCarrier<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<States>, Output, Emits extends ReadonlyArray<TaggedSchema>, OutputStates extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>> {
+    interface TypeCarrier<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<States>, Output, Emits extends ReadonlyArray<TaggedSchema>, OutputStates extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>> {
         readonly states: States;
         readonly events: Events;
         readonly input: Input;
@@ -1093,9 +1139,10 @@ export declare namespace Machine {
         readonly initialServices: InitialR;
         readonly finalStates: FinalStates;
         readonly output: Output;
-        readonly emits: Emits;
+        readonly emittedEvents: Emits;
         readonly outputStates: OutputStates;
         readonly inputEvents: InputEvents;
+        readonly parentEvents: ParentEvents;
     }
     /**
      * Any schema-first machine.
@@ -1112,11 +1159,12 @@ export declare namespace Machine {
     interface Any extends Pipeable {
         readonly [TypeId]: TypeId;
         /** @internal */
-        readonly [MachineTypeId]: TypeCarrier<any, any, any, any, any, any, any, any, any, any, any, any, any>;
+        readonly [MachineTypeId]: TypeCarrier<any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
         readonly states: StateSchemas;
-        readonly events: ReadonlyArray<TaggedSchema>;
-        readonly internalEvents: ReadonlyArray<TaggedSchema>;
-        readonly emits: ReadonlyArray<TaggedSchema>;
+        readonly events: EventProtocol.Any<"public">;
+        readonly internalEvents: EventProtocol.Any<"internal">;
+        readonly emittedEvents: EventProtocol.Any<"emitted">;
+        readonly parentEvents: EventProtocol.Any<"public">;
         readonly input: Schema.Top | undefined;
         readonly id: string | undefined;
         /** @internal */
@@ -1206,7 +1254,9 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type Emits<M extends Any> = M[typeof MachineTypeId]["emits"];
+    type EmittedEvents<M extends Any> = M[typeof MachineTypeId]["emittedEvents"];
+    /** @deprecated Use {@link EmittedEvents}. */
+    type Emits<M extends Any> = EmittedEvents<M>;
     /**
      * Extracts state paths with implemented output handlers.
      *
@@ -1221,6 +1271,15 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"];
+    /** Extracts the public input protocol required from an owning actor. */
+    type ParentEvents<M extends Any> = M[typeof MachineTypeId]["parentEvents"];
+    /** Extracts an internal event schema tuple from the complete and public protocols. */
+    type InternalEventSchemas<Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>> = Events extends readonly [
+        ...InputEvents,
+        ...infer Internal extends ReadonlyArray<TaggedSchema>
+    ] ? readonly [...Internal] : readonly [];
+    /** Extracts the internal event schema tuple carried by a machine definition. */
+    type InternalEvents<M extends Any> = InternalEventSchemas<Events<M>, InputEvents<M>>;
     /**
      * Extracts the complete event protocol handled inside a machine.
      *
@@ -1235,13 +1294,96 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InputEvent<M extends Any> = EventOf<InputEvents<M>>;
+    /**
+     * Opaque event construction returned by {@link events} and
+     * {@link internalEvents}.
+     *
+     * The machine resolves the instruction through its event schema when it is
+     * delivered. Only the discriminator is available before decoding succeeds.
+     */
+    interface EventConstruction<out Event extends {
+        readonly _tag: PropertyKey;
+    }> {
+        readonly [EventConstructionTypeId]: Event;
+        readonly _tag: Event["_tag"];
+    }
+    /** Opaque construction returned by {@link emittedEvents}. */
+    interface EmittedEventConstruction<out Event extends {
+        readonly _tag: PropertyKey;
+    }> {
+        readonly [EmittedEventConstructionTypeId]: Event;
+        readonly _tag: Event["_tag"];
+    }
+    /** A decoded event or a deferred machine-bound construction of that event. */
+    type EventInput<Event> = Event | (Event extends {
+        readonly _tag: PropertyKey;
+    } ? EventConstruction<Event> : never);
+    /** A decoded emitted event or a deferred emitted-event construction. */
+    type EmittedEventInput<Event> = Event | (Event extends {
+        readonly _tag: PropertyKey;
+    } ? EmittedEventConstruction<Event> : never);
+    /** Event inputs accepted for a schema tuple at machine delivery boundaries. */
+    type EventInputOf<Events extends ReadonlyArray<TaggedSchema>> = EventInput<EventOf<Events>>;
+    /** Identifies whether an event protocol is accepted publicly or only inside a machine. */
+    type EventProtocolKind = "public" | "internal" | "emitted";
+    type EventConstructorInput<EventSchema extends TaggedSchema> = Omit<EventSchema["~type.make.in"], "_tag">;
+    type EventConstructor<EventSchema extends TaggedSchema, Tag extends EventSchema["Type"]["_tag"], Kind extends EventProtocolKind> = {} extends EventConstructorInput<EventSchema> ? (input?: EventConstructorInput<EventSchema>) => Kind extends "emitted" ? EmittedEventConstruction<EventByTag<readonly [EventSchema], Tag>> : EventConstruction<EventByTag<readonly [EventSchema], Tag>> : (input: EventConstructorInput<EventSchema>) => Kind extends "emitted" ? EmittedEventConstruction<EventByTag<readonly [EventSchema], Tag>> : EventConstruction<EventByTag<readonly [EventSchema], Tag>>;
+    type FiniteEventTag<Tag extends PropertyKey> = string extends Tag ? never : number extends Tag ? never : symbol extends Tag ? never : Tag;
+    type EventConstructorsForSchema<EventSchema extends TaggedSchema, Kind extends EventProtocolKind> = EventSchema extends {
+        readonly cases: infer Cases extends Readonly<Record<PropertyKey, TaggedSchema>>;
+    } ? {
+        readonly [Tag in keyof Cases]: Tag extends Cases[Tag]["Type"]["_tag"] ? EventConstructor<Cases[Tag], Tag, Kind> : never;
+    } : EventSchema extends {
+        readonly members: infer Members extends ReadonlyArray<TaggedSchema>;
+    } ? Types.UnionToIntersection<EventConstructorsForSchema<Members[number], Kind>> : {
+        readonly [Tag in FiniteEventTag<EventSchema["Type"]["_tag"]>]: EventConstructor<EventSchema, Tag, Kind>;
+    };
+    /** Protocol-bound constructors keyed by each configured event tag. */
+    type EventConstructors<Events extends ReadonlyArray<TaggedSchema>, Kind extends EventProtocolKind = "public"> = {
+        readonly [Tag in keyof Types.UnionToIntersection<EventConstructorsForSchema<Events[number], Kind>>]: Types.UnionToIntersection<EventConstructorsForSchema<Events[number], Kind>>[Tag];
+    };
+    /**
+     * A schema-backed event protocol exposing only deferred event constructors.
+     *
+     * The schema tuple is retained opaquely for machine runtime validation and
+     * type inference. It is not exposed as a runtime property.
+     *
+     * @since 0.10.0
+     */
+    type EventProtocol<Kind extends EventProtocolKind, Schemas extends ReadonlyArray<TaggedSchema>> = EventConstructors<Schemas, Kind> & {
+        readonly [EventProtocolTypeId]: {
+            readonly kind: Kind;
+            readonly schemas: Schemas;
+        };
+    };
+    namespace EventProtocol {
+        /** An erased event protocol descriptor retaining its kind and schema carrier. */
+        interface Any<Kind extends EventProtocolKind = EventProtocolKind> {
+            readonly [EventProtocolTypeId]: {
+                readonly kind: Kind;
+                readonly schemas: ReadonlyArray<TaggedSchema>;
+            };
+        }
+    }
+    /** A schema or an existing protocol accepted by an event builder. */
+    type EventProtocolInput<Kind extends EventProtocolKind> = TaggedSchema | EventProtocol.Any<Kind>;
+    type EventProtocolInputSchemas<Kind extends EventProtocolKind, Input extends EventProtocolInput<Kind>> = Input extends EventProtocol<Kind, infer Schemas> ? Schemas : Input extends TaggedSchema ? readonly [Input] : readonly [];
+    /** Flattens schema and protocol inputs into one owned schema tuple. */
+    type EventProtocolInputSchemasOf<Kind extends EventProtocolKind, Inputs extends ReadonlyArray<EventProtocolInput<Kind>>> = Inputs extends readonly [
+        infer Head extends EventProtocolInput<Kind>,
+        ...infer Tail extends ReadonlyArray<EventProtocolInput<Kind>>
+    ] ? readonly [...EventProtocolInputSchemas<Kind, Head>, ...EventProtocolInputSchemasOf<Kind, Tail>] : readonly [];
+    /** @internal Extracts the schema tuple carried opaquely by an event protocol. */
+    type EventProtocolSchemas<Protocol extends EventProtocol.Any> = Protocol[typeof EventProtocolTypeId]["schemas"];
     /**
      * Extracts the event protocol emitted by a machine.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type Emit<M extends Any> = EmitOf<Emits<M>>;
+    type EmittedEvent<M extends Any> = EmittedEventOf<Emits<M>>;
+    /** @deprecated Use {@link EmittedEvent}. */
+    type Emit<M extends Any> = EmittedEvent<M>;
     /**
      * A schema whose decoded value contains a `_tag` discriminator.
      *
@@ -1596,6 +1738,10 @@ export declare namespace Machine {
         readonly type: "done";
     } | {
         readonly type: "choice";
+    } | {
+        readonly type: "invoke";
+        readonly id: string;
+        readonly outcome: "done" | "failure" | "snapshot";
     };
     /**
      * Statically inspectable destination paths for a transition handler.
@@ -1615,10 +1761,10 @@ export declare namespace Machine {
      *
      * **Details**
      *
-     * Event, eventless, and completion handlers may declare an upper bound of
-     * possible target paths. A handler without that declaration is explicitly
-     * reported as dynamic. The source, trigger, and reentry behavior are
-     * available without executing the handler.
+     * Event, eventless, completion, and invocation lifecycle handlers may
+     * declare an upper bound of possible target paths. A handler without that
+     * declaration is explicitly reported as dynamic. The source, trigger, and
+     * reentry behavior are available without executing the handler.
      *
      * @category models
      * @since 0.4.0
@@ -1632,9 +1778,9 @@ export declare namespace Machine {
     /**
      * Serializable description of state-owned work.
      *
-     * Static invoke descriptors expose their lifecycle id and kind without
-     * retaining Effects, closures, services, or child runtimes. A function-valued
-     * invoke factory is reported as dynamic and is never evaluated by inspection.
+     * Static invoke definitions expose their lifecycle id and kind without
+     * retaining Effects, closures, services, or child runtimes. Function-valued
+     * sources are reported as dynamic and are never evaluated by inspection.
      *
      * @category models
      * @since 0.4.0
@@ -1810,7 +1956,9 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type EmitOf<Emits extends ReadonlyArray<TaggedSchema>> = Emits[number]["Type"];
+    type EmittedEventOf<Emits extends ReadonlyArray<TaggedSchema>> = Emits[number]["Type"];
+    /** @deprecated Use {@link EmittedEventOf}. */
+    type EmitOf<Emits extends ReadonlyArray<TaggedSchema>> = EmittedEventOf<Emits>;
     /**
      * Event values received by lifecycle callbacks.
      *
@@ -2210,6 +2358,20 @@ export declare namespace Machine {
             readonly [AncestorStateId in ValuedStateIdentifier<States>]: StateByIdentifier<States, AncestorStateId>;
         }>;
     }
+    /**
+     * Opaque result returned by an explicitly targetless transition.
+     *
+     * The transition remains handled and retains its queued commands, raised
+     * events, and emitted events, but selects no concrete destination. Declared
+     * `targets` constrain only concrete destinations, so this result is always
+     * permitted from ordinary transition handlers.
+     *
+     * @category models
+     * @since 0.10.0
+     */
+    interface NoTarget {
+        readonly [Topology.NoTargetTypeId]: typeof Topology.NoTargetTypeId;
+    }
     /**
      * Transition instruction that restores a history pseudo-state's parent.
      *
@@ -2286,9 +2448,9 @@ export declare namespace Machine {
      *
      * **Details**
      *
-     * `local` targets the nearest compound scope for the source state, `branch`
-     * targets descendants of the source root, and `full` builds complete
-     * snapshots for any root.
+     * `none()` handles without selecting a destination, `local` targets the
+     * nearest compound scope for the source state, `branch` targets descendants
+     * of the source root, and `full` builds complete snapshots for any root.
      *
      * These builders control how the next active configuration is assembled; they
      * do not directly control state re-entry. Exit and entry paths are derived
@@ -2301,6 +2463,17 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     interface TargetBuilder<States extends StateSchemas, Source extends StateNodeIdentifier<States>> {
+        /**
+         * Selects an explicitly targetless transition.
+         *
+         * The event or lifecycle outcome is handled and queued operations are
+         * retained, while the current state configuration remains the transition
+         * result. This remains valid when the handler declares concrete `targets`,
+         * because those paths are an upper bound rather than an exhaustive result.
+         *
+         * @since 0.10.0
+         */
+        readonly none: () => NoTarget;
         /**
          * Moves to another state in the same local group. The value of the state
          * containing that group, and values in other active branches, are kept.
@@ -2338,10 +2511,10 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> {
+    interface HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
-        readonly parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
         /** Complete logical configuration captured at the start of this microstep. */
         readonly snapshot: Snapshot<States>;
         readonly event: EventByTag<Events, EventTag>;
@@ -2359,56 +2532,75 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface StateActionContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
+    interface StateActionContext<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 []> extends ActorContext<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
-        readonly parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
     }
     /**
-     * Context passed to an invoked child process source.
+     * Context passed to a function-valued invocation source.
      *
      * @category models
      * @since 0.4.0
      */
-    interface InvokeContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
+    interface InvokeContext<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 []> extends ActorContext<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
-        readonly parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
     }
     /**
-     * Context passed to an invoked child process active snapshot mapper.
+     * Context passed to an invocation's active-snapshot transition.
      *
      * @category models
      * @since 0.4.0
      */
-    interface InvokeSnapshotContext<State, Error, Output> {
+    interface InvokeSnapshotContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, State, Error, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
         readonly id: string;
+        readonly state: StateByIdentifier<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
+        readonly target: TargetBuilder<States, StateId>;
         readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
             readonly status: "active";
         }>;
     }
     /**
-     * Context passed to an invoked machine terminal output mapper.
+     * Context passed to an invocation's successful completion transition.
      *
      * @category models
      * @since 0.4.0
      */
-    interface InvokeDoneContext<Output> {
+    interface InvokeDoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
         readonly id: string;
+        readonly state: StateByIdentifier<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
+        readonly snapshot: Snapshot<States>;
+        readonly target: TargetBuilder<States, StateId>;
         readonly output: Output;
     }
+    /** Context passed to an invocation typed-failure transition. */
+    interface InvokeFailureContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Error, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+        readonly id: string;
+        readonly state: StateByIdentifier<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
+        readonly snapshot: Snapshot<States>;
+        readonly target: TargetBuilder<States, StateId>;
+        readonly error: Error;
+    }
     /**
      * Context passed to an eventless transition handler.
      *
      * @category models
      * @since 0.4.0
      */
-    interface AlwaysContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
+    interface AlwaysContext<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 []> extends ActorContext<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
-        readonly parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
         /** Complete logical configuration captured at the start of this microstep. */
         readonly snapshot: Snapshot<States>;
         readonly event: LifecycleEvent<Events>;
@@ -2427,10 +2619,10 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface DoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
+    interface DoneContext<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 []> extends ActorContext<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
-        readonly parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
         /** Complete logical configuration captured at the start of this microstep. */
         readonly snapshot: Snapshot<States>;
         readonly event: LifecycleEvent<Events>;
@@ -2445,9 +2637,9 @@ export declare namespace Machine {
         readonly target: TargetBuilder<States, StateId>;
     }
     /** Context passed to a transient choice resolver. There is no `state` value. */
-    interface ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>> {
-        readonly parent: StateByIdentifier<States, Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>>;
-        readonly parents: {
+    interface ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+        readonly containingState: StateByIdentifier<States, Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>>;
+        readonly ancestors: {
             readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, ValuedStateIdentifier<States>>]: StateByIdentifier<States, Parent>;
         };
         readonly event: LifecycleEvent<Events>;
@@ -2461,8 +2653,8 @@ export declare namespace Machine {
      */
     interface FinalOutputContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
-        readonly parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
     }
     /**
@@ -2485,8 +2677,8 @@ export declare namespace Machine {
      */
     interface ParallelOutputContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
-        readonly parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
         readonly outputs: ParallelOutputRegions<States, StateId>;
     }
@@ -2513,14 +2705,15 @@ export declare namespace Machine {
      *
      * **Details**
      *
-     * Handlers return snapshots for complete state replacement or target builder
-     * results for path-safe partial transitions. Raw decoded state values are not
-     * accepted at transition boundaries.
+     * Handlers return snapshots for complete state replacement, target builder
+     * results for path-safe partial transitions, or `target.none()` for an
+     * explicitly targetless transition. Raw decoded state values and `void` are
+     * not accepted at transition boundaries.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type HandlerResult<States extends StateSchemas, E, R> = Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>>> | void;
+    type HandlerResult<States extends StateSchemas, E, R> = Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>>> | NoTarget;
     /** A choice resolver must always select a typed target synchronously. */
     type ChoiceResult<States extends StateSchemas, E, R> = Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>>>;
     /**
@@ -2611,9 +2804,17 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
+    type InvokeResolvedSource<Source> = Source extends (...args: any) => infer Resolved ? Resolved : Source;
+    type ChildMachineLogic<Child> = Child extends ChildMachine<string, infer M> ? Logic<Snapshot<States<M>>, EventInput<InputEvent<M>>, Error<M> | ActionError<Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialServices<M> | Services<M>>, internalRuntime.MachineRuntime>, Event<M>, Emit<M>>, Output<M>, InitialError<M> | Error<M> | ActionError<InitialServices<M> | Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError> : never;
     type InvokeLogic<Invoke> = Invoke extends {
-        readonly src: (...args: any) => infer Logic;
-    } ? Logic : never;
+        readonly effect: infer Source;
+    } ? InvokeResolvedSource<Source> extends infer Fx extends Effect.Effect<any, any, any> ? Logic<void, never, Effect.Error<Fx>, Effect.Services<Fx>, Effect.Success<Fx>> : never : Invoke extends {
+        readonly after: unknown;
+    } ? Logic<void, never, never, never, void> : Invoke extends {
+        readonly logic: infer Source;
+    } ? InvokeResolvedSource<Source> : Invoke extends {
+        readonly child: infer Child;
+    } ? ChildMachineLogic<Child> : never;
     /**
      * Extracts the startup error from an invoke source child process logic.
      *
@@ -2666,34 +2867,41 @@ export declare namespace Machine {
      */
     type InvokeEmits<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
-            readonly emits: Types.Covariant<infer Emits>;
+            readonly emits: Types.Covariant<infer Emitted>;
         };
-    } ? Emits : never;
-    /**
-     * Extracts events returned by an invoked child snapshot mapper.
-     *
-     * @category utility types
-     * @since 0.4.0
-     */
-    type InvokeSnapshotEvent<Invoke> = Invoke extends {
+    } ? Emitted : Invoke extends {
+        readonly child: ChildMachine<string, infer M>;
+    } ? Emit<M> : never;
+    /** Public parent inputs required by an invoked child machine. */
+    type InvokeParentEvents<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
-            readonly snapshotEvent: Types.Covariant<infer Event>;
+            readonly parentEvents: Types.Covariant<infer ParentEvent>;
         };
-    } ? Event : never;
+    } ? ParentEvent : IsAny<Invoke> extends true ? never : Invoke extends {
+        readonly child: ChildMachine<string, infer M>;
+    } ? EventOf<ParentEvents<M>> : never;
+    /** Extracts transition results returned by invocation lifecycle handlers. */
+    type InvokeOutcomeReturn<Invoke> = Invoke extends unknown ? (Invoke extends {
+        readonly onDone?: infer Handler;
+    } ? EventTransitionReturn<NonNullable<Handler>> : never) | (Invoke extends {
+        readonly onFailure?: infer Handler;
+    } ? EventTransitionReturn<NonNullable<Handler>> : never) | (Invoke extends {
+        readonly onSnapshot?: infer Handler;
+    } ? EventTransitionReturn<NonNullable<Handler>> : never) : never;
     /**
      * Extracts the parent transition error contribution from invoked children.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type InvokeError<Config> = [InvokeReturn<Config>] extends [never] ? never : ChildAlreadyExistsError | InvokeInitialError<InvokeReturn<Config>> | InvokeRuntimeError<InvokeReturn<Config>>;
+    type InvokeError<Config> = [InvokeReturn<Config>] extends [never] ? never : ChildAlreadyExistsError | InvokeInitialError<InvokeReturn<Config>> | Effect.Error<InvokeOutcomeReturn<InvokeReturn<Config>>>;
     /**
      * Extracts the parent service requirement contribution from invoked children.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type InvokeRequirements<Config> = [InvokeReturn<Config>] extends [never] ? never : MachineRuntimeRequirement | InvokeServices<InvokeReturn<Config>>;
+    type InvokeRequirements<Config> = [InvokeReturn<Config>] extends [never] ? never : MachineRuntimeRequirement | InvokeServices<InvokeReturn<Config>> | Effect.Services<InvokeOutcomeReturn<InvokeReturn<Config>>>;
     /**
      * Extracts the return value from an eventless transition.
      *
@@ -2728,63 +2936,172 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type ConfigServices<Config> = Effect.Services<EventHandlerReturn<Config>> | Effect.Services<AlwaysReturn<Config>> | Effect.Services<DoneReturn<Config>> | Effect.Services<StateActionReturn<Config, "entry">> | Effect.Services<StateActionReturn<Config, "exit">> | Effect.Services<StateInitialReturn<Config>> | Effect.Services<HistoryDefaultReturn<Config>> | Effect.Services<ChoiceReturn<Config>> | InvokeRequirements<Config>;
-    /**
-     * Configuration for invoking a child process while a state is active.
-     *
-     * @category models
-     * @since 0.4.0
-     */
-    interface InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Event, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, ChildEmits = never, DeliveredOutput = ChildOutput> {
-        readonly [InvokeTypeId]: {
-            readonly output: Types.Covariant<DeliveredOutput>;
-            readonly emits: Types.Covariant<ChildEmits>;
-            readonly snapshotEvent: Types.Covariant<Event>;
-            readonly error: Types.Covariant<ChildError>;
-            readonly requirements: Types.Covariant<ChildRequirements>;
-            readonly initialError: Types.Covariant<ChildInitialError>;
-        };
-        /** @internal Serializable descriptor metadata used by inspection. */
-        readonly [Activities.ActivityMetadataTypeId]?: Activities.StaticActivityMetadata;
-        readonly id: string;
-        /**
-         * Optional parent-local address for sending events to this invocation.
-         *
-         * The invocation `id` is only its state-local lifecycle key. Use an
-         * explicit typed address when the parent must communicate with it.
-         */
-        readonly address?: string;
-        /** @internal */
-        readonly descriptor?: ChildMachine.Any;
-        src(): Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
-        snapshot?(context: InvokeSnapshotContext<ChildState, ChildError, ChildOutput>): Event | undefined;
-        onDone?(context: InvokeDoneContext<ChildOutput>): DeliveredOutput | undefined;
+    type InvokeTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context> = ((context: Context, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
+        readonly reenter?: boolean;
+        readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
+        readonly transition: (context: Context, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
+    };
+    type InvokeSource<Value, Context> = Value | ((context: Context) => Value);
+    interface AnyLogicSource {
+        initial(...args: ReadonlyArray<any>): Effect.Effect<any, any, any>;
+        run(...args: ReadonlyArray<any>): Effect.Effect<any, any, any>;
     }
-    /** @internal */
-    interface AnyInvokeConfig<Output = unknown, Error = unknown, Requirements = unknown, InitialError = unknown, Emits = never, SnapshotEvent = never> {
+    /** Inline state-owned work that runs for the lifetime of its active state. */
+    interface InvokeOwned<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
+        readonly "~effect/Machine/InvokeOwner"?: Types.Covariant<readonly [States, Events, Emits, StateId]>;
+    }
+    /** Type evidence retained by {@link invoke} without affecting runtime data. */
+    interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never, ParentEvent = never> {
         readonly [InvokeTypeId]: {
             readonly output: Types.Covariant<Output>;
-            readonly emits: Types.Covariant<Emits>;
-            readonly snapshotEvent: Types.Covariant<SnapshotEvent>;
             readonly error: Types.Covariant<Error>;
             readonly requirements: Types.Covariant<Requirements>;
             readonly initialError: Types.Covariant<InitialError>;
+            readonly emits: Types.Covariant<Emits>;
+            readonly parentEvents: Types.Covariant<ParentEvent>;
         };
     }
-    interface InvokeDefinitionValue {
-        readonly [InvokeTypeId]: unknown;
-    }
-    /**
-     * State-bound configuration for invoked child processes.
-     *
-     * **Details**
-     *
-     * A function form receives the owning state's typed value and lifecycle
-     * event before constructing one or more invoke configurations.
-     *
-     * @category models
-     * @since 0.4.0
-     */
-    type InvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeDefinitionValue | ReadonlyArray<InvokeDefinitionValue> | ((context: InvokeContext<States, Events, Emits, StateId>) => InvokeDefinitionValue | ReadonlyArray<InvokeDefinitionValue>);
+    type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeOwned<States, Events, Emits, StateId> & ({
+        readonly id: string;
+        readonly effect: InvokeSource<Effect.Effect<any, any, any>, InvokeContext<States, Events, Emits, StateId>>;
+        readonly after?: never;
+        readonly logic?: never;
+        readonly child?: never;
+        readonly address?: never;
+        readonly onDone?: unknown;
+        readonly onFailure?: unknown;
+        readonly onSnapshot?: never;
+    } | {
+        readonly id: string;
+        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>;
+        readonly effect?: never;
+        readonly logic?: never;
+        readonly child?: never;
+        readonly address?: never;
+        readonly onDone: unknown;
+        readonly onFailure?: never;
+        readonly onSnapshot?: never;
+    } | {
+        readonly id: string;
+        readonly address: string;
+        readonly logic: InvokeSource<AnyLogicSource, InvokeContext<States, Events, Emits, StateId>>;
+        readonly effect?: never;
+        readonly after?: never;
+        readonly child?: never;
+        readonly onDone?: unknown;
+        readonly onFailure?: unknown;
+        readonly onSnapshot?: unknown;
+    } | {
+        readonly child: ChildMachine.Any;
+        readonly input?: {} | null | ((context: InvokeContext<States, Events, Emits, StateId>) => unknown);
+        readonly id?: never;
+        readonly address?: never;
+        readonly effect?: never;
+        readonly after?: never;
+        readonly logic?: never;
+        readonly onDone?: unknown;
+        readonly onFailure?: unknown;
+        readonly onSnapshot?: unknown;
+    });
+    /** State-bound inline invocation configuration. */
+    type InvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeConfig<States, Events, Emits, StateId> | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId>>;
+    type InvokeHandlerRequirement<Value, Handler> = IsAny<Value> extends true ? {
+        readonly handler: Handler;
+    } : [Value] extends [never] ? {
+        readonly handler?: never;
+    } : {
+        readonly handler: Handler;
+    };
+    type InvokeDoneRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends infer Requirement ? Requirement extends {
+        readonly handler: infer Required;
+    } ? {
+        readonly onDone: Required;
+    } : {
+        readonly onDone?: never;
+    } : never;
+    type InvokeFailureRequirement<Value, Handler> = InvokeHandlerRequirement<Value, Handler> extends infer Requirement ? Requirement extends {
+        readonly handler: infer Required;
+    } ? {
+        readonly onFailure: Required;
+    } : {
+        readonly onFailure?: never;
+    } : never;
+    type EffectInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Fx extends Effect.Effect<any, any, any>, Source = Fx> = {
+        readonly id: InvokeLifecycleId;
+        readonly effect: Source;
+        readonly after?: never;
+        readonly logic?: never;
+        readonly child?: never;
+        readonly address?: never;
+        readonly onSnapshot?: never;
+    } & InvokeDoneRequirement<Effect.Success<NoInfer<Fx>>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<NoInfer<Fx>>>>> & InvokeFailureRequirement<Effect.Error<NoInfer<Fx>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<NoInfer<Fx>>>>>;
+    type TimerInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = {
+        readonly id: InvokeLifecycleId;
+        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>;
+        readonly effect?: never;
+        readonly logic?: never;
+        readonly child?: never;
+        readonly address?: never;
+        readonly onFailure?: never;
+        readonly onSnapshot?: never;
+        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void>>;
+    };
+    type LogicInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>> = {
+        readonly id: InvokeLifecycleId;
+        readonly address: Address & ChildAddress.Compatibility<Address, ChildEvent>;
+        readonly logic: Source;
+        readonly effect?: never;
+        readonly after?: never;
+        readonly child?: never;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, ChildState, ChildError, ChildOutput>>;
+    } & InvokeDoneRequirement<ChildOutput, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, ChildOutput>>> & InvokeFailureRequirement<ChildError, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, ChildError>>>;
+    type ChildInvokeArgs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, ChildDefinition extends Machine.Any, Child extends ChildMachine<string, ChildDefinition>> = {
+        readonly child: Child & (ChildDefinition extends EnsureExecutable<Machine.States<ChildDefinition>, Machine.UnhandledStates<ChildDefinition>, Machine.OutputStates<ChildDefinition>> ? unknown : never);
+        readonly id?: never;
+        readonly address?: never;
+        readonly effect?: never;
+        readonly after?: never;
+        readonly logic?: never;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>>>;
+    } & (Input<ChildDefinition> extends typeof Schema.Void ? {
+        readonly input?: never;
+    } : {
+        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>;
+    }) & InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>>>>;
+    type LogicStateOf<Value> = Value extends Logic<infer State, any, any, any, any, any> ? State : never;
+    type LogicEventOf<Value> = Value extends Logic<any, infer Event, any, any, any, any> ? Event : never;
+    type LogicErrorOf<Value> = Value extends Logic<any, any, infer Error, any, any, any> ? Error : never;
+    type LogicServicesOf<Value> = Value extends Logic<any, any, any, infer Services, any, any> ? Services : never;
+    type LogicOutputOf<Value> = Value extends Logic<any, any, any, any, infer Output, any> ? Output : never;
+    type LogicInitialErrorOf<Value> = Value extends Logic<any, any, any, any, any, infer Error> ? Error : never;
+    type ContextualInvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Raw> = Raw extends InvokeTyped<any, any, any, any, any> ? unknown : Raw extends {
+        readonly effect: infer Source;
+    } ? InvokeResolvedSource<Source> extends infer Fx extends Effect.Effect<any, any, any> ? InvokeDoneRequirement<Effect.Success<Fx>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>>>> & InvokeFailureRequirement<Effect.Error<Fx>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>>>> & {
+        readonly onSnapshot?: never;
+    } : never : Raw extends {
+        readonly after: unknown;
+    } ? {
+        readonly onDone: InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, void>>;
+        readonly onFailure?: never;
+        readonly onSnapshot?: never;
+    } : Raw extends {
+        readonly logic: infer Source;
+        readonly address: infer Address;
+    } ? InvokeResolvedSource<Source> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ? InvokeDoneRequirement<InvokeOutput<Raw>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>>>> & InvokeFailureRequirement<InvokeRuntimeError<Raw>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, InvokeRuntimeError<Raw>>>> & {
+        readonly address: ChildAddress<never> & ChildAddress.Compatibility<Address, ChildLogic extends Logic<any, infer ChildEvent, any, any, any, any> ? ChildEvent : never>;
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, ChildLogic extends Logic<infer ChildState, any, any, any, any, any> ? ChildState : never, InvokeRuntimeError<Raw>, InvokeOutput<Raw>>>;
+    } : never : Raw extends {
+        readonly child: infer Child extends ChildMachine<string, infer ChildDefinition>;
+    } ? ChildMachineLogic<Child> extends infer ChildLogic extends Logic<any, any, any, any, any, any> ? InvokeDoneRequirement<Output<ChildDefinition>, InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>>>> & InvokeFailureRequirement<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>>>> & (Input<ChildDefinition> extends typeof Schema.Void ? {
+        readonly input?: never;
+    } : {
+        readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>;
+    }) & {
+        readonly onSnapshot?: InvokeTransition<States, Events, Emits, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>>>;
+    } : never : never;
+    type ContextualInvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Raw> = Raw extends ReadonlyArray<any> ? {
+        readonly [Index in keyof Raw]: ContextualInvokeConfig<States, Events, Emits, StateId, Raw[Index]>;
+    } : ContextualInvokeConfig<States, Events, Emits, StateId, Raw>;
     type OutputHandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Context> = NodeByIdentifier<States, StateId> extends {
         readonly output: Schema.Top;
     } ? {
@@ -2803,33 +3120,33 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    type ActiveStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R> = {
-        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
-        readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
+    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 always?: ((context: AlwaysContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
+        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>>;
-            readonly transition: (context: AlwaysContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
+            readonly transition: (context: AlwaysContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
         };
-        readonly onDone?: ((context: DoneContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
+        readonly onDone?: ((context: DoneContext<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>>;
-            readonly transition: (context: DoneContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
+            readonly transition: (context: DoneContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
         };
         readonly on?: {
-            readonly [EventTag in TagOf<Events[number]>]?: ((context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
+            readonly [EventTag in TagOf<Events[number]>]?: ((context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
                 readonly reenter?: boolean;
                 /**
                  * Upper bound of state or history paths this handler may target.
-                 * Returning `void` is always permitted. Declaring a parent state also
+                 * Returning `target.none()` is always permitted. Declaring a parent state also
                  * permits concrete descendant targets below it.
                  */
                 readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
-                readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
+                readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
             };
         };
-        readonly initial?: StateInitialHandler<States, Events, Emits, StateId>;
+        readonly initial?: StateInitialHandler<States, Events, Emits, StateId, InputEvents, ParentEvents>;
     } & ActiveOutputHandlerConfig<States, Events, StateId>;
     /** Values supplied when a statechart implicitly enters a state's initial children. */
     type StateInitialValue<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeByIdentifier<States, StateId> extends infer Node ? Node extends {
@@ -2842,14 +3159,14 @@ export declare namespace Machine {
         readonly initial: infer Initial;
     } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never : NodeValue<Children[Initial]> : never : never : never;
     /** Context passed to an implicit child-state initializer. */
-    type StateInitialContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = StateActionContext<States, Events, Emits, StateId>;
+    type StateInitialContext<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 []> = StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>;
     /** Initial child value implementation for a compound or parallel state. */
-    type StateInitialHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = (context: StateInitialContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateInitialValue<States, StateId>;
+    type StateInitialHandler<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 []> = (context: StateInitialContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateInitialValue<States, StateId>;
     /** Context used only when a history node has no previously captured record. */
     interface HistoryDefaultContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>> {
         readonly event: LifecycleEvent<Events>;
         readonly target: HistoryDefaultTargetBuilder<States, ParentId>;
-        readonly parent: ParentId;
+        readonly owner: ParentId;
     }
     /**
      * Typed fallback evaluated when a history node has no record yet.
@@ -2866,11 +3183,11 @@ export declare namespace Machine {
         };
     };
     /** Required implementation for a choice pseudo-state. */
-    interface ChoiceStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>> {
+    interface ChoiceStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> {
         readonly choice: {
             /** Statically inspectable upper bound of every possible target. */
             readonly targets: readonly [StateNodeIdentifier<States>, ...ReadonlyArray<StateNodeIdentifier<States>>];
-            readonly transition: (context: ChoiceContext<States, Events, Emits, ChoiceId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => ChoiceResult<States, any, any>;
+            readonly transition: (context: ChoiceContext<States, Events, Emits, ChoiceId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => ChoiceResult<States, any, any>;
         };
         readonly entry?: never;
         readonly exit?: never;
@@ -2887,8 +3204,8 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    type FinalStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = {
-        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
+    type FinalStateConfig<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 entry?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
         readonly exit?: never;
         readonly always?: never;
         readonly onDone?: never;
@@ -2900,10 +3217,10 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    type HandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R> = NodeByIdentifier<States, StateId> extends {
+    type HandlerConfig<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 []> = NodeByIdentifier<States, StateId> extends {
         readonly type: "final";
-    } ? FinalStateConfig<States, Events, Emits, StateId> : ActiveStateConfig<States, Events, Emits, StateId, E, R>;
-    type HandlerNodeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Path extends StateNodeIdentifier<States>, E, R> = Path extends ChoiceIdentifier<States> ? ChoiceStateConfig<States, Events, Emits, Path> : Path extends StateIdentifier<States> ? HandlerConfig<States, Events, Emits, Path, E, R> : never;
+    } ? FinalStateConfig<States, Events, Emits, StateId, InputEvents, ParentEvents> : ActiveStateConfig<States, Events, Emits, StateId, E, R, InputEvents, ParentEvents>;
+    type HandlerNodeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Path extends StateNodeIdentifier<States>, E, R, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>> = Path extends ChoiceIdentifier<States> ? ChoiceStateConfig<States, Events, Emits, Path, InputEvents, ParentEvents> : Path extends StateIdentifier<States> ? HandlerConfig<States, Events, Emits, Path, E, R, InputEvents, ParentEvents> : never;
     type HandlerChildren<Node> = Node extends {
         readonly states: infer Children extends StateSchemas;
     } ? Children : never;
@@ -2918,6 +3235,12 @@ export declare namespace Machine {
         readonly states: infer Children extends StateSchemas;
     } ? HandlerNodeByPath<Children, Rest> : never : never : Path extends keyof States ? States[Path] : never;
     type HandlerConfigAtPath<Config, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Config ? HandlerConfigAtPath<HandlerNodeChildrenConfig<Config[Head]>, Rest> : never : Path extends keyof Config ? Config[Path] : never;
+    type HandlerInvokeContextAtPath<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, StateId extends StateNodeIdentifier<AllStates>, NodeConfig = HandlerConfigAtPath<Config, StateId>> = StateId extends StateIdentifier<AllStates> ? NodeConfig extends {
+        readonly invoke: infer Invoke;
+    } ? HandlerValidationAtPath<StateId, {
+        readonly invoke: ContextualInvokeDefinition<AllStates, Events, Emits, StateId, Invoke>;
+    }> : unknown : unknown;
+    type HandlerInvokeContexts<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config> = Types.UnionToIntersection<StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerInvokeContextAtPath<AllStates, Events, Emits, Config, StateId> : never : never>;
     type HandlerValidationAtPath<Path extends string, Validation> = Path extends `${infer Head}.${infer Rest}` ? {
         readonly [Key in Head]?: {
             readonly states: HandlerValidationAtPath<Rest, Validation>;
@@ -2925,21 +3248,21 @@ export declare namespace Machine {
     } : {
         readonly [Key in Path]?: Validation;
     };
-    type HandlerNode<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, StateId extends StateNodeIdentifier<AllStates>> = HandlerNodeConfig<AllStates, Events, Emits, StateId, E, R> & (StateId extends ChoiceIdentifier<AllStates> ? {
+    type HandlerNode<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>> = HandlerNodeConfig<AllStates, Events, Emits, StateId, E, R, InputEvents, ParentEvents> & (StateId extends ChoiceIdentifier<AllStates> ? {
         readonly states?: never;
         readonly history?: never;
     } : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? {
         readonly states?: never;
         readonly history?: never;
     } : {
-        readonly states?: HandlerTree<AllStates, Children, Events, Emits, E, R, Extract<StateId, StateIdentifier<AllStates>>>;
+        readonly states?: HandlerTree<AllStates, Children, Events, Emits, E, R, InputEvents, ParentEvents, Extract<StateId, StateIdentifier<AllStates>>>;
         readonly history?: HistoryDefaultConfig<AllStates, Events, Emits, Extract<StateId, StateIdentifier<AllStates>>, Children>;
     } : {
         readonly states?: never;
         readonly history?: never;
     });
-    type HandlerTree<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, Prefix extends string> = {
-        readonly [Key in ActiveStateKey<States> | ChoiceStateKey<States>]?: HandlerNode<AllStates, States[Key], Events, Emits, E, R, HandlerNodeId<AllStates, JoinPath<Prefix, Key>>>;
+    type HandlerTree<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Prefix extends string> = {
+        readonly [Key in ActiveStateKey<States> | ChoiceStateKey<States>]?: HandlerNode<AllStates, States[Key], Events, Emits, E, R, InputEvents, ParentEvents, HandlerNodeId<AllStates, JoinPath<Prefix, Key>>>;
     };
     type HandlerNodeConfigKey = "always" | "choice" | "entry" | "exit" | "history" | "initial" | "invoke" | "on" | "onDone" | "output" | "states";
     type HandlerValidationError<Message extends string, Path extends string, Detail = unknown> = {
@@ -3020,7 +3343,7 @@ export declare namespace Machine {
     ] extends [never] ? unknown : {
         readonly output: HandlerValidationError<"Handler config is missing a region output implementation required by parallel output", StateId, Exclude<RequiredParallelOutputStates<AllStates, StateId>, AvailableOutputStates>>;
     } : unknown : unknown);
-    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = StateId extends ChoiceIdentifier<AllStates> ? HandlerChoiceUnknownConfigKeyValidation<StateId, Config> & HandlerChoiceTargetValidation<StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : StateId extends StateIdentifier<AllStates> ? HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerOnTargetValidation<StateId, Config> & HandlerDirectTargetValidation<StateId, Config, "always"> & HandlerDirectTargetValidation<StateId, Config, "onDone"> & HandlerInvokeOutputValidation<Events, StateId, Config> & HandlerInvokeEmitsValidation<Events, StateId, Config> & HandlerInvokeSnapshotValidation<Events, StateId, Config> & HandlerChildrenValidation<Node, StateId, Config> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : unknown;
+    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = StateId extends ChoiceIdentifier<AllStates> ? HandlerChoiceUnknownConfigKeyValidation<StateId, Config> & HandlerChoiceTargetValidation<StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : StateId extends StateIdentifier<AllStates> ? HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerOnTargetValidation<StateId, Config> & HandlerDirectTargetValidation<StateId, Config, "always"> & HandlerDirectTargetValidation<StateId, Config, "onDone"> & HandlerInvokeParentEventsValidation<InputEvents, StateId, Config> & HandlerChildrenValidation<Node, StateId, Config> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : unknown;
     type HandlerChoiceUnknownConfigKeyValidation<StateId extends string, Config, UnknownKeys extends string = Exclude<Extract<keyof Config, string>, "choice">> = [UnknownKeys] extends [never] ? unknown : {
         readonly [Key in UnknownKeys]: HandlerValidationError<"Choice handler config contains an invalid key", StateId, Key>;
     };
@@ -3029,19 +3352,13 @@ export declare namespace Machine {
     } ? [UndeclaredTransitionTarget<Choice>] extends [never] ? unknown : {
         readonly choice: HandlerValidationError<"Choice resolver returns a target not listed in targets", StateId, UndeclaredTransitionTarget<Choice>>;
     } : unknown;
-    type HandlerInvokeOutputValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>] extends [never] ? unknown : {
-        readonly invoke: HandlerValidationError<"Invoked child output must be a machine event or void", StateId, Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>>;
-    };
-    type HandlerInvokeEmitsValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown : {
-        readonly invoke: HandlerValidationError<"Invoked child emits events not accepted by the parent machine", StateId, Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>>;
-    };
-    type HandlerInvokeSnapshotValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : IsAny<InvokeSnapshotEvent<InvokeReturn<Config>>> extends true ? unknown : [Exclude<InvokeSnapshotEvent<InvokeReturn<Config>>, EventOf<Events> | undefined>] extends [never] ? unknown : {
-        readonly invoke: HandlerValidationError<"Invoked child snapshot mapper must return a machine event or undefined", StateId, Exclude<InvokeSnapshotEvent<InvokeReturn<Config>>, EventOf<Events> | undefined>>;
+    type HandlerInvokeParentEventsValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeParentEvents<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown : {
+        readonly invoke: HandlerValidationError<"Invoked child expects parent events not accepted by this machine", StateId, Exclude<InvokeParentEvents<InvokeReturn<Config>>, EventOf<Events>>>;
     };
     type HandlerRuntimeValidation<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends string, Config, Incompatible = IncompatibleRuntime<ConfigServices<HandlerConfigPart<Config>>, EventOf<Events>, EmitOf<Emits>>> = [Incompatible] extends [never] ? unknown : HandlerValidationError<"Handler config requires an incompatible machine runtime", StateId, Incompatible>;
-    type HandlerNodeValidationAtPath<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>, StateId extends StateNodeIdentifier<AllStates>, NodeConfig = HandlerConfigAtPath<Config, StateId>> = [NodeConfig] extends [never] ? never : HandlerNodeValidation<AllStates, HandlerNodeByPath<AllStates, StateId>, Events, Emits, StateId, NodeConfig, AvailableOutputStates> extends infer Validation ? unknown extends Validation ? never : HandlerValidationAtPath<StateId, Validation> : never;
-    type HandlerTreeNodeValidations<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = Types.UnionToIntersection<StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerNodeValidationAtPath<AllStates, Events, Emits, Config, AvailableOutputStates, StateId> : never : never>;
-    type HandlerTreeValidation<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = HandlerUnknownStateKeyValidation<AllStates, "", Config> & HandlerTreeNodeValidations<AllStates, Events, Emits, Config, AvailableOutputStates>;
+    type HandlerNodeValidationAtPath<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>, StateId extends StateNodeIdentifier<AllStates>, NodeConfig = HandlerConfigAtPath<Config, StateId>> = [NodeConfig] extends [never] ? never : HandlerNodeValidation<AllStates, HandlerNodeByPath<AllStates, StateId>, Events, InputEvents, Emits, StateId, NodeConfig, AvailableOutputStates> extends infer Validation ? unknown extends Validation ? never : HandlerValidationAtPath<StateId, Validation> : never;
+    type HandlerTreeNodeValidations<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = Types.UnionToIntersection<StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerNodeValidationAtPath<AllStates, Events, InputEvents, Emits, Config, AvailableOutputStates, StateId> : never : never>;
+    type HandlerTreeValidation<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = HandlerUnknownStateKeyValidation<AllStates, "", Config> & HandlerTreeNodeValidations<AllStates, Events, InputEvents, Emits, Config, AvailableOutputStates>;
     type HandlerHasRequiredInitial<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = StateId extends RequiredHistoryInitializers<AllStates> ? "initial" extends keyof Config ? true : false : true;
     type HandlerHasRequiredHistoryDefaults<Node, Config> = Node extends {
         readonly states: infer Children extends StateSchemas;
@@ -3066,15 +3383,15 @@ export declare namespace Machine {
         readonly outputState: StateId extends StateIdentifier<AllStates> ? HandlerOutputStates<AllStates, StateId, HandlerConfigPart<NodeConfig>> : never;
     };
     type HandlerTreeEvidence<AllStates extends StateSchemas, Config> = StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerNodeEvidence<AllStates, Config, StateId> : never : never;
-    type HandleTreeResult<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<AllStates>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<AllStates>, Output, OutputStates extends StateIdentifier<AllStates>, InputEvents extends ReadonlyArray<TaggedSchema>, Config> = Machine<AllStates, Events, Input, Exclude<UnhandledStates, HandlerTreeEvidence<AllStates, Config>["stateId"]>, E | HandlerTreeEvidence<AllStates, Config>["error"], ExcludeCompatibleRuntime<R | HandlerTreeEvidence<AllStates, Config>["services"], EventOf<Events>, EmitOf<Emits>>, InitialE, InitialR, FinalStates, Output, Emits, OutputStates | Extract<HandlerTreeEvidence<AllStates, Config>["outputState"], StateIdentifier<AllStates>>, InputEvents>;
+    type HandleTreeResult<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<AllStates>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<AllStates>, Output, OutputStates extends StateIdentifier<AllStates>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Config> = Machine<AllStates, Events, Input, Exclude<UnhandledStates, HandlerTreeEvidence<AllStates, Config>["stateId"]>, E | HandlerTreeEvidence<AllStates, Config>["error"], ExcludeCompatibleRuntime<R | HandlerTreeEvidence<AllStates, Config>["services"], EventOf<Events>, EmitOf<Emits>>, InitialE, InitialR, FinalStates, Output, Emits, OutputStates | Extract<HandlerTreeEvidence<AllStates, Config>["outputState"], StateIdentifier<AllStates>>, InputEvents, ParentEvents>;
     /**
      * Adds state handlers from a root state object.
      *
      * @category combinators
      * @since 0.4.0
      */
-    interface Handler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<States>, Output, OutputStates extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>> {
-        <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(config: Config & HandlerTreeValidation<States, Events, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, Config>;
+    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>;
     }
     /**
      * Any state config.
@@ -3137,7 +3454,7 @@ export declare const isMachine: (u: unknown) => u is Machine.Any;
  * @category guards
  * @since 0.4.0
  */
-export declare const isFinal: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, state: Machine.Snapshot<States>) => state is Machine.SnapshotContainingFinal<States, FinalStates>;
+export declare const isFinal: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, 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>, state: Machine.Snapshot<States>) => state is Machine.SnapshotContainingFinal<States, FinalStates>;
 /**
  * Defines a state tree while preserving literal state paths.
  *
@@ -3166,7 +3483,7 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *
  * Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.idle.from()
  * })
  * ```
@@ -3175,19 +3492,20 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  * @since 0.4.0
  */
 export declare const defineStates: DefineStates;
-type MakeConfig<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>> = {
+type MakeConfig<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = {
     readonly id?: string;
     readonly states: States & DefineStateTreeInput<NoInfer<States>>;
-    readonly events: InputEvents & ValidateInputEventProtocol<NoInfer<InputEvents>>;
-    readonly internalEvents?: InternalEvents & ValidateInternalEventProtocol<NoInfer<InputEvents>, NoInfer<InternalEvents>>;
-    readonly emits?: Emits;
+    readonly events: Machine.EventProtocol<"public", InputEvents> & ValidateInputEventProtocol<NoInfer<InputEvents>>;
+    readonly internalEvents?: Machine.EventProtocol<"internal", InternalEvents> & ValidateInternalEventProtocol<NoInfer<InputEvents>, NoInfer<InternalEvents>>;
+    readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>;
+    readonly parentEvents?: Machine.EventProtocol<"public", ParentEvents>;
     readonly input?: Input;
     readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>;
 };
-type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>> = Machine<States, readonly [...InputEvents, ...InternalEvents], Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, never, InputEvents>;
+type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = Machine<States, readonly [...InputEvents, ...InternalEvents], Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, never, InputEvents, ParentEvents>;
 interface Make {
-    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>;
-    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>, "states"> & {
+    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>;
+    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "states"> & {
         readonly states: InvalidDefinedStateTreeInput<States>;
     }): never;
 }
@@ -3202,10 +3520,13 @@ interface Make {
  * `defineStates` or is passed inline. Call `handle` on the returned definition
  * to implement state behavior with ordinary TypeScript control flow.
  *
- * Schemas in `events` define the public input protocol. Schemas in
- * `internalEvents` are added to the complete handler protocol for invoke
- * results, child emissions, and other machine-local deliveries. Their tags
- * must be disjoint.
+ * `Machine.events` defines the public input protocol. `Machine.internalEvents`
+ * 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
+ * schemas opaquely for runtime validation. Public and internal tags must be
+ * disjoint.
  *
  * **Example** (Typed counter machine)
  *
@@ -3222,10 +3543,11 @@ interface Make {
  * }) {}
  *
  * const States = Machine.defineStates({ Count })
+ * const Events = Machine.events(Increment)
  *
  * const counter = Machine.make({
  *   states: States.states,
- *   events: [Increment],
+ *   events: Events,
  *   initial: () => States.initial.Count(new Count({ value: 0 }))
  * }).handle({
  *   Count: {
@@ -3242,49 +3564,75 @@ interface Make {
  * @since 0.4.0
  */
 export declare const make: Make;
-type EventConstructorArgs<EventSchema extends Machine.TaggedSchema> = {} extends EventSchema["~type.make.in"] ? [
-    input?: EventSchema["~type.make.in"]
-] : [input: EventSchema["~type.make.in"]];
 /**
- * Constructs an event from a schema owned by a machine's protocol.
+ * Extracts the decoded event union carried by an event protocol descriptor.
  *
- * **Details**
- *
- * The schema constructor runs exactly once. The resulting decoded event is
- * trusted by this machine and definitions derived from it with `handle`, so
- * repeated delivery does not decode the same already-constructed value again.
- * Events supplied through ordinary `send` and `plan` calls remain untrusted
- * and continue through full runtime schema validation.
- * Treat the returned event as immutable after construction.
+ * @category utility types
+ * @since 0.10.0
+ */
+export type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventOf<Machine.EventProtocolSchemas<Protocol>>;
+/**
+ * Defines a public event protocol and returns deferred constructors for every
+ * statically finite configured event tag.
  *
- * The schema must be one of the machine's configured public or internal event
- * schemas, or a case schema belonging to a configured `Schema.TaggedUnion`.
+ * Constructor inputs retain their schema-derived required fields, defaults,
+ * and transformations. Construction is deferred until delivery so failures
+ * enter the machine's `MachineSchemaDecodeError` channel rather than throwing
+ * at the call site.
  *
  * **Example**
  *
  * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
+ * const Events = Machine.events(Increment, Reset)
+ * const machine = Machine.make({ events: Events, ... })
+ * yield* ref.send(Events.Increment({ by: 1 }))
+ * ```
  *
- * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * class Increment extends Schema.TaggedClass<Increment>("Increment")("Increment", {
- *   by: Schema.Number
- * }) {}
+ * @category constructors
+ * @since 0.10.0
+ */
+export declare const events: {
+    <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(...schemas: Schemas & ValidateInputEventProtocol<NoInfer<Schemas>>): Machine.EventProtocol<"public", readonly [...Schemas]>;
+    <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"public">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"public", Inputs>): Machine.EventProtocol<"public", Machine.EventProtocolInputSchemasOf<"public", Inputs>>;
+};
+/**
+ * Defines an internal event protocol and returns deferred constructors for
+ * every statically finite configured event tag.
  *
- * const States = Machine.defineStates({ Idle })
- * const counter = Machine.make({
- *   states: States.states,
- *   events: [Increment],
- *   initial: () => States.initial.Idle.from()
- * }).handle({ Idle: { on: { Increment: () => States.initial.Idle.from() } } })
+ * Use these constructors for raised events and other machine-local deliveries.
+ * Construction failures are reported through the
+ * owning machine's `MachineSchemaDecodeError` channel.
+ *
+ * **Example**
+ *
+ * ```ts
+ * const InternalEvents = Machine.internalEvents(Loaded, Failed)
+ * const machine = Machine.make({ internalEvents: InternalEvents, ... })
  *
- * const increment = Machine.event(counter, Increment, { by: 1 })
+ * // Inside a transition callback:
+ * enqueue.raise(InternalEvents.Loaded({ value }))
  * ```
  *
  * @category constructors
- * @since 0.4.0
+ * @since 0.10.0
+ */
+export declare const internalEvents: {
+    <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(...schemas: Schemas & ValidateInternalEventProtocol<readonly [], NoInfer<Schemas>>): Machine.EventProtocol<"internal", readonly [...Schemas]>;
+    <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"internal">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"internal", Inputs>): Machine.EventProtocol<"internal", Machine.EventProtocolInputSchemasOf<"internal", Inputs>>;
+};
+/**
+ * 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
+ * the AtomMachine emission stream adapters.
+ *
+ * @category constructors
+ * @since 0.10.0
  */
-export declare const event: <const M extends Machine.Any, const EventSchema extends Machine.TaggedSchema>(machine: M, schema: EventSchema & ([EventSchema["Type"]] extends [Machine.Event<M>] ? unknown : never), ...args: EventConstructorArgs<EventSchema>) => EventSchema["Type"];
+export declare const emittedEvents: {
+    <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(...schemas: Schemas & ValidateEmittedEventProtocol<NoInfer<Schemas>>): Machine.EventProtocol<"emitted", readonly [...Schemas]>;
+    <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"emitted">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"emitted", Inputs>): Machine.EventProtocol<"emitted", Machine.EventProtocolInputSchemasOf<"emitted", Inputs>>;
+};
 /**
  * Encodes a decoded machine snapshot into a normalized data representation.
  *
@@ -3318,7 +3666,7 @@ export declare const event: <const M extends Machine.Any, const EventSchema exte
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -3332,7 +3680,7 @@ export declare const event: <const M extends Machine.Any, const EventSchema exte
  * @category encoding
  * @since 0.4.0
  */
-export declare const encodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, snapshot: Machine.Snapshot<States>) => Effect.Effect<Machine.EncodedSnapshot, MachineSchemaEncodeError, Machine.SnapshotEncodingServices<States>>;
+export declare const encodeSnapshot: <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>, snapshot: Machine.Snapshot<States>) => Effect.Effect<Machine.EncodedSnapshot, MachineSchemaEncodeError, Machine.SnapshotEncodingServices<States>>;
 /**
  * Decodes a normalized data representation into a validated machine snapshot.
  *
@@ -3362,7 +3710,7 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -3377,207 +3725,81 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * @category decoding
  * @since 0.4.0
  */
-export declare const decodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
-/**
- * Creates an invoked child process configuration for an active state.
- *
- * **When to use**
- *
- * Use to run a child process while a machine remains in a state. Successful
- * outputs are sent directly to the parent machine as events; `void` sends
- * nothing. Unrecovered child failures fail the owning machine. Active
- * snapshots can optionally be mapped to progress events.
- *
- * **Gotchas**
- *
- * Invoked child processes run while their owning state is active and are
- * stopped before the state exits. An unrecovered child failure fails the owning
- * machine; recover inside the child Effect when failure should become an event.
- * The `id` is a state-local lifecycle key, not a communication address. To
- * send events to the invocation, pass a typed `childAddress` as `address`.
- * The `src` callback is intentionally independent from its parent state. When
- * construction depends on the typed state, lifecycle event, or runtime, use
- * the state config factory form `invoke: (context) => Machine.invoke(...)` and
- * close over that context from `src`.
- *
- * **Example** (Effect output as a parent event)
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
- *   value: Schema.String
- * }) {}
- *
- * const load = Machine.invoke({
- *   id: "load",
- *   src: () => Machine.effect(Effect.succeed(new Loaded({ value: "ready" })))
- * })
- * ```
- *
- * @see {@link effect} for one-shot child effects.
- * @see {@link spawn} for children whose lifetime is controlled by actions.
- * @category constructors
- * @since 0.4.0
- */
-export declare const invoke: <ChildState, ChildEvent, ChildError = never, ChildRequirements = never, ChildOutput = never, ChildInitialError = never, Event = never, Address extends ChildAddress<never> | undefined = undefined>(config: {
+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>> = {
     readonly id: InvokeLifecycleId;
-    readonly src: () => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
-    readonly snapshot?: (context: Machine.InvokeSnapshotContext<ChildState, ChildError, ChildOutput>) => Event | undefined;
-} & ([Address] extends [undefined] ? {
+    readonly effect: Source;
+    readonly after?: never;
+    readonly logic?: never;
+    readonly child?: never;
     readonly address?: never;
-} : {
-    readonly address: Exclude<Address, undefined>;
-} & ChildAddress.Compatibility<Exclude<Address, undefined>, NoInfer<ChildEvent>>)) => Machine.InvokeConfig<any, any, any, any, Event, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
-type InvokeEffectResult<Requirements, Event> = Machine.InvokeConfig<any, any, any, any, never, void, never, never, Requirements, Event | void, never>;
-type InvokeEffectIsInfallible<Fx extends Effect.Effect<any, any, any>> = IsAny<Effect.Error<Fx>> extends true ? false : [Effect.Error<Fx>] extends [never] ? true : false;
-type InvokeEffectConfig<Fx extends Effect.Effect<any, any, any>, SuccessEvent, FailureEvent> = {
-    readonly id: InvokeLifecycleId;
-    readonly effect: Fx;
-    readonly onSuccess: (value: NoInfer<Effect.Success<Fx>>) => SuccessEvent | void;
-} & (InvokeEffectIsInfallible<Fx> extends true ? {
-    readonly onFailure?: never;
-} : {
-    readonly onFailure: (error: NoInfer<Effect.Error<Fx>>) => FailureEvent | void;
-});
+    readonly onSnapshot?: never;
+};
+type DynamicEffectDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>>>;
+type DynamicEffectFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>>>;
+type DynamicEffectInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeConfig<States, Events, Emits, StateId> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never>;
+type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false;
 /**
- * Invokes one Effect and maps its typed outcome into machine-local events.
+ * Preserves inference for a state-owned invocation configuration.
  *
- * **Details**
+ * Use `effect` for one-shot work, `after` for a cancellable timer, `logic` for
+ * reusable process logic, or `child` for a complete child machine. `onDone` is
+ * required whenever the source can complete with an output, while `onFailure`
+ * is required only when the source has a typed failure channel.
  *
- * This is the high-level one-shot counterpart to `invoke`. Success and typed
- * failure values are mapped independently, so callers do not need to recover
- * an Effect into a common event union by hand. Defects and interruption remain
- * failures of the owning machine.
- *
- * Declare mapped outcomes in `internalEvents` unless they are also legitimate
- * public commands.
- *
- * **Example**
+ * This constructor is an identity at runtime, but preserves lifecycle callback
+ * inference through published declarations. Effects and durations may be
+ * supplied directly or derived from the owning state's entry context. Dynamic
+ * Effect sources infer the owner context, output, error, and service channels
+ * together without a return annotation. Logic invocations require both a
+ * lifecycle `id` and a typed communication `address`. Child descriptors already
+ * own their identity, so `id` and `address` must not be repeated.
  *
  * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
- *   value: Schema.String
- * }) {}
- *
- * const load = Machine.invokeEffect({
+ * invoke: Machine.invoke({
  *   id: "load",
- *   effect: Effect.succeed("ready"),
- *   onSuccess: (value) => new Loaded({ value })
+ *   effect: Effect.tryPromise({
+ *     try: () => fetch("/api/data").then((response) => response.json()),
+ *     catch: (cause) => new LoadError({ cause })
+ *   }),
+ *   onDone: ({ output, target }) => target.full.Ready({ data: output }),
+ *   onFailure: ({ error, target }) => target.full.Failed({ error })
  * })
  * ```
  *
- * @see {@link invoke} for arbitrary child process logic.
- * @see {@link after} for a state-scoped delayed event.
- * @category constructors
- * @since 0.4.0
- */
-export declare const invokeEffect: <const Fx extends Effect.Effect<any, any, any>, SuccessEvent, FailureEvent = never>(config: InvokeEffectConfig<Fx, SuccessEvent, FailureEvent>) => InvokeEffectResult<Effect.Services<Fx>, SuccessEvent | (InvokeEffectIsInfallible<Fx> extends true ? never : FailureEvent)>;
-/**
- * Creates a cancellable state-scoped delayed event.
- *
- * The timer starts when its owning state is entered and is interrupted when
- * that state exits. The delayed value should normally be declared in
- * `internalEvents`.
- *
- * **Example**
- *
- * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class TimedOut extends Schema.TaggedClass<TimedOut>("TimedOut")("TimedOut", {}) {}
- *
- * const timeout = Machine.after("5 seconds", new TimedOut({}))
- * ```
- *
  * @category constructors
- * @since 0.4.0
- */
-export declare const after: <Event extends {
-    readonly _tag: PropertyKey;
-}>(duration: Duration.Input, event: Event, options?: {
-    readonly id?: InvokeLifecycleId;
-}) => InvokeEffectResult<never, Event>;
-type RetagFields<Target extends Machine.TaggedSchema> = Omit<Target["~type.make.in"], "_tag">;
-type RetagTargetCompatibility<Target extends Machine.TaggedSchema> = Target extends {
-    readonly fields: Schema.Struct.Fields;
-} ? "_tag" extends keyof Target["~type.make.in"] ? {} extends Pick<Target["~type.make.in"], "_tag"> ? unknown : {
-    readonly "~effect/Machine/RetagTargetError": "Target schema must supply its discriminator when make is called";
-} : unknown : {
-    readonly "~effect/Machine/RetagTargetError": "Target schema must be one tagged struct or tagged class";
-};
-type RequiredKeys<A> = {
-    readonly [Key in keyof A]-?: {} extends Pick<A, Key> ? never : Key;
-}[keyof A];
-type CompatibleSourceKeys<Fields, Source> = {
-    readonly [Key in Extract<keyof Fields, keyof Source>]: Source[Key] extends Fields[Key] ? Key : never;
-}[Extract<keyof Fields, keyof Source>];
-type RetagPatch<Target extends Machine.TaggedSchema, Source> = Partial<RetagFields<Target>> & Pick<RetagFields<Target>, Exclude<RequiredKeys<RetagFields<Target>>, CompatibleSourceKeys<RetagFields<Target>, Source>>>;
-type RetagArgs<Target extends Machine.TaggedSchema, Source> = [
-    Exclude<RequiredKeys<RetagFields<Target>>, CompatibleSourceKeys<RetagFields<Target>, Source>>
-] extends [never] ? [patch?: RetagPatch<Target, Source>] : [patch: RetagPatch<Target, Source>];
-/**
- * Constructs another tagged case from compatible source fields.
- *
- * The target must be one tagged struct or tagged class whose discriminator is
- * supplied by its constructor. Union wrappers are rejected because their
- * `make` operation cannot select a member after the source discriminator has
- * been discarded. Missing or incompatible required target fields must be
- * supplied by the patch, and the target schema's normal `make` validation
- * remains authoritative at runtime.
- *
- * @category constructors
- * @since 0.4.0
+ * @since 0.9.0
  */
-export declare const retag: <const Target extends Machine.TaggedSchema, const Source extends {
-    readonly _tag: PropertyKey;
-}>(target: Target & RetagTargetCompatibility<Target>, source: Source, ...args: RetagArgs<Target, Source>) => Target["Type"];
-type InvokeMachineInput<Input extends Schema.Top> = Input extends typeof Schema.Void ? {
-    readonly input?: never;
-} : {
-    readonly input: Input["Type"];
-};
-/**
- * Creates an invoked child process from a complete statechart machine.
- *
- * **When to use**
- *
- * Use when a state should own another statechart machine and communicate with
- * it through typed child events, emissions, snapshots, or terminal output.
- *
- * **Details**
- *
- * Child emissions are delivered directly to the parent as events. Active
- * snapshots and terminal output can be mapped to parent events. The owning
- * state controls the child lifetime.
- *
- * **Gotchas**
- *
- * Active invoked machines must have unique child addresses. A machine starts
- * after its owning state's entry actions, so those actions cannot send events
- * to a newly entered child. Unrecovered child failures fail the parent.
- *
- * @see {@link invoke} for invoking lower-level process logic.
- * @see {@link sendTo} for sending events to the invoked machine.
- * @category constructors
- * @since 0.4.0
- */
-export declare const invokeMachine: {
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, SnapshotEvent = never, DoneEvent = never, Id extends string = string, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(config: {
-        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>>;
-        readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
-        readonly onDone: (context: Machine.InvokeDoneContext<Output>) => DoneEvent | undefined;
-    } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>, DoneEvent>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, SnapshotEvent = never, Id extends string = string, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(config: {
-        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>>;
-        readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
+export declare const invoke: {
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Effect.Effect<unknown, unknown, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
+        readonly onDone: DynamicEffectDoneHandler<States, Events, Emits, StateId, Source>;
+        readonly onFailure: DynamicEffectFailureHandler<States, Events, Emits, StateId, Source>;
+    }, ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
+        "onDone must be omitted when the Effect output is never"
+    ] : InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
+        "onFailure must be omitted when the Effect error is never"
+    ] : []): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Effect.Effect<unknown, never, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
+        readonly onDone: DynamicEffectDoneHandler<States, Events, Emits, StateId, Source>;
+        readonly onFailure?: never;
+    }, ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
+        "onDone must be omitted when the Effect output is never"
+    ] : []): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Effect.Effect<never, unknown, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
+        readonly onDone?: never;
+        readonly onFailure: DynamicEffectFailureHandler<States, Events, Emits, StateId, Source>;
+    }, ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
+        "onFailure must be omitted when the Effect error is never"
+    ] : []): DynamicEffectInvokeResult<States, Events, Emits, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Effect.Effect<never, never, unknown>>(config: DynamicEffectInvokeSource<States, Events, Emits, StateId, Source> & {
         readonly onDone?: never;
-    } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>>;
+        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"]>>>;
 };
 /**
  * Plans the initial state for a machine without executing actor commands.
@@ -3607,7 +3829,7 @@ export declare const invokeMachine: {
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -3619,7 +3841,7 @@ export declare const invokeMachine: {
  * @category constructors
  * @since 0.4.0
  */
-export declare const planInitial: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
+export declare const planInitial: <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<{
     readonly startingState: Machine.Snapshot<States>;
     readonly initialEntryPaths: ReadonlyArray<Machine.StateIdentifier<States>>;
     readonly state: Machine.Snapshot<States>;
@@ -3678,10 +3900,9 @@ export declare const transitionDefinitions: <M extends Machine.Any>(machine: M)
  *
  * **Details**
  *
- * Static `invoke`, `invokeEffect`, `after`, and `invokeMachine` descriptors
- * expose stable ownership and lifecycle metadata without serializing runtime
- * values. Function-valued invoke factories are represented as dynamic and are
- * never evaluated during inspection.
+ * Static inline invocation definitions expose stable ownership and lifecycle
+ * metadata without serializing runtime values. Function-valued sources are
+ * represented as dynamic and are never evaluated during inspection.
  *
  * @category getters
  * @since 0.4.0
@@ -3706,7 +3927,7 @@ export declare const configuration: <M extends Machine.Any>(machine: M, state: M
  * @category getters
  * @since 0.4.0
  */
-export declare const enabled: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, state: Machine.Snapshot<States>) => ReadonlyArray<Machine.TagOf<Events[number]>>;
+export declare const enabled: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, 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>, state: Machine.Snapshot<States>) => ReadonlyArray<Machine.TagOf<Events[number]>>;
 /**
  * Plans the next state snapshot synchronously.
  *
@@ -3736,7 +3957,7 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * const States = Machine.defineStates({ Off, On })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [Toggle],
+ *   events: Machine.events(Toggle),
  *   initial: () => States.initial.Off.from()
  * }).handle({ Off: { on: { Toggle: () => States.initial.On.from() } }, On: {} })
  *
@@ -3751,7 +3972,7 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * @category combinators
  * @since 0.4.0
  */
-export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, state: Machine.Snapshot<States>, event: Machine.EventOf<InputEvents>) => Effect.Effect<{
+export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, 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>, state: Machine.Snapshot<States>, event: Machine.EventInputOf<InputEvents>) => Effect.Effect<{
     readonly next: Machine.Snapshot<States>;
     readonly commands: ReadonlyArray<Command>;
     readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
@@ -3773,49 +3994,6 @@ export declare const plan: <const States extends Machine.StateSchemas, const Eve
     readonly done: false;
     readonly output: undefined;
 }), E | InfiniteTransitionError | MachineSchemaDecodeError, never>;
-/**
- * Creates a one-shot child process from an Effect.
- *
- * **When to use**
- *
- * Use when you need side effects that produce one typed output or error.
- *
- * **Details**
- *
- * The Effect may run arbitrary side effects. Its success value is the process
- * output, its typed error is preserved, and its services are inferred. When
- * invoked, the output is sent to the owning machine as an event unless it is
- * `void`.
- *
- * **Gotchas**
- *
- * This process has no incoming event protocol. Its Effect runs once. Use
- * `transition` for a process that receives events over time and `logic` for
- * direct machine-local communication or intermediate snapshots.
- *
- * **Example** (Recover a child failure as output)
- *
- * ```ts
- * import { Effect, Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class LoadFailed extends Schema.TaggedClass<LoadFailed>("LoadFailed")("LoadFailed", {
- *   reason: Schema.String
- * }) {}
- *
- * const load = Machine.effect(
- *   Effect.fail("unavailable").pipe(
- *     Effect.catch((reason) => Effect.succeed(new LoadFailed({ reason })))
- *   )
- * )
- * ```
- *
- * @see {@link transition} for event-driven state.
- * @see {@link logic} for direct control over intermediate snapshots.
- * @category constructors
- * @since 0.4.0
- */
-export declare const effect: <Output, Error = never, Requirements = never>(effect: Effect.Effect<Output, Error, Requirements>) => Logic<void, never, Error, Requirements, Output>;
 /**
  * Creates advanced stateful process logic from explicit initialization and
  * execution methods.
@@ -3837,9 +4015,9 @@ export declare const effect: <Output, Error = never, Requirements = never>(effec
  * This is the low-level process constructor. Parent messages sent directly
  * through its scope are intentionally `unknown` because the logic does not know
  * which machine will eventually own it. Prefer typed output, typed child
- * addresses, or invoke snapshot mapping when possible.
+ * addresses, or invocation lifecycle transitions when possible.
  *
- * @see {@link effect} for one-shot work.
+ * Use an inline `invoke` with an `effect` source for one-shot work.
  * @see {@link transition} for event-driven state.
  * @category constructors
  * @since 0.4.0
@@ -3873,7 +4051,7 @@ export declare const logic: <State, Event = never, Output = void, Error = never,
  * )
  * ```
  *
- * @see {@link effect} for one-shot work.
+ * Use an inline `invoke` with an `effect` source for one-shot work.
  * @see {@link logic} for direct process lifecycle control.
  * @category constructors
  * @since 0.4.0
@@ -3981,7 +4159,7 @@ export declare const watch: <State, Event, Error = never, Output = never>(ref: M
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -3996,7 +4174,7 @@ export declare const watch: <State, Event, Error = never, Output = never>(ref: M
  * @category constructors
  * @since 0.4.0
  */
-export declare const start: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+export declare const start: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, 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<MachineRef<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 fresh managed runtime from a decoded logical snapshot.
  *
@@ -4007,8 +4185,8 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * entry or transition actions, re-deliver raised or emitted events, or
  * re-evaluate historical completion and eventless transitions. Active-state
  * invokes start once in ancestor and document order with {@link InitialEvent};
- * delayed invokes restart their complete duration and invoked machines start
- * from their own initial state.
+ * timer invocations restart their complete duration and child-machine
+ * invocations start from their own initial state.
  *
  * Only logical state, completion, and history metadata are resumed. Queues,
  * scopes, subscriptions, fibers, spawned children, invoke progress, and prior
@@ -4031,7 +4209,7 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -4048,5 +4226,5 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * @category constructors
  * @since 0.4.0
  */
-export declare const resume: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+export declare const resume: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, 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>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 //# sourceMappingURL=Machine.d.ts.map