effect-machine 0.6.0 → 0.7.0

package/dist/persistence/adapter.js

@@ -1,10 +1,10 @@
-import { Context, Schema } from "effect";
+import { Schema, ServiceMap } from "effect";
 
 //#region src/persistence/adapter.ts
 /**
 * Error type for persistence operations
 */
-var PersistenceError = class extends Schema.TaggedError()("PersistenceError", {
+var PersistenceError = class extends Schema.TaggedErrorClass()("PersistenceError", {
 	operation: Schema.String,
 	actorId: Schema.String,
 	cause: Schema.optional(Schema.Unknown),
@@ -13,7 +13,7 @@ var PersistenceError = class extends Schema.TaggedError()("PersistenceError", {
 /**
 * Version conflict error — snapshot version doesn't match expected
 */
-var VersionConflictError = class extends Schema.TaggedError()("VersionConflictError", {
+var VersionConflictError = class extends Schema.TaggedErrorClass()("VersionConflictError", {
 	actorId: Schema.String,
 	expectedVersion: Schema.Number,
 	actualVersion: Schema.Number
@@ -21,7 +21,7 @@ var VersionConflictError = class extends Schema.TaggedError()("VersionConflictEr
 /**
 * PersistenceAdapter service tag
 */
-var PersistenceAdapterTag = class extends Context.Tag("effect-machine/src/persistence/adapter/PersistenceAdapterTag")() {};
+var PersistenceAdapterTag = class extends ServiceMap.Service()("effect-machine/src/persistence/adapter/PersistenceAdapterTag") {};
 
 //#endregion
 export { PersistenceAdapterTag, PersistenceError, VersionConflictError };

package/dist/persistence/adapters/in-memory.js

@@ -42,7 +42,7 @@ const make = Effect.gen(function* () {
 					actualVersion: snapshot.version
 				});
 			}
-			const encoded = yield* Schema.encode(schema)(snapshot.state).pipe(Effect.mapError((cause) => new PersistenceError({
+			const encoded = yield* Schema.encodeEffect(schema)(snapshot.state).pipe(Effect.mapError((cause) => new PersistenceError({
 				operation: "saveSnapshot",
 				actorId: id,
 				cause,
@@ -61,7 +61,7 @@ const make = Effect.gen(function* () {
 			const actorStorage = yield* getOrCreateStorage(id);
 			if (Option.isNone(actorStorage.snapshot)) return Option.none();
 			const stored = actorStorage.snapshot.value;
-			const decoded = yield* Schema.decode(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
+			const decoded = yield* Schema.decodeEffect(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
 				operation: "loadSnapshot",
 				actorId: id,
 				cause,
@@ -75,7 +75,7 @@ const make = Effect.gen(function* () {
 		}),
 		appendEvent: Effect.fn("effect-machine.persistence.inMemory.appendEvent")(function* (id, event, schema) {
 			yield* getOrCreateStorage(id);
-			const encoded = yield* Schema.encode(schema)(event.event).pipe(Effect.mapError((cause) => new PersistenceError({
+			const encoded = yield* Schema.encodeEffect(schema)(event.event).pipe(Effect.mapError((cause) => new PersistenceError({
 				operation: "appendEvent",
 				actorId: id,
 				cause,
@@ -95,7 +95,7 @@ const make = Effect.gen(function* () {
 			const decoded = [];
 			for (const stored of actorStorage.events) {
 				if (afterVersion !== void 0 && stored.version <= afterVersion) continue;
-				const event = yield* Schema.decode(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
+				const event = yield* Schema.decodeEffect(schema)(stored.data).pipe(Effect.mapError((cause) => new PersistenceError({
 					operation: "loadEvents",
 					actorId: id,
 					cause,

package/dist/persistence/persistent-actor.js

@@ -139,10 +139,10 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	}));
 	const snapshotEnabledRef = yield* Ref.make(true);
 	const persistenceQueue = yield* Queue.unbounded();
-	const persistenceFiber = yield* Effect.forkDaemon(persistenceWorker(persistenceQueue));
+	const persistenceFiber = yield* Effect.forkDetach(persistenceWorker(persistenceQueue));
 	yield* Queue.offer(persistenceQueue, saveMetadata(id, resolvedInitial, initialVersion, createdAt, persistence, adapter));
 	const snapshotQueue = yield* Queue.unbounded();
-	const snapshotFiber = yield* Effect.forkDaemon(snapshotWorker(id, persistence, adapter, snapshotQueue, snapshotEnabledRef));
+	const snapshotFiber = yield* Effect.forkDetach(snapshotWorker(id, persistence, adapter, snapshotQueue, snapshotEnabledRef));
 	const backgroundFibers = [];
 	const initEvent = { _tag: INTERNAL_INIT_EVENT };
 	const initCtx = {
@@ -153,7 +153,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 	};
 	const { effects: effectSlots } = typedMachine._slots;
 	for (const bg of typedMachine.backgroundEffects) {
-		const fiber = yield* Effect.forkDaemon(bg.handler({
+		const fiber = yield* Effect.forkDetach(bg.handler({
 			state: resolvedInitial,
 			event: initEvent,
 			self,
@@ -178,7 +178,7 @@ const createPersistentActor = Effect.fn("effect-machine.persistentActor.spawn")(
 		}));
 		return buildPersistentActorRef(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, Ref.set(stoppedRef, true).pipe(Effect.withSpan("effect-machine.persistentActor.stop"), Effect.asVoid), adapter, system, childrenMap);
 	}
-	const loopFiber = yield* Effect.forkDaemon(persistentEventLoop(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, self, listeners, adapter, createdAt, stateScopeRef, backgroundFibers, snapshotQueue, snapshotEnabledRef, persistenceQueue, snapshotFiber, persistenceFiber, inspector, system));
+	const loopFiber = yield* Effect.forkDetach(persistentEventLoop(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, self, listeners, adapter, createdAt, stateScopeRef, backgroundFibers, snapshotQueue, snapshotEnabledRef, persistenceQueue, snapshotFiber, persistenceFiber, inspector, system));
 	return buildPersistentActorRef(id, persistentMachine, stateRef, versionRef, eventQueue, stoppedRef, listeners, Effect.gen(function* () {
 		const finalState = yield* SubscriptionRef.get(stateRef);
 		yield* emitWithTimestamp(inspector, (timestamp) => ({
@@ -250,7 +250,7 @@ const persistentEventLoop = Effect.fn("effect-machine.persistentActor.eventLoop"
 				version: newVersion,
 				timestamp: yield* now
 			};
-			const journalTask = adapter.appendEvent(id, persistedEvent, persistence.eventSchema).pipe(Effect.catchAll((e) => Effect.logWarning(`Failed to journal event for actor ${id}`, e)), Effect.asVoid);
+			const journalTask = adapter.appendEvent(id, persistedEvent, persistence.eventSchema).pipe(Effect.catchEager((e) => Effect.logWarning(`Failed to journal event for actor ${id}`, e)), Effect.asVoid);
 			yield* Queue.offer(persistenceQueue, journalTask);
 		}
 		yield* Queue.offer(persistenceQueue, saveMetadata(id, result.newState, newVersion, createdAt, persistence, adapter));
@@ -306,11 +306,11 @@ const persistenceWorker = Effect.fn("effect-machine.persistentActor.persistenceW
 * Snapshot scheduler worker (runs in background).
 */
 const snapshotWorker = Effect.fn("effect-machine.persistentActor.snapshotWorker")(function* (id, persistence, adapter, queue, enabledRef) {
-	const driver = yield* Schedule.driver(persistence.snapshotSchedule);
+	const step = yield* Schedule.toStep(persistence.snapshotSchedule);
 	while (true) {
 		const { state, version } = yield* Queue.take(queue);
 		if (!(yield* Ref.get(enabledRef))) continue;
-		if (!(yield* driver.next(state).pipe(Effect.match({
+		if (!(yield* step(yield* Clock.currentTimeMillis, state).pipe(Effect.match({
 			onFailure: () => false,
 			onSuccess: () => true
 		})))) {
@@ -330,7 +330,7 @@ const saveSnapshot = Effect.fn("effect-machine.persistentActor.saveSnapshot")(fu
 		version,
 		timestamp: yield* now
 	};
-	yield* adapter.saveSnapshot(id, snapshot, persistence.stateSchema).pipe(Effect.catchAll((e) => Effect.logWarning(`Failed to save snapshot for actor ${id}`, e)));
+	yield* adapter.saveSnapshot(id, snapshot, persistence.stateSchema).pipe(Effect.catchEager((e) => Effect.logWarning(`Failed to save snapshot for actor ${id}`, e)));
 });
 /**
 * Save or update actor metadata if adapter supports registry.
@@ -347,7 +347,7 @@ const saveMetadata = Effect.fn("effect-machine.persistentActor.saveMetadata")(fu
 		lastActivityAt,
 		version,
 		stateTag: state._tag
-	}).pipe(Effect.catchAll((e) => Effect.logWarning(`Failed to save metadata for actor ${id}`, e)));
+	}).pipe(Effect.catchEager((e) => Effect.logWarning(`Failed to save metadata for actor ${id}`, e)));
 });
 /**
 * Restore an actor from persistence.

package/dist/persistence/persistent-machine.d.ts

@@ -16,7 +16,7 @@ type BrandedEvent = {
  * Note: Schema types S and E should match the structural shape of the machine's
  * state and event types (without brands). The schemas don't know about brands.
  */
-interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
+interface PersistenceConfig<S, E> {
   /**
    * Schedule controlling when snapshots are taken.
    * Input is the new state after each transition.
@@ -36,12 +36,12 @@ interface PersistenceConfig<S, E, SSI = unknown, ESI = unknown> {
    * Schema for serializing/deserializing state.
    * Always present at runtime (resolved from config or machine).
    */
-  readonly stateSchema: Schema.Schema<S, SSI, never>;
+  readonly stateSchema: Schema.Codec<S, unknown, never, never>;
   /**
    * Schema for serializing/deserializing events.
    * Always present at runtime (resolved from config or machine).
    */
-  readonly eventSchema: Schema.Schema<E, ESI, never>;
+  readonly eventSchema: Schema.Codec<E, unknown, never, never>;
   /**
    * User-provided identifier for the machine type.
    * Used for filtering actors in restoreAll.

package/dist/schema.d.ts

@@ -36,8 +36,8 @@ type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends n
  */
 type VariantConstructors<D extends Record<string, Schema.Struct.Fields>, Brand> = { readonly [K in keyof D & string]: IsEmptyFields<D[K]> extends true ? TaggedStructType<K, D[K]> & Brand & {
   readonly derive: (source: object) => TaggedStructType<K, D[K]> & Brand;
-} : ((args: Schema.Struct.Constructor<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
-  readonly derive: (source: object, partial?: Partial<Schema.Struct.Constructor<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
+} : ((args: Schema.Struct.Type<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
+  readonly derive: (source: object, partial?: Partial<Schema.Struct.Type<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
   readonly _tag: K;
 } };
 /**
@@ -78,14 +78,14 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
  * The D type parameter captures the definition, creating a unique brand
  * per distinct schema definition shape.
  */
-type MachineStateSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Schema<VariantsUnion<D> & FullStateBrand<D>, VariantsUnion<D>, never> & MachineSchemaBase<D, FullStateBrand<D>> & VariantConstructors<D, FullStateBrand<D>>;
+type MachineStateSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Codec<VariantsUnion<D> & FullStateBrand<D>, unknown, never, never> & MachineSchemaBase<D, FullStateBrand<D>> & VariantConstructors<D, FullStateBrand<D>>;
 /**
  * Schema-first event definition (same structure as state, different brand)
  *
  * The D type parameter captures the definition, creating a unique brand
  * per distinct schema definition shape.
  */
-type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Schema<VariantsUnion<D> & FullEventBrand<D>, VariantsUnion<D>, never> & MachineSchemaBase<D, FullEventBrand<D>> & VariantConstructors<D, FullEventBrand<D>>;
+type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema.Codec<VariantsUnion<D> & FullEventBrand<D>, unknown, never, never> & MachineSchemaBase<D, FullEventBrand<D>> & VariantConstructors<D, FullEventBrand<D>>;
 /**
  * Create a schema-first State definition.
  *

package/dist/schema.js

@@ -69,8 +69,8 @@ const buildMachineSchema = (definition) => {
 		};
 	}
 	const variantArray = Object.values(variants);
-	if (variantArray.length === 0) throw new InvalidSchemaError();
-	const unionSchema = variantArray.length === 1 ? variantArray[0] : Schema.Union(...variantArray);
+	if (variantArray.length === 0) throw new InvalidSchemaError({});
+	const unionSchema = variantArray.length === 1 ? variantArray[0] : Schema.Union(variantArray);
 	const $is = (tag) => (u) => typeof u === "object" && u !== null && "_tag" in u && u._tag === tag;
 	const $match = (valueOrCases, maybeCases) => {
 		if (maybeCases !== void 0) {

package/dist/slot.d.ts

@@ -1,9 +1,9 @@
 import { ActorSystem } from "./actor.js";
-import { Context, Effect, Schema } from "effect";
+import { Effect, Schema, ServiceMap } from "effect";
 
 //#region src/slot.d.ts
 /** Schema fields definition (like Schema.Struct.Fields) */
-type Fields = Record<string, Schema.Schema.All>;
+type Fields = Record<string, Schema.Top>;
 /** Extract the encoded type from schema fields (used for parameters) */
 type FieldsToParams<F extends Fields> = keyof F extends never ? void : Schema.Schema.Type<Schema.Struct<F>>;
 /**
@@ -53,7 +53,7 @@ interface MachineContext<State, Event, Self> {
  * Single module-level tag instead of per-machine allocation.
  * @internal
  */
-declare const MachineContextTag: Context.Tag<MachineContext<any, any, any>, MachineContext<any, any, any>>;
+declare const MachineContextTag: ServiceMap.Service<MachineContext<any, any, any>, MachineContext<any, any, any>>;
 /**
  * Guard handler implementation.
  * Receives params and context, returns Effect<boolean>.

package/dist/slot.js

@@ -1,4 +1,4 @@
-import { Context } from "effect";
+import { ServiceMap } from "effect";
 
 //#region src/slot.ts
 /**
@@ -41,7 +41,7 @@ import { Context } from "effect";
 * Single module-level tag instead of per-machine allocation.
 * @internal
 */
-const MachineContextTag = Context.GenericTag("@effect-machine/Context");
+const MachineContextTag = ServiceMap.Service("@effect-machine/Context");
 /**
 * Generic slot schema factory. Used internally by Guards() and Effects().
 * @internal

package/dist-v3/_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-v3/actor.d.ts

@@ -0,0 +1,291 @@
+import { PersistentMachine } from "./persistence/persistent-machine.js";
+import { DuplicateActorError } from "./errors.js";
+import { EffectsDef, GuardsDef } from "./slot.js";
+import { ProcessEventError, ProcessEventHooks, ProcessEventResult, processEventCore, resolveTransition, runSpawnEffects } from "./internal/transition.js";
+import { PersistentActorRef } from "./persistence/persistent-actor.js";
+import { ActorMetadata, PersistenceAdapterTag, PersistenceError, RestoreResult, VersionConflictError } from "./persistence/adapter.js";
+import { BuiltMachine, Machine } from "./machine.js";
+import { Effect, Option, Queue, Ref, Stream, SubscriptionRef } from "effect";
+
+//#region src-v3/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;
+  /**
+   * The actor system this actor belongs to.
+   * Every actor always has a system — either inherited from context or implicitly created.
+   */
+  readonly system: ActorSystem;
+  /**
+   * Child actors spawned via `self.spawn` in this actor's handlers.
+   * State-scoped children are auto-removed on state exit.
+   */
+  readonly children: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
+}
+/** Base type for stored actors (internal) */
+type AnyState = {
+  readonly _tag: string;
+};
+/**
+ * Events emitted by the ActorSystem when actors are spawned or stopped.
+ */
+type SystemEvent = {
+  readonly _tag: "ActorSpawned";
+  readonly id: string;
+  readonly actor: ActorRef<AnyState, unknown>;
+} | {
+  readonly _tag: "ActorStopped";
+  readonly id: string;
+  readonly actor: ActorRef<AnyState, unknown>;
+};
+/**
+ * Listener callback for system events.
+ */
+type SystemEventListener = (event: SystemEvent) => void;
+/**
+ * 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>;
+  /**
+   * Async stream of system events (actor spawned/stopped).
+   * Each subscriber gets their own queue — late subscribers miss prior events.
+   */
+  readonly events: Stream.Stream<SystemEvent>;
+  /**
+   * Sync snapshot of all currently registered actors.
+   * Returns a new Map on each access (not live).
+   */
+  readonly actors: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
+  /**
+   * Subscribe to system events synchronously.
+   * Returns an unsubscribe function.
+   */
+  readonly subscribe: (fn: SystemEventListener) => () => void;
+  /**
+   * 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: any;
+/** 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>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>) => 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>, unknown, unknown>;
+/**
+ * Default ActorSystem layer
+ */
+declare const Default: any;
+//#endregion
+export { ActorRef, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, SystemEvent, SystemEventListener, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };