effect-machine 0.17.1 → 0.19.0

package/dist/actor.js

@@ -1,10 +1,9 @@
 import { ActorStoppedError, DuplicateActorError } from "./errors.js";
-import { processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
-import { emitWithTimestamp } from "./internal/inspection.js";
+import { resolveTransition } from "./internal/transition.js";
+import { emitWithTimestamp, makeInspectionHooks } from "./internal/inspection.js";
 import { Inspector } from "./inspection.js";
-import { materializeMachine } from "./machine.js";
 import { createRuntime } from "./internal/runtime.js";
-import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Schedule, Scope, Semaphore, Stream, SubscriptionRef } from "effect";
+import { Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Schedule, Scope, Semaphore, Stream, SubscriptionRef } from "effect";
 //#region src/actor.ts
 /**
 * Actor system: spawning, lifecycle, and event processing.
@@ -39,43 +38,19 @@ const notifyListeners = (listeners, state) => {
 /**
 * Build core ActorRef methods.
 */
-const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, listeners, stop, start, system, childrenMap, pendingReplies, transitionsPubSub, exitDeferred) => {
-	const send = Effect.fn("effect-machine.actor.send")(function* (event) {
-		if (yield* Ref.get(stoppedRef)) return;
-		const q = yield* Ref.get(eventQueueRef);
-		yield* Queue.offer(q, {
-			_tag: "send",
-			event
-		});
+const buildActorRefCore = (cell, stop, start) => {
+	const { id, machine, stateRef, runtimeRef, listeners, system } = cell;
+	const send = (event) => Effect.gen(function* () {
+		const runtime = runtimeRef.current;
+		if (runtime !== void 0) yield* runtime.send(event);
 	});
-	const call = Effect.fn("effect-machine.actor.call")(function* (event) {
-		if (yield* Ref.get(stoppedRef)) {
-			yield* Effect.logWarning("effect-machine.actor.call.stopped").pipe(Effect.annotateLogs({
-				actorId: id,
-				eventTag: event._tag
-			}));
-			const currentState = yield* SubscriptionRef.get(stateRef);
-			return {
-				newState: currentState,
-				previousState: currentState,
-				transitioned: false,
-				hasReply: false,
-				deferReply: false,
-				reply: void 0,
-				postponed: false,
-				lifecycleRan: false,
-				isFinal: machine.finalStates.has(currentState._tag)
-			};
-		}
-		const reply = yield* Deferred.make();
-		pendingReplies.add(reply);
-		const q = yield* Ref.get(eventQueueRef);
-		yield* Queue.offer(q, {
-			_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) => ({
+	const stoppedCall = (event) => Effect.gen(function* () {
+		yield* Effect.logWarning("effect-machine.actor.call.stopped").pipe(Effect.annotateLogs({
+			actorId: id,
+			eventTag: event._tag
+		}));
+		const currentState = yield* SubscriptionRef.get(stateRef);
+		return {
 			newState: currentState,
 			previousState: currentState,
 			transitioned: false,
@@ -84,30 +59,31 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 			reply: void 0,
 			postponed: false,
 			lifecycleRan: false,
-			isFinal: machine.finalStates.has(currentState._tag)
-		})))));
+			isFinal: machine._isFinal(currentState._tag)
+		};
+	});
+	const call = (event) => Effect.suspend(() => {
+		const runtime = runtimeRef.current;
+		if (runtime === void 0) return stoppedCall(event);
+		return runtime.call(event).pipe(Effect.catch(() => stoppedCall(event)));
 	});
 	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);
-		const q = yield* Ref.get(eventQueueRef);
-		yield* Queue.offer(q, {
-			_tag: "ask",
-			event,
-			reply
-		});
-		return yield* Deferred.await(reply).pipe(Effect.ensuring(Effect.sync(() => pendingReplies.delete(reply))));
+		const runtime = runtimeRef.current;
+		if (runtime === void 0) return yield* ActorStoppedError.make({ actorId: id });
+		return yield* runtime.ask(event);
 	});
 	const snapshot = SubscriptionRef.get(stateRef).pipe(Effect.withSpan("effect-machine.actor.snapshot"));
 	const matches = Effect.fn("effect-machine.actor.matches")(function* (tag) {
 		return (yield* SubscriptionRef.get(stateRef))._tag === tag;
 	});
 	const can = Effect.fn("effect-machine.actor.can")(function* (event) {
-		return resolveTransition(machine, yield* SubscriptionRef.get(stateRef), event) !== void 0;
+		const state = yield* SubscriptionRef.get(stateRef);
+		return resolveTransition(machine, state, event) !== void 0;
 	});
 	const waitFor = Effect.fn("effect-machine.actor.waitFor")(function* (predicateOrState) {
-		const predicate = typeof predicateOrState === "function" && !("_tag" in predicateOrState) ? predicateOrState : (s) => s._tag === predicateOrState._tag;
+		let predicate;
+		if (typeof predicateOrState === "function" && !("_tag" in predicateOrState)) predicate = predicateOrState;
+		else predicate = (s) => s._tag === predicateOrState._tag;
 		const current = yield* SubscriptionRef.get(stateRef);
 		if (predicate(current)) return current;
 		const done = yield* Deferred.make();
@@ -124,16 +100,16 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 		listeners.delete(listener);
 		return result;
 	});
