@typeonce/effect-machine 0.14.0 → 0.15.0

package/dist/Machine.d.ts

@@ -77,7 +77,7 @@ export declare const InitialEvent: InitialEvent;
 export declare const isInitialEvent: (u: unknown) => u is InitialEvent;
 type IsAny<A> = 0 extends (1 & A) ? true : false;
 /**
- * A schema-first machine definition.
+ * A schema-first machine implementation.
  *
  * **Details**
  *
@@ -157,20 +157,9 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
     /** @internal */
     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.
-     *
-     * @since 0.4.0
-     */
-    readonly handle: Machine.Handler<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents>;
-    /**
-     * Preserves invocation inference with this machine's public input and parent
-     * protocols. Prefer this bound constructor when an invocation source or
-     * lifecycle handler uses `self` or `parent`.
+     * 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
      */
@@ -180,6 +169,48 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
     /** @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
+     */
+    readonly handle: Machine.Handler<States, Events, Emits, Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, FinalStates, Output, never, InputEvents, ParentEvents>;
+}
+/**
+ * Namespace containing type-level members associated with {@link Definition}.
+ *
+ * @category models
+ * @since 0.15.0
+ */
+export declare namespace Definition {
+    /**
+     * Any schema-first machine definition.
+     *
+     * @category models
+     * @since 0.15.0
+     */
+    interface Any extends Machine.Any {
+        readonly handle: any;
+    }
+}
 export { 
 /**
  * Error returned by `spawn` when a child process with the same id already
@@ -467,7 +498,7 @@ type ValidateCompoundStateNode<Node extends Machine.StateNodeConfig, Children ex
     readonly initial: infer Initial;
 } ? 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"> : Node extends {
     readonly type: infer Type;
 } ? Type extends "final" ? ValidateOutputSchema<Node> : Type extends "active" | undefined ? "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown : StateDefinitionError<"State node type must be active, final, or parallel"> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown;
@@ -491,7 +522,15 @@ type ValidateDefinedStates<States extends Machine.StateSchemas> = [States] exten
 type InvalidDefinedStateTreeInput<States extends Machine.StateSchemas> = [States] extends [
     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>>): Machine.DefinedStates<States>;
     <const States extends Machine.StateSchemas>(states: InvalidDefinedStateTreeInput<States>): never;
 }
@@ -1399,8 +1438,6 @@ export declare namespace Machine {
         /** @internal */
         readonly handlers: any;
         /** @internal */
-        readonly handle: any;
-        /** @internal */
         readonly invoke: any;
         /** @internal */
         readonly initial: any;
@@ -1773,12 +1810,12 @@ export declare namespace Machine {
      */
     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**
      *
@@ -1790,7 +1827,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**
      *
@@ -1802,8 +1839,17 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     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
@@ -3818,6 +3864,13 @@ export declare namespace Machine {
      */
     type StateConfigs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, StateConfig<States, Events, Emits, StateId, EventTag, E, R> | ChoiceStateConfig<States, Events, Emits, ChoiceIdentifier<States>>>>;
 }
+/**
+ * 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`.
  *
@@ -3833,7 +3886,43 @@ export declare const isMachine: (u: unknown) => u is Machine.Any;
  */
 export declare const isFinal: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, state: Machine.Snapshot<States>) => state is Machine.SnapshotContainingFinal<States, FinalStates>;
 /**
- * Defines a state tree while preserving literal state paths.
+ * 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 declare const state: StateConstructor;
+/**
+ * Defines the complete state tree while preserving literal state paths.
  *
  * **When to use**
  *
@@ -3842,7 +3931,8 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *
  * **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,
@@ -3856,7 +3946,7 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *
  * 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,
@@ -3871,7 +3961,7 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  * @category constructors
  * @since 0.4.0
  */
-export declare const defineStates: DefineStates;
+export declare const states: StatesConstructor;
 type InitialDirectInput<States extends Machine.StateSchemas, Input, Selection extends Machine.TargetSelection<any, any, any>> = {
     readonly target: (to: Machine.InitialSelector<States>) => Selection;
     readonly resolve?: (context: {
@@ -3891,7 +3981,7 @@ type MakeConfig<States extends Machine.StateSchemas, InputEvents extends Readonl
     readonly input?: Input;
     readonly initial: unknown;
 };
-type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = Machine<States, readonly [...InputEvents, ...InternalEvents], Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, never, InputEvents, ParentEvents>;
+type MakeResult<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = Definition<States, readonly [...InputEvents, ...InternalEvents], Input, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, InputEvents, ParentEvents>;
 interface Make {
     <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const InitialSelection extends Machine.TargetSelection<any, any, any> = Machine.TargetSelection<any, any, any>>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "initial"> & {
         readonly initial: InitialDirectInput<States, Input["Type"], InitialSelection>;
@@ -3908,7 +3998,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`
@@ -3933,7 +4023,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({
@@ -3956,7 +4046,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
  */
@@ -3980,9 +4070,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
@@ -4003,11 +4098,16 @@ export declare 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
@@ -4023,6 +4123,17 @@ export declare 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
  */
@@ -4060,7 +4171,7 @@ export declare 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(),
@@ -4107,7 +4218,7 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * 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(),
@@ -4129,7 +4240,7 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * @since 0.4.0
  */
 export declare const decodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
-type EffectInvokeSource<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Effect.Effect<unknown, unknown, unknown>> = {
+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, InputEvents, ParentEvents>) => Effect.Effect<unknown, unknown, unknown>> = {
     readonly id: InvokeLifecycleId;
     readonly effect: Source;
     readonly after?: never;
@@ -4138,9 +4249,9 @@ type EffectInvokeSource<States extends Machine.StateSchemas, Events extends Read
     readonly address?: never;
     readonly onSnapshot?: never;
 };
-type EffectDoneHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, readonly [], readonly []>>;
-type EffectFailureHandler<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeTransition<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, readonly [], readonly []>>;
-type EffectInvokeResult<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, Source extends (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>> = Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never>;
+type 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<States, Events, Emits, StateId, Machine.InvokeDoneContext<States, Events, Emits, StateId, Effect.Success<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
+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<States, Events, Emits, StateId, Machine.InvokeFailureContext<States, Events, Emits, StateId, Effect.Error<ReturnType<NoInfer<Source>>>, InputEvents, ParentEvents>>;
+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, InputEvents, ParentEvents> & Machine.InvokeTyped<Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never>;
 type InvokeChannelIsNever<Value> = IsAny<Value> extends true ? false : [Value] extends [never] ? true : false;
 type BoundEffectInvokeSource<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;
@@ -4290,11 +4401,10 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
  * `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({
@@ -4319,34 +4429,34 @@ export interface Invoker<States extends Machine.StateSchemas, Events extends Rea
  * @since 0.9.0
  */
 export declare const invoke: {
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Effect.Effect<unknown, unknown, unknown>>(config: EffectInvokeSource<States, Events, Emits, StateId, Source> & {
-        readonly onDone: EffectDoneHandler<States, Events, Emits, StateId, Source>;
-        readonly onFailure: EffectFailureHandler<States, Events, Emits, StateId, Source>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, 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, InputEvents, ParentEvents, 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"
     ] : InvokeChannelIsNever<Effect.Error<ReturnType<Source>>> extends true ? [
         "onFailure must be omitted when the Effect error is never"
-    ] : []): EffectInvokeResult<States, Events, Emits, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Effect.Effect<unknown, never, unknown>>(config: EffectInvokeSource<States, Events, Emits, StateId, Source> & {
-        readonly onDone: EffectDoneHandler<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, 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, InputEvents, ParentEvents, 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>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Effect.Effect<never, unknown, unknown>>(config: EffectInvokeSource<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, 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, 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>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Source extends (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Effect.Effect<never, never, unknown>>(config: EffectInvokeSource<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, 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, InputEvents, ParentEvents, StateId, Source> & {
         readonly onDone?: never;
         readonly onFailure?: never;
-    }): EffectInvokeResult<States, Events, Emits, StateId, Source>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Config extends object>(config: Config & Machine.TimerInvokeArgs<States, Events, Emits, StateId, readonly [], readonly []>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<void, never, never, never>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>>(config: Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, (context: Machine.InvokeContext<States, Events, Emits, StateId, readonly [], readonly []>) => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, readonly [], readonly []>): Machine.InvokeConfig<States, Events, Emits, StateId, readonly [], readonly []> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object>(config: Config & Machine.LogicInvokeArgs<States, Events, Emits, StateId, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address, Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, readonly [], readonly []>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<ChildOutput, ChildError, ChildRequirements, ChildInitialError>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, readonly [], readonly []>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
+    }): 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 InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = 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, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(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>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, Address extends ChildAddress<never>, const Config extends object, const InputEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(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>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object, 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, 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"]>>>;
 };
 /**
  * Plans the initial state for a machine without executing machine commands.
@@ -4373,7 +4483,7 @@ export declare 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(),
@@ -4515,7 +4625,7 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * 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),
@@ -4722,7 +4832,7 @@ export declare const prepare: <const States extends Machine.StateSchemas, const
  * 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(),
@@ -4775,7 +4885,7 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * 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(),