effect-machine 0.3.1 → 0.3.2

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,18 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll };

package/dist/actor.d.ts

@@ -0,0 +1,251 @@
+import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
+import { PersistentMachine } from "./persistence/persistent-machine.js";
+import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
+import { PersistentActorRef } from "./persistence/persistent-actor.js";
+import { DuplicateActorError } from "./errors.js";
+import { ActorMetadata, PersistenceAdapterTag, PersistenceError, RestoreResult, VersionConflictError } from "./persistence/adapter.js";
+import { BuiltMachine, Machine, MachineRef } from "./machine.js";
+import { Context, Effect, Layer, Option, Queue, Ref, Scope, Stream, SubscriptionRef } from "effect";
+import * as effect_Tracer0 from "effect/Tracer";
+
+//#region src/actor.d.ts
+/**
+ * Reference to a running actor.
+ */
+interface ActorRef<State extends {
+  readonly _tag: string;
+}, Event> {
+  /**
+   * Unique identifier for this actor
+   */
+  readonly id: string;
+  /**
+   * Send an event to the actor
+   */
+  readonly send: (event: Event) => Effect.Effect<void>;
+  /**
+   * Observable state of the actor
+   */
+  readonly state: SubscriptionRef.SubscriptionRef<State>;
+  /**
+   * Stop the actor gracefully
+   */
+  readonly stop: Effect.Effect<void>;
+  /**
+   * Stop the actor (fire-and-forget).
+   * Signals graceful shutdown without waiting for completion.
+   * Use when stopping from sync contexts (e.g. framework cleanup hooks).
+   */
+  readonly stopSync: () => void;
+  /**
+   * Get current state snapshot (Effect)
+   */
+  readonly snapshot: Effect.Effect<State>;
+  /**
+   * Get current state snapshot (sync)
+   */
+  readonly snapshotSync: () => State;
+  /**
+   * Check if current state matches tag (Effect)
+   */
+  readonly matches: (tag: State["_tag"]) => Effect.Effect<boolean>;
+  /**
+   * Check if current state matches tag (sync)
+   */
+  readonly matchesSync: (tag: State["_tag"]) => boolean;
+  /**
+   * Check if event can be handled in current state (Effect)
+   */
+  readonly can: (event: Event) => Effect.Effect<boolean>;
+  /**
+   * Check if event can be handled in current state (sync)
+   */
+  readonly canSync: (event: Event) => boolean;
+  /**
+   * Stream of state changes
+   */
+  readonly changes: Stream.Stream<State>;
+  /**
+   * Wait for a state that matches predicate or state variant (includes current snapshot).
+   * Accepts a predicate function or a state constructor/value (e.g. `State.Active`).
+   */
+  readonly waitFor: {
+    (predicate: (state: State) => boolean): Effect.Effect<State>;
+    (state: {
+      readonly _tag: State["_tag"];
+    }): Effect.Effect<State>;
+  };
+  /**
+   * Wait for a final state (includes current snapshot)
+   */
+  readonly awaitFinal: Effect.Effect<State>;
+  /**
+   * Send event and wait for predicate, state variant, or final state.
+   * Accepts a predicate function or a state constructor/value (e.g. `State.Active`).
+   */
+  readonly sendAndWait: {
+    (event: Event, predicate: (state: State) => boolean): Effect.Effect<State>;
+    (event: Event, state: {
+      readonly _tag: State["_tag"];
+    }): Effect.Effect<State>;
+    (event: Event): Effect.Effect<State>;
+  };
+  /**
+   * Send event synchronously (fire-and-forget).
+   * No-op on stopped actors. Use when you need to send from sync contexts
+   * (e.g. framework hooks, event handlers).
+   */
+  readonly sendSync: (event: Event) => void;
+  /**
+   * Subscribe to state changes (sync callback)
+   * Returns unsubscribe function
+   */
+  readonly subscribe: (fn: (state: State) => void) => () => void;
+}
+/** Base type for stored actors (internal) */
+type AnyState = {
+  readonly _tag: string;
+};
+/**
+ * Actor system for managing actor lifecycles
+ */
+interface ActorSystem {
+  /**
+   * Spawn a new actor with the given machine.
+   *
+   * For regular machines, returns ActorRef.
+   * For persistent machines (created with Machine.persist), returns PersistentActorRef.
+   *
+   * All effect slots must be provided via `.build()` before spawning.
+   *
+   * @example
+   * ```ts
+   * // Regular machine (built)
+   * const built = machine.build({ fetchData: ... })
+   * const actor = yield* system.spawn("my-actor", built);
+   *
+   * // Persistent machine (auto-detected)
+   * const persistentActor = yield* system.spawn("my-actor", persistentMachine);
+   * persistentActor.persist; // available
+   * persistentActor.version; // available
+   * ```
+   */
+  readonly spawn: {
+    <S extends {
+      readonly _tag: string;
+    }, E extends {
+      readonly _tag: string;
+    }, R>(id: string, machine: BuiltMachine<S, E, R>): Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>;
+    <S extends {
+      readonly _tag: string;
+    }, E extends {
+      readonly _tag: string;
+    }, R>(id: string, machine: PersistentMachine<S, E, R>): Effect.Effect<PersistentActorRef<S, E, R>, PersistenceError | VersionConflictError | DuplicateActorError, R | PersistenceAdapterTag>;
+  };
+  /**
+   * Restore an actor from persistence.
+   * Returns None if no persisted state exists for the given ID.
+   *
+   * @example
+   * ```ts
+   * const maybeActor = yield* system.restore("order-1", persistentMachine);
+   * if (Option.isSome(maybeActor)) {
+   *   const actor = maybeActor.value;
+   *   const state = yield* actor.snapshot;
+   *   console.log(`Restored to state: ${state._tag}`);
+   * }
+   * ```
+   */
+  readonly restore: <S extends {
+    readonly _tag: string;
+  }, E extends {
+    readonly _tag: string;
+  }, R>(id: string, machine: PersistentMachine<S, E, R>) => Effect.Effect<Option.Option<PersistentActorRef<S, E, R>>, PersistenceError | DuplicateActorError, R | PersistenceAdapterTag>;
+  /**
+   * Get an existing actor by ID
+   */
+  readonly get: (id: string) => Effect.Effect<Option.Option<ActorRef<AnyState, unknown>>>;
+  /**
+   * Stop an actor by ID
+   */
+  readonly stop: (id: string) => Effect.Effect<boolean>;
+  /**
+   * List all persisted actor metadata.
+   * Returns empty array if adapter doesn't support registry.
+   *
+   * @example
+   * ```ts
+   * const actors = yield* system.listPersisted();
+   * for (const meta of actors) {
+   *   console.log(`${meta.id}: ${meta.stateTag} (v${meta.version})`);
+   * }
+   * ```
+   */
+  readonly listPersisted: () => Effect.Effect<ReadonlyArray<ActorMetadata>, PersistenceError, PersistenceAdapterTag>;
+  /**
+   * Restore multiple actors by ID.
+   * Returns both successfully restored actors and failures.
+   *
+   * @example
+   * ```ts
+   * const result = yield* system.restoreMany(["order-1", "order-2"], orderMachine);
+   * console.log(`Restored: ${result.restored.length}, Failed: ${result.failed.length}`);
+   * ```
+   */
+  readonly restoreMany: <S extends {
+    readonly _tag: string;
+  }, E extends {
+    readonly _tag: string;
+  }, R>(ids: ReadonlyArray<string>, machine: PersistentMachine<S, E, R>) => Effect.Effect<RestoreResult<S, E, R>, never, R | PersistenceAdapterTag>;
+  /**
+   * Restore all persisted actors for a machine type.
+   * Uses adapter registry if available, otherwise returns empty result.
+   *
+   * @example
+   * ```ts
+   * const result = yield* system.restoreAll(orderMachine, {
+   *   filter: (meta) => meta.stateTag !== "Done"
+   * });
+   * console.log(`Restored ${result.restored.length} active orders`);
+   * ```
+   */
+  readonly restoreAll: <S extends {
+    readonly _tag: string;
+  }, E extends {
+    readonly _tag: string;
+  }, R>(machine: PersistentMachine<S, E, R>, options?: {
+    filter?: (meta: ActorMetadata) => boolean;
+  }) => Effect.Effect<RestoreResult<S, E, R>, PersistenceError, R | PersistenceAdapterTag>;
+}
+/**
+ * ActorSystem service tag
+ */
+declare const ActorSystem: Context.Tag<ActorSystem, ActorSystem>;
+/** Listener set for sync subscriptions */
+type Listeners<S> = Set<(state: S) => void>;
+/**
+ * Notify all listeners of state change.
+ */
+declare const notifyListeners: <S>(listeners: Listeners<S>, state: S) => void;
+/**
+ * Build core ActorRef methods shared between regular and persistent actors.
+ */
+declare const buildActorRefCore: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, any, any, GD, EFD>, stateRef: SubscriptionRef.SubscriptionRef<S>, eventQueue: Queue.Queue<E>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>) => ActorRef<S, E>;
+/**
+ * Create and start an actor for a machine
+ */
+declare const createActor: <S extends {
+  readonly _tag: string;
+}, E extends {
+  readonly _tag: string;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>) => Effect.Effect<ActorRef<S, E>, never, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, effect_Tracer0.ParentSpan> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope> | Exclude<Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>, effect_Tracer0.ParentSpan>>;
+/**
+ * Default ActorSystem layer
+ */
+declare const Default: Layer.Layer<ActorSystem, never, never>;
+//#endregion
+export { ActorRef, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };

package/dist/actor.js

@@ -0,0 +1,385 @@
+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 { emitWithTimestamp } from "./internal/inspection.js";
+import { PersistenceAdapterTag, PersistenceError } from "./persistence/adapter.js";
+import { createPersistentActor, restorePersistentActor } from "./persistence/persistent-actor.js";
+import { Cause, Context, Deferred, Effect, Exit, Fiber, Layer, MutableHashMap, Option, Queue, Ref, Runtime, Scope, SubscriptionRef } from "effect";
+
+//#region src/actor.ts
+/**
+* ActorSystem service tag
+*/
+const ActorSystem = Context.GenericTag("@effect/machine/ActorSystem");
+/**
+* Notify all listeners of state change.
+*/
+const notifyListeners = (listeners, state) => {
+	for (const listener of listeners) try {
+		listener(state);
+	} catch {}
+};
+/**
+* Build core ActorRef methods shared between regular and persistent actors.
+*/
+const buildActorRefCore = (id, machine, stateRef, eventQueue, stoppedRef, listeners, stop) => {
+	const send = Effect.fn("effect-machine.actor.send")(function* (event) {
+		if (yield* Ref.get(stoppedRef)) return;
+		yield* Queue.offer(eventQueue, 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 waitFor = Effect.fn("effect-machine.actor.waitFor")(function* (predicateOrState) {
+		const predicate = typeof predicateOrState === "function" && !("_tag" in predicateOrState) ? predicateOrState : (s) => s._tag === predicateOrState._tag;
+		const current = yield* SubscriptionRef.get(stateRef);
+		if (predicate(current)) return current;
+		const done = yield* Deferred.make();
+		const rt = yield* Effect.runtime();
+		const runFork = Runtime.runFork(rt);
+		const listener = (state) => {
+			if (predicate(state)) runFork(Deferred.succeed(done, state));
+		};
+		listeners.add(listener);
+		const afterSubscribe = yield* SubscriptionRef.get(stateRef);
+		if (predicate(afterSubscribe)) {
+			listeners.delete(listener);
+			return afterSubscribe;
+		}
+		const result = yield* Deferred.await(done);
+		listeners.delete(listener);
+		return result;
+	});
+	const awaitFinal = waitFor((state) => machine.finalStates.has(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;
+	});
+	return {
+		id,
+		send,
+		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,
+		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);
+			};
+		}
+	};
+};
+/**
+* Create and start an actor for a machine
+*/
+const createActor = Effect.fn("effect-machine.actor.spawn")(function* (id, machine) {
+	yield* Effect.annotateCurrentSpan("effect_machine.actor.id", id);
+	const inspectorValue = Option.getOrUndefined(yield* Effect.serviceOption(Inspector));
+	const eventQueue = yield* Queue.unbounded();
+	const stoppedRef = yield* Ref.make(false);
+	const self = { send: Effect.fn("effect-machine.actor.self.send")(function* (event) {
+		if (yield* Ref.get(stoppedRef)) return;
+		yield* Queue.offer(eventQueue, event);
+	}) };
+	yield* Effect.annotateCurrentSpan("effect_machine.actor.initial_state", machine.initial._tag);
+	yield* emitWithTimestamp(inspectorValue, (timestamp) => ({
+		type: "@machine.spawn",
+		actorId: id,
+		initialState: machine.initial,
+		timestamp
+	}));
+	const stateRef = yield* SubscriptionRef.make(machine.initial);
+	const listeners = /* @__PURE__ */ new Set();
+	const backgroundFibers = [];
+	const initEvent = { _tag: INTERNAL_INIT_EVENT };
+	const ctx = {
+		state: machine.initial,
+		event: initEvent,
+		self
+	};
+	const { effects: effectSlots } = machine._slots;
+	for (const bg of machine.backgroundEffects) {
+		const fiber = yield* Effect.forkDaemon(bg.handler({
+			state: machine.initial,
+			event: initEvent,
+			self,
+			effects: effectSlots
+		}).pipe(Effect.provideService(machine.Context, ctx)));
+		backgroundFibers.push(fiber);
+	}
+	const stateScopeRef = { current: yield* Scope.make() };
+	yield* runSpawnEffectsWithInspection(machine, machine.initial, initEvent, self, stateScopeRef.current, id, inspectorValue);
+	if (machine.finalStates.has(machine.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,
+			timestamp
+		}));
+		yield* Ref.set(stoppedRef, true);
+		return buildActorRefCore(id, machine, stateRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid));
+	}
+	const loopFiber = yield* Effect.forkDaemon(eventLoop(machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, id, inspectorValue));
+	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* Scope.close(stateScopeRef.current, Exit.void);
+		yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
+	}).pipe(Effect.withSpan("effect-machine.actor.stop"), Effect.asVoid));
+});
+/**
+* Main event loop for the actor
+*/
+const eventLoop = Effect.fn("effect-machine.actor.eventLoop")(function* (machine, stateRef, eventQueue, stoppedRef, self, listeners, backgroundFibers, stateScopeRef, actorId, inspector) {
+	while (true) {
+		const event = yield* Queue.take(eventQueue);
+		const currentState = yield* SubscriptionRef.get(stateRef);
+		if (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))) {
+			yield* Ref.set(stoppedRef, true);
+			yield* Scope.close(stateScopeRef.current, Exit.void);
+			yield* Effect.all(backgroundFibers.map(Fiber.interrupt), { concurrency: "unbounded" });
+			return;
+		}
+	}
+});
+/**
+* Process a single event, returning true if the actor should stop.
+* Wraps processEventCore with actor-specific concerns (inspection, listeners, state ref).
+*/
+const processEvent = Effect.fn("effect-machine.actor.processEvent")(function* (machine, currentState, event, stateRef, self, listeners, stateScopeRef, actorId, inspector) {
+	yield* emitWithTimestamp(inspector, (timestamp) => ({
+		type: "@machine.event",
+		actorId,
+		state: currentState,
+		event,
+		timestamp
+	}));
+	const result = yield* processEventCore(machine, currentState, event, self, stateScopeRef, 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);
+		return false;
+	}
+	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,
+				timestamp
+			}));
+			return true;
+		}
+	}
+	return false;
+});
+/**
+* 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) {
+	yield* emitWithTimestamp(inspector, (timestamp) => ({
+		type: "@machine.effect",
+		actorId,
+		effectType: "spawn",
+		state,
+		timestamp
+	}));
+	yield* runSpawnEffects(machine, state, event, self, stateScope, 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
+	})));
+});
+/**
+* Internal implementation
+*/
+const make = Effect.fn("effect-machine.actorSystem.make")(function* () {
+	const actors = MutableHashMap.empty();
+	const withSpawnGate = (yield* Effect.makeSemaphore(1)).withPermits(1);
+	yield* Effect.addFinalizer(() => {
+		const stops = [];
+		MutableHashMap.forEach(actors, (actor) => {
+			stops.push(actor.stop);
+		});
+		return Effect.all(stops, { concurrency: "unbounded" }).pipe(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(actors, id)) {
+			yield* actor.stop;
+			return yield* new DuplicateActorError({ actorId: id });
+		}
+		MutableHashMap.set(actors, id, actor);
+		const maybeScope = yield* Effect.serviceOption(Scope.Scope);
+		if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, Effect.gen(function* () {
+			yield* actor.stop;
+			MutableHashMap.remove(actors, id);
+		}));
+		return actor;
+	});
+	const spawnRegular = Effect.fn("effect-machine.actorSystem.spawnRegular")(function* (id, built) {
+		if (MutableHashMap.has(actors, 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(actors, 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 get = Effect.fn("effect-machine.actorSystem.get")(function* (id) {
+		return yield* Effect.sync(() => MutableHashMap.get(actors, id));
+	});
+	const stop = Effect.fn("effect-machine.actorSystem.stop")(function* (id) {
+		const maybeActor = MutableHashMap.get(actors, id);
+		if (Option.isNone(maybeActor)) return false;
+		yield* maybeActor.value.stop;
+		MutableHashMap.remove(actors, id);
+		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(actors, 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,
+		listPersisted,
+		restoreMany,
+		restoreAll
+	});
+});
+/**
+* Default ActorSystem layer
+*/
+const Default = Layer.scoped(ActorSystem, make());
+
+//#endregion
+export { ActorSystem, Default, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };