@typeonce/effect-machine 0.9.0 → 0.11.0

package/src/Machine.ts

@@ -50,6 +50,8 @@ export const TypeId: TypeId = "~effect/Machine"
 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
 
 const ChildMachineLogicTypeId: typeof internal.ChildMachineLogicTypeId = internal.ChildMachineLogicTypeId
 
@@ -124,7 +126,8 @@ export interface Machine<
   Output = never,
   Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  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. */
@@ -141,7 +144,8 @@ export interface Machine<
     Output,
     Emits,
     OutputStates,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >
   /** @internal Prevents output implementation evidence from being widened. */
   readonly [MachineOutputStatesTypeId]: Readonly<Record<OutputStates, true>>
@@ -158,22 +162,37 @@ export interface Machine<
    *
    * @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.
@@ -223,9 +242,19 @@ export interface Machine<
     FinalStates,
     Output,
     OutputStates,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >
 
+  /**
+   * Preserves invocation inference with this machine's public input and parent
+   * protocols. Prefer this bound constructor when an invocation source or
+   * lifecycle handler uses `self` or `parent`.
+   *
+   * @since 0.11.0
+   */
+  readonly invoke: Invoker<States, Events, Emits, InputEvents, ParentEvents>
+
   /** @internal */
   readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
 }
@@ -343,7 +372,8 @@ export type ExecutionServices<Requirements> =
   | 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
@@ -357,11 +387,42 @@ 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
 }
 
 /**
@@ -376,11 +437,12 @@ 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
   }
@@ -401,7 +463,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
   }
   | {
@@ -676,8 +738,9 @@ type DuplicateEventTag<
   : 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>
+  ] ? Machine.TagOf<Head> extends infer Tag extends PropertyKey ?
+        | Extract<Tag, Seen>
+        | DuplicateEventTag<Tail, Seen | Tag>
     : never
   : never
 
@@ -687,6 +750,12 @@ type ValidateInputEventProtocol<
 > = [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>,
@@ -699,6 +768,14 @@ type ValidateInternalEventProtocol<
   : 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>
+
 const SnapshotBuilderStateTypeId: typeof internal.SnapshotBuilderStateTypeId = internal.SnapshotBuilderStateTypeId
 const SnapshotBuilderConstructionTypeId: unique symbol = Symbol("effect/Machine/SnapshotBuilderConstruction")
 
@@ -1626,6 +1703,33 @@ export type RuntimeOutcome<State, Error = never, Output = never> =
     readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, { readonly status: "stopped" }>
   }
 
+/**
+ * A fresh machine whose observable streams exist before initialization.
+ *
+ * Subscribe to `emissions` before evaluating `start` when initial-entry
+ * emissions must be observed. `start` is one-shot: concurrent and repeated
+ * evaluations share the same initialization and running reference.
+ *
+ * @category models
+ * @since 0.11.0
+ */
+export interface Prepared<out State, in Event, out Error, out Output, out Emitted, out StartError, StartRequirements> {
+  /** Stable machine definition id, or a generated fallback when none was declared. */
+  readonly id: string
+
+  /** Unique identity reserved for this prepared machine instance. */
+  readonly sessionId: string
+
+  /** Waits for startup, then streams the initial lifecycle snapshot and later changes. */
+  readonly changes: Stream.Stream<RuntimeSnapshot<State, Error, Output>, StartError>
+
+  /** Streams ephemeral notifications published after subscription. */
+  readonly emissions: Stream.Stream<Emitted>
+
+  /** Initializes this machine once and returns its running reference. */
+  readonly start: Effect.Effect<MachineRef<State, Event, Error, Output, Emitted>, StartError, StartRequirements>
+}
+
 /**
  * Provides access to a running machine's state, lifecycle, event input, and
  * termination operations.
@@ -1640,7 +1744,9 @@ 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
 
@@ -1653,9 +1759,15 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
   /** 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>
 
@@ -1767,13 +1879,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
    */
@@ -1787,14 +1892,14 @@ export declare namespace Logic {
     /** 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>
@@ -1883,7 +1988,8 @@ export declare namespace ChildMachine {
       | InfiniteTransitionError
       | MachineSchemaDecodeError
       | StoppedError,
-      Machine.Output<M>
+      Machine.Output<M>,
+      Machine.EmittedEvent<M>
     >
     : never
 
@@ -1893,7 +1999,8 @@ export declare namespace ChildMachine {
    * @category utility types
    * @since 0.4.0
    */
-  export type Event<Child> = Ref<Child> extends MachineRef<any, infer Event, any, any> ? Event : never
+  export type Event<Child> = Child extends ChildMachine<string, infer M> ? Machine.EventInput<Machine.InputEvent<M>>
+    : never
 }
 
 /**
@@ -2006,7 +2113,8 @@ export declare namespace Machine {
     Output,
     Emits extends ReadonlyArray<TaggedSchema>,
     OutputStates extends StateIdentifier<States>,
-    InputEvents extends ReadonlyArray<TaggedSchema>
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>
   > {
     readonly states: States
     readonly events: Events
@@ -2018,9 +2126,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
   }
 
   /**
@@ -2038,11 +2147,12 @@ export declare namespace Machine {
   export 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 */
@@ -2054,6 +2164,8 @@ export declare namespace Machine {
     /** @internal */
     readonly handle: any
     /** @internal */
+    readonly invoke: any
+    /** @internal */
     readonly initial: any
   }
 
