effect-machine 0.13.0 → 0.15.0

package/v3/dist/internal/brands.d.ts

@@ -1,10 +1,8 @@
 import { Brand } from "effect";
 
 //#region src/internal/brands.d.ts
-declare const StateTypeId: unique symbol;
-declare const EventTypeId: unique symbol;
-type StateTypeId = typeof StateTypeId;
-type EventTypeId = typeof EventTypeId;
+type StateTypeId = "effect-machine/StateTypeId";
+type EventTypeId = "effect-machine/EventTypeId";
 interface StateBrand extends Brand.Brand<StateTypeId> {}
 interface EventBrand extends Brand.Brand<EventTypeId> {}
 type BrandedState = {
@@ -13,8 +11,7 @@ type BrandedState = {
 type BrandedEvent = {
   readonly _tag: string;
 } & EventBrand;
-declare const SchemaIdTypeId: unique symbol;
-type SchemaIdTypeId = typeof SchemaIdTypeId;
+type SchemaIdTypeId = "effect-machine/SchemaIdTypeId";
 /**
  * Brand that captures the schema definition type D.
  * Two schemas with identical definition shapes will have compatible brands.
@@ -33,8 +30,7 @@ type FullEventBrand<D extends Record<string, unknown>> = EventBrand & SchemaIdBr
  * Brand that carries the reply type for an event variant.
  * Present only on events defined with Event.reply().
  */
-declare const ReplyTypeId: unique symbol;
-type ReplyTypeId = typeof ReplyTypeId;
+type ReplyTypeId = "effect-machine/ReplyTypeId";
 interface ReplyTypeBrand<R> extends Brand.Brand<ReplyTypeId> {
   readonly _ReplyType: R;
 }

package/v3/dist/internal/inspection.js

@@ -14,7 +14,7 @@ const emitWithTimestamp = Effect.fn("effect-machine.emitWithTimestamp")(function
 			return;
 		}
 	});
-	if (result !== void 0 && Effect.isEffect(result)) yield* result.pipe(Effect.catchAllCause(() => Effect.void));
+	if (Effect.isEffect(result)) yield* result.pipe(Effect.catchAllCause(() => Effect.void));
 });
 //#endregion
 export { emitWithTimestamp };

package/v3/dist/internal/runtime.d.ts

@@ -1,6 +1,6 @@
-import { ActorExit } from "../supervision.js";
 import { NoReplyError } from "../errors.js";
-import { EffectsDef, GuardsDef, MachineContext } from "../slot.js";
+import { MachineContext, SlotsDef } from "../slot.js";
+import { ActorExit } from "../supervision.js";
 import { ProcessEventHooks, ProcessEventResult } from "./transition.js";
 import { Machine, MachineRef } from "../machine.js";
 import { ActorSystem } from "../actor.js";
@@ -14,7 +14,7 @@ type RuntimeQueuedEvent<E> = {
 } | {
   readonly _tag: "sendWait";
   readonly event: E;
-  readonly done: Deferred.Deferred<void>;
+  readonly done: Deferred.Deferred<void, unknown>;
 } | {
   readonly _tag: "call";
   readonly event: E;
@@ -43,18 +43,24 @@ interface RuntimeCellResources<S, E> {
 interface RuntimeHandle<S, E> {
   /** Enqueue a fire-and-forget event */
   readonly send: (event: E) => Effect.Effect<void>;
-  /** Enqueue event and wait for processing to complete (for RPC Send) */
-  readonly sendWait: (event: E) => Effect.Effect<void>;
+  /** Enqueue event and wait for processing to complete (for RPC Send). Fails on defect. */
+  readonly sendWait: (event: E) => Effect.Effect<void, unknown>;
   /** Enqueue an ask event, returns the reply value */
   readonly ask: (event: E) => Effect.Effect<unknown, NoReplyError>;
   /** Get current state */
   readonly getState: Effect.Effect<S>;
-  /** SubscriptionRef for state observation */
+  /** SubscriptionRef for state observation (WatchState streaming) */
   readonly stateRef: SubscriptionRef.SubscriptionRef<S>;
   /** Whether the runtime has stopped (final state reached) */
   readonly isStopped: Effect.Effect<boolean>;
   /** Stop the runtime (interrupt event loop, clean up) */
   readonly stop: Effect.Effect<void>;
+  /**
+   * Start the runtime — fork event loop, background effects, spawn effects.
+   * Idempotent: first caller runs initialization, subsequent callers await completion.
+   * Events sent before start() are queued and processed when start() runs.
+   */
+  readonly start: Effect.Effect<void>;
   /** @internal — raw event queue for direct enqueue (actor.ts uses this for pendingReplies tracking) */
   readonly _queue: Queue.Queue<RuntimeQueuedEvent<E>>;
   /** @internal — stopped ref for direct access */
@@ -123,7 +129,7 @@ interface ProcessQueuedResult<S> {
  * and querying state. The runtime owns:
  * - Event loop fiber
  * - Postpone buffer
- * - Background effects
+ * - Background effects (under actorScope)
  * - State scope (spawn effects)
  * - Final state detection
  * - Exit reason via exitDeferred
@@ -137,6 +143,19 @@ declare const createRuntime: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, any, any, GD, EFD>, system: ActorSystem, config: RuntimeConfig<S, E>) => Effect.Effect<RuntimeHandle<S, E>, never, Scope.Scope | Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, system: ActorSystem, config: RuntimeConfig<S, E>) => Effect.Effect<{
+  stop: Effect.Effect<void, never, never>;
+  start: Effect.Effect<void, unknown, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+  send: (event: E) => Effect.Effect<void>;
+  sendWait: (event: E) => Effect.Effect<void, unknown>;
+  ask: (event: E) => Effect.Effect<unknown, NoReplyError>;
+  getState: Effect.Effect<S, never, never>;
+  stateRef: SubscriptionRef.SubscriptionRef<S>;
+  isStopped: Effect.Effect<boolean>;
+  _queue: Queue.Queue<RuntimeQueuedEvent<E>>;
+  _stoppedRef: Ref.Ref<boolean>;
+  exitDeferred: Deferred.Deferred<ActorExit<S>, never>;
+  actorScope: Scope.CloseableScope;
+}, never, Scope.Scope>;
 //#endregion
 export { ProcessQueuedResult, RuntimeCellResources, RuntimeConfig, RuntimeHandle, RuntimeLifecycleHooks, RuntimeQueuedEvent, createRuntime };

package/v3/dist/internal/runtime.js

@@ -3,7 +3,7 @@ import { NoReplyError } from "../errors.js";
 import { processEventCore, runSpawnEffects, shouldPostpone } from "./transition.js";
 import { ActorExit } from "../supervision.js";
 import { ActorSystem } from "../actor.js";
-import { Cause, Deferred, Effect, Exit, Fiber, Queue, Ref, Schema, Scope, SubscriptionRef } from "effect";
+import { Cause, Deferred, Effect, Exit, Fiber, Queue, Ref, Runtime, Schema, Scope, SubscriptionRef } from "effect";
 //#region src/internal/runtime.ts
 /**
 * Shared runtime kernel for machine event processing.
@@ -28,7 +28,7 @@ import { Cause, Deferred, Effect, Exit, Fiber, Queue, Ref, Schema, Scope, Subscr
 * and querying state. The runtime owns:
 * - Event loop fiber
 * - Postpone buffer
-* - Background effects
+* - Background effects (under actorScope)
 * - State scope (spawn effects)
 * - Final state detection
 * - Exit reason via exitDeferred
@@ -40,11 +40,14 @@ import { Cause, Deferred, Effect, Exit, Fiber, Queue, Ref, Schema, Scope, Subscr
 */
 const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (machine, system, config) {
 	const { actorId, hooks, lifecycle } = config;
+	const rt = yield* Effect.runtime();
+	const fork = Runtime.runFork(rt);
 	const stateRef = config.cellResources?.stateRef ?? (yield* SubscriptionRef.make(machine.initial));
 	const stoppedRef = config.cellResources?.stoppedRef ?? (yield* Ref.make(false));
 	const eventQueue = config.cellResources?.eventQueue ?? (yield* config.queueFactory ?? Queue.unbounded());
 	const exitDeferred = yield* Deferred.make();
 	const actorScope = yield* Scope.make();
+	const deferredReplyRef = { current: void 0 };
 	const selfSend = Effect.fn("effect-machine.runtime.self.send")(function* (event) {
 		if (!(yield* Ref.get(stoppedRef))) yield* Queue.offer(eventQueue, {
 			_tag: "send",
@@ -57,10 +60,18 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 	const self = {
 		send: selfSend,
 		cast: selfSend,
-		spawn: onChildSpawned !== void 0 ? (childId, childMachine) => defaultSpawn(childId, childMachine).pipe(Effect.tap((child) => onChildSpawned(childId, child))) : defaultSpawn
+		spawn: onChildSpawned !== void 0 ? (childId, childMachine) => defaultSpawn(childId, childMachine).pipe(Effect.tap((child) => onChildSpawned(childId, child))) : defaultSpawn,
+		reply: (value) => Effect.sync(() => {
+			const deferred = deferredReplyRef.current;
+			if (deferred !== void 0) {
+				deferredReplyRef.current = void 0;
+				fork(Deferred.succeed(deferred, value));
+				return true;
+			}
+			return false;
+		})
 	};
 	const stateScopeRef = { current: yield* Scope.make() };
-	const backgroundFibers = [];
 	const initEvent = { _tag: INTERNAL_INIT_EVENT };
 	const ctx = {
 		actorId,
@@ -69,65 +80,81 @@ const createRuntime = Effect.fn("effect-machine.runtime.create")(function* (mach
 		self,
 		system
 	};
-	const { effects: effectSlots } = machine._slots;
-	for (const bg of machine.backgroundEffects) {
-		const fiber = yield* Effect.forkDaemon(bg.handler({
-			actorId,
-			state: machine.initial,
-			event: initEvent,
-			self,
-			effects: effectSlots,
-			system
-		}).pipe(Effect.provideService(machine.Context, ctx)));
-		backgroundFibers.push(fiber);
-	}
-	if (lifecycle?.onInitialSpawnEffects !== void 0) yield* lifecycle.onInitialSpawnEffects(machine.initial);
+	const slots = machine._slots;
 	const loopFiberRef = { current: void 0 };
-	const initialSpawnDefectSignal = (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn")).pipe(Effect.zipRight(Ref.set(stoppedRef, true)), Effect.zipRight(Effect.suspend(() => loopFiberRef.current !== void 0 ? Fiber.interrupt(loopFiberRef.current) : Effect.void)), Effect.asVoid);
-	yield* runSpawnEffects(machine, machine.initial, initEvent, self, stateScopeRef.current, system, actorId, hooks?.onError, initialSpawnDefectSignal).pipe(Effect.catchAllCause((cause) => {
-		return Effect.gen(function* () {
+	/** Set the exit deferred exactly once. */
+	const setExit = (exit) => Deferred.succeed(exitDeferred, exit).pipe(Effect.asVoid);
+	const startDeferred = yield* Deferred.make();
+	const startedRef = yield* Ref.make(false);
+	const start = Effect.gen(function* () {
+		if (yield* Ref.getAndSet(startedRef, true)) {
+			yield* Deferred.await(startDeferred);
+			return;
+		}
+		const backgroundFibers = [];
+		for (const bg of machine.backgroundEffects) {
+			const fiber = yield* bg.handler({
+				actorId,
+				state: machine.initial,
+				event: initEvent,
+				self,
+				slots,
+				system
+			}).pipe(Effect.provideService(machine.Context, ctx), Effect.forkIn(actorScope));
+			backgroundFibers.push(fiber);
+		}
+		if (lifecycle?.onInitialSpawnEffects !== void 0) yield* lifecycle.onInitialSpawnEffects(machine.initial);
+		const initialSpawnDefectSignal = (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Effect.suspend(() => loopFiberRef.current !== void 0 ? Fiber.interrupt(loopFiberRef.current) : Effect.void)), Effect.asVoid);
+		yield* runSpawnEffects(machine, machine.initial, initEvent, self, stateScopeRef.current, system, actorId, hooks?.onError, initialSpawnDefectSignal).pipe(Effect.catchAllCause((cause) => {
+			return Effect.gen(function* () {
+				yield* Ref.set(stoppedRef, true);
+				yield* Scope.close(stateScopeRef.current, Exit.void);
+				yield* Scope.close(actorScope, Exit.void);
+				yield* Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn"));
+				return yield* Effect.failCause(cause);
+			});
+		}));
+		if (machine.finalStates.has(machine.initial._tag)) {
+			if (lifecycle?.onFinal !== void 0) yield* lifecycle.onFinal(machine.initial);
 			yield* Ref.set(stoppedRef, true);
 			yield* Scope.close(stateScopeRef.current, Exit.void);
 			yield* Scope.close(actorScope, Exit.void);
-			yield* Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "initial-spawn"));
-			return yield* Effect.failCause(cause);
-		});
-	}));
-	/** Set the exit deferred exactly once. */
-	const setExit = (exit) => Deferred.succeed(exitDeferred, exit).pipe(Effect.asVoid);
-	if (machine.finalStates.has(machine.initial._tag)) {
-		if (lifecycle?.onFinal !== void 0) yield* lifecycle.onFinal(machine.initial);
-		yield* Ref.set(stoppedRef, true);
-		yield* Scope.close(stateScopeRef.current, Exit.void);
-		yield* Scope.close(actorScope, Exit.void);
-		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
-		yield* setExit(ActorExit.Final(machine.initial));
-		return makeHandle(stateRef, stoppedRef, eventQueue, exitDeferred, actorScope);
-	}
-	const augmentedHooks = {
-		...hooks,
-		onSpawnDefect: (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "spawn")).pipe(Effect.zipRight(Ref.set(stoppedRef, true)), Effect.zipRight(Effect.suspend(() => loopFiberRef.current !== void 0 ? Fiber.interrupt(loopFiberRef.current) : Effect.void)), Effect.asVoid)
-	};
-	const loopFiber = yield* Effect.forkDaemon(runtimeEventLoop(machine, stateRef, eventQueue, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, augmentedHooks, lifecycle, config.wrapProcess));
-	loopFiberRef.current = loopFiber;
-	if (backgroundFibers.length > 0) yield* Effect.forkDaemon(Effect.raceAll(backgroundFibers.map((fiber) => Fiber.await(fiber).pipe(Effect.flatMap((exit) => {
-		if (exit._tag === "Failure" && !Cause.isInterruptedOnly(exit.cause)) return setExit(ActorExit.Defect(exit.cause, "background")).pipe(Effect.zipRight(Ref.set(stoppedRef, true)), Effect.zipRight(Fiber.interrupt(loopFiber)));
-		return Effect.never;
-	})))).pipe(Effect.catchAllCause(() => Effect.void)));
+			yield* setExit(ActorExit.Final(machine.initial));
+			yield* Deferred.succeed(startDeferred, void 0);
+			return;
+		}
+		const augmentedHooks = {
+			...hooks,
+			onSpawnDefect: (cause) => Deferred.succeed(exitDeferred, ActorExit.Defect(cause, "spawn")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Effect.suspend(() => loopFiberRef.current !== void 0 ? Fiber.interrupt(loopFiberRef.current) : Effect.void)), Effect.asVoid)
+		};
+		const loopFiber = yield* Effect.forkDaemon(runtimeEventLoop(machine, stateRef, eventQueue, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, augmentedHooks, deferredReplyRef, lifecycle, config.wrapProcess, fork));
+		loopFiberRef.current = loopFiber;
+		if (backgroundFibers.length > 0) yield* Effect.raceAll(backgroundFibers.map((fiber) => Fiber.await(fiber).pipe(Effect.flatMap((exit) => {
+			if (exit._tag === "Failure" && !Cause.isInterruptedOnly(exit.cause)) return setExit(ActorExit.Defect(exit.cause, "background")).pipe(Effect.andThen(Ref.set(stoppedRef, true)), Effect.andThen(Fiber.interrupt(loopFiber)));
+			return Effect.never;
+		})))).pipe(Effect.forkIn(actorScope));
+		yield* Effect.forkDaemon(Effect.gen(function* () {
+			const loopExit = yield* Fiber.await(loopFiber);
+			if (loopExit._tag === "Success") yield* Scope.close(actorScope, Exit.void);
+			else yield* Scope.close(actorScope, loopExit);
+		}));
+		yield* Deferred.succeed(startDeferred, void 0);
+	}).pipe(Effect.catchAllCause((cause) => Deferred.failCause(startDeferred, cause).pipe(Effect.andThen(Effect.failCause(cause)))));
 	const stop = Effect.gen(function* () {
 		if (yield* Ref.get(stoppedRef)) return;
 		if (lifecycle?.onShutdown !== void 0) yield* lifecycle.onShutdown();
 		yield* Ref.set(stoppedRef, true);
-		yield* Fiber.interrupt(loopFiber);
+		const loopFiber = loopFiberRef.current;
+		if (loopFiber !== void 0) yield* Fiber.interrupt(loopFiber);
 		yield* Scope.close(stateScopeRef.current, Exit.void);
 		yield* Scope.close(actorScope, Exit.void);
-		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 		yield* setExit(ActorExit.Stopped);
 	}).pipe(Effect.asVoid);
 	if (config.skipFinalizer !== true) yield* Effect.addFinalizer(() => stop);
 	return {
 		...makeHandle(stateRef, stoppedRef, eventQueue, exitDeferred, actorScope),
-		stop
+		stop,
+		start
 	};
 });
 /**
@@ -169,12 +196,14 @@ const makeHandle = (stateRef, stoppedRef, eventQueue, exitDeferred, actorScope)
 	stateRef,
 	isStopped: Ref.get(stoppedRef),
 	stop: Effect.void,
+	start: Effect.void,
 	_queue: eventQueue,
 	_stoppedRef: stoppedRef,
 	exitDeferred,
 	actorScope
 });
-const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, hooks, lifecycle, wrapProcess) {
+const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, stateScopeRef, actorId, system, exitDeferred, hooks, deferredReplyRef, lifecycle, wrapProcess, fork) {
+	const forkEffect = fork ?? Effect.runFork;
 	/** Set the exit deferred exactly once. */
 	const setExit = (exit) => Deferred.succeed(exitDeferred, exit).pipe(Effect.asVoid);
 	const postponed = [];
@@ -242,7 +271,8 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 						}
 						yield* Deferred.succeed(queued.reply, decoded);
 					} else yield* Deferred.succeed(queued.reply, result.reply);
-				} else yield* Deferred.fail(queued.reply, new NoReplyError({
+				} else if (result.deferReply && deferredReplyRef !== void 0) deferredReplyRef.current = queued.reply;
+				else yield* Deferred.fail(queued.reply, new NoReplyError({
 					actorId,
 					eventTag: event._tag
 				}));
@@ -260,16 +290,16 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 	const shutdown = (exitReason) => Effect.gen(function* () {
 		yield* Ref.set(stoppedRef, true);
 		if (lifecycle?.onShutdown !== void 0) yield* lifecycle.onShutdown();
-		settlePostponed(postponed, actorId);
+		settlePostponed(postponed, actorId, forkEffect);
 		const remaining = yield* Queue.takeAll(eventQueue);
-		for (const entry of remaining) if (entry._tag === "sendWait") Effect.runFork(Deferred.succeed(entry.done, void 0));
-		else if (entry._tag === "ask") Effect.runFork(Deferred.fail(entry.reply, new NoReplyError({
+		for (const entry of remaining) if (entry._tag === "sendWait") forkEffect(Deferred.succeed(entry.done, void 0));
+		else if (entry._tag === "ask") forkEffect(Deferred.fail(entry.reply, new NoReplyError({
 			actorId,
 			eventTag: entry.event._tag
 		})));
 		else if (entry._tag === "call") {
 			const currentState = yield* SubscriptionRef.get(stateRef);
-			Effect.runFork(Deferred.succeed(entry.reply, {
+			forkEffect(Deferred.succeed(entry.reply, {
 				newState: currentState,
 				previousState: currentState,
 				transitioned: false,
@@ -296,10 +326,10 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 		const { shouldStop, stateChanged } = yield* (wrapProcess !== void 0 ? Effect.gen(function* () {
 			return yield* wrapProcess(yield* SubscriptionRef.get(stateRef), eventQueued.event, processInner);
 		}) : processInner).pipe(Effect.catchAllCause((cause) => {
-			if (queued._tag === "sendWait") Effect.runFork(Deferred.succeed(queued.done, void 0));
-			else if (queued._tag === "ask") Effect.runFork(Deferred.die(queued.reply, cause));
-			else if (queued._tag === "call") Effect.runFork(Deferred.failCause(queued.reply, cause));
-			return shutdown(ActorExit.Defect(cause, "transition")).pipe(Effect.zipRight(Effect.failCause(cause)));
+			if (queued._tag === "sendWait") forkEffect(Deferred.failCause(queued.done, cause));
+			else if (queued._tag === "ask") forkEffect(Deferred.die(queued.reply, cause));
+			else if (queued._tag === "call") forkEffect(Deferred.failCause(queued.reply, cause));
+			return shutdown(ActorExit.Defect(cause, "transition")).pipe(Effect.andThen(Effect.failCause(cause)));
 		}));
 		if (shouldStop) {
 			const finalState = yield* SubscriptionRef.get(stateRef);
@@ -323,12 +353,12 @@ const runtimeEventLoop = Effect.fn("effect-machine.runtime.eventLoop")(function*
 	}
 });
 /** Settle all pending Deferreds in the postpone buffer on shutdown. */
-const settlePostponed = (postponed, actorId) => {
-	for (const entry of postponed) if (entry._tag === "ask") Effect.runFork(Deferred.fail(entry.reply, new NoReplyError({
+const settlePostponed = (postponed, actorId, forkFn) => {
+	for (const entry of postponed) if (entry._tag === "ask") forkFn(Deferred.fail(entry.reply, new NoReplyError({
 		actorId,
 		eventTag: entry.event._tag
 	})));
-	else if (entry._tag === "sendWait") Effect.runFork(Deferred.succeed(entry.done, void 0));
+	else if (entry._tag === "sendWait") forkFn(Deferred.succeed(entry.done, void 0));
 	postponed.length = 0;
 };
 //#endregion

package/v3/dist/internal/transition.d.ts

@@ -1,4 +1,4 @@
-import { EffectsDef, GuardsDef, MachineContext } from "../slot.js";
+import { MachineContext, SlotsDef } from "../slot.js";
 import { Machine, MachineRef, SpawnEffect, Transition } from "../machine.js";
 import { ActorSystem } from "../actor.js";
 import { Cause, Effect, Scope } from "effect";
@@ -21,7 +21,7 @@ interface TransitionExecutionResult<S> {
  *
  * Used by:
  * - executeTransition (actor event loop, testing)
- * - persistent-actor replay (restore, replayTo)
+ * - Machine.replay (event sourcing restore)
  *
  * @internal
  */
@@ -29,7 +29,7 @@ declare const runTransitionHandler: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, transition: Transition<S, E, GD, EFD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, transition: Transition<S, E, SD, R>, state: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
   newState: S;
   hasReply: boolean;
   deferReply: boolean;
@@ -50,7 +50,7 @@ declare const executeTransition: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, system: ActorSystem, actorId: string) => Effect.Effect<{
   newState: S;
   transitioned: boolean;
   reenter: boolean;
@@ -111,7 +111,7 @@ declare const shouldPostpone: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any, any>, stateTag: string, eventTag: string) => boolean;
+}, R>(machine: Machine<S, E, R, any, any, any>, stateTag: string, eventTag: string) => boolean;
 /**
  * Process a single event through the machine.
  *
@@ -128,7 +128,7 @@ declare const processEventCore: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, currentState: S, event: E, self: MachineRef<E>, stateScopeRef: {
   current: Scope.CloseableScope;
 }, system: ActorSystem, actorId: string, hooks?: ProcessEventHooks<S, E> | undefined) => Effect.Effect<{
   newState: S;
@@ -150,7 +150,7 @@ declare const runSpawnEffects: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef, EFD extends EffectsDef>(machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.CloseableScope, system: ActorSystem, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
+}, R, SD extends SlotsDef>(machine: Machine<S, E, R, any, any, SD>, state: S, event: E, self: MachineRef<E>, stateScope: Scope.CloseableScope, system: ActorSystem, actorId: string, onError?: ((info: ProcessEventError<S, E>) => Effect.Effect<void>) | undefined, onSpawnDefect?: ((cause: Cause.Cause<unknown>) => Effect.Effect<void>) | undefined) => Effect.Effect<void, never, Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>>;
 /**
  * Resolve which transition should fire for a given state and event.
  * Uses indexed O(1) lookup. First matching transition wins.
@@ -159,7 +159,7 @@ declare const resolveTransition: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R>(machine: Machine<S, E, R, any, any, any, any>, currentState: S, event: E) => (typeof machine.transitions)[number] | undefined;
+}, R>(machine: Machine<S, E, R, any, any, any>, currentState: S, event: E) => (typeof machine.transitions)[number] | undefined;
 /**
  * Invalidate cached index for a machine (call after mutation).
  */
@@ -174,7 +174,7 @@ declare const findTransitions: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(input: Machine<S, E, R, any, any, GD, EFD>, stateTag: string, eventTag: string) => ReadonlyArray<Transition<S, E, GD, EFD, R>>;
+}, R, SD extends SlotsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, SD>, stateTag: string, eventTag: string) => ReadonlyArray<Transition<S, E, SD, R>>;
 /**
  * Find all spawn effects for a state.
  * Returns empty array if no matches.
@@ -185,6 +185,6 @@ declare const findSpawnEffects: <S extends {
   readonly _tag: string;
 }, E extends {
   readonly _tag: string;
-}, R, GD extends GuardsDef = Record<string, never>, EFD extends EffectsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, GD, EFD>, stateTag: string) => ReadonlyArray<SpawnEffect<S, E, EFD, R>>;
+}, R, SD extends SlotsDef = Record<string, never>>(machine: Machine<S, E, R, any, any, SD>, stateTag: string) => ReadonlyArray<SpawnEffect<S, E, SD, R>>;
 //#endregion
 export { ProcessEventError, ProcessEventHooks, ProcessEventResult, TransitionExecutionResult, executeTransition, findSpawnEffects, findTransitions, invalidateIndex, processEventCore, resolveTransition, runSpawnEffects, runTransitionHandler, shouldPostpone };

package/v3/dist/internal/transition.js

@@ -17,7 +17,7 @@ import { Cause, Effect, Exit, Scope } from "effect";
 *
 * Used by:
 * - executeTransition (actor event loop, testing)
-* - persistent-actor replay (restore, replayTo)
+* - Machine.replay (event sourcing restore)
 *
 * @internal
 */
@@ -29,12 +29,10 @@ const runTransitionHandler = Effect.fn("effect-machine.runTransitionHandler")(fu
 		self,
 		system
 	};
-	const { guards, effects } = machine._slots;
 	const handlerCtx = {
 		state,
 		event,
-		guards,
-		effects
+		slots: machine._slots
 	};
 	const raw = transition.handler(handlerCtx);
 	const resolved = isEffect(raw) ? yield* raw.pipe(Effect.provideService(machine.Context, ctx)) : raw;
@@ -118,7 +116,7 @@ const processEventCore = Effect.fn("effect-machine.processEventCore")(function*
 			state: currentState,
 			event,
 			cause
-		}).pipe(Effect.zipRight(Effect.failCause(cause).pipe(Effect.orDie)));
+		}).pipe(Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
 	}));
 	if (!result.transitioned) return {
 		newState: currentState,
@@ -166,7 +164,7 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 		self,
 		system
 	};
-	const { effects: effectSlots } = machine._slots;
+	const slots = machine._slots;
 	const reportError = onError;
 	const defectSignal = onSpawnDefect;
 	for (const spawnEffect of spawnEffects) {
@@ -175,7 +173,7 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 			state,
 			event,
 			self,
-			effects: effectSlots,
+			slots,
 			system
 		}).pipe(Effect.provideService(machine.Context, ctx), Effect.catchAllCause((cause) => {
 			if (Cause.isInterruptedOnly(cause)) return Effect.interrupt;
@@ -186,7 +184,7 @@ const runSpawnEffects = Effect.fn("effect-machine.runSpawnEffects")(function* (m
 				cause
 			}) : Effect.void;
 			const signal = defectSignal !== void 0 ? defectSignal(cause) : Effect.void;
-			return report.pipe(Effect.zipRight(signal), Effect.zipRight(Effect.failCause(cause).pipe(Effect.orDie)));
+			return report.pipe(Effect.andThen(signal), Effect.andThen(Effect.failCause(cause).pipe(Effect.orDie)));
 		}));
 		yield* Effect.forkScoped(effect).pipe(Effect.provideService(Scope.Scope, stateScope));
 	}
@@ -261,8 +259,8 @@ const getIndex = (machine) => {
 *
 * O(1) lookup after first access (index is lazily built).
 */
-const findTransitions = (input, stateTag, eventTag) => {
-	const index = getIndex(input);
+const findTransitions = (machine, stateTag, eventTag) => {
+	const index = getIndex(machine);
 	const specific = index.transitions.get(stateTag)?.get(eventTag) ?? [];
 	if (specific.length > 0) return specific;
 	return index.transitions.get("*")?.get(eventTag) ?? [];

package/v3/dist/internal/utils.js

@@ -1,5 +1,9 @@
 import { Effect, Stream } from "effect";
 //#region src/internal/utils.ts
+/**
+* Internal utilities for effect-machine.
+* @internal
+*/
 const ReplyResultSymbol = Symbol.for("effect-machine/ReplyResult");
 /**
 * Create a reply result for ask-bearing event handlers.
@@ -50,7 +54,7 @@ const getTag = (constructorOrValue) => {
 	}
 };
 /** Check if a value is an Effect */
-const isEffect = (value) => typeof value === "object" && value !== null && Effect.EffectTypeId in value;
+const isEffect = Effect.isEffect;
 /**
 * Stub ActorSystem that dies on any method call.
 * Used in contexts where spawning/system access isn't supported