effect-machine 0.9.0 → 0.11.0

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

@@ -1,13 +1,10 @@
 import { Inspector } from "./inspection.js";
 import { INTERNAL_INIT_EVENT } from "./internal/utils.js";
-import { DuplicateActorError } from "./errors.js";
-import { isPersistentMachine } from "./persistence/persistent-machine.js";
-import { processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
+import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.js";
 import { emitWithTimestamp } from "./internal/inspection.js";
-import { PersistenceAdapterTag, PersistenceError } from "./persistence/adapter.js";
-import { createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
+import { processEventCore, resolveTransition, runSpawnEffects, shouldPostpone } from "./internal/transition.js";
 import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Runtime, Scope, Stream, SubscriptionRef } from "effect";
-//#region src-v3/actor.ts
+//#region src/actor.ts
 /**
 * Actor system: spawning, lifecycle, and event processing.
 *
@@ -31,10 +28,50 @@ const notifyListeners = (listeners, state) => {
 /**
 * Build core ActorRef methods shared between regular and persistent actors.
 */
-const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap) => {
+const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap, pendingReplies, transitionsPubSub) => {
 	const send = Effect.fn("effect-machine.actor.send")(function* (event) {
 		if (yield* Ref.get(stoppedRef)) return;
-		yield* Queue.offer(eventQueue, event);
+		yield* Queue.offer(eventQueue, {
+			_tag: "send",
+			event
+		});
+	});
+	const call = Effect.fn("effect-machine.actor.call")(function* (event) {
+		if (yield* Ref.get(stoppedRef)) {
+			const currentState = yield* SubscriptionRef.get(stateRef);
+			return {
+				newState: currentState,
+				previousState: currentState,
+				transitioned: false,
+				lifecycleRan: false,
+				isFinal: machine.finalStates.has(currentState._tag)
+			};
+		}
+		const reply = yield* Deferred.make();
+		pendingReplies.add(reply);
+		yield* Queue.offer(eventQueue, {
+			_tag: "call",
+			event,
+			reply
+		});
+		return yield* Deferred.await(reply).pipe(Effect.ensuring(Effect.sync(() => pendingReplies.delete(reply))), Effect.catchTag("ActorStoppedError", () => SubscriptionRef.get(stateRef).pipe(Effect.map((currentState) => ({
+			newState: currentState,
+			previousState: currentState,
+			transitioned: false,
+			lifecycleRan: false,
+			isFinal: machine.finalStates.has(currentState._tag)
+		})))));
+	});
+	const ask = Effect.fn("effect-machine.actor.ask")(function* (event) {
+		if (yield* Ref.get(stoppedRef)) return yield* new ActorStoppedError({ actorId: id });
+		const reply = yield* Deferred.make();
+		pendingReplies.add(reply);
+		yield* Queue.offer(eventQueue, {
+			_tag: "ask",
+			event,
+			reply
+		});
+		return yield* Deferred.await(reply).pipe(Effect.ensuring(Effect.sync(() => pendingReplies.delete(reply))));
 	});
 	const snapshot = SubscriptionRef.get(stateRef).pipe(Effect.withSpan("effect-machine.actor.snapshot"));
 	const matches = Effect.fn("effect-machine.actor.matches")(function* (tag) {
@@ -72,30 +109,39 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 	return {
 		id,
 		send,
+		cast: send,
+		call,
+		ask,
 		state: stateRef,
 		stop,
-		stopSync: () => Effect.runFork(stop),
 		snapshot,
-		snapshotSync: () => Effect.runSync(SubscriptionRef.get(stateRef)),
 		matches,
-		matchesSync: (tag) => Effect.runSync(SubscriptionRef.get(stateRef))._tag === tag,
 		can,
-		canSync: (event) => {
-			return resolveTransition(machine, Effect.runSync(SubscriptionRef.get(stateRef)), event) !== void 0;
-		},
 		changes: stateRef.changes,
+		transitions: transitionsPubSub !== void 0 ? Stream.fromPubSub(transitionsPubSub) : Stream.empty,
 		waitFor,
 		awaitFinal,
 		sendAndWait,
-		sendSync: (event) => {
-			if (!Effect.runSync(Ref.get(stoppedRef))) Effect.runSync(Queue.offer(eventQueue, event));
-		},
 		subscribe: (fn) => {
 			listeners.add(fn);
 			return () => {
 				listeners.delete(fn);
 			};
 		},
+		sync: {
+			send: (event) => {
+				if (!Effect.runSync(Ref.get(stoppedRef))) Effect.runSync(Queue.offer(eventQueue, {
+					_tag: "send",
+					event
+				}));
+			},
+			stop: () => Effect.runFork(stop),
+			snapshot: () => Effect.runSync(SubscriptionRef.get(stateRef)),
+			matches: (tag) => Effect.runSync(SubscriptionRef.get(stateRef))._tag === tag,
+			can: (event) => {
+				return resolveTransition(machine, Effect.runSync(SubscriptionRef.get(stateRef)), event) !== void 0;
+			}
+		},
 		system,
 		children: childrenMap
 	};
@@ -103,7 +149,8 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 /**
 * Create and start an actor for a machine
 */
-const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine) {
+const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine, options) {
+	const initial = options?.initialState ?? machine.initial;
 	yield* Effect.annotateCurrentSpan("effect_machine.actor.id", id);
 	const existingSystem = yield* Effect.serviceOption(ActorSystem);
 	let system;
@@ -118,11 +165,16 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	const eventQueue = yield* Queue.unbounded();
 	const stoppedRef = yield* Ref.make(false);
 	const childrenMap = /* @__PURE__ */ new Map();
+	const selfSend = Effect.fn("effect-machine.actor.self.send")(function* (event) {
+		if (yield* Ref.get(stoppedRef)) return;
+		yield* Queue.offer(eventQueue, {
+			_tag: "send",
+			event
+		});
+	});
 	const self = {
-		send: Effect.fn("effect-machine.actor.self.send")(function* (event) {
-			if (yield* Ref.get(stoppedRef)) return;
-			yield* Queue.offer(eventQueue, event);
-		}),
+		send: selfSend,
+		cast: selfSend,
 		spawn: (childId, childMachine) => Effect.gen(function* () {
 			const child = yield* system.spawn(childId, childMachine).pipe(Effect.provideService(ActorSystem, system));
 			childrenMap.set(childId, child);
@@ -133,19 +185,20 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 			return child;
 		})
 	};
-	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", machine.initial._tag);
+	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", initial._tag);
 	yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
 		type: "@machine.spawn",
 		actorId: id,
-		initialState: machine.initial,
+		initialState: initial,
 		timestamp
 	}));
-	const stateRef = yield* SubscriptionRef.make(machine.initial);
+	const stateRef = yield* SubscriptionRef.make(initial);
 	const listeners = /* @__PURE__ */ new Set();
 	const backgroundFibers = [];
 	const initEvent = { _tag: INTERNAL_INIT_EVENT };
 	const ctx = {
-		state: machine.initial,
+		actorId: id,
+		state: initial,
 		event: initEvent,
 		self,
 		system
@@ -153,7 +206,8 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	const { effects: effectSlots } = machine._slots;
 	for (const bg of machine.backgroundEffects) {
 		const fiber = yield* Effect.forkDaemon(bg.handler({
-			state: machine.initial,
+			actorId: id,
+			state: initial,
 			event: initEvent,
 			self,
 			effects: effectSlots,
@@ -162,21 +216,23 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 		backgroundFibers.push(fiber);
 	}
 	const stateScopeRef = { current: yield* Scope.make() };
-	yield* runSpawnEffectsWithInspection(machine, machine.initial, initEvent, self, stateScopeRef.current, id, inspectorValue, system);
-	if (machine.finalStates.has(machine.initial._tag)) {
+	yield* runSpawnEffectsWithInspection(machine, initial, initEvent, self, stateScopeRef.current, id, inspectorValue, system);
+	if (machine.finalStates.has(initial._tag)) {
 		yield* Scope.close(stateScopeRef.current, Exit.void);
 		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
 			type: "@machine.stop",
 			actorId: id,
-			finalState: machine.initial,
+			finalState: initial,
 			timestamp
 		}));
 		yield* Ref.set(stoppedRef, true);
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-		return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap);
+		return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap, /* @__PURE__ */ new Set());
 	}
-	const loopFiber = yield* Effect.forkDaemon(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system));
+	const pendingReplies = /* @__PURE__ */ new Set();
+	const transitionsPubSub = yield* PubSub.unbounded();
+	const loopFiber = yield* Effect.forkDaemon(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system, pendingReplies, transitionsPubSub));
 	return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
 		const finalState = yield* SubscriptionRef.get(stateRef);
 		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
