effect-machine 0.13.0 → 0.15.0

package/dist/machine.d.ts

@@ -2,15 +2,15 @@ import { DeferReplyResult, ReplyResult, TransitionResult } from "./internal/util
 import { BrandedEvent, BrandedState, ExtractReply, TaggedOrConstructor } from "./internal/brands.js";
 import { MachineEventSchema, MachineStateSchema, VariantsUnion } from "./schema.js";
 import { DuplicateActorError } from "./errors.js";
-import { EffectHandlers, EffectSlots, EffectsDef, EffectsSchema, GuardHandlers, GuardSlots, GuardsDef, GuardsSchema, MachineContext } from "./slot.js";
+import { MachineContext, ProvideSlots, SlotCalls, SlotsDef, SlotsSchema } from "./slot.js";
 import { Supervision } from "./supervision.js";
 import { findTransitions } from "./internal/transition.js";
 import { ActorRef, ActorSystem } from "./actor.js";
-import { Cause, Duration, Effect, Schema, Scope, ServiceMap } from "effect";
+import { Cause, Duration, Effect, Option, Schema, Scope, ServiceMap } from "effect";
 
 //#region src/machine.d.ts
 declare namespace machine_d_exports {
-  export { BackgroundEffect, DeferReplyResult, HandlerContext, Machine, MachineRef, MakeConfig, ProvideHandlers, ReplyResult, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, make, materializeMachine, replay, reply, spawn };
+  export { BackgroundEffect, DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, make, materializeMachine, replay, reply, spawn };
 }
 /**
  * Self reference for sending events back to the machine
@@ -23,7 +23,7 @@ interface MachineRef<Event> {
     readonly _tag: string;
   }, E2 extends {
     readonly _tag: string;
-  }, R2>(id: string, machine: Machine<S2, E2, R2, any, any, any, any>) => Effect.Effect<ActorRef<S2, E2>, DuplicateActorError, R2>;
+  }, R2>(id: string, machine: Machine<S2, E2, R2, any, any, any>) => Effect.Effect<ActorRef<S2, E2>, DuplicateActorError, R2>;
   /**
    * Settle a deferred reply from a spawn handler.
    * Only usable when the transition handler returned `Machine.deferReply(state)`.
@@ -34,21 +34,20 @@ interface MachineRef<Event> {
 /**
  * Handler context passed to transition handlers
  */
