effect-machine 0.12.0 → 0.14.0

package/dist/actor.js

@@ -1,9 +1,10 @@
-import { Inspector } from "./inspection.js";
-import { INTERNAL_INIT_EVENT } from "./internal/utils.js";
-import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.js";
+import { ActorStoppedError, DuplicateActorError } from "./errors.js";
+import { processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
 import { emitWithTimestamp } from "./internal/inspection.js";
-import { processEventCore, resolveTransition, runSpawnEffects, shouldPostpone } from "./internal/transition.js";
-import { Cause, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Schema, Scope, Semaphore, ServiceMap, Stream, SubscriptionRef } from "effect";
+import { Inspector } from "./inspection.js";
+import { materializeMachine } from "./machine.js";
+import { createRuntime } from "./internal/runtime.js";
+import { Cause, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, PubSub, Queue, Ref, Schedule, Scope, Semaphore, ServiceMap, Stream, SubscriptionRef } from "effect";
 //#region src/actor.ts
 /**
 * Actor system: spawning, lifecycle, and event processing.
@@ -28,10 +29,11 @@ const notifyListeners = (listeners, state) => {
 /**
 * Build core ActorRef methods.
 */
-const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listeners, stop, system, childrenMap, pendingReplies, transitionsPubSub) => {
+const buildActorRefCore = (id, machine, stateRef, eventQueueRef, stoppedRef, listeners, stop, system, childrenMap, pendingReplies, transitionsPubSub, exitDeferred) => {
 	const send = Effect.fn("effect-machine.actor.send")(function* (event) {
 		if (yield* Ref.get(stoppedRef)) return;
-		yield* Queue.offer(eventQueue, {
+		const q = yield* Ref.get(eventQueueRef);
+		yield* Queue.offer(q, {
 			_tag: "send",
 			event
 		});
@@ -49,7 +51,8 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 		}
 		const reply = yield* Deferred.make();
 		pendingReplies.add(reply);
-		yield* Queue.offer(eventQueue, {
+		const q = yield* Ref.get(eventQueueRef);
+		yield* Queue.offer(q, {
 			_tag: "call",
 			event,
 			reply
@@ -66,7 +69,8 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 		if (yield* Ref.get(stoppedRef)) return yield* new ActorStoppedError({ actorId: id });
 		const reply = yield* Deferred.make();
 		pendingReplies.add(reply);
-		yield* Queue.offer(eventQueue, {
+		const q = yield* Ref.get(eventQueueRef);
+		yield* Queue.offer(q, {
 			_tag: "ask",
 			event,
 			reply
@@ -126,12 +130,27 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 				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),
 		sync: {
 			send: (event) => {
-				if (!Effect.runSync(Ref.get(stoppedRef))) Effect.runSync(Queue.offer(eventQueue, {
-					_tag: "send",
-					event
-				}));
+				if (!Effect.runSync(Ref.get(stoppedRef))) {
+					const q = Effect.runSync(Ref.get(eventQueueRef));
+					Effect.runSync(Queue.offer(q, {
+						_tag: "send",
+						event
+					}));
+				}
 			},
 			stop: () => Effect.runFork(stop),
 			snapshot: () => Effect.runSync(SubscriptionRef.get(stateRef)),
@@ -144,325 +163,251 @@ const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listen
 		children: childrenMap
 	};
 };
+/** 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
+	}))
+});
 /**
-* Create and start an actor for a machine
+* Load persisted state and run onRestore hook if present.
+* Returns the resolved initial state (loaded, restored, or fallback to machineInitial).
+* @internal
 */
-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 loadAndRestore = (persist, machineInitial) => Effect.gen(function* () {
+	const loaded = yield* persist.load();
+	if (Option.isNone(loaded)) return machineInitial;
+	if (persist.onRestore === void 0) return loaded.value;
+	const restored = yield* persist.onRestore(loaded.value, { initial: machineInitial });
+	return Option.getOrElse(restored, () => machineInitial);
+});
+/**
+* Resolve actor system from context, creating an implicit one if none exists.
+* @internal
+*/
+const resolveActorSystem = Effect.fn("effect-machine.resolveActorSystem")(function* () {
 	const existingSystem = yield* Effect.serviceOption(ActorSystem);
-	let system;
-	let implicitSystemScope;
-	if (Option.isSome(existingSystem)) system = existingSystem.value;
-	else {
-		const scope = yield* Scope.make();
-		system = yield* make().pipe(Effect.provideService(Scope.Scope, scope));
-		implicitSystemScope = scope;
-	}
-	const inspectorValue = Option.getOrUndefined(yield* Effect.serviceOption(Inspector));
-	const eventQueue = yield* Queue.unbounded();
-	const stoppedRef = yield* Ref.make(false);
-	const childrenMap = /* @__PURE__ */ new Map();
-	const deferredReplyRef = { current: void 0 };
-	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: 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);
-			const maybeScope = yield* Effect.serviceOption(Scope.Scope);
-			if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.sync(() => {
-				childrenMap.delete(childId);
-			}));
-			return child;
-		}),
-		reply: (value) => Effect.sync(() => {
-			const deferred = deferredReplyRef.current;
-			if (deferred !== void 0) {
-				deferredReplyRef.current = void 0;
-				Effect.runFork(Deferred.succeed(deferred, value));
-				return true;
-			}
-			return false;
-		})
+	if (Option.isSome(existingSystem)) return {
+		system: existingSystem.value,
+		implicitSystemScope: void 0
 	};
-	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", initial._tag);
-	yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
-		type: "@machine.spawn",
-		actorId: id,
-		initialState: initial,
-		timestamp
-	}));
-	const stateRef = yield* SubscriptionRef.make(initial);
-	const listeners = /* @__PURE__ */ new Set();
-	const backgroundFibers = [];
-	const initEvent = { _tag: INTERNAL_INIT_EVENT };
-	const ctx = {
-		actorId: id,
-		state: initial,
-		event: initEvent,
-		self,
-		system
+	const scope = yield* Scope.make();
+	return {
+		system: yield* make().pipe(Effect.provideService(Scope.Scope, scope)),
+		implicitSystemScope: scope
 	};
-	const { effects: effectSlots } = machine._slots;
-	for (const bg of machine.backgroundEffects) {
-		const fiber = yield* Effect.forkDetach(bg.handler({
-			actorId: id,
-			state: initial,
-			event: initEvent,
-			self,
-			effects: effectSlots,
-			system
-		}).pipe(Effect.provideService(machine.Context, ctx)));
-		backgroundFibers.push(fiber);
-	}
-	const stateScopeRef = { current: yield* Scope.make() };
-	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: 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, /* @__PURE__ */ new Set());
-	}
-	const pendingReplies = /* @__PURE__ */ new Set();
-	const transitionsPubSub = yield* PubSub.unbounded();
-	const loopFiber = yield* Effect.forkDetach(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue, system, pendingReplies, transitionsPubSub, deferredReplyRef));
-	return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
-		const finalState = yield* SubscriptionRef.get(stateRef);
-		yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
-			type: "@machine.stop",
-			actorId: id,
-			finalState,
-			timestamp
-		}));
-		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, 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.
-* Includes postpone buffer — events matching postpone rules are buffered
-* and drained after state tag changes (gen_statem semantics).
+* Run the supervision loop for a supervised actor.
+* Observes exit deferred, applies restart policy, resets cell resources on restart.
+* @internal
 */
-const eventLoop = Effect.fn("effect-machine.actor.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, actorId, inspector, system, pendingReplies, transitionsPubSub, deferredReplyRef) {
-	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 (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,
-					deferReply: 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));
-		switch (queued._tag) {
-			case "call":
-				yield* Deferred.succeed(queued.reply, result);
-				break;
-			case "ask":
-				if (result.hasReply) {
-					const replySchema = machine._replySchemas?.get(event._tag);
-					if (replySchema !== void 0) {
-						let decoded;
-						try {
-							decoded = Schema.decodeUnknownSync(replySchema)(result.reply);
-						} catch (decodeError) {
-							yield* Deferred.die(queued.reply, decodeError);
-							return yield* Effect.die(decodeError);
-						}
-						yield* Deferred.succeed(queued.reply, decoded);
-					} else yield* Deferred.succeed(queued.reply, result.reply);
-				} else if (result.deferReply) deferredReplyRef.current = queued.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
-		};
-	});
+const runSupervisionLoop = (params) => Effect.gen(function* () {
+	const step = yield* Schedule.toStepWithSleep(params.supervision.schedule);
+	let generation = 0;
 	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" });
+		const currentRuntime = params.runtimeRef.current;
+		if (currentRuntime === void 0) return;
+		const generationExit = yield* Deferred.await(currentRuntime.exitDeferred);
+		if (generationExit._tag !== "Defect") {
+			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
 			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;
-			}
+		if (params.supervision.shouldRestart !== void 0 && !params.supervision.shouldRestart(generationExit)) {
+			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+			return;
+		}
+		if ((yield* step(generationExit).pipe(Effect.exit))._tag === "Failure") {
+			yield* Deferred.succeed(params.terminalExitDeferred, generationExit);
+			return;
 		}
+		const restartState = params.persist !== void 0 ? yield* loadAndRestore(params.persist, params.machine.initial) : params.machine.initial;
+		yield* settlePendingReplies(params.pendingReplies, params.id);
+		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;
+		generation++;
+		if (params.onRestart !== void 0) yield* params.onRestart(generation, generationExit);
+		notifyListeners(params.listeners, restartState);
 	}
 });
 /**
-* 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).
+* Create and start an actor for a machine.
+* Delegates to the shared runtime kernel with actor-specific lifecycle hooks.
 */