@@ -187,31 +243,115 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 		}));
 		yield* Ref.set(stoppedRef, true);
 		yield* Fiber.interrupt(loopFiber);
+		yield* settlePendingReplies(pendingReplies, id);
 		yield* Scope.close(stateScopeRef.current, Exit.void);
 		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap);
+	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid), system, childrenMap, pendingReplies, transitionsPubSub);
+});
+/** Fail all pending call/ask Deferreds with ActorStoppedError. Safe to call multiple times. */
+const settlePendingReplies = (pendingReplies, actorId) => Effect.sync(() => {
+	const error = new ActorStoppedError({ actorId });
+	for (const deferred of pendingReplies) Effect.runFork(Deferred.fail(deferred, error));
+	pendingReplies.clear();
 });
 /**
-* Main event loop for the actor
+* Main event loop for the actor.
+* Includes postpone buffer — events matching postpone rules are buffered
+* and drained after state tag changes (gen_statem semantics).
 */
-const eventLoop = Effect.fn("effect-machine.actor.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, actorId, inspector, system) {
-	while (true) {
-		const event = yield* Queue.take(eventQueue);
+const eventLoop = Effect.fn("effect-machine.actor.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, actorId, inspector, system, pendingReplies, transitionsPubSub) {
+	const postponed = [];
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const processQueued = Effect.fn("effect-machine.actor.processQueued")(function* (queued) {
+		const event = queued.event;
 		const currentState = yield* SubscriptionRef.get(stateRef);
-		if (yield* Effect.withSpan("effect-machine.event.process", { attributes: {
+		if (hasPostponeRules && shouldPostpone(machine, currentState._tag, event._tag)) {
+			postponed.push(queued);
+			if (queued._tag === "call") {
+				const postponedResult = {
+					newState: currentState,
+					previousState: currentState,
+					transitioned: false,
+					lifecycleRan: false,
+					isFinal: false,
+					hasReply: false,
+					reply: void 0,
+					postponed: true
+				};
+				yield* Deferred.succeed(queued.reply, postponedResult);
+			}
+			return {
+				shouldStop: false,
+				stateChanged: false
+			};
+		}
+		const { shouldStop, result } = yield* Effect.withSpan("effect-machine.event.process", { attributes: {
 			"effect_machine.actor.id": actorId,
 			"effect_machine.state.current": currentState._tag,
 			"effect_machine.event.type": event._tag
-		} })(processEvent(machine, currentState, event, stateRef, self, listeners, stateScopeRef, actorId, inspector, system))) {
+		} })(processEvent(machine, currentState, event, stateRef, self, listeners, stateScopeRef, actorId, inspector, system));
+		switch (queued._tag) {
+			case "call":
+				yield* Deferred.succeed(queued.reply, result);
+				break;
+			case "ask":
+				if (result.hasReply) yield* Deferred.succeed(queued.reply, result.reply);
+				else yield* Deferred.fail(queued.reply, new NoReplyError({
+					actorId,
+					eventTag: event._tag
+				}));
+				break;
+		}
+		if (result.transitioned) yield* PubSub.publish(transitionsPubSub, {
+			fromState: result.previousState,
+			toState: result.newState,
+			event
+		});
+		return {
+			shouldStop,
+			stateChanged: result.lifecycleRan
+		};
+	});
+	while (true) {
+		const { shouldStop, stateChanged } = yield* processQueued(yield* Queue.take(eventQueue));
+		if (shouldStop) {
 			yield* Ref.set(stoppedRef, true);
+			settlePostponedBuffer(postponed, pendingReplies, actorId);
+			yield* settlePendingReplies(pendingReplies, actorId);
 			yield* Scope.close(stateScopeRef.current, Exit.void);
 			yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
 			return;
 		}
+		let drainTriggered = stateChanged;
+		while (drainTriggered && postponed.length > 0) {
+			drainTriggered = false;
+			const drained = postponed.splice(0);
+			for (const entry of drained) {
+				const drain = yield* processQueued(entry);
+				if (drain.shouldStop) {
+					yield* Ref.set(stoppedRef, true);
+					settlePostponedBuffer(postponed, pendingReplies, actorId);
+					yield* settlePendingReplies(pendingReplies, actorId);
+					yield* Scope.close(stateScopeRef.current, Exit.void);
+					yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
+					return;
+				}
+				if (drain.stateChanged) drainTriggered = true;
+			}
+		}
 	}
 });
 /**
+* Settle all reply-bearing entries in the postpone buffer on shutdown.
+* Call entries already had their Deferred settled with the postponed result
+* (so their pendingReplies entry is already removed). Ask/send entries
+* with Deferreds are settled via the pendingReplies registry.
+*/
+const settlePostponedBuffer = (postponed, _pendingReplies, _actorId) => {
+	postponed.length = 0;
+};
+/**
 * Process a single event, returning true if the actor should stop.
 * Wraps processEventCore with actor-specific concerns (inspection, listeners, state ref).
 */
@@ -223,7 +363,7 @@ const processEvent = Effect.fn("effect-machine.actor.processEvent")(function* (m
 		event,
 		timestamp
 	}));
-	const result = yield* processEventCore(machine, currentState, event, self, stateScopeRef, system, inspector === void 0 ? void 0 : {
+	const result = yield* processEventCore(machine, currentState, event, self, stateScopeRef, system, actorId, inspector === void 0 ? void 0 : {
 		onSpawnEffect: (state) => emitWithTimestamp(inspector, (timestamp) => ({
 			type: "@machine.effect",
 			actorId,
@@ -251,7 +391,10 @@ const processEvent = Effect.fn("effect-machine.actor.processEvent")(function* (m
 	});
 	if (!result.transitioned) {
 		yield* Effect.annotateCurrentSpan("effect_machine.transition.matched", false);
-		return false;
+		return {
+			shouldStop: false,
+			result
+		};
 	}
 	yield* Effect.annotateCurrentSpan("effect_machine.transition.matched", true);
 	yield* SubscriptionRef.set(stateRef, result.newState);
@@ -266,10 +409,16 @@ const processEvent = Effect.fn("effect-machine.actor.processEvent")(function* (m
 				finalState: result.newState,
 				timestamp
 			}));
-			return true;
+			return {
+				shouldStop: true,
+				result
+			};
 		}
 	}
-	return false;
+	return {
+		shouldStop: false,
+		result
+	};
 });
 /**
 * Run spawn effects with actor-specific inspection and tracing.
@@ -284,7 +433,7 @@ const runSpawnEffectsWithInspection = Effect.fn("effect-machine.actor.spawnEffec
 		state,
 		timestamp
 	}));
-	yield* runSpawnEffects(machine, state, event, self, stateScope, system, inspector === void 0 ? void 0 : (info) => emitWithTimestamp(inspector, (timestamp) => ({
+	yield* runSpawnEffects(machine, state, event, self, stateScope, system, actorId, inspector === void 0 ? void 0 : (info) => emitWithTimestamp(inspector, (timestamp) => ({
 		type: "@machine.error",
 		actorId,
 		phase: info.phase,
@@ -305,13 +454,13 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 	const withSpawnGate = (yield* Effect.makeSemaphore(1)).withPermits(1);
 	const eventPubSub = yield* PubSub.unbounded();
 	const eventListeners = /* @__PURE__ */ new Set();
-	const emitSystemEvent = (event) => Effect.sync(() => notifySystemListeners(eventListeners, event)).pipe(Effect.andThen(PubSub.publish(eventPubSub, event)), Effect.catchAllCause(() => Effect.void), Effect.asVoid);
+	const emitSystemEvent = (event) => Effect.sync(() => notifySystemListeners(eventListeners, event)).pipe(Effect.zipRight(PubSub.publish(eventPubSub, event)), Effect.catchAllCause(() => Effect.void), Effect.asVoid);
 	yield* Effect.addFinalizer(() => {
 		const stops = [];
 		MutableHashMap.forEach(actorsMap, (actor) => {
 			stops.push(actor.stop);
 		});
-		return Effect.all(stops, { concurrency: "unbounded" }).pipe(Effect.andThen(PubSub.shutdown(eventPubSub)), Effect.asVoid);
+		return Effect.all(stops, { concurrency: "unbounded" }).pipe(Effect.zipRight(PubSub.shutdown(eventPubSub)), Effect.asVoid);
 	});
 	/** Check for duplicate ID, register actor, attach scope cleanup if available */
 	const registerActor = Effect.fn("effect-machine.actorSystem.register")(function* (id, actor) {
@@ -344,25 +493,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
 		return yield* registerActor(id, yield* createActor(id, built._inner));
 	});
-	const spawnPersistent = Effect.fn("effect-machine.actorSystem.spawnPersistent")(function* (id, persistentMachine) {
-		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
-		const adapter = yield* PersistenceAdapterTag;
-		const maybeSnapshot = yield* adapter.loadSnapshot(id, persistentMachine.persistence.stateSchema);
-		return yield* registerActor(id, yield* createPersistentActor(id, persistentMachine, maybeSnapshot, yield* adapter.loadEvents(id, persistentMachine.persistence.eventSchema, Option.isSome(maybeSnapshot) ? maybeSnapshot.value.version : void 0)));
-	});
-	const spawnImpl = Effect.fn("effect-machine.actorSystem.spawn")(function* (id, machine) {
-		if (isPersistentMachine(machine)) return yield* spawnPersistent(id, machine);
-		return yield* spawnRegular(id, machine);
-	});
-	function spawn(id, machine) {
-		return withSpawnGate(spawnImpl(id, machine));
-	}
-	const restoreImpl = Effect.fn("effect-machine.actorSystem.restore")(function* (id, persistentMachine) {
-		const maybeActor = yield* restorePersistentActor(id, persistentMachine);
-		if (Option.isSome(maybeActor)) yield* registerActor(id, maybeActor.value);
-		return maybeActor;
-	});
-	const restore = (id, persistentMachine) => withSpawnGate(restoreImpl(id, persistentMachine));
+	const spawn = (id, machine) => withSpawnGate(spawnRegular(id, machine));
 	const get = Effect.fn("effect-machine.actorSystem.get")(function* (id) {
 		return yield* Effect.sync(() => MutableHashMap.get(actorsMap, id));
 	});
@@ -379,55 +510,8 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		yield* actor.stop;
 		return true;
 	});
-	const listPersisted = Effect.fn("effect-machine.actorSystem.listPersisted")(function* () {
-		const adapter = yield* PersistenceAdapterTag;
-		if (adapter.listActors === void 0) return [];
-		return yield* adapter.listActors();
-	});
-	const restoreMany = Effect.fn("effect-machine.actorSystem.restoreMany")(function* (ids, persistentMachine) {
-		const restored = [];
-		const failed = [];
-		for (const id of ids) {
-			if (MutableHashMap.has(actorsMap, id)) continue;
-			const result = yield* Effect.either(restore(id, persistentMachine));
-			if (result._tag === "Left") failed.push({
-				id,
-				error: result.left
-			});
-			else if (Option.isSome(result.right)) restored.push(result.right.value);
-			else failed.push({
-				id,
-				error: new PersistenceError({
-					operation: "restore",
-					actorId: id,
-					message: "No persisted state found"
-				})
-			});
-		}
-		return {
-			restored,
-			failed
-		};
-	});
-	const restoreAll = Effect.fn("effect-machine.actorSystem.restoreAll")(function* (persistentMachine, options) {
-		const adapter = yield* PersistenceAdapterTag;
-		if (adapter.listActors === void 0) return {
-			restored: [],
-			failed: []
-		};
-		const machineType = persistentMachine.persistence.machineType;
-		if (machineType === void 0) return yield* new PersistenceError({
-			operation: "restoreAll",
-			actorId: "*",
-			message: "restoreAll requires explicit machineType in persistence config"
-		});
-		let filtered = (yield* adapter.listActors()).filter((meta) => meta.machineType === machineType);
-		if (options?.filter !== void 0) filtered = filtered.filter(options.filter);
-		return yield* restoreMany(filtered.map((meta) => meta.id), persistentMachine);
-	});
 	return ActorSystem.of({
 		spawn,
-		restore,
 		get,
 		stop,
 		events: Stream.fromPubSub(eventPubSub),
@@ -443,10 +527,7 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 			return () => {
 				eventListeners.delete(fn);
 			};
-		},
-		listPersisted,
-		restoreMany,
-		restoreAll
+		}
 	});
 });
 /**
@@ -454,4 +535,4 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 */
 const Default = Layer.scoped(ActorSystem, make());
 //#endregion
