effect-machine 0.9.0 → 0.11.0

package/{dist-v3 → v3/dist}/machine.d.ts

@@ -1,22 +1,23 @@
+import { EffectHandlers, EffectSlots, EffectsDef, EffectsSchema, GuardHandlers, GuardSlots, GuardsDef, GuardsSchema, MachineContext } from "./slot.js";
 import { TransitionResult } from "./internal/utils.js";
 import { BrandedEvent, BrandedState, TaggedOrConstructor } from "./internal/brands.js";
 import { MachineEventSchema, MachineStateSchema, VariantsUnion } from "./schema.js";
-import { PersistenceConfig, PersistentMachine } from "./persistence/persistent-machine.js";
 import { DuplicateActorError } from "./errors.js";
-import { EffectHandlers, EffectSlots, EffectsDef, EffectsSchema, GuardHandlers, GuardSlots, GuardsDef, GuardsSchema, MachineContext } from "./slot.js";
 import { findTransitions } from "./internal/transition.js";
 import { ActorRef, ActorSystem } from "./actor.js";
-import { Cause, Context, Effect, Schedule, Schema, Scope } from "effect";
+import { Cause, Context, Duration, Effect, Schema, Scope } from "effect";
 
-//#region src-v3/machine.d.ts
+//#region src/machine.d.ts
 declare namespace machine_d_exports {
-  export { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, PersistenceConfig, PersistentMachine, ProvideHandlers, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, Transition, TransitionHandler, findTransitions, make, spawn };
+  export { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, ProvideHandlers, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, findTransitions, make, replay, spawn };
 }
 /**
  * Self reference for sending events back to the machine
  */
 interface MachineRef<Event> {
   readonly send: (event: Event) => Effect.Effect<void>;
+  /** Fire-and-forget alias for send (OTP gen_server:cast). */
+  readonly cast: (event: Event) => Effect.Effect<void>;
   readonly spawn: <S2 extends {
     readonly _tag: string;
   }, E2 extends {
@@ -36,6 +37,7 @@ interface HandlerContext<State, Event, GD extends GuardsDef, ED extends EffectsD
  * Handler context passed to state effect handlers (onEnter, spawn, background)
  */
 interface StateHandlerContext<State, Event, ED extends EffectsDef> {
+  readonly actorId: string;
   readonly state: State;
   readonly event: Event;
   readonly self: MachineRef<Event>;
@@ -72,13 +74,22 @@ interface SpawnEffect<State, Event, ED extends EffectsDef, R> {
 interface BackgroundEffect<State, Event, ED extends EffectsDef, R> {
   readonly handler: StateEffectHandler<State, Event, ED, R>;
 }
-/** Options for `persist` */
-interface PersistOptions {
-  readonly snapshotSchedule: Schedule.Schedule<unknown, {
-    readonly _tag: string;
-  }>;
-  readonly journalEvents: boolean;
-  readonly machineType?: string;
+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;
+  readonly name?: string;
+}
+/**
+ * Configuration for `.timeout()` — gen_statem-style state timeouts.
+ *
+ * Entering the state starts a timer. Leaving cancels it.
+ * `.reenter()` restarts the timer with fresh state values.
+ */
+interface TimeoutConfig<State, Event> {
+  /** Duration before firing. Static or derived from current state. */
+  readonly duration: Duration.DurationInput | ((state: State) => Duration.DurationInput);
+  /** Event to send when the timer fires. Static or derived from current state. */
+  readonly event: Event | ((state: State) => Event);
 }
 type IsAny<T> = 0 extends 1 & T ? true : false;
 type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) : false;
@@ -117,11 +128,6 @@ declare class BuiltMachine<State, Event, R = never> {
   /** @internal */
   constructor(machine: Machine<State, Event, R, any, any, any, any>);
   get initial(): State;
-  persist(config: PersistOptions): PersistentMachine<State & {
-    readonly _tag: string;
-  }, Event & {
-    readonly _tag: string;
-  }, R>;
 }
 /**
  * Machine definition with fluent builder API.
@@ -146,6 +152,11 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
   /** @internal */
   readonly _finalStates: Set<string>;
   /** @internal */
+  readonly _postponeRules: Array<{
+    readonly stateTag: string;
+    readonly eventTag: string;
+  }>;
+  /** @internal */
   readonly _guardsSchema?: GuardsSchema<GD>;
   /** @internal */
   readonly _effectsSchema?: EffectsSchema<EFD>;
@@ -169,10 +180,18 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
   get spawnEffects(): ReadonlyArray<SpawnEffect<State, Event, EFD, R>>;
   get backgroundEffects(): ReadonlyArray<BackgroundEffect<State, Event, EFD, R>>;
   get finalStates(): ReadonlySet<string>;
+  get postponeRules(): ReadonlyArray<{
+    readonly stateTag: string;
+    readonly eventTag: string;
+  }>;
   get guardsSchema(): GuardsSchema<GD> | undefined;
   get effectsSchema(): EffectsSchema<EFD> | undefined;
   /** @internal */
   constructor(initial: State, stateSchema?: Schema.Schema<State, unknown, never>, eventSchema?: Schema.Schema<Event, unknown, never>, 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>;
+  /** @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>, reenter: boolean): Machine<State, Event, R, _SD, _ED, GD, EFD>;
   /** 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>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
   /** Register transition for multiple states (handler receives union of state types) */
@@ -219,10 +238,29 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * State-scoped task that runs on entry and sends success/failure events.
    * Interrupts do not emit failure events.
    */
-  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: {
-    readonly onSuccess: (value: A, ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent, EFD>) => ES;
-    readonly onFailure?: (cause: Cause.Cause<E1>, ctx: StateHandlerContext<NS, VariantsUnion<_ED> & BrandedEvent, EFD>) => EF;
-  }): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  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>;
+  /**
+   * State timeout — gen_statem's `state_timeout`.
+   *
+   * Entering the state starts a timer. Leaving cancels it (via state scope).
+   * `.reenter()` restarts the timer with fresh state values.
+   * Compiles to `.task()` internally — preserves `@machine.task` inspection events.
+   *
+   * @example
+   * ```ts
+   * machine
+   *   .timeout(State.Loading, {
+   *     duration: Duration.seconds(30),
+   *     event: Event.Timeout,
+   *   })
+   *   // Dynamic duration from state
+   *   .timeout(State.Retrying, {
+   *     duration: (state) => Duration.seconds(state.backoff),
+   *     event: Event.GiveUp,
+   *   })
+   * ```
+   */
+  timeout<NS extends VariantsUnion<_SD> & BrandedState>(state: TaggedOrConstructor<NS>, config: TimeoutConfig<NS, VariantsUnion<_ED> & BrandedEvent>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
   /**
    * 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.
@@ -244,6 +282,24 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * ```
    */
   background(handler: StateEffectHandler<State, Event, EFD, Scope.Scope>): Machine<State, Event, R, _SD, _ED, GD, EFD>;
+  /**
+   * Postpone events — gen_statem's event postpone.
+   *
+   * When a matching event arrives in the given state, it is buffered instead of
+   * processed. After the next state transition (tag change), all buffered events
+   * are drained through the loop in FIFO order.
+   *
+   * Reply-bearing events (from `call`/`ask`) in the postpone buffer are settled
+   * with `ActorStoppedError` on stop/interrupt/final-state.
+   *
+   * @example
+   * ```ts
+   * machine
+   *   .postpone(State.Connecting, Event.Data)           // single event
+   *   .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>;
   /**
    * Finalize the machine. Returns a `BuiltMachine` — the only type accepted by `Machine.spawn`.
@@ -252,26 +308,43 @@ declare class Machine<State, Event, R = never, _SD extends Record<string, Schema
    * - Machines without slots: call with no arguments.
    */
   build<R2 = never>(...args: HasSlots<GD, EFD> extends true ? [handlers: ProvideHandlers<State, Event, GD, EFD, R2>] : [handlers?: ProvideHandlers<State, Event, GD, EFD, R2>]): BuiltMachine<State, Event, R | NormalizeR<R2>>;
-  /** @internal Persist from raw Machine — prefer BuiltMachine.persist() */
-  persist(config: PersistOptions): PersistentMachine<State & {
-    readonly _tag: string;
-  }, Event & {
-    readonly _tag: string;
-  }, R>;
   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>;
 }
+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> {
+  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>): 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>): TransitionScope<State, Event, R, _SD, _ED, GD, EFD, SelectedState>;
+}
 declare const make: typeof Machine.make;
-declare const spawn: {
-  <S extends {
-    readonly _tag: string;
-  }, E extends {
-    readonly _tag: string;
-  }, R>(machine: BuiltMachine<S, E, R>): Effect.Effect<ActorRef<S, E>, never, R>;
-  <S extends {
-    readonly _tag: string;
-  }, E extends {
-    readonly _tag: string;
-  }, R>(machine: BuiltMachine<S, E, R>, id: string): Effect.Effect<ActorRef<S, E>, never, R>;
-};
+/**
+ * Spawn an actor from a built machine.
+ *
+ * Options:
+ * - `id` — custom actor ID (default: random)
+ * - `hydrate` — restore from a previously-saved state snapshot.
+ *   The actor starts in the hydrated state and re-runs spawn effects
+ *   for that state (timers, scoped resources, etc.). Transition history
+ *   is not replayed — only the current state's entry effects run.
+ *
+ * Persistence is composed in userland by observing `actor.changes`
+ * and saving snapshots to your own storage.
+ */
+declare const spawn: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R>(machine: BuiltMachine<S, E, R>, idOrOptions?: string | {
+  id?: string;
+  hydrate?: S;
+}) => Effect.Effect<ActorRef<S, E>, never, R>;
+declare const replay: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R>(machine: BuiltMachine<S, E, R>, events: ReadonlyArray<E>, options?: {
+  from?: S;
+}) => Effect.Effect<S, never, R>;
 //#endregion
-export { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, PersistOptions, type PersistenceConfig, type PersistentMachine, ProvideHandlers, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, Transition, TransitionHandler, findTransitions, machine_d_exports, make, spawn };
+export { BackgroundEffect, BuiltMachine, HandlerContext, Machine, MachineRef, MakeConfig, ProvideHandlers, SlotContext, SpawnEffect, StateEffectHandler, StateHandlerContext, TaskOptions, TimeoutConfig, Transition, TransitionHandler, findTransitions, machine_d_exports, make, replay, spawn };

package/{dist-v3 → v3/dist}/machine.js

@@ -1,19 +1,30 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { getTag } from "./internal/utils.js";
+import { Inspector } from "./inspection.js";
+import { getTag, stubSystem } from "./internal/utils.js";
 import { ProvisionValidationError, SlotProvisionError } from "./errors.js";
-import { persist } from "./persistence/persistent-machine.js";
+import { emitWithTimestamp } from "./internal/inspection.js";
 import { MachineContextTag } from "./slot.js";
-import { findTransitions, invalidateIndex } from "./internal/transition.js";
+import { findTransitions, invalidateIndex, resolveTransition, runTransitionHandler, shouldPostpone } from "./internal/transition.js";
 import { createActor } from "./actor.js";
 import { Cause, Effect, Exit, Option, Scope } from "effect";
-//#region src-v3/machine.ts
+//#region src/machine.ts
 var machine_exports = /* @__PURE__ */ __exportAll({
 	BuiltMachine: () => BuiltMachine,
 	Machine: () => Machine,
 	findTransitions: () => findTransitions,
 	make: () => make,
+	replay: () => replay,
 	spawn: () => spawn
 });
+const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOptional(Inspector).pipe(Effect.option), (inspector) => Option.isNone(inspector) ? Effect.void : emitWithTimestamp(inspector.value, (timestamp) => ({
+	type: "@machine.task",
+	actorId: input.actorId,
+	state: input.state,
+	taskName: input.taskName,
+	phase: input.phase,
+	error: input.error,
+	timestamp
+})));
 /**
 * A finalized machine ready for spawning.
 *
@@ -31,9 +42,6 @@ var BuiltMachine = class {
 	get initial() {
 		return this._inner.initial;
 	}
-	persist(config) {
-		return this._inner.persist(config);
-	}
 };
 /**
 * Machine definition with fluent builder API.
@@ -53,6 +61,7 @@ var Machine = class Machine {
 	/** @internal */ _spawnEffects;
 	/** @internal */ _backgroundEffects;
 	/** @internal */ _finalStates;