-const processEvent = Effect.fn("effect-machine.actor.processEvent")(function* (machine, currentState, event, stateRef, self, listeners, stateScopeRef, actorId, inspector, system) {
-	yield* emitWithTimestamp(inspector, (timestamp) => ({
-		type: "@machine.event",
-		actorId,
-		state: currentState,
-		event,
+const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine, options) {
+	const persist = options?.persist;
+	const initial = options?.initialState ?? (persist !== void 0 ? yield* loadAndRestore(persist, machine.initial) : 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();
+	yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
+		type: "@machine.spawn",
+		actorId: id,
+		initialState: initial,
 		timestamp
 	}));
-	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,
-			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
-		}))
-	});
-	if (!result.transitioned) {
-		yield* Effect.annotateCurrentSpan("effect_machine.transition.matched", false);
+	const hooks = inspectorValue !== void 0 ? buildInspectionHooks(id, inspectorValue) : void 0;
+	const machineWithState = initial !== machine.initial ? Object.create(machine, { initial: {
+		value: initial,
+		enumerable: true
+	} }) : machine;
+	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;
+	const runtimeRef = { current: void 0 };
+	/** Build lifecycle hooks for a generation */
+	const buildLifecycle = () => {
+		stopEmitted = false;
 		return {
-			shouldStop: false,
-			result
-		};
-	}
-	yield* Effect.annotateCurrentSpan("effect_machine.transition.matched", true);
-	yield* SubscriptionRef.set(stateRef, result.newState);
-	notifyListeners(listeners, result.newState);
-	if (result.lifecycleRan) {
-		yield* Effect.annotateCurrentSpan("effect_machine.state.from", result.previousState._tag);
-		yield* Effect.annotateCurrentSpan("effect_machine.state.to", result.newState._tag);
-		if (result.isFinal) {
-			yield* emitWithTimestamp(inspector, (timestamp) => ({
-				type: "@machine.stop",
-				actorId,
-				finalState: result.newState,
+			onEvent: inspectorValue !== void 0 ? (state, event) => emitWithTimestamp(inspectorValue, (timestamp) => ({
+				type: "@machine.event",
+				actorId: id,
+				state,
+				event,
 				timestamp
-			}));
-			return {
-				shouldStop: true,
-				result
-			};
-		}
-	}
-	return {
-		shouldStop: false,
-		result
+			})) : void 0,
+			onStateChange: (result, _event) => Effect.gen(function* () {
+				notifyListeners(listeners, result.newState);
+				if (persist !== void 0 && result.transitioned) {
+					if (persist.shouldSave === void 0 || persist.shouldSave(result.newState, result.previousState)) yield* persist.save(result.newState);
+				}
+				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",
+					actorId: id,
+					finalState: state,
+					timestamp
+				}));
+			}) : void 0,
+			onShutdown: () => Effect.gen(function* () {
+				if (!stopEmitted) {
+					const finalState = yield* SubscriptionRef.get(stateRef);
+					yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
+						type: "@machine.stop",
+						actorId: id,
+						finalState,
+						timestamp
+					}));
+				}
+				yield* settlePendingReplies(pendingReplies, id);
+			}),
+			onInitialSpawnEffects: inspectorValue !== void 0 ? (state) => emitWithTimestamp(inspectorValue, (timestamp) => ({
+				type: "@machine.effect",
+				actorId: id,
+				effectType: "spawn",
+				state,
+				timestamp
+			})) : void 0
+		};
 	};