-	const awaitFinal = waitFor((state) => machine.finalStates.has(state._tag)).pipe(Effect.withSpan("effect-machine.actor.awaitFinal"));
+	const awaitFinal = waitFor((state) => machine._isFinal(state._tag)).pipe(Effect.withSpan("effect-machine.actor.awaitFinal"));
 	const sendAndWait = Effect.fn("effect-machine.actor.sendAndWait")(function* (event, predicateOrState) {
 		yield* send(event);
 		if (predicateOrState !== void 0) return yield* waitFor(predicateOrState);
 		return yield* awaitFinal;
 	});
+	const transitions = Stream.fromPubSub(cell.transitions);
 	return {
 		id,
 		send,
-		cast: send,
 		call,
 		ask,
 		state: stateRef,
@@ -143,7 +119,7 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 		matches,
 		can,
 		changes: SubscriptionRef.changes(stateRef),
-		transitions: transitionsPubSub !== void 0 ? Stream.fromPubSub(transitionsPubSub) : Stream.empty,
+		transitions,
 		waitFor,
 		awaitFinal,
 		sendAndWait,
@@ -153,66 +129,24 @@ const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, lis
 				listeners.delete(fn);
 			};
 		},
-		awaitExit: Deferred.await(exitDeferred),
-		watch: (other) => other.awaitExit,
-		drain: Effect.gen(function* () {
-			if (yield* Ref.get(stoppedRef)) return;
-			const q = yield* Ref.get(eventQueueRef);
-			const done = yield* Deferred.make();
-			yield* Queue.offer(q, {
-				_tag: "drain",
-				done
-			});
-			yield* Deferred.await(done);
-		}).pipe(Effect.asVoid),
+		awaitExit: Deferred.await(cell.terminalExitDeferred),
+		drain: Effect.suspend(() => runtimeRef.current?.drain ?? Effect.void),
 		sync: {
 			send: (event) => {
-				if (!Effect.runSync(Ref.get(stoppedRef))) {
-					const q = Effect.runSync(Ref.get(eventQueueRef));
-					Effect.runSync(Queue.offer(q, {
-						_tag: "send",
-						event
-					}));
-				}
+				runtimeRef.current?.sendSync(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;
+				const state = Effect.runSync(SubscriptionRef.get(stateRef));
+				return resolveTransition(machine, state, event) !== void 0;
 			}
 		},
 		system,
-		children: childrenMap
+		children: cell.children
 	};
 };
-/** Build ProcessEventHooks from an inspector */
-const buildInspectionHooks = (actorId, inspector) => ({
-	onSpawnEffect: (state) => emitWithTimestamp(inspector, (timestamp) => ({
-		type: "@machine.effect",
-		actorId,
-		effectType: "spawn",
-		state,
-		timestamp
-	})),
-	onTransition: (from, to, ev) => emitWithTimestamp(inspector, (timestamp) => ({
-		type: "@machine.transition",
-		actorId,
-		fromState: from,
-		toState: to,
-		event: ev,
-		timestamp
-	})),
-	onError: (info) => emitWithTimestamp(inspector, (timestamp) => ({
-		type: "@machine.error",
-		actorId,
-		phase: info.phase,
-		state: info.state,
-		event: info.event,
-		error: Cause.pretty(info.cause),
-		timestamp
-	}))
-});
 /**
 * Resolve actor system from context, creating an implicit one if none exists.
 * @internal
@@ -234,50 +168,48 @@ const resolveActorSystem = Effect.fn("effect-machine.resolveActorSystem")(functi
 * Observes exit deferred, applies restart policy, resets cell resources on restart.
 * @internal
 */
-const runSupervisionLoop = (params) => Effect.gen(function* () {
-	const step = yield* Schedule.toStepWithSleep(params.supervision.schedule);
+const runSupervisionLoop = (cell, options) => Effect.gen(function* () {
+	const step = yield* Schedule.toStepWithSleep(options.supervision.schedule);
 	while (true) {
-		const currentRuntime = params.runtimeRef.current;
+		const currentRuntime = cell.runtimeRef.current;
 		if (currentRuntime === void 0) return;
 		const generationExit = yield* Deferred.await(currentRuntime.exitDeferred);
 		if (generationExit._tag !== "Defect") {
-			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+			yield* Deferred.succeed(cell.terminalExitDeferred, generationExit);
 			return;
 		}
-		if (params.supervision.shouldRestart !== void 0 && !params.supervision.shouldRestart(generationExit)) {
-			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+		if (options.supervision.shouldRestart !== void 0 && !options.supervision.shouldRestart(generationExit)) {
+			yield* Deferred.succeed(cell.terminalExitDeferred, generationExit);
 			return;
 		}
 		if ((yield* step(generationExit).pipe(Effect.exit))._tag === "Failure") {
-			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+			yield* Deferred.succeed(cell.terminalExitDeferred, generationExit);
 			return;
 		}
-		const nextGeneration = params.generationRef.get() + 1;
-		params.generationRef.set(nextGeneration);
-		let restartState = params.machine.initial;
-		if (params.lifecycle?.recovery !== void 0) {
-			const resolved = yield* params.lifecycle.recovery.resolve({
-				actorId: params.id,
+		const nextGeneration = cell.generation.current + 1;
+		cell.generation.current = nextGeneration;
+		let restartState = cell.machine.initial;
+		if (options.lifecycle?.recovery !== void 0) {
+			const resolved = yield* options.lifecycle.recovery.resolve({
+				actorId: cell.id,
 				generation: nextGeneration,
-				machineInitial: params.machine.initial
+				machineInitial: cell.machine.initial
 			});
 			if (Option.isSome(resolved)) restartState = resolved.value;
 		}
-		yield* settlePendingReplies(params.pendingReplies, params.id);
+		yield* currentRuntime.settlePendingRequests;
 		const freshQueue = yield* Queue.unbounded();
-		yield* Ref.set(params.eventQueueRef, freshQueue);
-		yield* SubscriptionRef.set(params.stateRef, restartState);
-		yield* Ref.set(params.stoppedRef, false);
-		params.childrenMap.clear();
-		const machineForRestart = restartState !== params.machine.initial ? Object.create(params.machine, { initial: {
-			value: restartState,
-			enumerable: true
-		} }) : params.machine;
-		const newRuntime = yield* params.spawnGeneration(machineForRestart);
-		params.runtimeRef.current = newRuntime;
+		yield* Ref.set(cell.eventQueueRef, freshQueue);
+		yield* SubscriptionRef.set(cell.stateRef, restartState);
+		yield* Ref.set(cell.stoppedRef, false);
+		cell.children.clear();
+		let machineForRestart = cell.machine;
+		if (restartState !== cell.machine.initial) machineForRestart = cell.machine._withInitial(restartState);
+		const newRuntime = yield* options.spawnGeneration(machineForRestart);
+		cell.runtimeRef.current = newRuntime;
 		yield* newRuntime.start;
-		if (params.onRestart !== void 0) yield* params.onRestart(nextGeneration, generationExit);
-		notifyListeners(params.listeners, restartState);
+		if (options.onRestart !== void 0) yield* options.onRestart(nextGeneration, generationExit);
+		notifyListeners(cell.listeners, restartState);
 	}
 });
 /**
@@ -286,72 +218,95 @@ const runSupervisionLoop = (params) => Effect.gen(function* () {
 */
 const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine, options) {
 	const lifecycle = options?.lifecycle;
+	const serviceContext = yield* Effect.context();
 	const initial = options?.initialState ?? machine.initial;
 	yield* Effect.annotateCurrentSpan("effect_machine.actor.id", id);
 	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", initial._tag);
 	const { system, implicitSystemScope } = yield* resolveActorSystem();
 	const inspectorValue = Option.getOrUndefined(yield* Effect.serviceOption(Inspector));
 	const childrenMap = /* @__PURE__ */ new Map();
-	const pendingReplies = /* @__PURE__ */ new Set();
 	const listeners = /* @__PURE__ */ new Set();
 	const transitionsPubSub = yield* PubSub.unbounded();
-	const hooks = inspectorValue !== void 0 ? buildInspectionHooks(id, inspectorValue) : void 0;
-	const machineWithState = initial !== machine.initial ? Object.create(machine, { initial: {
-		value: initial,
-		enumerable: true
-	} }) : machine;
+	let hooks = void 0;
+	if (inspectorValue !== void 0) hooks = makeInspectionHooks(id, inspectorValue);
+	let machineWithState = machine;
+	if (initial !== machine.initial) machineWithState = machine._withInitial(initial);
 	const stateRef = yield* SubscriptionRef.make(initial);
 	const stoppedRef = yield* Ref.make(false);
 	const initialQueue = yield* Queue.unbounded();
 	const eventQueueRef = yield* Ref.make(initialQueue);
 	const terminalExitDeferred = yield* Deferred.make();
 	let stopEmitted = false;
-	let generation = 0;
+	const generation = { current: 0 };
 	const runtimeRef = { current: void 0 };
 	const supervisorFiberRef = { current: void 0 };
+	const cell = {
+		id,
+		machine,
+		stateRef,
+		stoppedRef,
+		eventQueueRef,
+		runtimeRef,
+		terminalExitDeferred,
+		listeners,
+		children: childrenMap,
+		transitions: transitionsPubSub,
+		system,
+		generation
+	};
 	/** Build lifecycle hooks for a generation */
 	const buildRuntimeLifecycle = () => {
 		stopEmitted = false;
-		return {
-			onEvent: inspectorValue !== void 0 ? (state, event) => emitWithTimestamp(inspectorValue, (timestamp) => ({
-				type: "@machine.event",
+		let onEvent = void 0;
+		if (inspectorValue !== void 0) onEvent = (state, event) => emitWithTimestamp(inspectorValue, (timestamp) => ({
+			type: "@machine.event",
+			actorId: id,
+			state,
+			event,
+			timestamp
+		}));
+		let onFinal = void 0;
+		if (inspectorValue !== void 0) onFinal = (state) => Effect.gen(function* () {
+			stopEmitted = true;
+			yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
+				type: "@machine.stop",
 				actorId: id,
-				state,
-				event,
+				finalState: state,
 				timestamp
-			})) : void 0,
-			onStateChange: (result, event) => Effect.gen(function* () {
+			}));
+		});
+		let onInitialSpawnEffects = void 0;
+		if (inspectorValue !== void 0) onInitialSpawnEffects = (state) => emitWithTimestamp(inspectorValue, (timestamp) => ({
+			type: "@machine.effect",
+			actorId: id,
+			effectType: "spawn",
+			state,
+			timestamp
+		}));
+		return {
+			onEvent,
+			onStateChange: (result, event) => {
 				notifyListeners(listeners, result.newState);
-				if (lifecycle?.durability !== void 0 && result.transitioned) {
-					const durability = lifecycle.durability;
-					if (durability.shouldSave === void 0 || durability.shouldSave(result.newState, result.previousState)) yield* durability.save({
-						actorId: id,
-						generation,
-						previousState: result.previousState,
-						nextState: result.newState,
-						event
-					});
-				}
-				yield* Effect.annotateCurrentSpan("effect_machine.transition.matched", true);
-				if (result.lifecycleRan) {
-					yield* Effect.annotateCurrentSpan("effect_machine.state.from", result.previousState._tag);
-					yield* Effect.annotateCurrentSpan("effect_machine.state.to", result.newState._tag);
-				}
-			}),
-			onProcessed: (result, event) => result.transitioned ? PubSub.publish(transitionsPubSub, {
-				fromState: result.previousState,
-				toState: result.newState,
-				event
-			}).pipe(Effect.asVoid) : Effect.void,
-			onFinal: inspectorValue !== void 0 ? (state) => Effect.gen(function* () {
-				stopEmitted = true;
-				yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
-					type: "@machine.stop",
+				const durability = lifecycle?.durability;
+				if (durability === void 0 || !result.transitioned) return;
+				if (!(durability.shouldSave === void 0 || durability.shouldSave(result.newState, result.previousState))) return;
+				return durability.save({
 					actorId: id,
-					finalState: state,
-					timestamp
-				}));
-			}) : void 0,
+					generation: generation.current,
+					previousState: result.previousState,
+					nextState: result.newState,
+					event
+				});
+			},
+			onProcessed: (result, event) => {
+				if (!result.transitioned || transitionsPubSub.subscribers.size === 0) return;
+				return PubSub.publish(transitionsPubSub, {
+					fromState: result.previousState,
+					toState: result.newState,
+					event
+				}).pipe(Effect.asVoid);
+			},
+			onFinal,
 			onShutdown: () => Effect.gen(function* () {
 				if (!stopEmitted) {
 					const finalState = yield* SubscriptionRef.get(stateRef);
@@ -362,15 +317,8 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 						timestamp
 					}));
 				}
-				yield* settlePendingReplies(pendingReplies, id);
 			}),
-			onInitialSpawnEffects: inspectorValue !== void 0 ? (state) => emitWithTimestamp(inspectorValue, (timestamp) => ({
-				type: "@machine.effect",
-				actorId: id,
-				effectType: "spawn",
-				state,
-				timestamp
-			})) : void 0
+			onInitialSpawnEffects
 		};
 	};
 	/** Create a single runtime generation. machineForGen is machineWithState for initial, machine for restarts. */
@@ -384,11 +332,6 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 			eventQueue: currentQueue
 		},
 		lifecycle: buildRuntimeLifecycle(),
-		wrapProcess: (state, event, inner) => Effect.withSpan("effect-machine.event.process", { attributes: {
-			"effect_machine.actor.id": id,
-			"effect_machine.state.current": state._tag,
-			"effect_machine.event.type": event._tag
-		} })(inner.pipe(Effect.tap((r) => Effect.annotateCurrentSpan("effect_machine.transition.matched", r.result.transitioned)))),
 		onChildSpawned: (childId, child) => Effect.gen(function* () {
 			childrenMap.set(childId, child);
 			const maybeScope = yield* Effect.serviceOption(Scope.Scope);
@@ -399,27 +342,26 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 	})));
 	runtimeRef.current = yield* spawnGeneration(machineWithState);
 	const supervision = options?.supervision;
-	const stop = Effect.gen(function* () {
+	const stop = Effect.fn("effect-machine.actor.stop")(function* () {
 		if (supervisorFiberRef.current !== void 0) yield* Fiber.interrupt(supervisorFiberRef.current);
 		const currentRuntime = runtimeRef.current;
 		if (currentRuntime !== void 0) yield* currentRuntime.stop;
 		yield* Deferred.succeed(terminalExitDeferred, { _tag: "Stopped" });
 		if (implicitSystemScope !== void 0) yield* Scope.close(implicitSystemScope, Exit.void);
-	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid);
+	})().pipe(Effect.provide(serviceContext), Effect.asVoid);
 	const isHydrated = options?.initialState !== void 0;
-	return buildActorRefCore(id, machine, stateRef, eventQueueRef, stoppedRef, listeners, stop, Effect.gen(function* () {
+	const start = Effect.fn("effect-machine.actor.start")(function* () {
 		if (lifecycle?.recovery !== void 0 && !isHydrated) {
 			const resolved = yield* lifecycle.recovery.resolve({
 				actorId: id,
-				generation,
+				generation: generation.current,
 				machineInitial: machine.initial
 			});
 			if (Option.isSome(resolved)) {
 				yield* SubscriptionRef.set(stateRef, resolved.value);
-				runtimeRef.current = yield* spawnGeneration(Object.create(machine, { initial: {
-					value: resolved.value,
-					enumerable: true
-				} }));
+				const recoveredMachine = machine._withInitial(resolved.value);
+				const newRuntime = yield* spawnGeneration(recoveredMachine);
+				runtimeRef.current = newRuntime;
 			}
 		}
 		const currentState = yield* SubscriptionRef.get(stateRef);
@@ -429,26 +371,10 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 			initialState: currentState,
 			timestamp
 		}));
-		if (supervision !== void 0) supervisorFiberRef.current = yield* Effect.forkDetach(runSupervisionLoop({
+		if (supervision !== void 0) supervisorFiberRef.current = yield* Effect.forkDetach(runSupervisionLoop(cell, {
 			supervision,
-			machine,
-			id,
-			runtimeRef,
-			terminalExitDeferred,
-			pendingReplies,
-			eventQueueRef,
-			stateRef,
-			stoppedRef,
-			childrenMap,
-			listeners,
 			spawnGeneration,
 			lifecycle,
-			generationRef: {
-				get: () => generation,
-				set: (g) => {
-					generation = g;
-				}
-			},
 			onRestart: options?.onRestart
 		}));
 		else {
@@ -457,13 +383,8 @@ const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machi
 		}
 		const currentRuntime = runtimeRef.current;
 		if (currentRuntime !== void 0) yield* currentRuntime.start;
-	}).pipe(Effect.withSpan("effect-machine.actor.start"), Effect.asVoid), system, childrenMap, pendingReplies, transitionsPubSub, terminalExitDeferred);
-});
-/** 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();
+	})().pipe(Effect.provide(serviceContext), Effect.asVoid);
+	return buildActorRefCore(cell, stop, start);
 });
 /** Notify all system event listeners (sync). */
 const notifySystemListeners = (listeners, event) => {
@@ -482,13 +403,13 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		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).pipe(Effect.andThen(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) {
 		if (MutableHashMap.has(actorsMap, id)) {
 			yield* actor.stop;
-			return yield* new DuplicateActorError({ actorId: id });
+			return yield* DuplicateActorError.make({ actorId: id });
 		}
 		const actorRef = actor;
 		MutableHashMap.set(actorsMap, id, actorRef);
@@ -513,19 +434,24 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		return actor;
 	});
 	const spawnRegular = Effect.fn("effect-machine.actorSystem.spawnRegular")(function* (id, machine, spawnOptions) {
-		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
-		const materialized = spawnOptions?.slots !== void 0 ? materializeMachine(machine, spawnOptions.slots) : machine;
+		if (MutableHashMap.has(actorsMap, id)) return yield* DuplicateActorError.make({ actorId: id });
 		let actorRef;
-		const actor = yield* createActor(id, materialized, {
-			supervision: spawnOptions?.supervision,
-			lifecycle: spawnOptions?.lifecycle,
-			onRestart: spawnOptions?.supervision !== void 0 ? (generation, exit) => actorRef !== void 0 ? emitSystemEvent({
+		let onRestart = void 0;
+		if (spawnOptions?.supervision !== void 0) onRestart = (generation, exit) => {
+			const currentActor = actorRef;
+			if (currentActor === void 0) return Effect.void;
+			return emitSystemEvent({
 				_tag: "ActorRestarted",
 				id,
-				actor: actorRef,
+				actor: currentActor,
 				generation,
 				exit
-			}) : Effect.void : void 0
+			});
+		};
+		const actor = yield* createActor(id, machine, {
+			supervision: spawnOptions?.supervision,
+			lifecycle: spawnOptions?.lifecycle,
+			onRestart
 		});
 		actorRef = actor;
 		yield* registerActor(id, actor);
@@ -580,4 +506,4 @@ const makeSystem = make;
 */
 const Default = Layer.effect(ActorSystem, make());
 //#endregion
-export { ActorScope, ActorSystem, Default, buildActorRefCore, createActor, makeSystem, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };
+export { ActorScope, ActorSystem, Default, createActor, makeSystem };

package/dist/atom.d.ts

@@ -0,0 +1,31 @@
+import { ActorRef } from "./actor.js";
+import * as Atom from "effect/unstable/reactivity/Atom";
+//#region src/atom.d.ts
+/**
+ * A writable Atom projection of an actor.
+ *
+ * The Atom value is the current actor state. Atom writes send actor events.
+ */
+type ActorAtom<State, Event> = Atom.Writable<State, Event>;
+/**
+ * Make a writable Atom from an actor.
+ *
+ * The actor stays the single state owner. The Atom follows recovery,
+ * supervision restarts, and normal transitions through the actor's
+ * SubscriptionRef.
+ */
+declare const make: <State extends {
+  readonly _tag: string;
+}, Event>(actor: ActorRef<State, Event>) => ActorAtom<State, Event>;
+/**
+ * Select part of an actor state.
+ *
+ * The selected Atom stays writable. Writes still send events to the actor.
+ * The equality function controls when Atom subscribers receive a new value.
+ */
+declare const select: {
+  <State, Selection>(selector: (state: State) => Selection, equals?: (value: Selection, next: Selection) => boolean): <Event>(self: ActorAtom<State, Event>) => ActorAtom<Selection, Event>;
+  <State, Event, Selection>(self: ActorAtom<State, Event>, selector: (state: State) => Selection, equals?: (value: Selection, next: Selection) => boolean): ActorAtom<Selection, Event>;
+};
+//#endregion
+export { ActorAtom, make, select };

package/dist/atom.js

@@ -0,0 +1,29 @@
+import { dual } from "effect/Function";
+import * as Atom from "effect/unstable/reactivity/Atom";
+//#region src/atom.ts
+/**
+* Effect Atom integration for actors.
+*
+* The adapter keeps the actor as the state owner. Atom registries observe the
+* actor's SubscriptionRef and write events through its synchronous boundary.
+*/
+/**
+* Make a writable Atom from an actor.
+*
+* The actor stays the single state owner. The Atom follows recovery,
+* supervision restarts, and normal transitions through the actor's
+* SubscriptionRef.
+*/
+const make = (actor) => {
+	const state = Atom.subscriptionRef(actor.state);
+	return Atom.writable((get) => get(state), (_ctx, event) => actor.sync.send(event));
+};
+/**
+* Select part of an actor state.
+*
+* The selected Atom stays writable. Writes still send events to the actor.
+* The equality function controls when Atom subscribers receive a new value.
+*/
+const select = dual((args) => Atom.isAtom(args[0]), (self, selector, equals = Object.is) => Atom.withEquality(Atom.map(self, selector), equals));
+//#endregion
+export { make, select };

package/dist/cluster/adapters/in-memory.d.ts

@@ -1,6 +1,5 @@
 import { PersistedEvent, PersistenceAdapter, PersistenceAdapterService, Snapshot } from "../persistence.js";
 import { Effect, Layer, Ref } from "effect";
-
 //#region src/cluster/adapters/in-memory.d.ts
 interface EntityStore {
   snapshot: Snapshot<unknown> | undefined;