-export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };
+export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };

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

@@ -5,7 +5,7 @@ import { Layer } from "effect";
 import { Entity } from "@effect/cluster";
 import { Rpc } from "@effect/rpc";
 
-//#region src-v3/cluster/entity-machine.d.ts
+//#region src/cluster/entity-machine.d.ts
 /**
  * Options for EntityMachine.layer
  */

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

@@ -2,7 +2,7 @@ import { processEventCore, runSpawnEffects } from "../internal/transition.js";
 import { ActorSystem } from "../actor.js";
 import { Effect, Option, Queue, Ref, Scope } from "effect";
 import { Entity } from "@effect/cluster";
-//#region src-v3/cluster/entity-machine.ts
+//#region src/cluster/entity-machine.ts
 /**
 * EntityMachine adapter - wires a machine to a cluster Entity layer.
 *
@@ -13,7 +13,7 @@ import { Entity } from "@effect/cluster";
 * Returns the new state after processing.
 */
 const processEvent = Effect.fn("effect-machine.cluster.processEvent")(function* (machine, stateRef, event, self, stateScopeRef, system, hooks) {
-	const result = yield* processEventCore(machine, yield* Ref.get(stateRef), event, self, stateScopeRef, system, hooks);
+	const result = yield* processEventCore(machine, yield* Ref.get(stateRef), event, self, stateScopeRef, system, "*", hooks);
 	if (result.transitioned) yield* Ref.set(stateRef, result.newState);
 	return result.newState;
 });