+	/** @internal */ _postponeRules;
 	/** @internal */ _guardsSchema;
 	/** @internal */ _effectsSchema;
 	/** @internal */ _guardHandlers;
@@ -77,6 +86,9 @@ var Machine = class Machine {
 	get finalStates() {
 		return this._finalStates;
 	}
+	get postponeRules() {
+		return this._postponeRules;
+	}
 	get guardsSchema() {
 		return this._guardsSchema;
 	}
@@ -90,6 +102,7 @@ var Machine = class Machine {
 		this._spawnEffects = [];
 		this._backgroundEffects = [];
 		this._finalStates = /* @__PURE__ */ new Set();
+		this._postponeRules = [];
 		this._guardsSchema = guardsSchema;
 		this._effectsSchema = effectsSchema;
 		this._guardHandlers = /* @__PURE__ */ new Map();
@@ -116,6 +129,15 @@ var Machine = class Machine {
 			})) : {}
 		};
 	}
+	from(stateOrStates, build) {
+		build(new TransitionScope(this, Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates]));
+		return this;
+	}
+	/** @internal */
+	scopeTransition(states, event, handler, reenter) {
+		for (const state of states) this.addTransition(state, event, handler, reenter);
+		return this;
+	}
 	on(stateOrStates, event, handler) {
 		const states = Array.isArray(stateOrStates) ? stateOrStates : [stateOrStates];
 		for (const s of states) this.addTransition(s, event, handler, false);
@@ -190,14 +212,41 @@ var Machine = class Machine {
 	*/
 	task(state, run, options) {
 		const handler = Effect.fn("effect-machine.task")(function* (ctx) {
+			yield* emitTaskInspection({
+				actorId: ctx.actorId,
+				state: ctx.state,
+				taskName: options.name,
+				phase: "start"
+			});
 			const exit = yield* Effect.exit(run(ctx));
 			if (Exit.isSuccess(exit)) {
+				yield* emitTaskInspection({
+					actorId: ctx.actorId,
+					state: ctx.state,
+					taskName: options.name,
+					phase: "success"
+				});
 				yield* ctx.self.send(options.onSuccess(exit.value, ctx));
 				yield* Effect.yieldNow();
 				return;
 			}
 			const cause = exit.cause;
-			if (Cause.isInterruptedOnly(cause)) return;
+			if (Cause.isInterruptedOnly(cause)) {
+				yield* emitTaskInspection({
+					actorId: ctx.actorId,
+					state: ctx.state,
+					taskName: options.name,
+					phase: "interrupt"
+				});
+				return;
+			}
+			yield* emitTaskInspection({
+				actorId: ctx.actorId,
+				state: ctx.state,
+				taskName: options.name,
+				phase: "failure",
+				error: Cause.pretty(cause)
+			});
 			if (options.onFailure !== void 0) {
 				yield* ctx.self.send(options.onFailure(cause, ctx));
 				yield* Effect.yieldNow();
@@ -208,6 +257,36 @@ var Machine = class Machine {
 		return this.spawn(state, handler);
 	}
 	/**
+	* State timeout — gen_statem's `state_timeout`.
+	*
+	* Entering the state starts a timer. Leaving cancels it (via state scope).
+	* `.reenter()` restarts the timer with fresh state values.
+	* Compiles to `.task()` internally — preserves `@machine.task` inspection events.
+	*
+	* @example
+	* ```ts
+	* machine
+	*   .timeout(State.Loading, {
+	*     duration: Duration.seconds(30),
+	*     event: Event.Timeout,
+	*   })
+	*   // Dynamic duration from state
+	*   .timeout(State.Retrying, {
+	*     duration: (state) => Duration.seconds(state.backoff),
+	*     event: Event.GiveUp,
+	*   })
+	* ```
+	*/
+	timeout(state, config) {
+		const stateTag = getTag(state);
+		const resolveDuration = typeof config.duration === "function" ? config.duration : () => config.duration;
+		const resolveEvent = typeof config.event === "function" ? config.event : () => config.event;
+		return this.task(state, (ctx) => Effect.sleep(resolveDuration(ctx.state)), {
+			onSuccess: (_, ctx) => resolveEvent(ctx.state),
+			name: `$timeout:${stateTag}`
+		});
+	}
+	/**
 	* 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.
 	*
@@ -231,6 +310,35 @@ var Machine = class Machine {
 		this._backgroundEffects.push({ handler });
 		return this;
 	}
+	/**
+	* Postpone events — gen_statem's event postpone.
+	*
+	* When a matching event arrives in the given state, it is buffered instead of
+	* processed. After the next state transition (tag change), all buffered events
+	* are drained through the loop in FIFO order.
+	*
+	* Reply-bearing events (from `call`/`ask`) in the postpone buffer are settled
+	* with `ActorStoppedError` on stop/interrupt/final-state.
+	*
+	* @example
+	* ```ts
+	* machine
+	*   .postpone(State.Connecting, Event.Data)           // single event
+	*   .postpone(State.Connecting, [Event.Data, Event.Cmd]) // multiple events
+	* ```
+	*/
+	postpone(state, events) {
+		const stateTag = getTag(state);
+		const eventList = Array.isArray(events) ? events : [events];
+		for (const ev of eventList) {
+			const eventTag = getTag(ev);
+			this._postponeRules.push({
+				stateTag,
+				eventTag
+			});
+		}
+		return this;
+	}
 	final(state) {
 		const stateTag = getTag(state);
 		this._finalStates.add(stateTag);
@@ -262,6 +370,7 @@ var Machine = class Machine {
 			result._finalStates = new Set(this._finalStates);
 			result._spawnEffects = [...this._spawnEffects];
 			result._backgroundEffects = [...this._backgroundEffects];
+			result._postponeRules = [...this._postponeRules];
 			const anyHandlers = handlers;
 			if (this._guardsSchema !== void 0) for (const name of Object.keys(this._guardsSchema.definitions)) result._guardHandlers.set(name, anyHandlers[name]);
 			if (this._effectsSchema !== void 0) for (const name of Object.keys(this._effectsSchema.definitions)) result._effectHandlers.set(name, anyHandlers[name]);
@@ -269,20 +378,87 @@ var Machine = class Machine {
 		}
 		return new BuiltMachine(this);
 	}
-	/** @internal Persist from raw Machine — prefer BuiltMachine.persist() */
-	persist(config) {
-		return persist(config)(this);
-	}
 	static make(config) {
 		return new Machine(config.initial, config.state, config.event, config.guards, config.effects);
 	}
 };
+var TransitionScope = class {
+	constructor(machine, states) {
+		this.machine = machine;
+		this.states = states;
+	}
+	on(event, handler) {
+		this.machine.scopeTransition(this.states, event, handler, false);
+		return this;
+	}
+	reenter(event, handler) {
+		this.machine.scopeTransition(this.states, event, handler, true);
+		return this;
+	}
+};
 const make = Machine.make;
-const spawn = Effect.fn("effect-machine.spawn")(function* (built, id) {
-	const actor = yield* createActor(id ?? `actor-${Math.random().toString(36).slice(2)}`, built._inner);
+/**
+* Spawn an actor from a built machine.
+*
+* Options:
+* - `id` — custom actor ID (default: random)
+* - `hydrate` — restore from a previously-saved state snapshot.
+*   The actor starts in the hydrated state and re-runs spawn effects
+*   for that state (timers, scoped resources, etc.). Transition history
+*   is not replayed — only the current state's entry effects run.
+*
+* Persistence is composed in userland by observing `actor.changes`
+* and saving snapshots to your own storage.
+*/
+const spawn = Effect.fn("effect-machine.spawn")(function* (built, idOrOptions) {
+	const opts = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+	const actor = yield* createActor(opts?.id ?? `actor-${Math.random().toString(36).slice(2)}`, built._inner, { initialState: opts?.hydrate });
 	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
 	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
 	return actor;
 });
+const replay = Effect.fn("effect-machine.replay")(function* (built, events, options) {
+	const machine = built._inner;
+	let state = options?.from ?? machine.initial;
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const postponed = [];
+	const dummySend = Effect.fn("effect-machine.replay.send")((_event) => Effect.void);
+	const self = {
+		send: dummySend,
+		cast: dummySend,
+		spawn: () => Effect.die("spawn not supported in replay")
+	};
+	for (const event of events) {
+		if (machine.finalStates.has(state._tag)) break;
+		if (hasPostponeRules && shouldPostpone(machine, state._tag, event._tag)) {
+			postponed.push(event);
+			continue;
+		}
+		const transition = resolveTransition(machine, state, event);
+		if (transition !== void 0) {
+			const result = yield* runTransitionHandler(machine, transition, state, event, self, stubSystem, "replay");
+			const previousTag = state._tag;
+			state = result.newState;
+			if ((state._tag !== previousTag || transition.reenter === true) && postponed.length > 0) {
+				let drainTag = previousTag;
+				while (state._tag !== drainTag && postponed.length > 0) {
+					if (machine.finalStates.has(state._tag)) break;
+					drainTag = state._tag;
+					const drained = postponed.splice(0);
+					for (const postponedEvent of drained) {
+						if (machine.finalStates.has(state._tag)) break;
+						if (shouldPostpone(machine, state._tag, postponedEvent._tag)) {
+							postponed.push(postponedEvent);
+							continue;
+						}
+						const pTransition = resolveTransition(machine, state, postponedEvent);
+						if (pTransition !== void 0) state = (yield* runTransitionHandler(machine, pTransition, state, postponedEvent, self, stubSystem, "replay")).newState;
+					}
+				}
+			}
+		}
+	}
+	return state;
+});
 //#endregion
-export { BuiltMachine, Machine, findTransitions, machine_exports, make, spawn };
+export { BuiltMachine, Machine, findTransitions, machine_exports, make, replay, spawn };

package/{dist-v3 → v3/dist}/schema.d.ts

@@ -1,7 +1,7 @@
 import { FullEventBrand, FullStateBrand } from "./internal/brands.js";
 import { Schema } from "effect";
 
-//#region src-v3/schema.d.ts
+//#region src/schema.d.ts
 /**
  * Extract the TypeScript type from a TaggedStruct schema
  */

package/{dist-v3 → v3/dist}/schema.js

@@ -1,6 +1,6 @@
 import { InvalidSchemaError, MissingMatchHandlerError } from "./errors.js";
 import { Schema } from "effect";
-//#region src-v3/schema.ts
+//#region src/schema.ts
 /**
 * Schema-first State/Event definitions for effect-machine.
 *
@@ -58,7 +58,10 @@ const buildMachineSchema = (definition) => {
 			constructor.derive = (source, partial) => {
 				const result = { _tag: tag };
 				for (const key of fieldNames) if (key in source) result[key] = source[key];
-				if (partial !== void 0) for (const [key, value] of Object.entries(partial)) result[key] = value;
+				if (partial !== void 0) for (const [key, value] of Object.entries(partial)) {
+					if (key === "_tag") continue;
+					result[key] = value;
+				}
 				return result;
 			};
 			constructors[tag] = constructor;

package/{dist-v3 → v3/dist}/slot.d.ts

@@ -1,7 +1,7 @@
 import { ActorSystem } from "./actor.js";
-import { Effect, Schema } from "effect";
+import { Context, Effect, Schema } from "effect";
 
-//#region src-v3/slot.d.ts
+//#region src/slot.d.ts
 /** Schema fields definition (like Schema.Struct.Fields) */
 type Fields = Record<string, Schema.Schema.All>;
 /** Extract the encoded type from schema fields (used for parameters) */
@@ -43,6 +43,7 @@ type EffectSlots<D extends EffectsDef> = { readonly [K in keyof D & string]: Eff
  * Shared across all machines via MachineContextTag.
  */
 interface MachineContext<State, Event, Self> {
+  readonly actorId: string;
   readonly state: State;
   readonly event: Event;
   readonly self: Self;
@@ -53,7 +54,7 @@ interface MachineContext<State, Event, Self> {
  * Single module-level tag instead of per-machine allocation.
  * @internal
  */
-declare const MachineContextTag: any;
+declare const MachineContextTag: Context.Tag<MachineContext<any, any, any>, MachineContext<any, any, any>>;
 /**
  * Guard handler implementation.
  * Receives params and context, returns Effect<boolean>.

package/{dist-v3 → v3/dist}/slot.js

@@ -1,5 +1,5 @@
 import { Context } from "effect";
-//#region src-v3/slot.ts
+//#region src/slot.ts
 /**
 * Slot module - schema-based, parameterized guards and effects.
 *

package/{dist-v3 → v3/dist}/testing.d.ts

@@ -1,9 +1,9 @@
+import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
 import { AssertionError } from "./errors.js";
-import { EffectsDef, GuardsDef } from "./slot.js";
-import { BuiltMachine, Machine } from "./machine.js";
+import { BuiltMachine, Machine, MachineRef } from "./machine.js";
 import { Effect, SubscriptionRef } from "effect";
 
-//#region src-v3/testing.d.ts
+//#region src/testing.d.ts
 /** Accept either Machine or BuiltMachine for testing utilities. */
 type MachineInput<S, E, R, GD extends GuardsDef, EFD extends EffectsDef> = Machine<S, E, R, any, any, GD, EFD> | BuiltMachine<S, E, R>;
 /**
@@ -40,7 +40,7 @@ declare const simulate: <S extends {
 }, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[]) => Effect.Effect<{
   states: S[];
   finalState: S;
-}, never, Exclude<R, unknown>>;
+}, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Assert that a machine can reach a specific state given a sequence of events
  */
@@ -48,7 +48,7 @@ declare const assertReaches: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedTag: string) => Effect.Effect<any, unknown, unknown>;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedTag: string) => Effect.Effect<S, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Assert that a machine follows a specific path of state tags
  *
@@ -65,7 +65,10 @@ declare const assertPath: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedPath: readonly string[]) => Effect.Effect<any, unknown, unknown>;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], expectedPath: readonly string[]) => Effect.Effect<{
+  states: S[];
+  finalState: S;
+}, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Assert that a machine never reaches a specific state given a sequence of events
  *
@@ -83,7 +86,10 @@ declare const assertNeverReaches: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], forbiddenTag: string) => Effect.Effect<any, unknown, unknown>;
+}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, events: readonly E[], forbiddenTag: string) => Effect.Effect<{
+  states: S[];
+  finalState: S;
+}, AssertionError, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
 /**
  * Create a controllable test harness for a machine
  */
@@ -129,7 +135,7 @@ declare const createTestHarness: <S extends {
   readonly _tag: string;
 }, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: MachineInput<S, E, R, GD, EFD>, options?: TestHarnessOptions<S, E> | undefined) => Effect.Effect<{
   state: SubscriptionRef.SubscriptionRef<S>;
-  send: (event: E) => Effect.Effect<S, never, never>;
+  send: (event: E) => Effect.Effect<S, never, Exclude<R, MachineContext<S, E, MachineRef<E>>>>;
   getState: Effect.Effect<S, never, never>;
 }, never, never>;
 //#endregion