@@ -2143,7 +2255,10 @@ export declare namespace Machine {
    * @category utility types
    * @since 0.4.0
    */
-  export type Emits<M extends Any> = M[typeof MachineTypeId]["emits"]
+  export type EmittedEvents<M extends Any> = M[typeof MachineTypeId]["emittedEvents"]
+
+  /** @deprecated Use {@link EmittedEvents}. */
+  export type Emits<M extends Any> = EmittedEvents<M>
 
   /**
    * Extracts state paths with implemented output handlers.
@@ -2161,13 +2276,22 @@ export declare namespace Machine {
    */
   export type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"]
 
-  /** Extracts the internal event schema tuple carried by a machine definition. */
-  export type InternalEvents<M extends Any> = Events<M> extends readonly [
-    ...InputEvents<M>,
+  /** Extracts the public input protocol required from an owning actor. */
+  export type ParentEvents<M extends Any> = M[typeof MachineTypeId]["parentEvents"]
+
+  /** Extracts an internal event schema tuple from the complete and public protocols. */
+  export type InternalEventSchemas<
+    Events extends ReadonlyArray<TaggedSchema>,
+    InputEvents extends ReadonlyArray<TaggedSchema>
+  > = Events extends readonly [
+    ...InputEvents,
     ...infer Internal extends ReadonlyArray<TaggedSchema>
-  ] ? Internal
+  ] ? readonly [...Internal]
     : readonly []
 
+  /** Extracts the internal event schema tuple carried by a machine definition. */
+  export type InternalEvents<M extends Any> = InternalEventSchemas<Events<M>, InputEvents<M>>
+
   /**
    * Extracts the complete event protocol handled inside a machine.
    *
@@ -2196,48 +2320,133 @@ export declare namespace Machine {
     readonly _tag: Event["_tag"]
   }
 
+  /** Opaque construction returned by {@link emittedEvents}. */
+  export 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. */
   export type EventInput<Event> =
     | Event
     | (Event extends { readonly _tag: PropertyKey } ? EventConstruction<Event> : never)
 
+  /** A decoded emitted event or a deferred emitted-event construction. */
+  export type EmittedEventInput<Event> =
+    | Event
+    | (Event extends { readonly _tag: PropertyKey } ? EmittedEventConstruction<Event> : never)
+
   /** Event inputs accepted for a schema tuple at machine delivery boundaries. */
   export type EventInputOf<Events extends ReadonlyArray<TaggedSchema>> = EventInput<EventOf<Events>>
 
+  /** Identifies whether an event protocol is accepted publicly or only inside a machine. */
+  export 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 {
+    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>
+      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]>>
+      Types.UnionToIntersection<EventConstructorsForSchema<Members[number], Kind>>
     : {
-      readonly [Tag in EventSchema["Type"]["_tag"]]: EventConstructor<EventSchema, Tag>
+      readonly [Tag in FiniteEventTag<EventSchema["Type"]["_tag"]>]: EventConstructor<EventSchema, Tag, Kind>
     }
 
   /** Protocol-bound constructors keyed by each configured event tag. */
-  export type EventConstructors<Events extends ReadonlyArray<TaggedSchema>> = {
-    readonly [Tag in keyof Types.UnionToIntersection<EventConstructorsForSchema<Events[number]>>]:
-      Types.UnionToIntersection<EventConstructorsForSchema<Events[number]>>[Tag]
+  export 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
+   */
+  export type EventProtocol<
+    Kind extends EventProtocolKind,
+    Schemas extends ReadonlyArray<TaggedSchema>
+  > = EventConstructors<Schemas, Kind> & {
+    readonly [EventProtocolTypeId]: {
+      readonly kind: Kind
+      readonly schemas: Schemas
+    }
+  }
+
+  export namespace EventProtocol {
+    /** An erased event protocol descriptor retaining its kind and schema carrier. */
+    export 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. */
+  export 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. */
+  export 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. */
+  export 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
    */
-  export type Emit<M extends Any> = EmitOf<Emits<M>>
+  export type EmittedEvent<M extends Any> = EmittedEventOf<Emits<M>>
+
+  /** @deprecated Use {@link EmittedEvent}. */
+  export type Emit<M extends Any> = EmittedEvent<M>
 
   /**
    * A schema whose decoded value contains a `_tag` discriminator.
@@ -3025,7 +3234,10 @@ export declare namespace Machine {
    * @category utility types
    * @since 0.4.0
    */
-  export type EmitOf<Emits extends ReadonlyArray<TaggedSchema>> = Emits[number]["Type"]
+  export type EmittedEventOf<Emits extends ReadonlyArray<TaggedSchema>> = Emits[number]["Type"]
+
+  /** @deprecated Use {@link EmittedEventOf}. */
+  export type EmitOf<Emits extends ReadonlyArray<TaggedSchema>> = EmittedEventOf<Emits>
 
   /**
    * Event values received by lifecycle callbacks.
@@ -3597,6 +3809,21 @@ export declare namespace Machine {
     >
   }
 
+  /**
+   * 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
+   */
+  export interface NoTarget {
+    readonly [Topology.NoTargetTypeId]: typeof Topology.NoTargetTypeId
+  }
+
   /**
    * Transition instruction that restores a history pseudo-state's parent.
    *
@@ -3703,9 +3930,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
@@ -3721,6 +3948,18 @@ export declare namespace Machine {
     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.
@@ -3769,11 +4008,13 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     EventTag extends TagOf<Events[number]>,
     E,
-    R
-  > {
+    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>
@@ -3797,11 +4038,13 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
-  > {
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > 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>
   }
 
@@ -3815,11 +4058,13 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
-  > {
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > 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>
   }
 
@@ -3836,12 +4081,14 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     State,
     Error,
-    Output
-  > {
+    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" }>
   }
@@ -3857,12 +4104,14 @@ export declare namespace Machine {
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
-    Output
-  > {
+    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
@@ -3874,12 +4123,14 @@ export declare namespace Machine {
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
-    Error
-  > {
+    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
@@ -3895,11 +4146,13 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
-  > {
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > 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>
@@ -3924,11 +4177,13 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
-  > {
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
+  > 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>
@@ -3949,13 +4204,15 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    ChoiceId extends ChoiceIdentifier<States>
-  > {
-    readonly parent: StateByIdentifier<
+    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 parents: {
+    readonly ancestors: {
       readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, ValuedStateIdentifier<States>>]: StateByIdentifier<
         States,
         Parent
@@ -3977,8 +4234,8 @@ export declare namespace Machine {
     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>
   }
 
@@ -4012,8 +4269,8 @@ export declare namespace Machine {
     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>
   }
@@ -4047,9 +4304,10 @@ 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
@@ -4065,7 +4323,7 @@ export declare namespace Machine {
       | HistoryTarget<States, HistoryIdentifier<States>>
       | ChoiceTarget<States, ChoiceIdentifier<States>>
     >
-    | void
+    | NoTarget
 
   /** A choice resolver must always select a typed target synchronously. */
   export type ChoiceResult<States extends StateSchemas, E, R> =
@@ -4264,6 +4522,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. */
+  export 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. */
   export type InvokeOutcomeReturn<Invoke> = Invoke extends unknown ?
       | (Invoke extends { readonly onDone?: infer Handler } ? EventTransitionReturn<NonNullable<Handler>> : never)
@@ -4373,13 +4639,14 @@ export declare namespace Machine {
   }
 
   /** Type evidence retained by {@link invoke} without affecting runtime data. */
-  export interface InvokeTyped<Output, Error, Requirements, InitialError, Emits = never> {
+  export 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>
     }
   }
 
@@ -4387,13 +4654,18 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
     & InvokeOwned<States, Events, Emits, StateId>
     & (
       | {
         readonly id: string
-        readonly effect: InvokeSource<Effect.Effect<any, any, any>, InvokeContext<States, Events, Emits, StateId>>
+        readonly effect: InvokeSource<
+          Effect.Effect<any, any, any>,
+          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        >
         readonly after?: never
         readonly logic?: never
         readonly child?: never
@@ -4404,7 +4676,10 @@ export declare namespace Machine {
       }
       | {
         readonly id: string
-        readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>
+        readonly after: InvokeSource<
+          Duration.Input,
+          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        >
         readonly effect?: never
         readonly logic?: never
         readonly child?: never
@@ -4416,7 +4691,10 @@ export declare namespace Machine {
       | {
         readonly id: string
         readonly address: string
-        readonly logic: InvokeSource<AnyLogicSource, InvokeContext<States, Events, Emits, StateId>>
+        readonly logic: InvokeSource<
+          AnyLogicSource,
+          InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+        >
         readonly effect?: never
         readonly after?: never
         readonly child?: never
@@ -4426,7 +4704,10 @@ export declare namespace Machine {
       }
       | {
         readonly child: ChildMachine.Any
-        readonly input?: {} | null | ((context: InvokeContext<States, Events, Emits, StateId>) => unknown)
+        readonly input?:
+          | {}
+          | null
+          | ((context: InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => unknown)
         readonly id?: never
         readonly address?: never
         readonly effect?: never
@@ -4443,10 +4724,16 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
-    | InvokeConfig<States, Events, Emits, StateId>
-    | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId>>
+    | InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    | ReadonlyArray<InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>>
+
+  type TypedInvokeDefinition =
+    | InvokeTyped<any, any, any, any, any, any>
+    | ReadonlyArray<InvokeTyped<any, any, any, any, any, any>>
 
   type InvokeHandlerRequirement<Value, Handler> = IsAny<Value> extends true ? { readonly handler: Handler }
     : [Value] extends [never] ? { readonly handler?: never }
@@ -4468,7 +4755,9 @@ export declare namespace Machine {
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     Fx extends Effect.Effect<any, any, any>,
-    Source = Fx
+    Source = Fx,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
     & {
       readonly id: InvokeLifecycleId
@@ -4485,7 +4774,15 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
-        InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<NoInfer<Fx>>>
+        InvokeDoneContext<
+          States,
+          Events,
+          Emits,
+          StateId,
+          Effect.Success<NoInfer<Fx>>,
+          InputEvents,
+          ParentEvents
+        >
       >
     >
     & InvokeFailureRequirement<
@@ -4494,7 +4791,15 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
-        InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<NoInfer<Fx>>>
+        InvokeFailureContext<
+          States,
+          Events,
+          Emits,
+          StateId,
+          Effect.Error<NoInfer<Fx>>,
+          InputEvents,
+          ParentEvents
+        >
       >
     >
 
@@ -4502,10 +4807,15 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = {
     readonly id: InvokeLifecycleId
-    readonly after: InvokeSource<Duration.Input, InvokeContext<States, Events, Emits, StateId>>
+    readonly after: InvokeSource<
+      Duration.Input,
+      InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    >
     readonly effect?: never
     readonly logic?: never
     readonly child?: never
@@ -4516,7 +4826,7 @@ export declare namespace Machine {
       States,
       Events,
       Emits,
-      InvokeDoneContext<States, Events, Emits, StateId, void>
+      InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
     >
   }
 
@@ -4532,7 +4842,9 @@ export declare namespace Machine {
     ChildOutput,
     ChildInitialError,
     Address extends ChildAddress<never>,
-    Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>
+    Source = Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
     & {
       readonly id: InvokeLifecycleId
@@ -4545,16 +4857,36 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
-        InvokeSnapshotContext<States, Events, Emits, StateId, ChildState, ChildError, ChildOutput>
+        InvokeSnapshotContext<
+          States,
+          Events,
+          Emits,
+          StateId,
+          ChildState,
+          ChildError,
+          ChildOutput,
+          InputEvents,
+          ParentEvents
+        >
       >
     }
     & InvokeDoneRequirement<
       ChildOutput,
-      InvokeTransition<States, Events, Emits, InvokeDoneContext<States, Events, Emits, StateId, ChildOutput>>
+      InvokeTransition<
+        States,
+        Events,
+        Emits,
+        InvokeDoneContext<States, Events, Emits, StateId, ChildOutput, InputEvents, ParentEvents>
+      >
     >
     & InvokeFailureRequirement<
       ChildError,
-      InvokeTransition<States, Events, Emits, InvokeFailureContext<States, Events, Emits, StateId, ChildError>>
+      InvokeTransition<
+        States,
+        Events,
+        Emits,
+        InvokeFailureContext<States, Events, Emits, StateId, ChildError, InputEvents, ParentEvents>
+      >
     >
 
   export type ChildInvokeArgs<
@@ -4563,7 +4895,9 @@ export declare namespace Machine {
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     ChildDefinition extends Machine.Any,
-    Child extends ChildMachine<string, ChildDefinition>
+    Child extends ChildMachine<string, ChildDefinition>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > =
     & {
       readonly child:
@@ -4590,12 +4924,17 @@ export declare namespace Machine {
           StateId,
           Snapshot<Machine.States<ChildDefinition>>,
           Error<ChildDefinition>,
-          Output<ChildDefinition>
+          Output<ChildDefinition>,
+          InputEvents,
+          ParentEvents
         >
       >
     }
     & (Input<ChildDefinition> extends typeof Schema.Void ? { readonly input?: never } : {
-      readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>
+      readonly input: InvokeSource<
+        Input<ChildDefinition>["Type"],
+        InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+      >
     })
     & InvokeDoneRequirement<
       Output<ChildDefinition>,
@@ -4603,7 +4942,15 @@ export declare namespace Machine {
         States,
         Events,
         Emits,
-        InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>>
+        InvokeDoneContext<
+          States,
+          Events,
+          Emits,
+          StateId,
+          Output<ChildDefinition>,
+          InputEvents,
+          ParentEvents
+        >
       >
     >
     & InvokeFailureRequirement<
@@ -4617,7 +4964,9 @@ export declare namespace Machine {
           Events,
           Emits,
           StateId,
-          Error<ChildDefinition> | ActionError<Services<ChildDefinition>>
+          Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
+          InputEvents,
+          ParentEvents
         >
       >
     >
@@ -4634,6 +4983,8 @@ export declare namespace Machine {
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Raw
   > = Raw extends InvokeTyped<any, any, any, any, any> ? unknown
     : Raw extends { readonly effect: infer Source } ?
@@ -4644,7 +4995,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>>
+              InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<Fx>, InputEvents, ParentEvents>
             >
           >
           & InvokeFailureRequirement<
@@ -4653,7 +5004,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>>
+              InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<Fx>, InputEvents, ParentEvents>
             >
           >
           & { readonly onSnapshot?: never }
@@ -4663,7 +5014,7 @@ export declare namespace Machine {
           States,
           Events,
           Emits,
-          InvokeDoneContext<States, Events, Emits, StateId, void>
+          InvokeDoneContext<States, Events, Emits, StateId, void, InputEvents, ParentEvents>
         >
         readonly onFailure?: never
         readonly onSnapshot?: never
@@ -4676,7 +5027,7 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>>
+              InvokeDoneContext<States, Events, Emits, StateId, InvokeOutput<Raw>, InputEvents, ParentEvents>
             >
           >
           & InvokeFailureRequirement<
@@ -4685,7 +5036,15 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeFailureContext<States, Events, Emits, StateId, InvokeRuntimeError<Raw>>
+              InvokeFailureContext<
+                States,
+                Events,
+                Emits,
+                StateId,
+                InvokeRuntimeError<Raw>,
+                InputEvents,
+                ParentEvents
+              >
             >
           >
           & {
@@ -4706,7 +5065,9 @@ export declare namespace Machine {
                 StateId,
                 ChildLogic extends Logic<infer ChildState, any, any, any, any, any> ? ChildState : never,
                 InvokeRuntimeError<Raw>,
-                InvokeOutput<Raw>
+                InvokeOutput<Raw>,
+                InputEvents,
+                ParentEvents
               >
             >
           }
@@ -4719,7 +5080,15 @@ export declare namespace Machine {
               States,
               Events,
               Emits,
-              InvokeDoneContext<States, Events, Emits, StateId, Output<ChildDefinition>>
+              InvokeDoneContext<
+                States,
+                Events,
+                Emits,
+                StateId,
+                Output<ChildDefinition>,
+                InputEvents,
+                ParentEvents
+              >
             >
           >
           & InvokeFailureRequirement<
@@ -4733,12 +5102,17 @@ export declare namespace Machine {
                 Events,
                 Emits,
                 StateId,
-                Error<ChildDefinition> | ActionError<Services<ChildDefinition>>
+                Error<ChildDefinition> | ActionError<Services<ChildDefinition>>,
+                InputEvents,
+                ParentEvents
               >
             >
           >
           & (Input<ChildDefinition> extends typeof Schema.Void ? { readonly input?: never } : {
-            readonly input: InvokeSource<Input<ChildDefinition>["Type"], InvokeContext<States, Events, Emits, StateId>>
+            readonly input: InvokeSource<
+              Input<ChildDefinition>["Type"],
+              InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+            >
           })
           & {
             readonly onSnapshot?: InvokeTransition<
@@ -4752,7 +5126,9 @@ export declare namespace Machine {
                 StateId,
                 Snapshot<Machine.States<ChildDefinition>>,
                 Error<ChildDefinition>,
-                Output<ChildDefinition>
+                Output<ChildDefinition>,
+                InputEvents,
+                ParentEvents
               >
             >
           }
@@ -4764,11 +5140,21 @@ export declare namespace Machine {
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Raw
   > = Raw extends ReadonlyArray<any> ? {
-      readonly [Index in keyof Raw]: ContextualInvokeConfig<States, Events, Emits, StateId, Raw[Index]>
+      readonly [Index in keyof Raw]: ContextualInvokeConfig<
+        States,
+        Events,
+        Emits,
+        StateId,
+        InputEvents,
+        ParentEvents,
+        Raw[Index]
+      >
     }
-    : ContextualInvokeConfig<States, Events, Emits, StateId, Raw>
+    : ContextualInvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents, Raw>
 
   type OutputHandlerConfig<
     States extends StateSchemas,
@@ -4808,64 +5194,68 @@ export declare namespace Machine {
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     E,
-    R
+    R,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = {
     readonly entry?: (
-      context: StateActionContext<States, Events, Emits, StateId>,
+      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>,
+      context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
       enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
     ) => StateActionResult<any, any>
-    readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>
+    readonly invoke?:
+      | InvokeDefinition<States, Events, Emits, StateId, InputEvents, ParentEvents>
+      | TypedInvokeDefinition
     readonly always?:
       | ((
-        context: AlwaysContext<States, Events, Emits, StateId>,
+        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>,
+          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>,
+        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>,
+          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>,
+          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>,
+            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. */
@@ -4890,17 +5280,21 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
-  > = StateActionContext<States, Events, Emits, StateId>
+    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. */
   export type StateInitialHandler<
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = (
-    context: StateInitialContext<States, Events, Emits, StateId>,
+    context: StateInitialContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
     enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
   ) => StateInitialValue<States, StateId>
 
@@ -4913,7 +5307,7 @@ export declare namespace Machine {
   > {
     readonly event: LifecycleEvent<Events>
     readonly target: HistoryDefaultTargetBuilder<States, ParentId>
-    readonly parent: ParentId
+    readonly owner: ParentId
   }
 
   /**
@@ -4953,13 +5347,15 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    ChoiceId extends ChoiceIdentifier<States>
+    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>,
+        context: ChoiceContext<States, Events, Emits, ChoiceId, InputEvents, ParentEvents>,
         enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
       ) => ChoiceResult<States, any, any>
     }
@@ -4983,10 +5379,12 @@ export declare namespace Machine {
     States extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
-    StateId extends StateIdentifier<States>
+    StateId extends StateIdentifier<States>,
+    InputEvents extends ReadonlyArray<TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
   > = {
     readonly entry?: (
-      context: StateActionContext<States, Events, Emits, StateId>,
+      context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>,
       enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>
     ) => StateActionResult<any, any>
     readonly exit?: never
@@ -5007,10 +5405,12 @@ export declare namespace Machine {
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateIdentifier<States>,
     E,
-    R
+    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>
+    FinalStateConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    : ActiveStateConfig<States, Events, Emits, StateId, E, R, InputEvents, ParentEvents>
 
   type HandlerNodeConfig<
     States extends StateSchemas,
@@ -5018,9 +5418,11 @@ export declare namespace Machine {
     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>
+    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
@@ -5057,14 +5459,26 @@ export declare namespace Machine {
   type HandlerInvokeContextAtPath<
     AllStates extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Config,
     StateId extends StateNodeIdentifier<AllStates>,
     NodeConfig = HandlerConfigAtPath<Config, StateId>
   > = StateId extends StateIdentifier<AllStates> ?
     NodeConfig extends { readonly invoke: infer Invoke } ? HandlerValidationAtPath<
         StateId,
-        { readonly invoke: ContextualInvokeDefinition<AllStates, Events, Emits, StateId, Invoke> }
+        {
+          readonly invoke: ContextualInvokeDefinition<
+            AllStates,
+            Events,
+            Emits,
+            StateId,
+            InputEvents,
+            ParentEvents,
+            Invoke
+          >
+        }
       >
     : unknown
     : unknown
@@ -5072,14 +5486,18 @@ export declare namespace Machine {
   type HandlerInvokeContexts<
     AllStates extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Config
   > = Types.UnionToIntersection<
     StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ?
       StateId extends StateNodeIdentifier<AllStates> ? HandlerInvokeContextAtPath<
           AllStates,
           Events,
+          InputEvents,
           Emits,
+          ParentEvents,
           Config,
           StateId
         >
@@ -5103,9 +5521,11 @@ export declare namespace Machine {
     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>
+    & HandlerNodeConfig<AllStates, Events, Emits, StateId, E, R, InputEvents, ParentEvents>
     & (StateId extends ChoiceIdentifier<AllStates> ? {
         readonly states?: never
         readonly history?: never
@@ -5122,6 +5542,8 @@ export declare namespace Machine {
             Emits,
             E,
             R,
+            InputEvents,
+            ParentEvents,
             Extract<StateId, StateIdentifier<AllStates>>
           >
           readonly history?: HistoryDefaultConfig<
@@ -5144,6 +5566,8 @@ export declare namespace Machine {
     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<
@@ -5153,6 +5577,8 @@ export declare namespace Machine {
       Emits,
       E,
       R,
+      InputEvents,
+      ParentEvents,
       HandlerNodeId<AllStates, JoinPath<Prefix, Key>>
     >
   }
@@ -5387,6 +5813,7 @@ export declare namespace Machine {
     AllStates extends StateSchemas,
     Node,
     Events extends ReadonlyArray<TaggedSchema>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     StateId extends StateNodeIdentifier<AllStates>,
     Config,
@@ -5401,7 +5828,7 @@ export declare namespace Machine {
         & HandlerOnTargetValidation<StateId, Config>
         & HandlerDirectTargetValidation<StateId, Config, "always">
         & HandlerDirectTargetValidation<StateId, Config, "onDone">
-        & HandlerInvokeEmitsValidation<Events, StateId, Config>
+        & HandlerInvokeParentEventsValidation<InputEvents, StateId, Config>
         & HandlerChildrenValidation<Node, StateId, Config>
         & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config>
         & HandlerRuntimeValidation<Events, Emits, StateId, Config>
@@ -5430,17 +5857,17 @@ export declare namespace Machine {
     }
     : unknown
 
-  type HandlerInvokeEmitsValidation<
+  type HandlerInvokeParentEventsValidation<
     Events extends ReadonlyArray<TaggedSchema>,
     StateId extends string,
     Config
   > = [InvokeReturn<Config>] extends [never] ? unknown
-    : [Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown
+    : [Exclude<InvokeParentEvents<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown
     : {
       readonly invoke: HandlerValidationError<
-        "Invoked child emits events not accepted by the parent machine",
+        "Invoked child expects parent events not accepted by this machine",
         StateId,
-        Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>
+        Exclude<InvokeParentEvents<InvokeReturn<Config>>, EventOf<Events>>
       >
     }
 
@@ -5460,6 +5887,7 @@ export declare namespace Machine {
   type HandlerNodeValidationAtPath<
     AllStates extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     Config,
     AvailableOutputStates extends StateIdentifier<AllStates>,
@@ -5470,6 +5898,7 @@ export declare namespace Machine {
       AllStates,
       HandlerNodeByPath<AllStates, StateId>,
       Events,
+      InputEvents,
       Emits,
       StateId,
       NodeConfig,
@@ -5481,6 +5910,7 @@ export declare namespace Machine {
   type HandlerTreeNodeValidations<
     AllStates extends StateSchemas,
     Events extends ReadonlyArray<TaggedSchema>,
+    InputEvents extends ReadonlyArray<TaggedSchema>,
     Emits extends ReadonlyArray<TaggedSchema>,
     Config,
     AvailableOutputStates extends StateIdentifier<AllStates>
@@ -5489,6 +5919,7 @@ export declare namespace Machine {
       StateId extends StateNodeIdentifier<AllStates> ? HandlerNodeValidationAtPath<
           AllStates,
           Events,
+          InputEvents,
           Emits,
           Config,
           AvailableOutputStates,
@@ -5501,12 +5932,13 @@ export declare namespace Machine {
   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, Emits, Config, AvailableOutputStates>
+    & HandlerTreeNodeValidations<AllStates, Events, InputEvents, Emits, Config, AvailableOutputStates>
 
   type HandlerHasRequiredInitial<
     AllStates extends StateSchemas,
@@ -5602,6 +6034,7 @@ export declare namespace Machine {
     Output,
     OutputStates extends StateIdentifier<AllStates>,
     InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>,
     Config
   > = Machine<
     AllStates,
@@ -5620,7 +6053,8 @@ export declare namespace Machine {
     Output,
     Emits,
     OutputStates | Extract<HandlerTreeEvidence<AllStates, Config>["outputState"], StateIdentifier<AllStates>>,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >
 
   /**
@@ -5642,15 +6076,29 @@ export declare namespace Machine {
     FinalStates extends StateIdentifier<States>,
     Output,
     OutputStates extends StateIdentifier<States>,
-    InputEvents extends ReadonlyArray<TaggedSchema>
+    InputEvents extends ReadonlyArray<TaggedSchema>,
+    ParentEvents extends ReadonlyArray<TaggedSchema>
   > {
-    <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(
+    <
+      const Config extends HandlerTree<
+        States,
+        States,
+        Events,
+        Emits,
+        E,
+        R,
+        InputEvents,
+        ParentEvents,
+        ""
+      >
+    >(
       config:
         & Config
-        & HandlerInvokeContexts<States, Events, Emits, NoInfer<Config>>
+        & HandlerInvokeContexts<States, Events, InputEvents, Emits, ParentEvents, NoInfer<Config>>
         & HandlerTreeValidation<
           States,
           Events,
+          InputEvents,
           Emits,
           NoInfer<Config>,
           | OutputStates
@@ -5673,6 +6121,7 @@ export declare namespace Machine {
       Output,
       OutputStates,
       InputEvents,
+      ParentEvents,
       Config
     >
   }
@@ -5824,7 +6273,8 @@ export const isFinal: <
   FinalStates extends Machine.StateIdentifier<States> = never,
   Output = never,
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   machine: Machine<
     States,
@@ -5839,10 +6289,11 @@ export const isFinal: <
     Output,
     Emits,
     OutputStates,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >,
   state: Machine.Snapshot<States>
-) => state is Machine.SnapshotContainingFinal<States, FinalStates> = internal.isFinal
+) => state is Machine.SnapshotContainingFinal<States, FinalStates> = internal.isFinal as any
 
 /**
  * Defines a state tree while preserving literal state paths.
@@ -5872,7 +6323,7 @@ export const isFinal: <
  *
  * Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.idle.from()
  * })
  * ```
@@ -5889,18 +6340,22 @@ type MakeConfig<
   Input extends Schema.Top,
   InitialE,
   InitialR,
-  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>
+  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 events:
+    & Machine.EventProtocol<"public", InputEvents>
+    & ValidateInputEventProtocol<NoInfer<InputEvents>>
   readonly internalEvents?:
-    & InternalEvents
+    & Machine.EventProtocol<"internal", InternalEvents>
     & ValidateInternalEventProtocol<
       NoInfer<InputEvents>,
       NoInfer<InternalEvents>
     >
-  readonly emits?: Emits
+  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>
 }
@@ -5912,7 +6367,8 @@ type MakeResult<
   Input extends Schema.Top,
   InitialE,
   InitialR,
-  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>
+  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
 > = Machine<
   States,
   readonly [...InputEvents, ...InternalEvents],
@@ -5926,7 +6382,8 @@ type MakeResult<
   Machine.TerminalOutput<States>,
   Emits,
   never,
-  InputEvents
+  InputEvents,
+  ParentEvents
 >
 
 interface Make {
@@ -5937,11 +6394,12 @@ interface Make {
     const Input extends Schema.Top = typeof Schema.Void,
     InitialE = never,
     InitialR = never,
-    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
-    config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>,
+    config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>,
     ..._validation: ValidateDefinedStates<NoInfer<States>>
-  ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>
+  ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>
   <
     const States extends Machine.StateSchemas,
     const InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
@@ -5949,10 +6407,11 @@ interface Make {
     const Input extends Schema.Top = typeof Schema.Void,
     InitialE = never,
     InitialR = never,
-    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>, "states">
+      & Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "states">
       & { readonly states: InvalidDefinedStateTreeInput<States> }
   ): never
 }
@@ -5968,10 +6427,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)
  *
@@ -5988,10 +6450,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: {
@@ -6009,94 +6472,92 @@ interface Make {
  */
 export const make: Make = internal.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**
+ * Extracts the decoded event union carried by an event protocol descriptor.
  *
- * 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.
+ * @category utility types
+ * @since 0.10.0
+ */
+export type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventOf<
+  Machine.EventProtocolSchemas<Protocol>
+>
+
+/**
+ * Defines a public event protocol and returns deferred constructors for every
+ * statically finite configured event tag.
  *
- * The schema must be one of the machine's configured public or internal event
- * schemas, or a case schema belonging to a configured `Schema.TaggedUnion`.
+ * Constructor inputs retain their schema-derived required fields, defaults,
+ * and transformations. Construction is deferred until delivery so failures
+ * enter the machine's `MachineSchemaDecodeError` channel rather than throwing
+ * at the call site.
  *
  * **Example**
  *
  * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * 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() } } })
- *
- * const increment = Machine.event(counter, 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.4.0
+ * @since 0.10.0
  */
-export 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"] = internal.event
+export 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>>
+} = internal.events as any
 
 /**
- * Returns deferred constructors for every public event in a machine protocol.
+ * Defines an internal 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
- * enter the machine's `MachineSchemaDecodeError` channel rather than throwing
- * at the call site.
+ * 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 Event = Machine.events(counter)
- * yield* ref.send(Event.Increment({ by: 1 }))
+ * 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 const events: <const M extends Machine.Any>(
-  machine: M
-) => Machine.EventConstructors<Machine.InputEvents<M>> = internal.events
+export 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>>
+} = internal.internalEvents as any
 
 /**
- * Returns deferred constructors for every internal event in a machine
- * protocol.
- *
- * Use these constructors for raised events and other machine-local deliveries.
- * Construction failures are reported through the
- * owning machine's `MachineSchemaDecodeError` channel.
+ * 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.9.0
+ * @since 0.10.0
  */
-export const internalEvents: <const M extends Machine.Any>(
-  machine: M
-) => Machine.EventConstructors<Machine.InternalEvents<M>> = internal.internalEvents
+export 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>>
+} = internal.emittedEvents as any
 
 /**
  * Encodes a decoded machine snapshot into a normalized data representation.
@@ -6131,7 +6592,7 @@ export const internalEvents: <const M extends Machine.Any>(
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -6158,7 +6619,8 @@ export const encodeSnapshot: <
   FinalStates extends Machine.StateIdentifier<States> = never,
   Output = never,
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   machine: Machine<
     States,
@@ -6173,14 +6635,15 @@ export const encodeSnapshot: <
     Output,
     Emits,
     OutputStates,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >,
   snapshot: Machine.Snapshot<States>
 ) => Effect.Effect<
   Machine.EncodedSnapshot,
   MachineSchemaEncodeError,
   Machine.SnapshotEncodingServices<States>
-> = internal.encodeSnapshot
+> = internal.encodeSnapshot as any
 
 /**
  * Decodes a normalized data representation into a validated machine snapshot.
@@ -6211,7 +6674,7 @@ export const encodeSnapshot: <
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -6239,7 +6702,8 @@ export const decodeSnapshot: <
   FinalStates extends Machine.StateIdentifier<States> = never,
   Output = never,
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   machine: Machine<
     States,
@@ -6254,14 +6718,15 @@ export const decodeSnapshot: <
     Output,
     Emits,
     OutputStates,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >,
   encoded: unknown
 ) => Effect.Effect<
   Machine.Snapshot<States>,
   MachineSchemaDecodeError,
   Machine.SnapshotDecodingServices<States>
-> = internal.decodeSnapshot
+> = internal.decodeSnapshot as any
 
 type DynamicEffectInvokeSource<
   States extends Machine.StateSchemas,
@@ -6269,7 +6734,7 @@ type DynamicEffectInvokeSource<
   Emits extends ReadonlyArray<Machine.TaggedSchema>,
   StateId extends Machine.StateIdentifier<States>,
   Source extends (
-    context: Machine.InvokeContext<States, Events, Emits, StateId>
+    context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
   ) => Effect.Effect<unknown, unknown, unknown>
 > = {
   readonly id: InvokeLifecycleId
@@ -6291,7 +6756,15 @@ type DynamicEffectDoneHandler<
   States,
   Events,
   Emits,
-  Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>>
+  Machine.InvokeDoneContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Effect.Success<ReturnType<NoInfer<Source>>>,
+    readonly [],
+    readonly []
+  >
 >
 
 type DynamicEffectFailureHandler<
@@ -6304,7 +6777,15 @@ type DynamicEffectFailureHandler<
   States,
   Events,
   Emits,
-  Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>>
+  Machine.InvokeFailureContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Effect.Error<ReturnType<NoInfer<Source>>>,
+    readonly [],
+    readonly []
+  >
 >
 
 type DynamicEffectInvokeResult<
@@ -6314,7 +6795,7 @@ type DynamicEffectInvokeResult<
   StateId extends Machine.StateIdentifier<States>,
   Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
 > =
-  & Machine.InvokeConfig<States, Events, Emits, StateId>
+  & Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []>
   & Machine.InvokeTyped<
     Effect.Success<ReturnType<Source>>,
     Effect.Error<ReturnType<Source>>,
@@ -6324,6 +6805,325 @@ type DynamicEffectInvokeResult<
 
 type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false
 
+type BoundDynamicEffectInvokeSource<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (
+    context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  ) => Effect.Effect<unknown, unknown, unknown>
+> = {
+  readonly id: InvokeLifecycleId
+  readonly effect: Source
+  readonly after?: never
+  readonly logic?: never
+  readonly child?: never
+  readonly address?: never
+  readonly onSnapshot?: never
+}
+
+type BoundDynamicEffectDoneHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  Machine.InvokeDoneContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Effect.Success<ReturnType<NoInfer<Source>>>,
+    InputEvents,
+    ParentEvents
+  >
+>
+
+type BoundDynamicEffectFailureHandler<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
+> = Machine.InvokeTransition<
+  States,
+  Events,
+  Emits,
+  Machine.InvokeFailureContext<
+    States,
+    Events,
+    Emits,
+    StateId,
+    Effect.Error<ReturnType<NoInfer<Source>>>,
+    InputEvents,
+    ParentEvents
+  >
+>
+
+type BoundDynamicEffectInvokeResult<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  StateId extends Machine.StateIdentifier<States>,
+  Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
+> =
+  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  & Machine.InvokeTyped<
+    Effect.Success<ReturnType<Source>>,
+    Effect.Error<ReturnType<Source>>,
+    Effect.Services<ReturnType<Source>>,
+    never
+  >
+
+/**
+ * Machine-bound invocation constructor that preserves the owning machine's
+ * public input and parent protocols in every invocation callback.
+ *
+ * @category constructors
+ * @since 0.11.0
+ */
+export interface Invoker<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Emits extends ReadonlyArray<Machine.TaggedSchema>,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
+> {
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<unknown, unknown, unknown>
+  >(
+    config:
+      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onDone: BoundDynamicEffectDoneHandler<
+          States,
+          Events,
+          Emits,
+          InputEvents,
+          ParentEvents,
+          StateId,
+          Source
+        >
+        readonly onFailure: BoundDynamicEffectFailureHandler<
+          States,
+          Events,
+          Emits,
+          InputEvents,
+          ParentEvents,
+          StateId,
+          Source
+        >
+      },
+    ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
+        "onDone must be omitted when the Effect output is never"
+      ]
+      : InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
+          "onFailure must be omitted when the Effect error is never"
+        ]
+      : []
+  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<unknown, never, unknown>
+  >(
+    config:
+      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onDone: BoundDynamicEffectDoneHandler<
+          States,
+          Events,
+          Emits,
+          InputEvents,
+          ParentEvents,
+          StateId,
+          Source
+        >
+        readonly onFailure?: never
+      },
+    ..._validation: InvokeChannelIsNever<Effect.Success<ReturnType<Source>>> extends true ? [
+        "onDone must be omitted when the Effect output is never"
+      ]
+      : []
+  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<never, unknown, unknown>
+  >(
+    config:
+      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onDone?: never
+        readonly onFailure: BoundDynamicEffectFailureHandler<
+          States,
+          Events,
+          Emits,
+          InputEvents,
+          ParentEvents,
+          StateId,
+          Source
+        >
+      },
+    ..._validation: InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
+        "onFailure must be omitted when the Effect error is never"
+      ]
+      : []
+  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Source extends (
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<never, never, unknown>
+  >(
+    config:
+      & BoundDynamicEffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+      & {
+        readonly onDone?: never
+        readonly onFailure?: never
+      }
+  ): BoundDynamicEffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Fx extends Effect.Effect<any, any, any>,
+    const Config extends object
+  >(
+    config:
+      & Config
+      & Machine.EffectInvokeArgs<
+        States,
+        Events,
+        Emits,
+        StateId,
+        Fx,
+        Fx,
+        InputEvents,
+        ParentEvents
+      >
+  ):
+    & Config
+    & Machine.InvokeOwned<States, Events, Emits, StateId>
+    & Machine.InvokeTyped<Effect.Success<Fx>, Effect.Error<Fx>, Effect.Services<Fx>, never>
+  <StateId extends Machine.StateIdentifier<States>, const Config extends object>(
+    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>
+  ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    ChildState,
+    ChildEvent,
+    ChildError,
+    ChildRequirements,
+    ChildOutput,
+    ChildInitialError,
+    Address extends ChildAddress<never>
+  >(
+    config: Machine.LogicInvokeArgs<
+      States,
+      Events,
+      Emits,
+      StateId,
+      ChildState,
+      ChildEvent,
+      ChildError,
+      ChildRequirements,
+      ChildOutput,
+      ChildInitialError,
+      Address,
+      (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Logic<
+        ChildState,
+        ChildEvent,
+        ChildError,
+        ChildRequirements,
+        ChildOutput,
+        ChildInitialError
+      >,
+      InputEvents,
+      ParentEvents
+    >
+  ):
+    & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    ChildState,
+    ChildEvent,
+    ChildError,
+    ChildRequirements,
+    ChildOutput,
+    ChildInitialError,
+    Address extends ChildAddress<never>,
+    const Config extends object
+  >(
+    config:
+      & Config
+      & Machine.LogicInvokeArgs<
+        States,
+        Events,
+        Emits,
+        StateId,
+        ChildState,
+        ChildEvent,
+        ChildError,
+        ChildRequirements,
+        ChildOutput,
+        ChildInitialError,
+        Address,
+        Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
+        InputEvents,
+        ParentEvents
+      >
+  ):
+    & Config
+    & Machine.InvokeOwned<States, Events, Emits, StateId>
+    & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>
+  <
+    StateId extends Machine.StateIdentifier<States>,
+    const Child extends ChildMachine.Any,
+    const Config extends object
+  >(
+    config:
+      & Config
+      & Machine.ChildInvokeArgs<
+        States,
+        Events,
+        Emits,
+        StateId,
+        Child["machine"],
+        Child,
+        InputEvents,
+        ParentEvents
+      >
+  ):
+    & Config
+    & Machine.InvokeOwned<States, Events, Emits, StateId>
+    & Machine.InvokeTyped<
+      Machine.Output<Child["machine"]>,
+      Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>,
+      Machine.Services<Child["machine"]>,
+      Machine.InitialError<Child["machine"]>,
+      Machine.Emit<Child["machine"]>,
+      Machine.EventOf<Machine.ParentEvents<Child["machine"]>>
+    >
+}
+
 /**
  * Preserves inference for a state-owned invocation configuration.
  *
@@ -6340,6 +7140,12 @@ type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] e
  * lifecycle `id` and a typed communication `address`. Child descriptors already
  * own their identity, so `id` and `address` must not be repeated.
  *
+ * Owner references are intentionally non-sendable here because this standalone
+ * constructor does not know the owning definition. When a callback sends to
+ * `self` or `parent`, use the bound constructor on the owning definition
+ * (`definition.invoke(...)`) so the exact public input and `parentEvents`
+ * protocols are available.
+ *
  * ```ts
  * invoke: Machine.invoke({
  *   id: "load",
@@ -6362,7 +7168,7 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
     ) => Effect.Effect<unknown, unknown, unknown>
   >(
     config:
@@ -6385,7 +7191,7 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
     ) => Effect.Effect<unknown, never, unknown>
   >(
     config:
@@ -6405,7 +7211,7 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
     ) => Effect.Effect<never, unknown, unknown>
   >(
     config:
@@ -6425,7 +7231,7 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
     ) => Effect.Effect<never, never, unknown>
   >(
     config:
@@ -6443,7 +7249,9 @@ export const invoke: {
     const Fx extends Effect.Effect<any, any, any>,
     const Config extends object
   >(
-    config: Config & Machine.EffectInvokeArgs<States, Events, Emits, StateId, Fx>
+    config:
+      & Config
+      & Machine.EffectInvokeArgs<States, Events, Emits, StateId, Fx, Fx, readonly [], readonly []>
   ):
     & Config
     & Machine.InvokeOwned<States, Events, Emits, StateId>
@@ -6460,7 +7268,7 @@ export const invoke: {
     StateId extends Machine.StateIdentifier<States>,
     const Config extends object
   >(
-    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId>
+    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, readonly [], readonly []>
   ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
   <
     const States extends Machine.StateSchemas,
@@ -6487,17 +7295,19 @@ export const invoke: {
       ChildOutput,
       ChildInitialError,
       Address,
-      (context: Machine.InvokeContext<States, Events, Emits, StateId>) => Logic<
+      (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Logic<
         ChildState,
         ChildEvent,
         ChildError,
         ChildRequirements,
         ChildOutput,
         ChildInitialError
-      >
+      >,
+      readonly [],
+      readonly []
     >
   ):
-    & Machine.InvokeConfig<States, Events, Emits, StateId>
+    & Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []>
     & Machine.InvokeTyped<
       ChildOutput,
       ChildError,
@@ -6531,7 +7341,10 @@ export const invoke: {
         ChildRequirements,
         ChildOutput,
         ChildInitialError,
-        Address
+        Address,
+        Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
+        readonly [],
+        readonly []
       >
   ):
     & Config
@@ -6550,7 +7363,9 @@ export const invoke: {
     const Child extends ChildMachine.Any,
     const Config extends object
   >(
-    config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child>
+    config:
+      & Config
+      & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, readonly [], readonly []>
   ):
     & Config
     & Machine.InvokeOwned<States, Events, Emits, StateId>
@@ -6559,60 +7374,10 @@ export const invoke: {
       Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>,
       Machine.Services<Child["machine"]>,
       Machine.InitialError<Child["machine"]>,
-      Machine.Emit<Child["machine"]>
+      Machine.Emit<Child["machine"]>,
+      Machine.EventOf<Machine.ParentEvents<Child["machine"]>>
     >
 } = ((config: unknown) => config) as any
-type RetagFields<Target extends Machine.TaggedSchema> = Omit<Target["~type.make.in"], "_tag">
-
-type RetagTargetCompatibility<Target extends Machine.TaggedSchema> = Target extends {
-  readonly fields: Schema.Struct.Fields
-} ? "_tag" extends keyof Target["~type.make.in"] ? {} extends Pick<Target["~type.make.in"], "_tag"> ? unknown : {
-      readonly "~effect/Machine/RetagTargetError": "Target schema must supply its discriminator when make is called"
-    }
-  : unknown
-  : {
-    readonly "~effect/Machine/RetagTargetError": "Target schema must be one tagged struct or tagged class"
-  }
-
-type RequiredKeys<A> = {
-  readonly [Key in keyof A]-?: {} extends Pick<A, Key> ? never : Key
-}[keyof A]
-
-type CompatibleSourceKeys<Fields, Source> = {
-  readonly [Key in Extract<keyof Fields, keyof Source>]: Source[Key] extends Fields[Key] ? Key : never
-}[Extract<keyof Fields, keyof Source>]
-
-type RetagPatch<Target extends Machine.TaggedSchema, Source> =
-  & Partial<RetagFields<Target>>
-  & Pick<
-    RetagFields<Target>,
-    Exclude<RequiredKeys<RetagFields<Target>>, CompatibleSourceKeys<RetagFields<Target>, Source>>
-  >
-
-type RetagArgs<Target extends Machine.TaggedSchema, Source> = [
-  Exclude<RequiredKeys<RetagFields<Target>>, CompatibleSourceKeys<RetagFields<Target>, Source>>
-] extends [never] ? [patch?: RetagPatch<Target, Source>]
-  : [patch: RetagPatch<Target, Source>]
-
-/**
- * Constructs another tagged case from compatible source fields.
- *
- * The target must be one tagged struct or tagged class whose discriminator is
- * supplied by its constructor. Union wrappers are rejected because their
- * `make` operation cannot select a member after the source discriminator has
- * been discarded. Missing or incompatible required target fields must be
- * supplied by the patch, and the target schema's normal `make` validation
- * remains authoritative at runtime.
- *
- * @category constructors
- * @since 0.4.0
- */
-export 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"] = internal.retag
-
 /**
  * Plans the initial state for a machine without executing actor commands.
  *
@@ -6641,7 +7406,7 @@ export const retag: <const Target extends Machine.TaggedSchema, const Source ext
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -6666,7 +7431,8 @@ export const planInitial: <
   FinalStates extends Machine.StateIdentifier<States> = never,
   Output = never,
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   machine:
     & Machine<
@@ -6682,7 +7448,8 @@ export const planInitial: <
       Output,
       Emits,
       OutputStates,
-      InputEvents
+      InputEvents,
+      ParentEvents
     >
     & EnsureExecutable<States, UnhandledStates, OutputStates>,
   ...args: [...Machine.InputArgs<Input>]
@@ -6723,7 +7490,7 @@ export const planInitial: <
   ),
   InitialE | E | InfiniteTransitionError | MachineSchemaDecodeError | StartupError,
   never
-> = internal.planInitial
+> = internal.planInitial as any
 
 /**
  * Returns every compiled state node in definition order.
@@ -6827,7 +7594,8 @@ export const enabled: <
   FinalStates extends Machine.StateIdentifier<States> = never,
   Output = never,
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   machine: Machine<
     States,
@@ -6842,10 +7610,11 @@ export const enabled: <
     Output,
     Emits,
     OutputStates,
-    InputEvents
+    InputEvents,
+    ParentEvents
   >,
   state: Machine.Snapshot<States>
-) => ReadonlyArray<Machine.TagOf<Events[number]>> = internal.enabled
+) => ReadonlyArray<Machine.TagOf<Events[number]>> = internal.enabled as any
 
 /**
  * Plans the next state snapshot synchronously.
@@ -6876,7 +7645,7 @@ export const enabled: <
  * 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: {} })
  *
@@ -6904,7 +7673,8 @@ export const plan: <
   FinalStates extends Machine.StateIdentifier<States> = never,
   Output = never,
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   machine:
     & Machine<
@@ -6920,7 +7690,8 @@ export const plan: <
       Output,
       Emits,
       OutputStates,
-      InputEvents
+      InputEvents,
+      ParentEvents
     >
     & EnsureExecutable<States, UnhandledStates, OutputStates>,
   state: Machine.Snapshot<States>,
@@ -6960,7 +7731,7 @@ export const plan: <
   ),
   E | InfiniteTransitionError | MachineSchemaDecodeError,
   never
-> = internal.plan
+> = internal.plan as any
 
 /**
  * Creates advanced stateful process logic from explicit initialization and
@@ -7164,6 +7935,89 @@ export const watch: <State, Event, Error = never, Output = never>(
   ref: MachineRef<State, Event, Error, Output>
 ) => Stream.Stream<RuntimeOutcome<State, Error, Output>> = internal.watch
 
+/**
+ * Prepares a fresh machine without initializing it.
+ *
+ * Use this constructor when observation must be composed before initial-entry
+ * actions run. Subscribe to `prepared.emissions`, then evaluate
+ * `prepared.start`. Ordinary callers can continue to use {@link start}, which
+ * starts directly and does not allocate the prepared lifecycle boundary.
+ *
+ * ```ts
+ * const prepared = yield* Machine.prepare(machine)
+ *
+ * yield* prepared.emissions.pipe(
+ *   Stream.runForEach(handleEmission),
+ *   Effect.forkScoped({ startImmediately: true })
+ * )
+ *
+ * const ref = yield* prepared.start
+ * ```
+ *
+ * @category constructors
+ * @since 0.11.0
+ */
+export const prepare: <
+  const States extends Machine.StateSchemas,
+  const Events extends ReadonlyArray<Machine.TaggedSchema>,
+  const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+  const Input extends Schema.Top = typeof Schema.Void,
+  UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>,
+  E = never,
+  R = never,
+  InitialE = never,
+  InitialR = never,
+  FinalStates extends Machine.StateIdentifier<States> = never,
+  Output = never,
+  OutputStates extends Machine.StateIdentifier<States> = never,
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+>(
+  machine:
+    & Machine<
+      States,
+      Events,
+      Input,
+      UnhandledStates,
+      E,
+      R,
+      InitialE,
+      InitialR,
+      FinalStates,
+      Output,
+      Emits,
+      OutputStates,
+      InputEvents,
+      ParentEvents
+    >
+    & EnsureExecutable<States, UnhandledStates, OutputStates>,
+  ...args: [...Machine.InputArgs<Input>]
+) => Effect.Effect<
+  Prepared<
+    Machine.Snapshot<States>,
+    Machine.EventInputOf<InputEvents>,
+    | E
+    | ActionError<R>
+    | InfiniteTransitionError
+    | MachineSchemaDecodeError
+    | StoppedError,
+    Output,
+    Machine.EmittedEventOf<Emits>,
+    | InitialE
+    | E
+    | ActionError<InitialR | R>
+    | InfiniteTransitionError
+    | MachineSchemaDecodeError
+    | StartupError
+    | StoppedError,
+    ExcludeCompatibleRuntime<
+      ExecutionServices<InitialR | R>,
+      Machine.EventOf<Events>,
+      Machine.EmitOf<Emits>
+    >
+  >
+> = internal.prepare as any
+
 /**
  * Starts a machine.
  *
@@ -7196,7 +8050,7 @@ export const watch: <State, Event, Error = never, Output = never>(
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -7224,7 +8078,8 @@ export const start: <
   FinalStates extends Machine.StateIdentifier<States> = never,
   Output = never,
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   machine:
     & Machine<
@@ -7240,7 +8095,8 @@ export const start: <
       Output,
       Emits,
       OutputStates,
-      InputEvents
+      InputEvents,
+      ParentEvents
     >
     & EnsureExecutable<States, UnhandledStates, OutputStates>,
   ...args: [...Machine.InputArgs<Input>]
@@ -7253,7 +8109,8 @@ export const start: <
     | InfiniteTransitionError
     | MachineSchemaDecodeError
     | StoppedError,
-    Output
+    Output,
+    Machine.EmittedEventOf<Emits>
   >,
   | InitialE
   | E
@@ -7267,7 +8124,7 @@ export const start: <
     Machine.EventOf<Events>,
     Machine.EmitOf<Emits>
   >
-> = internal.start
+> = internal.start as any
 
 /**
  * Starts a fresh managed runtime from a decoded logical snapshot.
@@ -7303,7 +8160,7 @@ export const start: <
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -7333,7 +8190,8 @@ export const resume: <
   FinalStates extends Machine.StateIdentifier<States> = never,
   Output = never,
   OutputStates extends Machine.StateIdentifier<States> = never,
-  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   machine:
     & Machine<
@@ -7349,7 +8207,8 @@ export const resume: <
       Output,
       Emits,
       OutputStates,
-      InputEvents
+      InputEvents,
+      ParentEvents
     >
     & EnsureExecutable<States, UnhandledStates, OutputStates>,
   snapshot: Machine.Snapshot<States>
@@ -7362,7 +8221,8 @@ export const resume: <
     | InfiniteTransitionError
     | MachineSchemaDecodeError
     | StoppedError,
-    Output
+    Output,
+    Machine.EmittedEventOf<Emits>
   >,
   MachineSchemaDecodeError,
   ExcludeCompatibleRuntime<
@@ -7370,4 +8230,4 @@ export const resume: <
     Machine.EventOf<Events>,
     Machine.EmitOf<Emits>
   >
-> = internal.resume
+> = internal.resume as any