@typeonce/effect-machine 0.14.1 → 0.15.0

package/src/Machine.ts

@@ -96,7 +96,7 @@ export const isInitialEvent = (u: unknown): u is InitialEvent => hasProperty(u,
 type IsAny<A> = 0 extends (1 & A) ? true : false
 
 /**
- * A schema-first machine definition.
+ * A schema-first machine implementation.
  *
  * **Details**
  *
@@ -222,12 +222,68 @@ export interface Machine<
   readonly handlers: Machine.StateConfigs<States, Events, Emits, UnhandledStates, Machine.TagOf<Events[number]>, E, R>
 
   /**
-   * Adds typed state handlers and returns the refined machine definition.
-   * Successive calls implement the remaining unhandled states while retaining
-   * accumulated errors, services, final states, and output evidence.
-   * Event dispatch maps and transition descriptors are captured by value, so
-   * later mutation of the objects supplied to this call cannot alter the
-   * resulting machine.
+   * Machine-bound equivalent of {@link invoke}. Both forms preserve this
+   * machine's public input and parent protocols in invocation callbacks;
+   * `Machine.invoke(...)` inside `handle(...)` is the canonical inline form.
+   *
+   * @since 0.11.0
+   */
+  readonly invoke: Invoker<States, Events, Emits, InputEvents, ParentEvents>
+
+  /** @internal */
+  readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
+  /** @internal */
+  readonly initialDefinition: Machine.InitialDefinition
+}
+
+/**
+ * A schema-first machine definition that can produce independent
+ * implementations.
+ *
+ * **Details**
+ *
+ * Call `handle` once for each implementation. The returned {@link Machine}
+ * does not expose `handle`, so handler configuration cannot be accumulated or
+ * replaced through chained calls. Calling `handle` multiple times on the same
+ * definition remains supported and creates independent machines.
+ *
+ * @category models
+ * @since 0.15.0
+ */
+export interface Definition<
+  States extends Machine.StateSchemas,
+  Events extends ReadonlyArray<Machine.TaggedSchema>,
+  Input extends Schema.Top = typeof Schema.Void,
+  InitialE = never,
+  InitialR = never,
+  FinalStates extends Machine.StateIdentifier<States> = never,
+  Output = never,
+  Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+  InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+> extends
+  Machine<
+    States,
+    Events,
+    Input,
+    Machine.StateIdentifier<States>,
+    never,
+    never,
+    InitialE,
+    InitialR,
+    FinalStates,
+    Output,
+    Emits,
+    never,
+    InputEvents,
+    ParentEvents
+  >
+{
+  /**
+   * Adds typed state handlers and returns an independent machine
+   * implementation. Event dispatch maps and transition descriptors are
+   * captured by value, so later mutation of the supplied objects cannot alter
+   * the resulting machine.
    *
    * @since 0.4.0
    */
@@ -236,31 +292,35 @@ export interface Machine<
     Events,
     Emits,
     Input,
-    UnhandledStates,
-    E,
-    R,
+    Machine.StateIdentifier<States>,
+    never,
+    never,
     InitialE,
     InitialR,
     FinalStates,
     Output,
-    OutputStates,
+    never,
     InputEvents,
     ParentEvents
   >
+}
 
+/**
+ * Namespace containing type-level members associated with {@link Definition}.
+ *
+ * @category models
+ * @since 0.15.0
+ */
+export declare namespace Definition {
   /**
-   * 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`.
+   * Any schema-first machine definition.
    *
-   * @since 0.11.0
+   * @category models
+   * @since 0.15.0
    */
-  readonly invoke: Invoker<States, Events, Emits, InputEvents, ParentEvents>
-
-  /** @internal */
-  readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
-  /** @internal */
-  readonly initialDefinition: Machine.InitialDefinition
+  export interface Any extends Machine.Any {
+    readonly handle: any
+  }
 }
 
 export {
@@ -687,8 +747,12 @@ type ValidateCompoundStateNode<
   Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> ? {
       readonly states: ValidateStateTree<Children, true, Extract<Path, string>>
     }
-  : StateDefinitionError<"Compound initial must be one of its direct child keys">
-  : StateDefinitionError<"Compound states must declare an initial child">
+  : StateDefinitionError<
+    "Compound initial must be one of its direct child keys",
+    Path,
+    Extract<Initial, PropertyKey>
+  >
+  : StateDefinitionError<"Compound states must declare an initial child", Path>
 
 type ValidateStateNodeWithoutChildren<Node extends Machine.StateNodeConfig> = "initial" extends keyof Node ?
   StateDefinitionError<"Atomic states cannot declare an initial child">
@@ -723,7 +787,29 @@ type InvalidDefinedStateTreeInput<States extends Machine.StateSchemas> = [States
   [Machine.ValidateStateSchemas<States>] ? never
   : States & Machine.ValidateStateSchemas<States>
 
-interface DefineStates {
+type ReusableStateNodeConfig =
+  | Machine.AtomicStateNodeConfig
+  | Machine.CompoundStateNodeConfig
+  | Machine.ParallelStateNodeConfig
+
+type ReusableStateValidation<Node> = Node extends ReusableStateNodeConfig ? ValidateStateNode<Node, false, "state">
+  : StateDefinitionError<"Reusable states must be active state nodes", "state">
+
+type ValidateDefinedState<Node> = [Node] extends [ReusableStateValidation<Node>] ? []
+  : [validation: ReusableStateValidation<Node>]
+
+type InvalidDefinedStateInput<Node> = [Node] extends [ReusableStateValidation<Node>] ? never
+  : Node & ReusableStateValidation<Node>
+
+interface StateConstructor {
+  <const Node>(
+    node: Node & DefineStateNodeInput<NoInfer<Node>>,
+    ..._validation: ValidateDefinedState<NoInfer<Node>>
+  ): Node
+  <const Node>(node: InvalidDefinedStateInput<Node>): never
+}
+
+interface StatesConstructor {
   <const States extends Machine.StateSchemas>(
     states: States & DefineStateTreeInput<NoInfer<States>>,
     ..._validation: ValidateDefinedStates<NoInfer<States>>
@@ -2410,8 +2496,6 @@ export declare namespace Machine {
     /** @internal */
     readonly handlers: any
     /** @internal */
-    readonly handle: any
-    /** @internal */
     readonly invoke: any
     /** @internal */
     readonly initial: any
@@ -2882,12 +2966,12 @@ export declare namespace Machine {
   export type StateSchemas = StateTree
 
   /**
-   * Builder for initial state snapshots generated by `defineStates`.
+   * Builder for initial state snapshots generated by `states`.
    *
    * **When to use**
    *
    * Use when you need the type of the `initial` property returned by
-   * `defineStates` or want to expose an initial snapshot builder from a helper.
+   * `states` or want to expose an initial snapshot builder from a helper.
    *
    * **Details**
    *
@@ -2900,7 +2984,7 @@ export declare namespace Machine {
   type InitialBuilder<States extends StateSchemas> = InitialSnapshotBuilderWithPrefix<States>
 
   /**
-   * State definitions and snapshot access helpers returned by `defineStates`.
+   * State definitions and snapshot access helpers returned by `states`.
    *
    * **Details**
    *
@@ -2912,9 +2996,19 @@ export declare namespace Machine {
    * @since 0.4.0
    */
   export interface DefinedStates<States extends StateSchemas> {
-    /** Original state tree supplied to {@link defineStates}. */
+    /** Captured state tree supplied to {@link states}. */
     readonly states: States
 
+    /**
+     * Checks and preserves one active state path from this definition.
+     *
+     * This is useful for named path helpers, including finite template-literal
+     * families. Every member of a path union must exist in the state tree.
+     *
+     * @since 0.15.0
+     */
+    readonly path: <const Path extends StateIdentifier<States>>(path: Path) => Path
+
     /**
      * Returns the decoded value for an active state path. The supplied
      * snapshot may be a complete root snapshot or a snapshot previously
@@ -6827,6 +6921,16 @@ export declare namespace Machine {
   >
 }
 
+/**
+ * Extracts the complete logical snapshot represented by a state definition.
+ *
+ * @category utility types
+ * @since 0.15.0
+ */
+export type Snapshot<Defined extends Machine.DefinedStates<any>> = Defined extends Machine.DefinedStates<infer States>
+  ? Machine.Snapshot<States>
+  : never
+
 /**
  * Returns `true` if a value is a `Machine`.
  *
@@ -6877,7 +6981,44 @@ export const isFinal: <
 ) => state is Machine.SnapshotContainingFinal<States, FinalStates> = internal.isFinal as any
 
 /**
- * Defines a state tree while preserving literal state paths.
+ * Defines one reusable active state while preserving its exact child topology.
+ *
+ * Prefer declaring state nodes inline in {@link states}. Use this constructor
+ * only when the same state definition is mounted more than once.
+ * Tagged schemas are already reusable and do not need this constructor.
+ *
+ * **Example** (Repeated compound state)
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * const TradingState = Schema.TaggedUnion({
+ *   InSession: {},
+ *   Applying: {}
+ * })
+ * const TradingSlot = Machine.state({
+ *   initial: "Idle",
+ *   states: {
+ *     Idle: {},
+ *     InSession: TradingState.cases.InSession,
+ *     Applying: TradingState.cases.Applying
+ *   }
+ * })
+ *
+ * const States = Machine.states({
+ *   slot1: TradingSlot,
+ *   slot2: TradingSlot
+ * })
+ * ```
+ *
+ * @category constructors
+ * @since 0.15.0
+ */
+export const state: StateConstructor = internal.state as StateConstructor
+
+/**
+ * Defines the complete state tree while preserving literal state paths.
  *
  * **When to use**
  *
@@ -6886,7 +7027,8 @@ export const isFinal: <
  *
  * **Details**
  *
- * The returned `states` property is the same object passed to `defineStates`.
+ * The returned `states` property is an immutable structural capture of the
+ * supplied tree.
  * `Machine.make` derives its initial target selector from that tree and
  * enforces compound and parallel initial-state rules. Active nodes may omit
  * `schema` when they own no value and still participate fully in targeting,
@@ -6900,7 +7042,7 @@ export const isFinal: <
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
  *
- * const States = Machine.defineStates({ idle: Idle })
+ * const States = Machine.states({ idle: Idle })
  *
  * Machine.make({
  *   states: States.states,
@@ -6915,7 +7057,7 @@ export const isFinal: <
  * @category constructors
  * @since 0.4.0
  */
-export const defineStates: DefineStates = internal.defineStates
+export const states: StatesConstructor = internal.states
 
 type InitialDirectInput<
   States extends Machine.StateSchemas,
@@ -6967,19 +7109,15 @@ type MakeResult<
   InitialR,
   InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
   ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
-> = Machine<
+> = Definition<
   States,
   readonly [...InputEvents, ...InternalEvents],
   Input,
-  Machine.StateIdentifier<States>,
-  never,
-  never,
   InitialE,
   InitialR,
   Machine.FinalStateFromDefinition<States>,
   Machine.TerminalOutput<States>,
   Emits,
-  never,
   InputEvents,
   ParentEvents
 >
@@ -7028,7 +7166,7 @@ interface Make {
  * State and event schemas provide runtime boundary validation while their
  * decoded types drive handler, state, event, target, error, and service
  * inference. State-tree validation is applied whether `states` comes from
- * `defineStates` or is passed inline. Call `handle` on the returned definition
+ * `states` or is passed inline. Call `handle` on the returned definition
  * to implement state behavior with ordinary TypeScript control flow.
  *
  * `Machine.events` defines the public input protocol. `Machine.internalEvents`
@@ -7053,7 +7191,7 @@ interface Make {
  *   by: Schema.Number
  * }) {}
  *
- * const States = Machine.defineStates({ Count })
+ * const States = Machine.states({ Count })
  * const Events = Machine.events(Increment)
  *
  * const counter = Machine.make({
@@ -7076,7 +7214,7 @@ interface Make {
  * })
  * ```
  *
- * @see {@link defineStates} for typed state-tree helpers.
+ * @see {@link states} for typed state-tree helpers.
  * @category constructors
  * @since 0.4.0
  */
@@ -7104,9 +7242,14 @@ export type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventO
  * **Example**
  *
  * ```ts
- * const Events = Machine.events(Increment, Reset)
- * const machine = Machine.make({ events: Events, ... })
- * yield* ref.send(Events.Increment({ by: 1 }))
+ * export const Event = Machine.events(
+ *   Schema.TaggedUnion({
+ *     Increment: { by: Schema.Number },
+ *     Reset: {}
+ *   })
+ * )
+ * const machine = Machine.make({ events: Event, ... })
+ * yield* ref.send(Event.Increment({ by: 1 }))
  * ```
  *
  * @category constructors
@@ -7132,11 +7275,16 @@ export const events: {
  * **Example**
  *
  * ```ts
- * const InternalEvents = Machine.internalEvents(Loaded, Failed)
- * const machine = Machine.make({ internalEvents: InternalEvents, ... })
+ * const Internal = Machine.internalEvents(
+ *   Schema.TaggedUnion({
+ *     Loaded: { value: Schema.String },
+ *     Failed: { message: Schema.String }
+ *   })
+ * )
+ * const machine = Machine.make({ internalEvents: Internal, ... })
  *
  * // Inside a transition callback:
- * enqueue.raise(InternalEvents.Loaded({ value }))
+ * enqueue.raise(Internal.Loaded({ value }))
  * ```
  *
  * @category constructors
@@ -7157,6 +7305,17 @@ export const internalEvents: {
  * implicitly to a parent machine. Observe them through `MachineRef.emissions` or
  * the AtomMachine emission stream adapters.
  *
+ * **Example**
+ *
+ * ```ts
+ * const Emitted = Machine.emittedEvents(
+ *   Schema.TaggedUnion({
+ *     Saved: { id: Schema.String }
+ *   })
+ * )
+ * const machine = Machine.make({ emittedEvents: Emitted, ... })
+ * ```
+ *
  * @category constructors
  * @since 0.10.0
  */
@@ -7199,7 +7358,7 @@ export const emittedEvents: {
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
@@ -7284,7 +7443,7 @@ export const encodeSnapshot: <
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
@@ -7348,9 +7507,11 @@ type EffectInvokeSource<
   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, readonly [], readonly []>
+    context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
   ) => Effect.Effect<unknown, unknown, unknown>
 > = {
   readonly id: InvokeLifecycleId
@@ -7366,6 +7527,8 @@ type EffectDoneHandler<
   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<
@@ -7379,8 +7542,8 @@ type EffectDoneHandler<
     Emits,
     StateId,
     Effect.Success<ReturnType<NoInfer<Source>>>,
-    readonly [],
-    readonly []
+    InputEvents,
+    ParentEvents
   >
 >
 
@@ -7388,6 +7551,8 @@ type EffectFailureHandler<
   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<
@@ -7401,8 +7566,8 @@ type EffectFailureHandler<
     Emits,
     StateId,
     Effect.Error<ReturnType<NoInfer<Source>>>,
-    readonly [],
-    readonly []
+    InputEvents,
+    ParentEvents
   >
 >
 
@@ -7410,10 +7575,12 @@ type EffectInvokeResult<
   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, readonly [], readonly []>
+  & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
   & Machine.InvokeTyped<
     Effect.Success<ReturnType<Source>>,
     Effect.Error<ReturnType<Source>>,
@@ -7897,11 +8064,10 @@ export interface Invoker<
  * `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.
+ * Inside `handle(...)`, the owning definition contextually supplies its public
+ * input and `parentEvents` protocols. Invocation sources and lifecycle handlers
+ * can therefore send through `self` and `parent` without naming the definition.
+ * The bound `definition.invoke(...)` constructor remains an equivalent form.
  *
  * ```ts
  * invoke: Machine.invoke({
@@ -7932,14 +8098,16 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
-    ) => Effect.Effect<unknown, unknown, unknown>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<unknown, unknown, unknown>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & EffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
-        readonly onDone: EffectDoneHandler<States, Events, Emits, StateId, Source>
-        readonly onFailure: EffectFailureHandler<States, Events, Emits, StateId, Source>
+        readonly onDone: EffectDoneHandler<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
+        readonly onFailure: EffectFailureHandler<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"
@@ -7948,71 +8116,79 @@ export const invoke: {
           "onFailure must be omitted when the Effect error is never"
         ]
       : []
-  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
-    ) => Effect.Effect<unknown, never, unknown>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<unknown, never, unknown>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & EffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
-        readonly onDone: EffectDoneHandler<States, Events, Emits, StateId, Source>
+        readonly onDone: EffectDoneHandler<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"
       ]
       : []
-  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
-    ) => Effect.Effect<never, unknown, unknown>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<never, unknown, unknown>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & EffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
         readonly onDone?: never
-        readonly onFailure: EffectFailureHandler<States, Events, Emits, StateId, Source>
+        readonly onFailure: EffectFailureHandler<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"
       ]
       : []
-  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Source extends (
-      context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>
-    ) => Effect.Effect<never, never, unknown>
+      context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>
+    ) => Effect.Effect<never, never, unknown>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & EffectInvokeSource<States, Events, Emits, StateId, Source>
+      & EffectInvokeSource<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
       & {
         readonly onDone?: never
         readonly onFailure?: never
       }
-  ): EffectInvokeResult<States, Events, Emits, StateId, Source>
+  ): EffectInvokeResult<States, Events, Emits, InputEvents, ParentEvents, StateId, Source>
   <
     const States extends Machine.StateSchemas,
     const Events extends ReadonlyArray<Machine.TaggedSchema>,
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
-    const Config extends object
+    const Config extends object,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
-    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, readonly [], readonly []>
+    config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, InputEvents, ParentEvents>
   ): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>
   <
     const States extends Machine.StateSchemas,
@@ -8025,7 +8201,9 @@ export const invoke: {
     ChildRequirements,
     ChildOutput,
     ChildInitialError,
-    Address extends ChildAddress<never>
+    Address extends ChildAddress<never>,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config: Machine.LogicInvokeArgs<
       States,
@@ -8039,7 +8217,7 @@ export const invoke: {
       ChildOutput,
       ChildInitialError,
       Address,
-      (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Logic<
+      (context: Machine.InvokeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>) => Logic<
         ChildState,
         ChildEvent,
         ChildError,
@@ -8047,11 +8225,11 @@ export const invoke: {
         ChildOutput,
         ChildInitialError
       >,
-      readonly [],
-      readonly []
+      InputEvents,
+      ParentEvents
     >
   ):
-    & Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []>
+    & Machine.InvokeConfig<States, Events, Emits, StateId, InputEvents, ParentEvents>
     & Machine.InvokeTyped<
       ChildOutput,
       ChildError,
@@ -8070,7 +8248,9 @@ export const invoke: {
     ChildOutput,
     ChildInitialError,
     Address extends ChildAddress<never>,
-    const Config extends object
+    const Config extends object,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
       & Config
@@ -8087,8 +8267,8 @@ export const invoke: {
         ChildInitialError,
         Address,
         Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
-        readonly [],
-        readonly []
+        InputEvents,
+        ParentEvents
       >
   ):
     & Config
@@ -8105,11 +8285,13 @@ export const invoke: {
     const Emits extends ReadonlyArray<Machine.TaggedSchema>,
     StateId extends Machine.StateIdentifier<States>,
     const Child extends ChildMachine.Any,
-    const Config extends object
+    const Config extends object,
+    const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
       & Config
-      & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, readonly [], readonly []>
+      & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, InputEvents, ParentEvents>
   ):
     & Config
     & Machine.InvokeOwned<States, Events, Emits, StateId>
@@ -8147,7 +8329,7 @@ export const invoke: {
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
@@ -8403,7 +8585,7 @@ export const enabled: <
  * class Off extends Schema.TaggedClass<Off>("Off")("Off", {}) {}
  * class On extends Schema.TaggedClass<On>("On")("On", {}) {}
  * class Toggle extends Schema.TaggedClass<Toggle>("Toggle")("Toggle", {}) {}
- * const States = Machine.defineStates({ Off, On })
+ * const States = Machine.states({ Off, On })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(Toggle),
@@ -8786,7 +8968,7 @@ export const prepare: <
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),
@@ -8899,7 +9081,7 @@ export const start: <
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.defineStates({ Idle })
+ * const States = Machine.states({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
  *   events: Machine.events(),