@@ -54,15 +54,17 @@ const EntityMachine = { layer: (entity, machine, options) => {
 		if (Option.isNone(existingSystem)) return yield* Effect.die("EntityMachine requires ActorSystem in context");
 		const system = existingSystem.value;
 		const internalQueue = yield* Queue.unbounded();
+		const clusterSend = Effect.fn("effect-machine.cluster.self.send")(function* (event) {
+			yield* Queue.offer(internalQueue, event);
+		});
 		const self = {
-			send: Effect.fn("effect-machine.cluster.self.send")(function* (event) {
-				yield* Queue.offer(internalQueue, event);
-			}),
+			send: clusterSend,
+			cast: clusterSend,
 			spawn: (childId, childMachine) => system.spawn(childId, childMachine).pipe(Effect.provideService(ActorSystem, system))
 		};
 		const stateRef = yield* Ref.make(initialState);
 		const stateScopeRef = { current: yield* Scope.make() };
-		yield* runSpawnEffects(machine, initialState, { _tag: "$init" }, self, stateScopeRef.current, system, options?.hooks?.onError);
+		yield* runSpawnEffects(machine, initialState, { _tag: "$init" }, self, stateScopeRef.current, system, entityId, options?.hooks?.onError);
 		const runInternalEvent = Effect.fn("effect-machine.cluster.internalEvent")(function* () {
 			yield* processEvent(machine, stateRef, yield* Queue.take(internalQueue), self, stateScopeRef, system, options?.hooks);
 		});

package/{dist-v3 → v3/dist}/cluster/to-entity.d.ts

@@ -2,7 +2,7 @@ import { Machine } from "../machine.js";
 import { Schema } from "effect";
 import { Rpc } from "@effect/rpc";
 
-//#region src-v3/cluster/to-entity.d.ts
+//#region src/cluster/to-entity.d.ts
 /**
  * Options for toEntity.
  */

package/{dist-v3 → v3/dist}/cluster/to-entity.js

@@ -1,7 +1,7 @@
 import { MissingSchemaError } from "../errors.js";
 import { Entity } from "@effect/cluster";
 import { Rpc } from "@effect/rpc";
-//#region src-v3/cluster/to-entity.ts
+//#region src/cluster/to-entity.ts
 /**
 * Generate Entity definition from a machine.
 *

package/v3/dist/errors.d.ts

@@ -0,0 +1,76 @@
+import { Schema } from "effect";
+
+//#region src/errors.d.ts
+declare const DuplicateActorError_base: Schema.TaggedErrorClass<DuplicateActorError, "DuplicateActorError", {
+  readonly _tag: Schema.tag<"DuplicateActorError">;
+} & {
+  actorId: typeof Schema.String;
+}>;
+/** Attempted to spawn/restore actor with ID already in use */
+declare class DuplicateActorError extends DuplicateActorError_base {}
+declare const UnprovidedSlotsError_base: Schema.TaggedErrorClass<UnprovidedSlotsError, "UnprovidedSlotsError", {
+  readonly _tag: Schema.tag<"UnprovidedSlotsError">;
+} & {
+  slots: Schema.Array$<typeof Schema.String>;
+}>;
+/** Machine has unprovided effect slots */
+declare class UnprovidedSlotsError extends UnprovidedSlotsError_base {}
+declare const MissingSchemaError_base: Schema.TaggedErrorClass<MissingSchemaError, "MissingSchemaError", {
+  readonly _tag: Schema.tag<"MissingSchemaError">;
+} & {
+  operation: typeof Schema.String;
+}>;
+/** Operation requires schemas attached to machine */
+declare class MissingSchemaError extends MissingSchemaError_base {}
+declare const InvalidSchemaError_base: Schema.TaggedErrorClass<InvalidSchemaError, "InvalidSchemaError", {
+  readonly _tag: Schema.tag<"InvalidSchemaError">;
+}>;
+/** State/Event schema has no variants */
+declare class InvalidSchemaError extends InvalidSchemaError_base {}
+declare const MissingMatchHandlerError_base: Schema.TaggedErrorClass<MissingMatchHandlerError, "MissingMatchHandlerError", {
+  readonly _tag: Schema.tag<"MissingMatchHandlerError">;
+} & {
+  tag: typeof Schema.String;
+}>;
+/** $match called with missing handler for tag */
+declare class MissingMatchHandlerError extends MissingMatchHandlerError_base {}
+declare const SlotProvisionError_base: Schema.TaggedErrorClass<SlotProvisionError, "SlotProvisionError", {
+  readonly _tag: Schema.tag<"SlotProvisionError">;
+} & {
+  slotName: typeof Schema.String;
+  slotType: Schema.Literal<["guard", "effect"]>;
+}>;
+/** Slot handler not found at runtime (internal error) */
+declare class SlotProvisionError extends SlotProvisionError_base {}
+declare const ProvisionValidationError_base: Schema.TaggedErrorClass<ProvisionValidationError, "ProvisionValidationError", {
+  readonly _tag: Schema.tag<"ProvisionValidationError">;
+} & {
+  missing: Schema.Array$<typeof Schema.String>;
+  extra: Schema.Array$<typeof Schema.String>;
+}>;
+/** Machine.build() validation failed - missing or extra handlers */
+declare class ProvisionValidationError extends ProvisionValidationError_base {}
+declare const AssertionError_base: Schema.TaggedErrorClass<AssertionError, "AssertionError", {
+  readonly _tag: Schema.tag<"AssertionError">;
+} & {
+  message: typeof Schema.String;
+}>;
+/** Assertion failed in testing utilities */
+declare class AssertionError extends AssertionError_base {}
+declare const ActorStoppedError_base: Schema.TaggedErrorClass<ActorStoppedError, "ActorStoppedError", {
+  readonly _tag: Schema.tag<"ActorStoppedError">;
+} & {
+  actorId: typeof Schema.String;
+}>;
+/** Actor was stopped while a call/ask was pending */
+declare class ActorStoppedError extends ActorStoppedError_base {}
+declare const NoReplyError_base: Schema.TaggedErrorClass<NoReplyError, "NoReplyError", {
+  readonly _tag: Schema.tag<"NoReplyError">;
+} & {
+  actorId: typeof Schema.String;
+  eventTag: typeof Schema.String;
+}>;
+/** ask() was used but the transition handler did not call reply */
+declare class NoReplyError extends NoReplyError_base {}
+//#endregion
+export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };

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

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-//#region src-v3/errors.ts
+//#region src/errors.ts
 /**
 * Typed error classes for effect-machine.
 *
@@ -32,5 +32,12 @@ var ProvisionValidationError = class extends Schema.TaggedError()("ProvisionVali
 }) {};
 /** Assertion failed in testing utilities */
 var AssertionError = class extends Schema.TaggedError()("AssertionError", { message: Schema.String }) {};
+/** Actor was stopped while a call/ask was pending */
+var ActorStoppedError = class extends Schema.TaggedError()("ActorStoppedError", { actorId: Schema.String }) {};
+/** ask() was used but the transition handler did not call reply */
+var NoReplyError = class extends Schema.TaggedError()("NoReplyError", {
+	actorId: Schema.String,
+	eventTag: Schema.String
+}) {};
 //#endregion
-export { AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };
+export { ActorStoppedError, AssertionError, DuplicateActorError, InvalidSchemaError, MissingMatchHandlerError, MissingSchemaError, NoReplyError, ProvisionValidationError, SlotProvisionError, UnprovidedSlotsError };