effect-machine 0.10.0 → 0.12.0

package/dist/machine.js

@@ -1,19 +1,21 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { Inspector } from "./inspection.js";
-import { getTag } from "./internal/utils.js";
+import { getTag, makeDeferReply, makeReply, stubSystem } from "./internal/utils.js";
 import { ProvisionValidationError, SlotProvisionError } from "./errors.js";
-import { persist } from "./persistence/persistent-machine.js";
 import { emitWithTimestamp } from "./internal/inspection.js";
 import { MachineContextTag } from "./slot.js";
-import { findTransitions, invalidateIndex } from "./internal/transition.js";
+import { findTransitions, invalidateIndex, resolveTransition, runTransitionHandler, shouldPostpone } from "./internal/transition.js";
 import { createActor } from "./actor.js";
 import { Cause, Effect, Exit, Option, Scope } from "effect";
 //#region src/machine.ts
 var machine_exports = /* @__PURE__ */ __exportAll({
 	BuiltMachine: () => BuiltMachine,
 	Machine: () => Machine,
+	deferReply: () => deferReply,
 	findTransitions: () => findTransitions,
 	make: () => make,
+	replay: () => replay,
+	reply: () => reply,
 	spawn: () => spawn
 });
 const emitTaskInspection = (input) => Effect.flatMap(Effect.serviceOption(Inspector), (inspector) => Option.isNone(inspector) ? Effect.void : emitWithTimestamp(inspector.value, (timestamp) => ({
@@ -42,9 +44,6 @@ var BuiltMachine = class {
 	get initial() {
 		return this._inner.initial;
 	}
-	persist(config) {
-		return this._inner.persist(config);
-	}
 };
 /**
 * Machine definition with fluent builder API.
@@ -72,6 +71,7 @@ var Machine = class Machine {
 	/** @internal */ _slots;
 	stateSchema;
 	eventSchema;
+	/** @internal */ _replySchemas;
 	/**
 	* Context tag for accessing machine state/event/self in slot handlers.
 	* Uses shared module-level tag for all machines.
@@ -98,6 +98,9 @@ var Machine = class Machine {
 	get effectsSchema() {
 		return this._effectsSchema;
 	}
+	get replySchemas() {
+		return this._replySchemas;
+	}
 	/** @internal */
 	constructor(initial, stateSchema, eventSchema, guardsSchema, effectsSchema) {
 		this.initial = initial;
@@ -108,6 +111,7 @@ var Machine = class Machine {
 		this._postponeRules = [];
 		this._guardsSchema = guardsSchema;
 		this._effectsSchema = effectsSchema;
+		this._replySchemas = eventSchema?._replySchemas ?? /* @__PURE__ */ new Map();
 		this._guardHandlers = /* @__PURE__ */ new Map();
 		this._effectHandlers = /* @__PURE__ */ new Map();
 		this.stateSchema = stateSchema;
@@ -378,6 +382,7 @@ var Machine = class Machine {
 			result._spawnEffects = [...this._spawnEffects];
 			result._backgroundEffects = [...this._backgroundEffects];
 			result._postponeRules = [...this._postponeRules];
+			result._replySchemas = this._replySchemas;
 			const anyHandlers = handlers;
 			if (this._guardsSchema !== void 0) for (const name of Object.keys(this._guardsSchema.definitions)) result._guardHandlers.set(name, anyHandlers[name]);
 			if (this._effectsSchema !== void 0) for (const name of Object.keys(this._effectsSchema.definitions)) result._effectHandlers.set(name, anyHandlers[name]);
@@ -385,10 +390,6 @@ var Machine = class Machine {
 		}
 		return new BuiltMachine(this);
 	}
-	/** @internal Persist from raw Machine — prefer BuiltMachine.persist() */
-	persist(config) {
-		return persist(config)(this);
-	}
 	static make(config) {
 		return new Machine(config.initial, config.state, config.event, config.guards, config.effects);
 	}
@@ -408,11 +409,71 @@ var TransitionScope = class {
 	}
 };
 const make = Machine.make;
-const spawn = Effect.fn("effect-machine.spawn")(function* (built, id) {
-	const actor = yield* createActor(id ?? `actor-${Math.random().toString(36).slice(2)}`, built._inner);
+/**
+* Spawn an actor from a built machine.
+*
+* Options:
+* - `id` — custom actor ID (default: random)
+* - `hydrate` — restore from a previously-saved state snapshot.
+*   The actor starts in the hydrated state and re-runs spawn effects
+*   for that state (timers, scoped resources, etc.). Transition history
+*   is not replayed — only the current state's entry effects run.
+*
+* Persistence is composed in userland by observing `actor.changes`
+* and saving snapshots to your own storage.
+*/
+const spawn = Effect.fn("effect-machine.spawn")(function* (built, idOrOptions) {
+	const opts = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+	const actor = yield* createActor(opts?.id ?? `actor-${Math.random().toString(36).slice(2)}`, built._inner, { initialState: opts?.hydrate });
 	const maybeScope = yield* Effect.serviceOption(Scope.Scope);
 	if (Option.isSome(maybeScope)) yield* Scope.addFinalizer(maybeScope.value, actor.stop);
 	return actor;
 });
+const replay = Effect.fn("effect-machine.replay")(function* (built, events, options) {
+	const machine = built._inner;
+	let state = options?.from ?? machine.initial;
+	const hasPostponeRules = machine.postponeRules.length > 0;
+	const postponed = [];
+	const dummySend = Effect.fn("effect-machine.replay.send")((_event) => Effect.void);
+	const self = {
+		send: dummySend,
+		cast: dummySend,
+		spawn: () => Effect.die("spawn not supported in replay"),
+		reply: () => Effect.succeed(false)
+	};
+	for (const event of events) {
+		if (machine.finalStates.has(state._tag)) break;
+		if (hasPostponeRules && shouldPostpone(machine, state._tag, event._tag)) {
+			postponed.push(event);
+			continue;
+		}
+		const transition = resolveTransition(machine, state, event);
+		if (transition !== void 0) {
+			const result = yield* runTransitionHandler(machine, transition, state, event, self, stubSystem, "replay");
+			const previousTag = state._tag;
+			state = result.newState;
+			if ((state._tag !== previousTag || transition.reenter === true) && postponed.length > 0) {
+				let drainTag = previousTag;
+				while (state._tag !== drainTag && postponed.length > 0) {
+					if (machine.finalStates.has(state._tag)) break;
+					drainTag = state._tag;
+					const drained = postponed.splice(0);
+					for (const postponedEvent of drained) {
+						if (machine.finalStates.has(state._tag)) break;
+						if (shouldPostpone(machine, state._tag, postponedEvent._tag)) {
+							postponed.push(postponedEvent);
+							continue;
+						}
+						const pTransition = resolveTransition(machine, state, postponedEvent);
+						if (pTransition !== void 0) state = (yield* runTransitionHandler(machine, pTransition, state, postponedEvent, self, stubSystem, "replay")).newState;
+					}
+				}
+			}
+		}
+	}
+	return state;
+});
+const reply = makeReply;
+const deferReply = makeDeferReply;
 //#endregion
-export { BuiltMachine, Machine, findTransitions, machine_exports, make, spawn };
+export { BuiltMachine, Machine, deferReply, findTransitions, machine_exports, make, replay, reply, spawn };

package/dist/schema.d.ts

@@ -1,7 +1,17 @@
-import { FullEventBrand, FullStateBrand } from "./internal/brands.js";
+import { FullEventBrand, FullStateBrand, ReplyTypeBrand } from "./internal/brands.js";
 import { Schema } from "effect";
 
 //#region src/schema.d.ts
+declare const ReplySchemaSymbol: unique symbol;
+type ReplySchemaSymbol = typeof ReplySchemaSymbol;
+/**
+ * Fields annotated with a reply schema.
+ * Structurally identical to Schema.Struct.Fields at runtime,
+ * but carries the reply schema type at compile time.
+ */
+type ReplyFields<F extends Schema.Struct.Fields, RS extends Schema.Schema<unknown>> = F & {
+  readonly [ReplySchemaSymbol]: RS;
+};
 /**
  * Extract the TypeScript type from a TaggedStruct schema
  */
@@ -12,20 +22,23 @@ type TaggedStructType<Tag extends string, Fields extends Schema.Struct.Fields> =
 type VariantSchemas<D extends Record<string, Schema.Struct.Fields>> = { readonly [K in keyof D & string]: Schema.TaggedStruct<K, D[K]> };
 /**
  * Build union type from variant schemas.
- * Used for constraining fluent method type params.
+ * Reply-bearing variants carry ReplyTypeBrand<R> for ask() inference.
  */
-type VariantsUnion<D extends Record<string, Schema.Struct.Fields>> = { [K in keyof D & string]: TaggedStructType<K, D[K]> }[keyof D & string];
+type VariantsUnion<D extends Record<string, Schema.Struct.Fields>> = { [K in keyof D & string]: TaggedStructType<K, D[K]> & (D[K] extends {
+  readonly [ReplySchemaSymbol]: Schema.Schema<infer R>;
+} ? ReplyTypeBrand<R> : unknown) }[keyof D & string];
 /**
- * Check if fields are empty (no required properties)
+ * Check if fields are empty (no required string properties).
+ * Symbol keys (like ReplySchemaSymbol) are metadata, not payload fields.
  */
-type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends never ? true : false;
+type IsEmptyFields<Fields extends Schema.Struct.Fields> = string & keyof Fields extends never ? true : false;
 /**
- * Constructor functions for each variant.
- * Empty structs: plain values with `_tag`: `State.Idle`
- * Non-empty structs require args: `State.Loading({ url })`
- *
- * Each variant also has a `derive` method for constructing from a source object.
+ * Resolve the reply brand for a variant's fields.
+ * If fields carry ReplySchemaSymbol, adds ReplyTypeBrand<R>.
  */
+type VariantReplyBrand<Fields extends Schema.Struct.Fields> = Fields extends {
+  readonly [ReplySchemaSymbol]: Schema.Schema<infer R>;
+} ? ReplyTypeBrand<R> : unknown;
 /**
  * Constructor functions for each variant.
  * Empty structs: plain values with `_tag`: `State.Idle`
@@ -33,10 +46,11 @@ type IsEmptyFields<Fields extends Schema.Struct.Fields> = keyof Fields extends n
  *
  * Each variant also has a `derive` method for constructing from a source object.
  * The source type uses `object` to accept branded state types without index signature issues.
+ * Reply-bearing variants carry ReplyTypeBrand<R> for ask() type inference.
  */
-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 & {
+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 & VariantReplyBrand<D[K]> & {
   readonly derive: (source: object) => TaggedStructType<K, D[K]> & Brand;
-} : ((args: Schema.Struct.Type<D[K]>) => TaggedStructType<K, D[K]> & Brand) & {
+} : ((args: Schema.Struct.Type<D[K]>) => TaggedStructType<K, D[K]> & Brand & VariantReplyBrand<D[K]>) & {
   readonly derive: (source: object, partial?: Partial<Schema.Struct.Type<D[K]>>) => TaggedStructType<K, D[K]> & Brand;
   readonly _tag: K;
 } };
@@ -67,6 +81,11 @@ interface MachineSchemaBase<D extends Record<string, Schema.Struct.Fields>, Bran
     <R>(cases: MatchCases<D, R>): (value: VariantsUnion<D> & Brand) => R;
     <R>(value: VariantsUnion<D> & Brand, cases: MatchCases<D, R>): R;
   };
+  /**
+   * Reply schemas per variant tag. Only populated for event schemas
+   * with variants defined via `Event.reply()`.
+   */
+  readonly _replySchemas: ReadonlyMap<string, Schema.Decoder<unknown>>;
 }
 /**
  * Schema-first state definition that provides:
@@ -116,26 +135,8 @@ type MachineEventSchema<D extends Record<string, Schema.Struct.Fields>> = Schema
  * ```
  */
 declare const State: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineStateSchema<D>;
-/**
- * Create a schema-first Event definition.
- *
- * The schema's definition type D creates a unique brand, preventing
- * accidental use of constructors from different event schemas
- * (unless they have identical definitions).
- *
- * @example
- * ```ts
- * const OrderEvent = MachineSchema.Event({
- *   Ship: { trackingId: Schema.String },
- *   Cancel: {},
- * })
- *
- * type OrderEvent = typeof OrderEvent.Type
- *
- * // Construct
- * const e = OrderEvent.Ship({ trackingId: "abc" })
- * ```
- */
-declare const Event: <const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>;
+declare const Event: (<const D extends Record<string, Schema.Struct.Fields>>(definition: D) => MachineEventSchema<D>) & {
+  reply: <F extends Schema.Struct.Fields, RS extends Schema.Schema<unknown>>(fields: F, replySchema: RS) => ReplyFields<F, RS>;
+};
 //#endregion
-export { Event, MachineEventSchema, MachineStateSchema, State, VariantsUnion };
+export { Event, MachineEventSchema, MachineStateSchema, ReplyFields, ReplySchemaSymbol, State, VariantsUnion };

package/dist/schema.js

@@ -38,6 +38,7 @@ import { Schema } from "effect";
 *
 * @module
 */
+const ReplySchemaSymbol = Symbol.for("effect-machine/ReplySchema");
 /**
 * Build a schema-first definition from a record of tag -> fields
 */
@@ -45,9 +46,14 @@ const RESERVED_DERIVE_KEYS = new Set(["_tag"]);
 const buildMachineSchema = (definition) => {
 	const variants = {};
 	const constructors = {};
+	const replySchemas = /* @__PURE__ */ new Map();
 	for (const tag of Object.keys(definition)) {
 		const fields = definition[tag];
 		if (fields === void 0) continue;
+		if (ReplySchemaSymbol in fields) {
+			const rs = fields[ReplySchemaSymbol];
+			if (rs !== void 0) replySchemas.set(tag, rs);
+		}
 		variants[tag] = Schema.TaggedStruct(tag, fields);
 		const fieldNames = new Set(Object.keys(fields));
 		if (fieldNames.size > 0) {
@@ -94,6 +100,7 @@ const buildMachineSchema = (definition) => {
 		variants,
 		constructors,
 		_definition: definition,
+		replySchemas,
 		$is,
 		$match
 	};
@@ -103,10 +110,11 @@ const buildMachineSchema = (definition) => {
 * Builds the schema object with variants, constructors, $is, and $match.
 */
 const createMachineSchema = (definition) => {
-	const { schema, variants, constructors, _definition, $is, $match } = buildMachineSchema(definition);
+	const { schema, variants, constructors, _definition, replySchemas, $is, $match } = buildMachineSchema(definition);
 	return Object.assign(Object.create(schema), {
 		variants,
 		_definition,
+		_replySchemas: replySchemas,
 		$is,
 		$match,
 		...constructors
@@ -149,19 +157,40 @@ const State = (definition) => createMachineSchema(definition);
 * accidental use of constructors from different event schemas
 * (unless they have identical definitions).
 *
+* Use `Event.reply(fields, replySchema)` to define events that support
+* typed `ask()` replies.
+*
 * @example
 * ```ts
-* const OrderEvent = MachineSchema.Event({
+* const OrderEvent = Event({
 *   Ship: { trackingId: Schema.String },
 *   Cancel: {},
+*   GetTotal: Event.reply({}, Schema.Number),
 * })
 *
 * type OrderEvent = typeof OrderEvent.Type
 *
 * // Construct
 * const e = OrderEvent.Ship({ trackingId: "abc" })
+*
+* // Typed ask
+* const total = yield* actor.ask(OrderEvent.GetTotal) // number
 * ```
 */
-const Event = (definition) => createMachineSchema(definition);
+const EventImpl = (definition) => createMachineSchema(definition);
+/**
+* Annotate event fields with a reply schema.
+* Events defined with `Event.reply(fields, replySchema)` enable typed `ask()`.
+*/
+const replyFieldsFn = (fields, replySchema) => {
+	const annotated = { ...fields };
+	Object.defineProperty(annotated, ReplySchemaSymbol, {
+		value: replySchema,
+		enumerable: false,
+		writable: false
+	});
+	return annotated;
+};
+const Event = Object.assign(EventImpl, { reply: replyFieldsFn });
 //#endregion
 export { Event, State };

package/dist/testing.js

@@ -30,7 +30,8 @@ const simulate = Effect.fn("effect-machine.simulate")(function* (input, events)
 	const dummySelf = {
 		send: dummySend,
 		cast: dummySend,
-		spawn: () => Effect.die("spawn not supported in simulation")
+		spawn: () => Effect.die("spawn not supported in simulation"),
+		reply: () => Effect.succeed(false)
 	};
 	let currentState = machine.initial;
 	const states = [currentState];
@@ -143,7 +144,8 @@ const createTestHarness = Effect.fn("effect-machine.createTestHarness")(function
 	const dummySelf = {
 		send: dummySend,
 		cast: dummySend,
-		spawn: () => Effect.die("spawn not supported in test harness")
+		spawn: () => Effect.die("spawn not supported in test harness"),
+		reply: () => Effect.succeed(false)
 	};
 	const stateRef = yield* SubscriptionRef.make(machine.initial);
 	const hasPostponeRules = machine.postponeRules.length > 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-machine",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/effect-machine.git"
@@ -56,7 +56,7 @@
     "release": "bun run build && changeset publish"
   },
   "dependencies": {
-    "effect": "4.0.0-beta.35"
+    "effect": "4.0.0-beta.42"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
@@ -64,7 +64,7 @@
     "@effect/language-service": "^0.82.0",
     "@types/bun": "1.3.11",
     "concurrently": "^9.2.1",
-    "effect-bun-test": "0.2.1",
+    "effect-bun-test": "0.3.0",
     "effect-v3": "npm:effect@^3.21.0",
     "lefthook": "^2.1.4",
     "oxfmt": "^0.41.0",
@@ -81,6 +81,6 @@
     }
   },
   "overrides": {
-    "effect": "4.0.0-beta.35"
+    "effect": "4.0.0-beta.42"
   }
 }

package/v3/dist/actor.d.ts

@@ -1,11 +1,9 @@
 import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
-import { PersistentMachine } from "./persistence/persistent-machine.js";
+import { ExtractReply, ReplyTypeBrand } from "./internal/brands.js";
 import { ActorStoppedError, DuplicateActorError, NoReplyError } from "./errors.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, MachineRef } from "./machine.js";
-import { Context, Deferred, Effect, Layer, Option, Queue, Ref, Scope, Stream, SubscriptionRef } from "effect";
+import { Context, Deferred, Effect, Layer, Option, PubSub, Queue, Ref, Scope, Stream, SubscriptionRef } from "effect";
 import * as effect_dist_dts_Tracer_js0 from "effect/dist/dts/Tracer.js";
 
 //#region src/actor.d.ts
@@ -39,6 +37,15 @@ interface ActorRefSync<State extends {
   readonly matches: (tag: State["_tag"]) => boolean;
   readonly can: (event: Event) => boolean;
 }
+/**
+ * Information about a successful transition.
+ * Emitted on the `transitions` stream after each accepted event.
+ */
+interface TransitionInfo<State, Event> {
+  readonly fromState: State;
+  readonly toState: State;
+  readonly event: Event;
+}
 interface ActorRef<State extends {
   readonly _tag: string;
 }, Event> {
@@ -53,11 +60,11 @@ interface ActorRef<State extends {
    */
   readonly call: (event: Event) => Effect.Effect<ProcessEventResult<State>>;
   /**
-   * Typed request-reply. Event is processed through the queue; caller gets
-   * the domain value returned by the handler's `reply` field.
+   * Typed request-reply. Accepts only events with a reply schema
+   * (defined via `Event.reply()`). Return type is inferred from the schema.
    * Fails with NoReplyError if the handler doesn't provide a reply.
    */
-  readonly ask: <R>(event: Event) => Effect.Effect<R, NoReplyError | ActorStoppedError>;
+  readonly ask: <E extends Event & ReplyTypeBrand<unknown>>(event: E) => Effect.Effect<ExtractReply<E>, NoReplyError | ActorStoppedError>;
   /** Observable state. */
   readonly state: SubscriptionRef.SubscriptionRef<State>;
   /** Stop the actor gracefully. */
@@ -70,6 +77,14 @@ interface ActorRef<State extends {
   readonly can: (event: Event) => Effect.Effect<boolean>;
   /** Stream of state changes. */
   readonly changes: Stream.Stream<State>;
+  /**
+   * Stream of accepted transitions (edge stream).
+   *
+   * Emits `{ fromState, toState, event }` on every successful transition,
+   * including same-state reenters. PubSub-backed — late subscribers miss
+   * past edges. This is observational, not a durability guarantee.
+   */
+  readonly transitions: Stream.Stream<TransitionInfo<State, Event>>;
   /** Wait for a state matching predicate or variant (includes current snapshot). */
   readonly waitFor: {
     (predicate: (state: State) => boolean): Effect.Effect<State>;
@@ -123,54 +138,17 @@ 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 spawn: <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>;
+  }, R>(id: string, machine: BuiltMachine<S, E, R>) => Effect.Effect<ActorRef<S, E>, DuplicateActorError, R>;
   /**
    * Get an existing actor by ID
    */
@@ -194,53 +172,6 @@ interface ActorSystem {
    * 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
@@ -259,7 +190,7 @@ 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<QueuedEvent<E>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>) => ActorRef<S, E>;
+}, 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<QueuedEvent<E>>, stoppedRef: Ref.Ref<boolean>, listeners: Listeners<S>, stop: Effect.Effect<void>, system: ActorSystem, childrenMap: ReadonlyMap<string, ActorRef<AnyState, unknown>>, pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, transitionsPubSub?: PubSub.PubSub<TransitionInfo<S, E>>) => ActorRef<S, E>;
 /**
  * Create and start an actor for a machine
  */
@@ -267,7 +198,9 @@ 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_dist_dts_Tracer_js0.ParentSpan> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope> | Exclude<Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>, effect_dist_dts_Tracer_js0.ParentSpan>>;
+}, R, GD extends GuardsDef, EFD extends EffectsDef>(id: string, machine: Machine<S, E, R, Record<string, never>, Record<string, never>, GD, EFD>, options?: {
+  initialState?: S;
+} | undefined) => Effect.Effect<ActorRef<S, E>, never, Exclude<R, MachineContext<S, E, MachineRef<E>>> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, effect_dist_dts_Tracer_js0.ParentSpan> | Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope> | Exclude<Exclude<Exclude<R, MachineContext<S, E, MachineRef<E>>>, Scope.Scope>, effect_dist_dts_Tracer_js0.ParentSpan>>;
 /** Fail all pending call/ask Deferreds with ActorStoppedError. Safe to call multiple times. */
 declare const settlePendingReplies: (pendingReplies: Set<Deferred.Deferred<unknown, unknown>>, actorId: string) => Effect.Effect<void, never, never>;
 /**
@@ -275,4 +208,4 @@ declare const settlePendingReplies: (pendingReplies: Set<Deferred.Deferred<unkno
  */
 declare const Default: Layer.Layer<ActorSystem, never, never>;
 //#endregion
-export { ActorRef, ActorRefSync, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };
+export { ActorRef, ActorRefSync, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, TransitionInfo, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };