effect-machine 0.18.0 → 0.20.0

package/dist/machine.d.ts

@@ -1,12 +1,12 @@
 import { DeferReplyResult, ReplyResult, TransitionResult, makeDeferReply, makeReply } from "./internal/utils.js";
 import { BrandedEvent, BrandedState, ExtractReply, TaggedOrConstructor } from "./internal/brands.js";
 import { MachineEventSchema, MachineStateSchema, VariantsUnion } from "./schema.js";
-import { DuplicateActorError } from "./errors.js";
+import { ActorStoppedError, DuplicateActorError } from "./errors.js";
 import { Supervision } from "./supervision.js";
 import { ActorRef, ActorSystemService } from "./actor.js";
-import { Cause, Duration, Effect, Option, Schema, Scope } from "effect";
+import { Duration, Effect, Option, Schema, Scope } from "effect";
 declare namespace machine_d_exports {
-  export { DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplyResult, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, TransitionHandler, deferReply, make, replay, reply, scoped, spawn };
+  export { DeferReplyResult, Durability, DurabilityCommit, FinalContext, GuardPredicate, HandlerContext, InputMakeConfig, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplayOptions, ReplyResult, SpawnOptions, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, TransitionHandler, deferReply, make, replay, reply, run, scoped, spawn };
 }
 /**
  * Self reference for sending events back to the machine
@@ -37,6 +37,7 @@ interface HandlerContext<State, Event> {
  */
 interface StateHandlerContext<State, Event> {
   readonly actorId: string;
+  readonly generation: number;
   readonly state: State;
   readonly event: Event;
   readonly self: MachineRef<Event>;
@@ -52,9 +53,11 @@ type TransitionHandler<S, E, NewState, R, Reply = never> = (ctx: HandlerContext<
  * State effect handler function
  */
 type StateEffectHandler<S, E, R> = (ctx: StateHandlerContext<S, E>) => Effect.Effect<void, never, R>;
+/** A condition for a transition candidate. Its error channel must be `never`. */
+type GuardPredicate<State, Event, R = never> = (ctx: HandlerContext<State, Event>) => boolean | Effect.Effect<boolean, never, R>;
 interface TaskOptions<State, Event, A, E1, ES, EF> {
   readonly onSuccess?: (value: A, ctx: StateHandlerContext<State, Event>) => ES;
-  readonly onFailure?: (cause: Cause.Cause<E1>, ctx: StateHandlerContext<State, Event>) => EF;
+  readonly onFailure?: (error: E1, ctx: StateHandlerContext<State, Event>) => EF;
   readonly name?: string;
 }
 /**
@@ -113,6 +116,23 @@ interface MakeConfig<SD extends Record<string, Schema.Struct.Fields>, ED extends
   };
   readonly initial: S;
 }
+interface InputMakeConfig<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent, Input> {
+  readonly state: MachineStateSchema<SD> & {
+    Type: S;
+  };
+  readonly event: MachineEventSchema<ED> & {
+    Type: E;
+  };
+  readonly initial: (input: Input) => S;
+}
+interface FinalContext<State> {
+  readonly state: State;
+}
+type TaggedValue<Union, Tagged> = Tagged extends ((...args: never[]) => infer Value) ? Value : Tagged extends {
+  readonly _tag: infer Tag;
+} ? Extract<Union, {
+  readonly _tag: Tag;
+}> : never;
 /**
  * Machine definition with fluent builder API.
  *
@@ -123,34 +143,54 @@ interface MakeConfig<SD extends Record<string, Schema.Struct.Fields>, ED extends
  * - `_SD`: State schema definition (for compile-time validation)
  * - `_ED`: Event schema definition (for compile-time validation)
  */
-declare class Machine<State, Event, R = never, _SD extends Record<string, Schema.Struct.Fields> = Record<string, Schema.Struct.Fields>, _ED extends Record<string, Schema.Struct.Fields> = Record<string, Schema.Struct.Fields>> {
+declare class Machine<State, Event, R = never, _SD extends Record<string, Schema.Struct.Fields> = Record<string, Schema.Struct.Fields>, _ED extends Record<string, Schema.Struct.Fields> = Record<string, Schema.Struct.Fields>, Input = void, Output = State> {
   #private;
-  readonly initial: State;
+  readonly initial: Input extends void ? State : undefined;
   readonly stateSchema: MachineStateSchema<_SD> & {
     readonly Type: State;
   };
   readonly eventSchema: MachineEventSchema<_ED> & {
     readonly Type: Event;
   };
-  from<NS extends VariantsUnion<_SD> & BrandedState, R1>(state: TaggedOrConstructor<NS>, build: (scope: TransitionScope<State, Event, R, _SD, _ED, NS>) => R1): Machine<State, Event, R, _SD, _ED>;
-  from<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, R1>(states: NS, build: (scope: TransitionScope<State, Event, R, _SD, _ED, NS[number] extends TaggedOrConstructor<infer S extends VariantsUnion<_SD> & BrandedState> ? S : never>) => R1): Machine<State, Event, R, _SD, _ED>;
+  from<NS extends VariantsUnion<_SD> & BrandedState, R1>(state: TaggedOrConstructor<NS>, build: (scope: TransitionScope<State, Event, R, _SD, _ED, NS, Input, Output>) => TransitionScope<State, Event, R, _SD, _ED, NS, Input, Output, R1>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
+  from<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, R1>(states: NS, build: (scope: TransitionScope<State, Event, R, _SD, _ED, NS[number] extends TaggedOrConstructor<infer S extends VariantsUnion<_SD> & BrandedState> ? S : never, Input, Output>) => TransitionScope<State, Event, R, _SD, _ED, NS[number] extends TaggedOrConstructor<infer S extends VariantsUnion<_SD> & BrandedState> ? S : never, Input, Output, R1>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
   /** Register transition for a single state */
-  on<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED>;
+  on<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, R1, ExtractReply<NE>>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
   /** Register transition for multiple states (handler receives union of state types) */
-  on<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(states: NS, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, NE, RS, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED>;
+  on<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(states: NS, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, NE, RS, R1, ExtractReply<NE>>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
+  /** Register a conditional transition for a single state. */
+  when<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, predicate: GuardPredicate<NS, NE, RG>, handler: TransitionHandler<NS, NE, RS, R1, ExtractReply<NE>>): Machine<State, Event, R | RG | R1, _SD, _ED, Input, Output>;
+  /** Register a conditional transition for multiple states. */
+  when<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(states: NS, event: TaggedOrConstructor<NE>, predicate: GuardPredicate<NS[number] extends TaggedOrConstructor<infer S> ? S : never, NE, RG>, handler: TransitionHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, NE, RS, R1, ExtractReply<NE>>): Machine<State, Event, R | RG | R1, _SD, _ED, Input, Output>;
   /**
    * Like `on()`, but forces onEnter/spawn to run even when transitioning to the same state tag.
    * Use this to restart timers, re-run spawned effects, or reset state-scoped effects.
    */
   /** Single state */
-  reenter<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED>;
+  reenter<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, R1, ExtractReply<NE>>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
   /** Multiple states */
-  reenter<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(states: NS, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, NE, RS, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED>;
+  reenter<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(states: NS, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, NE, RS, R1, ExtractReply<NE>>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
+  /** Register a conditional reenter transition for a single state. */
+  reenterWhen<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(state: TaggedOrConstructor<NS>, event: TaggedOrConstructor<NE>, predicate: GuardPredicate<NS, NE, RG>, handler: TransitionHandler<NS, NE, RS, R1, ExtractReply<NE>>): Machine<State, Event, R | RG | R1, _SD, _ED, Input, Output>;
+  /** Register a conditional reenter transition for multiple states. */
+  reenterWhen<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(states: NS, event: TaggedOrConstructor<NE>, predicate: GuardPredicate<NS[number] extends TaggedOrConstructor<infer S> ? S : never, NE, RG>, handler: TransitionHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, NE, RS, R1, ExtractReply<NE>>): Machine<State, Event, R | RG | R1, _SD, _ED, Input, Output>;
   /**
    * Register a wildcard transition that fires from any state when no specific transition matches.
    * Specific `.on()` transitions always take priority over `.onAny()`.
    */
-  onAny<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<VariantsUnion<_SD> & BrandedState, NE, RS, never>): Machine<State, Event, R, _SD, _ED>;
+  onAny<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<VariantsUnion<_SD> & BrandedState, NE, RS, R1>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
+  /** Register a conditional wildcard transition. */
+  whenAny<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(event: TaggedOrConstructor<NE>, predicate: GuardPredicate<VariantsUnion<_SD> & BrandedState, NE, RG>, handler: TransitionHandler<VariantsUnion<_SD> & BrandedState, NE, RS, R1>): Machine<State, Event, R | RG | R1, _SD, _ED, Input, Output>;
+  /**
+   * Register an eventless transition. The actor runs immediate transitions until stable.
+   * UI observers see only the stable state.
+   */
+  immediate<NS extends VariantsUnion<_SD> & BrandedState, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(state: TaggedOrConstructor<NS>, handler: TransitionHandler<NS, VariantsUnion<_ED> & BrandedEvent, RS, R1>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
+  immediate<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(states: NS, handler: TransitionHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, RS, R1>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
+  /** Register a conditional eventless transition for a single state. */
+  immediateWhen<NS extends VariantsUnion<_SD> & BrandedState, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(state: TaggedOrConstructor<NS>, predicate: GuardPredicate<NS, VariantsUnion<_ED> & BrandedEvent, RG>, handler: TransitionHandler<NS, VariantsUnion<_ED> & BrandedEvent, RS, R1>): Machine<State, Event, R | RG | R1, _SD, _ED, Input, Output>;
+  /** Register a conditional eventless transition for multiple states. */
+  immediateWhen<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(states: NS, predicate: GuardPredicate<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, RG>, handler: TransitionHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, RS, R1>): Machine<State, Event, R | RG | R1, _SD, _ED, Input, Output>;
   /**
    * State-scoped effect that is forked on state entry and automatically cancelled on state exit.
    *
@@ -166,9 +206,9 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * ```
    */
   /** Single state */
-  spawn<NS extends VariantsUnion<_SD> & BrandedState, R1>(state: TaggedOrConstructor<NS>, handler: StateEffectHandler<NS, VariantsUnion<_ED> & BrandedEvent, Scope.Scope | R1>): Machine<State, Event, R | R1, _SD, _ED>;
+  spawn<NS extends VariantsUnion<_SD> & BrandedState, R1>(state: TaggedOrConstructor<NS>, handler: StateEffectHandler<NS, VariantsUnion<_ED> & BrandedEvent, Scope.Scope | R1>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
   /** Multiple states */
-  spawn<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, R1>(states: NS, handler: StateEffectHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, Scope.Scope | R1>): Machine<State, Event, R | R1, _SD, _ED>;
+  spawn<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, R1>(states: NS, handler: StateEffectHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, Scope.Scope | R1>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
   private registerTransition;
   /**
    * State-scoped task that runs on entry and sends success/failure events.
@@ -180,9 +220,9 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * - `.task([State.X, State.Y], run, opts)` — multi-state
    */
   /** Single state — onSuccess optional (defaults to identity when task returns Event) */
-  task<NS extends VariantsUnion<_SD> & BrandedState, A, E1, R1, ES extends VariantsUnion<_ED> & BrandedEvent, EF extends VariantsUnion<_ED> & BrandedEvent>(state: TaggedOrConstructor<NS>, run: (ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent>) => Effect.Effect<A, E1, Scope.Scope | R1>, options: TaskOptions<NS, VariantsUnion<_ED> & BrandedEvent, A, E1, ES, EF>): Machine<State, Event, R | R1, _SD, _ED>;
+  task<NS extends VariantsUnion<_SD> & BrandedState, A, E1, R1, ES extends VariantsUnion<_ED> & BrandedEvent, EF extends VariantsUnion<_ED> & BrandedEvent>(state: TaggedOrConstructor<NS>, run: (ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent>) => Effect.Effect<A, E1, Scope.Scope | R1>, options: TaskOptions<NS, VariantsUnion<_ED> & BrandedEvent, A, E1, ES, EF>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
   /** Multiple states, explicit onSuccess */
-  task<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, A, E1, R1, ES extends VariantsUnion<_ED> & BrandedEvent, EF extends VariantsUnion<_ED> & BrandedEvent>(states: NS, run: (ctx: StateHandlerContext<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent>) => Effect.Effect<A, E1, Scope.Scope | R1>, options: TaskOptions<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, A, E1, ES, EF>): Machine<State, Event, R | R1, _SD, _ED>;
+  task<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, A, E1, R1, ES extends VariantsUnion<_ED> & BrandedEvent, EF extends VariantsUnion<_ED> & BrandedEvent>(states: NS, run: (ctx: StateHandlerContext<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent>) => Effect.Effect<A, E1, Scope.Scope | R1>, options: TaskOptions<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, A, E1, ES, EF>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
   /**
    * State timeout — gen_statem's `state_timeout`.
    *
@@ -204,7 +244,7 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    *   })
    * ```
    */
-  timeout<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, config: TimeoutConfig<NS, VariantsUnion<_ED> & BrandedEvent>): Machine<State, Event, R, _SD, _ED>;
+  timeout<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, config: TimeoutConfig<NS, VariantsUnion<_ED> & BrandedEvent>): Machine<State, Event, R, _SD, _ED, Input, Output>;
   /**
    * Machine-lifetime effect that is forked on actor spawn and runs until the actor stops.
    *
@@ -217,7 +257,7 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * );
    * ```
    */
-  background<R1>(handler: StateEffectHandler<State, Event, Scope.Scope | R1>): Machine<State, Event, R | R1, _SD, _ED>;
+  background<R1>(handler: StateEffectHandler<State, Event, Scope.Scope | R1>): Machine<State, Event, R | R1, _SD, _ED, Input, Output>;
   /**
    * Postpone events — gen_statem's event postpone.
    *
@@ -235,18 +275,61 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    *   .postpone(State.Connecting, [Event.Data, Event.Cmd]) // multiple events
    * ```
    */
-  postpone<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, events: TaggedOrConstructor<VariantsUnion<_ED> & BrandedEvent> | ReadonlyArray<TaggedOrConstructor<VariantsUnion<_ED> & BrandedEvent>>): Machine<State, Event, R, _SD, _ED>;
-  final<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>): Machine<State, Event, R, _SD, _ED>;
-  static make<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent>(config: MakeConfig<SD, ED, S, E>): Machine<S, E, never, SD, ED>;
+  postpone<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, events: TaggedOrConstructor<VariantsUnion<_ED> & BrandedEvent> | ReadonlyArray<TaggedOrConstructor<VariantsUnion<_ED> & BrandedEvent>>): Machine<State, Event, R, _SD, _ED, Input, Output>;
+  final<Tagged extends TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>(state: Tagged): Machine<State, Event, R, _SD, _ED, Input, Output | TaggedValue<State, Tagged>>;
+  final<Tagged extends TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>, O>(state: Tagged, output: (ctx: FinalContext<TaggedValue<State, Tagged>>) => O): Machine<State, Event, R, _SD, _ED, Input, Output | O>;
+  static make<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent>(config: MakeConfig<SD, ED, S, E>): Machine<S, E, never, SD, ED, void, never>;
+  static make<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent, Input>(config: InputMakeConfig<SD, ED, S, E, Input>): Machine<S, E, never, SD, ED, Input, never>;
 }
-declare class TransitionScope<State, Event, R, _SD extends Record<string, Schema.Struct.Fields>, _ED extends Record<string, Schema.Struct.Fields>, SelectedState extends VariantsUnion<_SD> & BrandedState> {
+declare class TransitionScope<State, Event, R, _SD extends Record<string, Schema.Struct.Fields>, _ED extends Record<string, Schema.Struct.Fields>, SelectedState extends VariantsUnion<_SD> & BrandedState, Input, Output, RAdded = never> {
   private readonly machine;
   private readonly states;
-  constructor(machine: Machine<State, Event, R, _SD, _ED>, states: ReadonlyArray<TaggedOrConstructor<SelectedState>>);
-  on<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, never, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, SelectedState>;
-  reenter<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, never, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, SelectedState>;
+  constructor(machine: Machine<State, Event, R, _SD, _ED, Input, Output>, states: ReadonlyArray<TaggedOrConstructor<SelectedState>>);
+  on<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, R1, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, SelectedState, Input, Output, RAdded | R1>;
+  reenter<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, R1 = never>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, R1, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, SelectedState, Input, Output, RAdded | R1>;
+  when<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(event: TaggedOrConstructor<NE>, predicate: GuardPredicate<SelectedState, NE, RG>, handler: TransitionHandler<SelectedState, NE, RS, R1, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, SelectedState, Input, Output, RAdded | RG | R1>;
+  reenterWhen<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState, RG = never, R1 = never>(event: TaggedOrConstructor<NE>, predicate: GuardPredicate<SelectedState, NE, RG>, handler: TransitionHandler<SelectedState, NE, RS, R1, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, SelectedState, Input, Output, RAdded | RG | R1>;
 }
 declare const make: typeof Machine.make;
+/**
+ * Spawn an actor directly without ActorSystem ceremony.
+ *
+ * **Single actor, no registry.** Caller manages lifetime via `actor.stop`.
+ * If an `ActorScope` exists in context, cleanup attaches automatically on scope close.
+ * Use `Machine.scoped` to bridge from `Scope` to `ActorScope`.
+ *
+ * For registry, lookup by ID, persistence, or multi-actor coordination,
+ * use `ActorSystem` / `system.spawn` instead.
+ *
+ * @example
+ * ```ts
+ * // Fire-and-forget — caller manages lifetime
+ * const actor = yield* Machine.spawn(machine);
+ * yield* actor.start;
+ * yield* actor.send(Event.Start);
+ * yield* actor.awaitFinal;
+ * yield* actor.stop;
+ *
+ * // Scope-aware — auto-cleans up on scope close
+ * yield* Effect.scoped(Machine.scoped(Effect.gen(function* () {
+ *   const actor = yield* Machine.spawn(machine);
+ *   yield* actor.start;
+ *   yield* actor.send(Event.Start);
+ *   // actor.stop called automatically when scope closes
+ * })));
+ * ```
+ */
+type AnyMachine<S, E, R, Input = void, Output = S> = Machine<S, E, R, any, any, Input, Output>;
+type SpawnOptions<S, E, Input> = {
+  readonly id?: string;
+  readonly hydrate?: S;
+  readonly supervision?: Supervision.Policy;
+  readonly lifecycle?: Lifecycle<S, E>;
+} & ([Input] extends [void] ? {
+  readonly input?: never;
+} : {
+  readonly input: Input;
+});
 /**
  * Spawn an actor from a machine.
  *
@@ -263,16 +346,31 @@ declare const make: typeof Machine.make;
  * });
  * ```
  */
-declare const spawn: <S extends {
-  readonly _tag: string;
-}, E extends {
-  readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any>, options?: string | {
-  id?: string;
-  hydrate?: S;
-  supervision?: Supervision.Policy;
-  lifecycle?: Lifecycle<S, E>;
-}) => Effect.Effect<ActorRef<S, E>, never, R>;
+declare const spawn: {
+  <S extends {
+    readonly _tag: string;
+  }, E extends {
+    readonly _tag: string;
+  }, R, Output>(machine: AnyMachine<S, E, R, void, Output>, options?: string | SpawnOptions<S, E, void>): Effect.Effect<ActorRef<S, E, Output>, never, R>;
+  <S extends {
+    readonly _tag: string;
+  }, E extends {
+    readonly _tag: string;
+  }, R, Input, Output>(machine: AnyMachine<S, E, R, Input, Output>, options: SpawnOptions<S, E, Input>): Effect.Effect<ActorRef<S, E, Output>, never, R>;
+};
+/** Run one actor to final output and always release its resources. */
+declare const run: {
+  <S extends {
+    readonly _tag: string;
+  }, E extends {
+    readonly _tag: string;
+  }, R, Output>(machine: AnyMachine<S, E, R, void, Output>, options?: string | SpawnOptions<S, E, void>): Effect.Effect<Output, ActorStoppedError, R>;
+  <S extends {
+    readonly _tag: string;
+  }, E extends {
+    readonly _tag: string;
+  }, R, Input, Output>(machine: AnyMachine<S, E, R, Input, Output>, options: SpawnOptions<S, E, Input>): Effect.Effect<Output, ActorStoppedError, R>;
+};
 /**
  * Wrap an effect to provide an `ActorScope` from the current `Scope`.
  *
@@ -293,16 +391,29 @@ declare const spawn: <S extends {
  * ```
  */
 declare const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Scope.Scope>;
+type ReplayOptions<S, Input> = {
+  readonly from: S;
+  readonly input?: never;
+} | ([Input] extends [void] ? {
+  readonly from?: never;
+  readonly input?: never;
+} : {
+  readonly from?: never;
+  readonly input: Input;
+});
 declare const replay: {
   <S extends {
     readonly _tag: string;
   }, E extends {
     readonly _tag: string;
-  }, R>(machine: Machine<S, E, R, any, any>, events: ReadonlyArray<E>, options?: {
-    from?: S;
-  }): Effect.Effect<S, never, R>;
+  }, R>(machine: Machine<S, E, R, any, any, void, any>, events: ReadonlyArray<E>, options?: ReplayOptions<S, void>): Effect.Effect<S, never, R>;
+  <S extends {
+    readonly _tag: string;
+  }, E extends {
+    readonly _tag: string;
+  }, R, Input>(machine: Machine<S, E, R, any, any, Input, any>, events: ReadonlyArray<E>, options: ReplayOptions<S, Input>): Effect.Effect<S, never, R>;
 };
 declare const reply: typeof makeReply;
 declare const deferReply: typeof makeDeferReply;
 //#endregion
-export { type DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, type ReplyResult, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, TransitionHandler, deferReply, machine_d_exports, make, replay, reply, scoped, spawn };
+export { type DeferReplyResult, Durability, DurabilityCommit, FinalContext, GuardPredicate, HandlerContext, InputMakeConfig, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplayOptions, type ReplyResult, SpawnOptions, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, TransitionHandler, deferReply, machine_d_exports, make, replay, reply, run, scoped, spawn };