-});
-/**
-* Run spawn effects with actor-specific inspection and tracing.
-* Wraps the core runSpawnEffects with inspection events and spans.
-* @internal
-*/
-const runSpawnEffectsWithInspection = Effect.fn("effect-machine.actor.spawnEffects")(function* (machine, state, event, self, stateScope, actorId, inspector, system) {
-	yield* emitWithTimestamp(inspector, (timestamp) => ({
-		type: "@machine.effect",
-		actorId,
-		effectType: "spawn",
-		state,
-		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,
-		state: info.state,
-		event: info.event,
-		error: Cause.pretty(info.cause),
-		timestamp
+	/** Create a single runtime generation. machineForGen is machineWithState for initial, machine for restarts. */
+	const spawnGeneration = (machineForGen) => Ref.get(eventQueueRef).pipe(Effect.flatMap((currentQueue) => createRuntime(machineForGen, system, {
+		actorId: id,
+		hooks,
+		skipFinalizer: true,
+		cellResources: {
+			stateRef,
+			stoppedRef,
+			eventQueue: currentQueue
+		},
+		lifecycle: buildLifecycle(),
+		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);
+			if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.sync(() => {
+				childrenMap.delete(childId);
+			}));
+		})
 	})));
+	const runtime = yield* spawnGeneration(machineWithState);
+	runtimeRef.current = runtime;
+	const supervision = options?.supervision;
+	let supervisorFiber;
+	if (supervision !== void 0) supervisorFiber = yield* Effect.forkDetach(runSupervisionLoop({
+		supervision,
+		machine,
+		id,
+		runtimeRef,
+		terminalExitDeferred,
+		pendingReplies,
+		eventQueueRef,
+		stateRef,
+		stoppedRef,
+		childrenMap,
+		listeners,
+		spawnGeneration,
+		persist,
+		onRestart: options?.onRestart
+	}));
+	else yield* Effect.forkDetach(Deferred.await(runtime.exitDeferred).pipe(Effect.tap((exit) => Deferred.succeed(terminalExitDeferred, exit))));
+	return buildActorRefCore(id, machine, stateRef, eventQueueRef, stoppedRef, listeners, Effect.gen(function* () {
+		if (supervisorFiber !== void 0) yield* Fiber.interrupt(supervisorFiber);
+		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), 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();
 });
 /** Notify all system event listeners (sync). */
 const notifySystemListeners = (listeners, event) => {
@@ -502,7 +447,8 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 				yield* emitSystemEvent({
 					_tag: "ActorStopped",
 					id,
-					actor: actorRef
+					actor: actorRef,
+					exit: { _tag: "Stopped" }
 				});
 				MutableHashMap.remove(actorsMap, id);
 			}
@@ -510,11 +456,25 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		}));
 		return actor;
 	});