-interface HandlerContext<State, Event, GD extends GuardsDef, ED extends EffectsDef> {
+interface HandlerContext<State, Event, SD extends SlotsDef = Record<string, never>> {
   readonly state: State;
   readonly event: Event;
-  readonly guards: GuardSlots<GD>;
-  readonly effects: EffectSlots<ED>;
+  readonly slots: SlotCalls<SD>;
 }
 /**
  * Handler context passed to state effect handlers (onEnter, spawn, background)
  */
-interface StateHandlerContext<State, Event, ED extends EffectsDef> {
+interface StateHandlerContext<State, Event, SD extends SlotsDef = Record<string, never>> {
   readonly actorId: string;
   readonly state: State;
   readonly event: Event;
   readonly self: MachineRef<Event>;
-  readonly effects: EffectSlots<ED>;
+  readonly slots: SlotCalls<SD>;
   readonly system: ActorSystem;
 }
 /**
@@ -56,38 +55,73 @@ interface StateHandlerContext<State, Event, ED extends EffectsDef> {
  * When Reply is concrete (event has a reply schema), handler must return Machine.reply().
  * When Reply is never, handler returns plain state.
  */
-type TransitionHandler<S, E, NewState, GD extends GuardsDef, ED extends EffectsDef, R, Reply = never> = (ctx: HandlerContext<S, E, GD, ED>) => TransitionResult<NewState, R, Reply>;
+type TransitionHandler<S, E, NewState, SD extends SlotsDef, R, Reply = never> = (ctx: HandlerContext<S, E, SD>) => TransitionResult<NewState, R, Reply>;
 /**
  * State effect handler function
  */
-type StateEffectHandler<S, E, ED extends EffectsDef, R> = (ctx: StateHandlerContext<S, E, ED>) => Effect.Effect<void, never, R>;
+type StateEffectHandler<S, E, SD extends SlotsDef, R> = (ctx: StateHandlerContext<S, E, SD>) => Effect.Effect<void, never, R>;
 /**
  * Transition definition
  */
-interface Transition<State, Event, GD extends GuardsDef, ED extends EffectsDef, R> {
+interface Transition<State, Event, SD extends SlotsDef, R> {
   readonly stateTag: string;
   readonly eventTag: string;
-  readonly handler: TransitionHandler<State, Event, State, GD, ED, R>;
+  readonly handler: TransitionHandler<State, Event, State, SD, R>;
   readonly reenter?: boolean;
 }
 /**
  * Spawn effect - state-scoped forked effect
  */
-interface SpawnEffect<State, Event, ED extends EffectsDef, R> {
+interface SpawnEffect<State, Event, SD extends SlotsDef, R> {
   readonly stateTag: string;
-  readonly handler: StateEffectHandler<State, Event, ED, R>;
+  readonly handler: StateEffectHandler<State, Event, SD, R>;
 }
 /**
  * Background effect - runs for entire machine lifetime
  */
-interface BackgroundEffect<State, Event, ED extends EffectsDef, R> {
-  readonly handler: StateEffectHandler<State, Event, ED, R>;
+interface BackgroundEffect<State, Event, SD extends SlotsDef, R> {
+  readonly handler: StateEffectHandler<State, Event, SD, R>;
 }
-interface TaskOptions<State, Event, ED extends EffectsDef, A, E1, ES, EF> {
-  readonly onSuccess: (value: A, ctx: StateHandlerContext<State, Event, ED>) => ES;
-  readonly onFailure?: (cause: Cause.Cause<E1>, ctx: StateHandlerContext<State, Event, ED>) => EF;
+interface TaskOptions<State, Event, SD extends SlotsDef, A, E1, ES, EF> {
+  readonly onSuccess?: (value: A, ctx: StateHandlerContext<State, Event, SD>) => ES;
+  readonly onFailure?: (cause: Cause.Cause<E1>, ctx: StateHandlerContext<State, Event, SD>) => EF;
   readonly name?: string;
 }
+/**
+ * Recovery resolves the initial state for a generation. Runs during actor.start.
+ *
+ * For initial start (generation 0): loads persisted state.
+ * For supervision restart (generation 1+): reloads state after crash.
+ */
+interface Recovery<S> {
+  readonly resolve: (ctx: RecoveryContext<S>) => Effect.Effect<Option.Option<S>>;
+}
+interface RecoveryContext<S> {
+  readonly actorId: string;
+  readonly generation: number;
+  readonly machineInitial: S;
+}
+/**
+ * Durability saves state after committed transitions. Runs during runtime.
+ */
+interface Durability<S, E> {
+  readonly save: (commit: DurabilityCommit<S, E>) => Effect.Effect<void>;
+  readonly shouldSave?: (state: S, previousState: S) => boolean;
+}
+interface DurabilityCommit<S, E> {
+  readonly actorId: string;
+  readonly generation: number;
+  readonly previousState: S;
+  readonly nextState: S;
+  readonly event: E;
+}
+/**
+ * Actor lifecycle configuration.
+ */
+interface Lifecycle<S, E> {
+  readonly recovery?: Recovery<S>;
+  readonly durability?: Durability<S, E>;
+}
 /**
  * Configuration for `.timeout()` — gen_statem-style state timeouts.
  *
@@ -100,25 +134,18 @@ interface TimeoutConfig<State, Event> {
   /** Event to send when the timer fires. Static or derived from current state. */
   readonly event: Event | ((state: State) => Event);
 }
-interface MakeConfig<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent, GD extends GuardsDef, EFD extends EffectsDef> {
+interface MakeConfig<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent, SLD extends SlotsDef = Record<string, never>> {
   readonly state: MachineStateSchema<SD> & {
     Type: S;
   };
   readonly event: MachineEventSchema<ED> & {
     Type: E;
   };
-  readonly guards?: GuardsSchema<GD>;
-  readonly effects?: EffectsSchema<EFD>;
+  readonly slots?: SlotsSchema<SLD>;
   readonly initial: S;
+  /** Validate slot inputs/outputs at runtime. Default: true. Set to false for hot paths. */
+  readonly slotValidation?: boolean;
 }
-/** Check if a GuardsDef has any actual keys */
-type HasGuardKeys<GD extends GuardsDef> = [keyof GD] extends [never] ? false : GD extends Record<string, never> ? false : true;
-/** Check if an EffectsDef has any actual keys */
-type HasEffectKeys<EFD extends EffectsDef> = [keyof EFD] extends [never] ? false : EFD extends Record<string, never> ? false : true;
-/** Context type passed to guard/effect handlers */
-type SlotContext<State, Event> = MachineContext<State, Event, MachineRef<Event>>;
-/** Combined handlers for build() - guards and effects only */
-type ProvideHandlers<State, Event, GD extends GuardsDef, EFD extends EffectsDef, R> = (HasGuardKeys<GD> extends true ? GuardHandlers<GD, SlotContext<State, Event>, R> : object) & (HasEffectKeys<EFD> extends true ? EffectHandlers<EFD, SlotContext<State, Event>, R> : object);
 /**
  * Bind slot handlers to a machine, returning a fresh copy with handlers installed.
  * If no handlers provided and machine has no slots, returns the machine as-is.
@@ -126,7 +153,7 @@ type ProvideHandlers<State, Event, GD extends GuardsDef, EFD extends EffectsDef,
  *
  * @internal — used by spawn, replay, simulate, test harness, entity-machine
  */
-declare const materializeMachine: <S, E, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, any, any, GD, EFD>, handlers?: Record<string, any>) => Machine<S, E, never, any, any, GD, EFD>;
+declare const materializeMachine: <S, E, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, handlers?: Record<string, any>) => Machine<S, E, never, any, any, SD>;
 /**
  * Machine definition with fluent builder API.
  *
@@ -136,17 +163,16 @@ declare const materializeMachine: <S, E, R, GD extends GuardsDef, EFD extends Ef
  * - `R`: Effect requirements
  * - `_SD`: State schema definition (for compile-time validation)
  * - `_ED`: Event schema definition (for compile-time validation)
- * - `GD`: Guard definitions
- * - `EFD`: Effect definitions
+ * - `SD`: Slot definitions
  */
-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>, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>> {
+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>, SD extends SlotsDef = Record<string, never>> {
   readonly initial: State;
   /** @internal */
-  readonly _transitions: Array<Transition<State, Event, GD, EFD, R>>;
+  readonly _transitions: Array<Transition<State, Event, SD, R>>;
   /** @internal */
-  readonly _spawnEffects: Array<SpawnEffect<State, Event, EFD, R>>;
+  readonly _spawnEffects: Array<SpawnEffect<State, Event, SD, R>>;
   /** @internal */
-  readonly _backgroundEffects: Array<BackgroundEffect<State, Event, EFD, R>>;
+  readonly _backgroundEffects: Array<BackgroundEffect<State, Event, SD, R>>;
   /** @internal */
   readonly _finalStates: Set<string>;
   /** @internal */
@@ -155,18 +181,13 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
     readonly eventTag: string;
   }>;
   /** @internal */
-  readonly _guardsSchema?: GuardsSchema<GD>;
-  /** @internal */
-  readonly _effectsSchema?: EffectsSchema<EFD>;
+  readonly _slotsSchema?: SlotsSchema<SD>;
   /** @internal */
-  readonly _guardHandlers: Map<string, (params: unknown, ctx: SlotContext<State, Event>) => boolean | Effect.Effect<boolean, never, R>>;
+  readonly _slotHandlers: Map<string, (params: unknown) => unknown | Effect.Effect<unknown, never, R>>;
   /** @internal */
-  readonly _effectHandlers: Map<string, (params: unknown, ctx: SlotContext<State, Event>) => Effect.Effect<void, never, R>>;
+  readonly _slots: SlotCalls<SD>;
   /** @internal */
-  readonly _slots: {
-    guards: GuardSlots<GD>;
-    effects: EffectSlots<EFD>;
-  };
+  readonly _slotValidation: boolean;
   readonly stateSchema?: Schema.Schema<State>;
   readonly eventSchema?: Schema.Schema<Event>;
   /** @internal */
@@ -176,70 +197,72 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * Uses shared module-level tag for all machines.
    */
   readonly Context: ServiceMap.Service<MachineContext<State, Event, MachineRef<Event>>, MachineContext<State, Event, MachineRef<Event>>>;
-  get transitions(): ReadonlyArray<Transition<State, Event, GD, EFD, R>>;
-  get spawnEffects(): ReadonlyArray<SpawnEffect<State, Event, EFD, R>>;
-  get backgroundEffects(): ReadonlyArray<BackgroundEffect<State, Event, EFD, R>>;
+  get transitions(): ReadonlyArray<Transition<State, Event, SD, R>>;
+  get spawnEffects(): ReadonlyArray<SpawnEffect<State, Event, SD, R>>;
+  get backgroundEffects(): ReadonlyArray<BackgroundEffect<State, Event, SD, R>>;
   get finalStates(): ReadonlySet<string>;
   get postponeRules(): ReadonlyArray<{
     readonly stateTag: string;
     readonly eventTag: string;
   }>;
-  get guardsSchema(): GuardsSchema<GD> | undefined;
-  get effectsSchema(): EffectsSchema<EFD> | undefined;
+  get slotsSchema(): SlotsSchema<SD> | undefined;
   get replySchemas(): ReadonlyMap<string, Schema.Decoder<unknown>>;
   /** @internal */
-  constructor(initial: State, stateSchema?: Schema.Schema<State>, eventSchema?: Schema.Schema<Event>, guardsSchema?: GuardsSchema<GD>, effectsSchema?: EffectsSchema<EFD>);
-  from<NS extends VariantsUnion<_SD> & BrandedState, R1>(state: TaggedOrConstructor<NS>, build: (scope: TransitionScope<State, Event, R, _SD, _ED, GD, EFD, NS>) => R1): Machine<State, Event, R, _SD, _ED, GD, EFD>;
-  from<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, R1>(states: NS, build: (scope: TransitionScope<State, Event, R, _SD, _ED, GD, EFD, NS[number] extends TaggedOrConstructor<infer S extends VariantsUnion<_SD> & BrandedState> ? S : never>) => R1): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  constructor(initial: State, stateSchema?: Schema.Schema<State>, eventSchema?: Schema.Schema<Event>, slotsSchema?: SlotsSchema<SD>, slotValidation?: boolean);
+  from<NS extends VariantsUnion<_SD> & BrandedState, R1>(state: TaggedOrConstructor<NS>, build: (scope: TransitionScope<State, Event, R, _SD, _ED, SD, NS>) => R1): Machine<State, Event, R, _SD, _ED, SD>;
+  from<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, R1>(states: NS, build: (scope: TransitionScope<State, Event, R, _SD, _ED, SD, NS[number] extends TaggedOrConstructor<infer S extends VariantsUnion<_SD> & BrandedState> ? S : never>) => R1): Machine<State, Event, R, _SD, _ED, SD>;
   /** @internal */
-  scopeTransition<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(states: ReadonlyArray<TaggedOrConstructor<NS>>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, GD, EFD, never, ExtractReply<NE>>, reenter: boolean): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  scopeTransition<NS extends VariantsUnion<_SD> & BrandedState, NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(states: ReadonlyArray<TaggedOrConstructor<NS>>, event: TaggedOrConstructor<NE>, handler: TransitionHandler<NS, NE, RS, SD, never, ExtractReply<NE>>, reenter: boolean): Machine<State, Event, R, _SD, _ED, SD>;
   /** 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, GD, EFD, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  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, SD, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED, SD>;
   /** 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, GD, EFD, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  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, SD, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED, SD>;
   /**
    * 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, GD, EFD, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  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, SD, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED, SD>;
   /** 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, GD, EFD, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  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, SD, never, ExtractReply<NE>>): Machine<State, Event, R, _SD, _ED, SD>;
   /**
    * 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, GD, EFD, never>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  onAny<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<VariantsUnion<_SD> & BrandedState, NE, RS, SD, never>): Machine<State, Event, R, _SD, _ED, SD>;
   /** @internal */
   private addTransition;
   /**
    * State-scoped effect that is forked on state entry and automatically cancelled on state exit.
-   * Use effect slots defined via `Slot.Effects` for the actual work.
    *
    * @example
    * ```ts
-   * const MyEffects = Slot.Effects({
-   *   fetchData: { url: Schema.String },
-   * });
-   *
-   * machine
-   *   .spawn(State.Loading, ({ effects, state }) => effects.fetchData({ url: state.url }))
-   *   .build({
-   *     fetchData: ({ url }, { self }) =>
-   *       Effect.gen(function* () {
-   *         yield* Effect.addFinalizer(() => Effect.log("Leaving Loading"));
-   *         const data = yield* Http.get(url);
-   *         yield* self.send(Event.Loaded({ data }));
-   *       }),
-   *   });
+   * machine.spawn(State.Loading, ({ self, state }) =>
+   *   Effect.gen(function* () {
+   *     yield* Effect.addFinalizer(() => Effect.log("Leaving Loading"));
+   *     const data = yield* Http.get(state.url);
+   *     yield* self.send(Event.Loaded({ data }));
+   *   }),
+   * );
    * ```
    */
-  spawn<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, handler: StateEffectHandler<NS, VariantsUnion<_ED> & BrandedEvent, EFD, Scope.Scope>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  /** Single state */
+  spawn<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, handler: StateEffectHandler<NS, VariantsUnion<_ED> & BrandedEvent, SD, Scope.Scope>): Machine<State, Event, R, _SD, _ED, SD>;
+  /** Multiple states */
+  spawn<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>>(states: NS, handler: StateEffectHandler<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, SD, Scope.Scope>): Machine<State, Event, R, _SD, _ED, SD>;
   /**
    * State-scoped task that runs on entry and sends success/failure events.
    * Interrupts do not emit failure events.
+   *
+   * Supports multi-state and shorthand overloads:
+   * - `.task(State.X, run, { onSuccess, onFailure })` — explicit mapping
+   * - `.task(State.X, run, { onFailure })` — shorthand when run returns Event directly
+   * - `.task([State.X, State.Y], run, opts)` — multi-state
    */
-  task<NS extends VariantsUnion<_SD> & BrandedState, A, E1, ES extends VariantsUnion<_ED> & BrandedEvent, EF extends VariantsUnion<_ED> & BrandedEvent>(state: TaggedOrConstructor<NS>, run: (ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent, EFD>) => Effect.Effect<A, E1, Scope.Scope>, options: TaskOptions<NS, VariantsUnion<_ED> & BrandedEvent, EFD, A, E1, ES, EF>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  /** Single state — onSuccess optional (defaults to identity when task returns Event) */
+  task<NS extends VariantsUnion<_SD> & BrandedState, A, E1, ES extends VariantsUnion<_ED> & BrandedEvent, EF extends VariantsUnion<_ED> & BrandedEvent>(state: TaggedOrConstructor<NS>, run: (ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent, SD>) => Effect.Effect<A, E1, Scope.Scope>, options: TaskOptions<NS, VariantsUnion<_ED> & BrandedEvent, SD, A, E1, ES, EF>): Machine<State, Event, R, _SD, _ED, SD>;
+  /** Multiple states, explicit onSuccess */
+  task<NS extends ReadonlyArray<TaggedOrConstructor<VariantsUnion<_SD> & BrandedState>>, A, E1, 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, SD>) => Effect.Effect<A, E1, Scope.Scope>, options: TaskOptions<NS[number] extends TaggedOrConstructor<infer S> ? S : never, VariantsUnion<_ED> & BrandedEvent, SD, A, E1, ES, EF>): Machine<State, Event, R, _SD, _ED, SD>;
   /**
    * State timeout — gen_statem's `state_timeout`.
    *
@@ -261,28 +284,20 @@ 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, GD, EFD>;
+  timeout<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, config: TimeoutConfig<NS, VariantsUnion<_ED> & BrandedEvent>): Machine<State, Event, R, _SD, _ED, SD>;
   /**
    * Machine-lifetime effect that is forked on actor spawn and runs until the actor stops.
-   * Use effect slots defined via `Slot.Effects` for the actual work.
    *
    * @example
    * ```ts
-   * const MyEffects = Slot.Effects({
-   *   heartbeat: {},
-   * });
-   *
-   * machine
-   *   .background(({ effects }) => effects.heartbeat())
-   *   .build({
-   *     heartbeat: (_, { self }) =>
-   *       Effect.forever(
-   *         Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(Event.Ping)))
-   *       ),
-   *   });
+   * machine.background(({ self }) =>
+   *   Effect.forever(
+   *     Effect.sleep("30 seconds").pipe(Effect.andThen(self.send(Event.Ping))),
+   *   ),
+   * );
    * ```
    */
-  background(handler: StateEffectHandler<State, Event, EFD, Scope.Scope>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  background(handler: StateEffectHandler<State, Event, SD, Scope.Scope>): Machine<State, Event, R, _SD, _ED, SD>;
   /**
    * Postpone events — gen_statem's event postpone.
    *
@@ -300,45 +315,18 @@ 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, GD, EFD>;
-  final<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
-  static make<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(config: MakeConfig<SD, ED, S, E, GD, EFD>): Machine<S, E, never, SD, ED, GD, EFD>;
+  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, SD>;
+  final<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>): Machine<State, Event, R, _SD, _ED, SD>;
+  static make<SD extends Record<string, Schema.Struct.Fields>, ED extends Record<string, Schema.Struct.Fields>, S extends BrandedState, E extends BrandedEvent, SLD extends SlotsDef = Record<string, never>>(config: MakeConfig<SD, ED, S, E, SLD>): Machine<S, E, never, SD, ED, SLD>;
 }
-declare class TransitionScope<State, Event, R, _SD extends Record<string, Schema.Struct.Fields>, _ED extends Record<string, Schema.Struct.Fields>, GD extends GuardsDef, EFD extends EffectsDef, 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>, SD extends SlotsDef, SelectedState extends VariantsUnion<_SD> & BrandedState> {
   private readonly machine;
   private readonly states;
-  constructor(machine: Machine<State, Event, R, _SD, _ED, GD, EFD>, states: ReadonlyArray<TaggedOrConstructor<SelectedState>>);
-  on<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, GD, EFD, never, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, GD, EFD, SelectedState>;
-  reenter<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, GD, EFD, never, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, GD, EFD, SelectedState>;
+  constructor(machine: Machine<State, Event, R, _SD, _ED, SD>, states: ReadonlyArray<TaggedOrConstructor<SelectedState>>);
+  on<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, SD, never, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, SD, SelectedState>;
+  reenter<NE extends VariantsUnion<_ED> & BrandedEvent, RS extends VariantsUnion<_SD> & BrandedState>(event: TaggedOrConstructor<NE>, handler: TransitionHandler<SelectedState, NE, RS, SD, never, ExtractReply<NE>>): TransitionScope<State, Event, R, _SD, _ED, SD, SelectedState>;
 }
 declare const make: typeof Machine.make;
-/**
- * Spawn an actor directly without ActorSystem ceremony.
- * Accepts a `Machine` directly. For slotful machines, pass `{ slots }` in options.
- *
- * **Single actor, no registry.** Caller manages lifetime via `actor.stop`.
- * If a `Scope` exists in context, cleanup attaches automatically on scope close.
- *
- * For registry, lookup by ID, persistence, or multi-actor coordination,
- * use `ActorSystemService` / `system.spawn` instead.
- *
- * @example
- * ```ts
- * // Fire-and-forget — caller manages lifetime
- * const actor = yield* Machine.spawn(machine.build());
- * yield* actor.send(Event.Start);
- * yield* actor.awaitFinal;
- * yield* actor.stop;
- *
- * // Scope-aware — auto-cleans up on scope close
- * yield* Effect.scoped(Effect.gen(function* () {
- *   const actor = yield* Machine.spawn(machine.build());
- *   yield* actor.send(Event.Start);
- *   // actor.stop called automatically when scope closes
- * }));
- * ```
- */
-type AnyMachine<S, E, R> = Machine<S, E, R, any, any, any, any>;
 /**
  * Spawn an actor from a machine.
  *
@@ -351,34 +339,40 @@ type AnyMachine<S, E, R> = Machine<S, E, R, any, any, any, any>;
  *
  * // With slots
  * const actor = yield* Machine.spawn(machine, {
- *   slots: { canRetry: ({ max }, { state }) => state.attempts < max },
+ *   slots: { canRetry: ({ max }) => attempts < max },
  * });
  *
- * // With hydration
- * const actor = yield* Machine.spawn(machine, { hydrate: savedState });
+ * // With lifecycle (recovery + durability)
+ * const actor = yield* Machine.spawn(machine, {
+ *   lifecycle: {
+ *     recovery: { resolve: (ctx) => storage.get("actor-state") },
+ *     durability: { save: (commit) => storage.set("actor-state", commit.nextState) },
+ *   },
+ * });
  * ```
  */
 declare const spawn: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R>(machine: AnyMachine<S, E, R>, options?: string | {
+}, R, SD extends SlotsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, SD>, options?: string | {
   id?: string;
   hydrate?: S;
-  slots?: Record<string, any>;
+  slots?: ProvideSlots<SD, any>;
   supervision?: Supervision.Policy;
+  lifecycle?: Lifecycle<S, E>;
 }) => Effect.Effect<ActorRef<S, E>, never, R>;
 declare const replay: {
   <S extends {
     readonly _tag: string;
   }, E extends {
     readonly _tag: string;
-  }, R>(machine: AnyMachine<S, E, R>, events: ReadonlyArray<E>, options?: {
+  }, R, SD extends SlotsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, SD>, events: ReadonlyArray<E>, options?: {
     from?: S;
-    slots?: Record<string, any>;
+    slots?: ProvideSlots<SD, any>;
   }): Effect.Effect<S, never, R>;
 };
 declare const reply: <State, Reply>(state: State, reply: Reply) => ReplyResult<State, Reply>;
 declare const deferReply: <State>(state: State) => DeferReplyResult<State>;
 //#endregion
-export { BackgroundEffect, type DeferReplyResult, HandlerContext, Machine, MachineRef, MakeConfig, ProvideHandlers, type ReplyResult, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, machine_d_exports, make, materializeMachine, replay, reply, spawn };
+export { BackgroundEffect, type DeferReplyResult, Durability, DurabilityCommit, HandlerContext, Lifecycle, Machine, MachineRef, MakeConfig, Recovery, RecoveryContext, type ReplyResult, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, deferReply, findTransitions, machine_d_exports, make, materializeMachine, replay, reply, spawn };