@typeonce/effect-machine 0.9.0 → 0.10.0

package/dist/Machine.d.ts

@@ -38,6 +38,8 @@ 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
@@ -92,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>>;
     /**
@@ -109,20 +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 raised events, 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.
      *
@@ -151,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>;
 }
@@ -257,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
@@ -270,11 +284,34 @@ export interface Runtime<in Events, in Emits> {
      */
     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
@@ -287,10 +324,11 @@ export interface Runtime<in Events, in Emits> {
 export interface Enqueue<in Events, in Emits> {
     /** Raises an event inside the current macrostep. */
     readonly raise: (event: Machine.EventInput<Events>) => void;
-    /** Emits an event through the machine's parent boundary. */
-    readonly emit: (event: Emits) => 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;
     };
@@ -308,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";
@@ -451,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> = {
@@ -825,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. */
@@ -834,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. */
@@ -903,13 +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
-     * invocation lifecycle transition when either can represent the
-     * communication.
-     *
      * @category models
      * @since 0.4.0
      */
@@ -920,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>;
     }
@@ -992,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.EventInput<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.
@@ -1089,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;
@@ -1100,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.
@@ -1119,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 */
@@ -1213,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.
      *
@@ -1228,11 +1271,15 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"];
-    /** Extracts the internal event schema tuple carried by a machine definition. */
-    type InternalEvents<M extends Any> = Events<M> extends readonly [
-        ...InputEvents<M>,
+    /** 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>
-    ] ? Internal : readonly [];
+    ] ? 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.
      *
@@ -1260,34 +1307,83 @@ export declare namespace Machine {
         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"]> = {} extends EventConstructorInput<EventSchema> ? (input?: EventConstructorInput<EventSchema>) => EventConstruction<EventByTag<readonly [EventSchema], Tag>> : (input: EventConstructorInput<EventSchema>) => EventConstruction<EventByTag<readonly [EventSchema], Tag>>;
-    type EventConstructorsForSchema<EventSchema extends TaggedSchema> = EventSchema extends {
+    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> : never;
+        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]>> : {
-        readonly [Tag in EventSchema["Type"]["_tag"]]: EventConstructor<EventSchema, Tag>;
+    } ? 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>> = {
-        readonly [Tag in keyof Types.UnionToIntersection<EventConstructorsForSchema<Events[number]>>]: Types.UnionToIntersection<EventConstructorsForSchema<Events[number]>>[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.
      *
@@ -1860,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.
      *
@@ -2260,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.
      *
@@ -2336,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
@@ -2351,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.
@@ -2388,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>;
@@ -2409,10 +2532,10 @@ 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>;
     }
     /**
@@ -2421,10 +2544,10 @@ export declare namespace Machine {
      * @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>;
     }
     /**
@@ -2433,11 +2556,11 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface InvokeSnapshotContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, 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 parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<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";
@@ -2449,21 +2572,21 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface InvokeDoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, 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 parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<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> {
+    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 parent: ParentStateValue<States, StateId>;
-        readonly parents: ParentStateValues<States, StateId>;
+        readonly containingState: ParentStateValue<States, StateId>;
+        readonly ancestors: ParentStateValues<States, StateId>;
         readonly snapshot: Snapshot<States>;
         readonly target: TargetBuilder<States, StateId>;
         readonly error: Error;
@@ -2474,10 +2597,10 @@ export declare namespace Machine {
      * @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>;
@@ -2496,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>;
@@ -2514,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>;
@@ -2530,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>;
     }
     /**
@@ -2554,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>;
     }
@@ -2582,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>>>;
     /**
@@ -2748,6 +2872,14 @@ export declare namespace Machine {
     } ? 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 parentEvents: Types.Covariant<infer ParentEvent>;
+        };
+    } ? 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;
@@ -2819,13 +2951,14 @@ export declare namespace Machine {
         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> {
+    interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never, ParentEvent = never> {
         readonly [InvokeTypeId]: {
             readonly output: Types.Covariant<Output>;
             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>;
         };
     }
     type InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeOwned<States, Events, Emits, StateId> & ({
@@ -2987,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 {
@@ -3026,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.
@@ -3050,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;
@@ -3071,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;
@@ -3084,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;
@@ -3115,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> = {
@@ -3210,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"> & HandlerInvokeEmitsValidation<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>;
     };
@@ -3219,13 +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 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 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;
@@ -3250,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 & HandlerInvokeContexts<States, Events, Emits, NoInfer<Config>> & HandlerTreeValidation<States, Events, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, Config>;
+    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.
@@ -3321,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.
  *
@@ -3350,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()
  * })
  * ```
@@ -3359,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;
 }
@@ -3386,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 raised
- * events, 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)
  *
@@ -3406,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: {
@@ -3426,54 +3564,16 @@ 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.
- *
- * **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.
- * This eager low-level constructor throws `MachineSchemaDecodeError` when
- * construction fails. Prefer {@link events} and {@link internalEvents} for
- * ordinary delivery so construction remains inside the machine error channel.
- *
- * The schema must be one of the machine's configured public or internal event
- * schemas, or a case schema belonging to a configured `Schema.TaggedUnion`.
- *
- * **Example**
- *
- * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * class Increment extends Schema.TaggedClass<Increment>("Increment")("Increment", {
- *   by: Schema.Number
- * }) {}
- *
- * 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() } } })
+ * Extracts the decoded event union carried by an event protocol descriptor.
  *
- * const increment = Machine.event(counter, Increment, { by: 1 })
- * ```
- *
- * @category constructors
- * @since 0.4.0
+ * @category utility types
+ * @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 type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventOf<Machine.EventProtocolSchemas<Protocol>>;
 /**
- * Returns deferred constructors for every public event in a machine protocol.
+ * Defines a public event protocol and returns deferred constructors for every
+ * statically finite configured event tag.
  *
  * Constructor inputs retain their schema-derived required fields, defaults,
  * and transformations. Construction is deferred until delivery so failures
@@ -3483,26 +3583,56 @@ export declare const event: <const M extends Machine.Any, const EventSchema exte
  * **Example**
  *
  * ```ts
- * const Event = Machine.events(counter)
- * yield* ref.send(Event.Increment({ by: 1 }))
+ * const Events = Machine.events(Increment, Reset)
+ * const machine = Machine.make({ events: Events, ... })
+ * yield* ref.send(Events.Increment({ by: 1 }))
  * ```
  *
  * @category constructors
- * @since 0.9.0
+ * @since 0.10.0
  */
-export declare const events: <const M extends Machine.Any>(machine: M) => Machine.EventConstructors<Machine.InputEvents<M>>;
+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>>;
+};
 /**
- * Returns deferred constructors for every internal event in a machine
- * protocol.
+ * Defines an internal event protocol and returns deferred constructors for
+ * every statically finite configured event tag.
  *
  * 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, ... })
+ *
+ * // Inside a transition callback:
+ * enqueue.raise(InternalEvents.Loaded({ value }))
+ * ```
+ *
  * @category constructors
- * @since 0.9.0
+ * @since 0.10.0
  */
-export declare const internalEvents: <const M extends Machine.Any>(machine: M) => Machine.EventConstructors<Machine.InternalEvents<M>>;
+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 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.
  *
@@ -3536,7 +3666,7 @@ export declare const internalEvents: <const M extends Machine.Any>(machine: M) =
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -3550,7 +3680,7 @@ export declare const internalEvents: <const M extends Machine.Any>(machine: M) =
  * @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.
  *
@@ -3580,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: {} })
  *
@@ -3595,7 +3725,7 @@ 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>>;
+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 effect: Source;
@@ -3669,42 +3799,8 @@ 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 Config extends object>(config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>;
     <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>>(config: Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>>): Machine.InvokeConfig<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
     <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object>(config: Config & Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>>;
-};
-type RetagFields<Target extends Machine.TaggedSchema> = Omit<Target["~type.make.in"], "_tag">;
-type RetagTargetCompatibility<Target extends Machine.TaggedSchema> = Target extends {
-    readonly fields: Schema.Struct.Fields;
-} ? "_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";
+    <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"]>>>;
 };
-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
- */
-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"];
 /**
  * Plans the initial state for a machine without executing actor commands.
  *
@@ -3733,7 +3829,7 @@ export declare const retag: <const Target extends Machine.TaggedSchema, const So
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -3745,7 +3841,7 @@ export declare const retag: <const Target extends Machine.TaggedSchema, const So
  * @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>;
@@ -3831,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.
  *
@@ -3861,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: {} })
  *
@@ -3876,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.EventInputOf<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>>;
@@ -4063,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: {} })
  *
@@ -4078,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.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+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.
  *
@@ -4113,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: {} })
  *
@@ -4130,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.EventInputOf<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