-	const spawnRegular = Effect.fn("effect-machine.actorSystem.spawnRegular")(function* (id, built) {
+	const spawnRegular = Effect.fn("effect-machine.actorSystem.spawnRegular")(function* (id, machine, spawnOptions) {
 		if (MutableHashMap.has(actorsMap, id)) return yield* new DuplicateActorError({ actorId: id });
-		return yield* registerActor(id, yield* createActor(id, built._inner));
+		const materialized = spawnOptions?.slots !== void 0 ? materializeMachine(machine, spawnOptions.slots) : machine;
+		let actorRef;
+		const actor = yield* createActor(id, materialized, {
+			supervision: spawnOptions?.supervision,
+			persist: spawnOptions?.persist,
+			onRestart: spawnOptions?.supervision !== void 0 ? (generation, exit) => actorRef !== void 0 ? emitSystemEvent({
+				_tag: "ActorRestarted",
+				id,
+				actor: actorRef,
+				generation,
+				exit
+			}) : Effect.void : void 0
+		});
+		actorRef = actor;
+		return yield* registerActor(id, actor);
 	});
-	const spawn = (id, machine) => withSpawnGate(spawnRegular(id, machine));
+	const spawn = (id, machine, options) => withSpawnGate(spawnRegular(id, machine, options));
 	const get = Effect.fn("effect-machine.actorSystem.get")(function* (id) {
 		return yield* Effect.sync(() => MutableHashMap.get(actorsMap, id));
 	});
@@ -526,7 +486,8 @@ const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
 		yield* emitSystemEvent({
 			_tag: "ActorStopped",
 			id,
-			actor
+			actor,
+			exit: { _tag: "Stopped" }
 		});
 		yield* actor.stop;
 		return true;