effect-machine 0.9.0 → 0.11.0

package/README.md

@@ -74,8 +74,12 @@ const orderMachine = Machine.make({
 const program = Effect.gen(function* () {
   const actor = yield* Machine.spawn(orderMachine);
 
+  // fire-and-forget
   yield* actor.send(OrderEvent.Process);
-  yield* actor.send(OrderEvent.Ship({ trackingId: "TRACK-123" }));
+
+  // request-reply — get ProcessEventResult back
+  const result = yield* actor.call(OrderEvent.Ship({ trackingId: "TRACK-123" }));
+  console.log(result.transitioned); // true
 
   const state = yield* actor.waitFor(OrderState.Shipped);
   console.log(state); // Shipped { orderId: "order-1", trackingId: "TRACK-123" }
@@ -183,6 +187,53 @@ machine.task(State.Loading, ({ effects, state }) => effects.fetchData({ url: sta
 });
 ```
 
+### State Timeouts
+
+`.timeout()` — gen_statem-style state timeouts. Timer starts on state entry, cancels on exit:
+
+```ts
+machine
+  .timeout(State.Loading, {
+    duration: Duration.seconds(30),
+    event: Event.Timeout,
+  })
+  // Dynamic duration from state
+  .timeout(State.Retrying, {
+    duration: (state) => Duration.seconds(state.backoff),
+    event: Event.GiveUp,
+  });
+```
+
+`.reenter()` restarts the timer with fresh state values.
+
+### Event Postpone
+
+`.postpone()` — gen_statem-style event postpone. When a matching event arrives in the given state, it is buffered. After the next state transition (tag change), buffered events drain in FIFO order, looping until stable:
+
+```ts
+machine
+  .postpone(State.Connecting, Event.Data) // single event
+  .postpone(State.Connecting, [Event.Data, Event.Cmd]); // multiple events
+```
+
+Reply-bearing events (`call`/`ask`) in the postpone buffer are settled with `ActorStoppedError` on stop/interrupt/final-state.
+
+### ask / reply
+
+Handlers can return a domain reply via `{ state, reply }`:
+
+```ts
+.on(State.Active, Event.GetCount, ({ state }) => ({
+  state, // stay in same state
+  reply: state.count, // domain value returned to caller
+}))
+
+// Caller side:
+const count = yield* actor.ask<number>(Event.GetCount);
+```
+
+`ask` fails with `NoReplyError` if the handler doesn't provide a reply, and `ActorStoppedError` if the actor stops while the request is pending.
+
 ### Child Actors
 
 Spawn children from `.spawn()` handlers with `self.spawn`. Children are state-scoped — auto-stopped on state exit:
@@ -206,6 +257,31 @@ const child = yield * parent.system.get("worker-1"); // Option<ActorRef>
 
 Every actor always has a system — `Machine.spawn` creates an implicit one if no `ActorSystem` is in context.
 
+### Persistence
+
+Persistence is composed from primitives — no built-in adapter or framework:
+
+```ts
+// Snapshot persistence — observe state changes, save externally
+yield * actor.changes.pipe(Stream.runForEach((state) => saveSnapshot(actor.id, state)));
+
+// Event journal — observe transitions
+yield * actor.transitions.pipe(Stream.runForEach(({ event }) => appendEvent(actor.id, event)));
+
+// Restore from snapshot
+const savedState = yield * loadSnapshot(id);
+const actor = yield * Machine.spawn(machine, { hydrate: savedState });
+
+// Restore from event log
+const events = yield * loadEvents(id);
+const state = yield * Machine.replay(machine, events);
+const actor = yield * Machine.spawn(machine, { hydrate: state });
+
+// Restore from snapshot + tail events
+const state = yield * Machine.replay(machine, tailEvents, { from: snapshot });
+const actor = yield * Machine.spawn(machine, { hydrate: state });
+```
+
 ### System Observation
 
 React to actors joining and leaving the system:
@@ -245,21 +321,6 @@ expect(result.states.map((s) => s._tag)).toEqual(["Idle", "Loading", "Done"]);
 yield * assertPath(machine, events, ["Idle", "Loading", "Done"]);
 ```
 
-## Documentation
-
-See the [primer](./primer/) for comprehensive documentation:
-
-| Topic       | File                                      | Description                    |
-| ----------- | ----------------------------------------- | ------------------------------ |
-| Overview    | [index.md](./primer/index.md)             | Navigation and quick reference |
-| Basics      | [basics.md](./primer/basics.md)           | Core concepts                  |
-| Handlers    | [handlers.md](./primer/handlers.md)       | Transitions and guards         |
-| Effects     | [effects.md](./primer/effects.md)         | spawn, background, timeouts    |
-| Testing     | [testing.md](./primer/testing.md)         | simulate, harness, assertions  |
-| Actors      | [actors.md](./primer/actors.md)           | ActorSystem, ActorRef          |
-| Persistence | [persistence.md](./primer/persistence.md) | Snapshots, event sourcing      |
-| Gotchas     | [gotchas.md](./primer/gotchas.md)         | Common mistakes                |
-
 ## API Quick Reference
 
 ### Building
@@ -273,55 +334,47 @@ See the [primer](./primer/) for comprehensive documentation:
 | `.reenter(State.X, Event.Y, handler)`     | Force re-entry on same state                                |
 | `.spawn(State.X, handler)`                | State-scoped effect                                         |
 | `.task(State.X, run, { onSuccess })`      | State-scoped task                                           |
+| `.timeout(State.X, { duration, event })`  | State timeout (gen_statem)                                  |
+| `.postpone(State.X, Event.Y)`             | Postpone event in state (gen_statem)                        |
 | `.background(handler)`                    | Machine-lifetime effect                                     |
 | `.final(State.X)`                         | Mark final state                                            |
 | `.build({ slot: impl })`                  | Provide implementations, returns `BuiltMachine` (terminal)  |
 | `.build()`                                | Finalize no-slot machine, returns `BuiltMachine` (terminal) |
-| `.persist(config)`                        | Enable persistence                                          |
-
-### State Constructors
-
-| Method                                 | Purpose                        |
-| -------------------------------------- | ------------------------------ |
-| `State.X.derive(source)`               | Pick target fields from source |
-| `State.X.derive(source, { field: v })` | Pick fields + apply overrides  |
-| `State.$is("X")(value)`                | Type guard                     |
-| `State.$match(value, { X: fn, ... })`  | Pattern matching               |
 
 ### Running
 
-| Method                       | Purpose                                                                                                 |
-| ---------------------------- | ------------------------------------------------------------------------------------------------------- |
-| `Machine.spawn(machine)`     | Single actor, no registry. Caller manages lifetime via `actor.stop`. Auto-cleans up if `Scope` present. |
-| `Machine.spawn(machine, id)` | Same as above with custom ID                                                                            |
-| `system.spawn(id, machine)`  | Registry, lookup by ID, bulk ops, persistence. Cleans up on system teardown.                            |
-
-### Testing
-
-| Function                                   | Description                                                      |
-| ------------------------------------------ | ---------------------------------------------------------------- |
-| `simulate(machine, events)`                | Run events, get all states (accepts `Machine` or `BuiltMachine`) |
-| `createTestHarness(machine)`               | Step-by-step testing (accepts `Machine` or `BuiltMachine`)       |
-| `assertPath(machine, events, path)`        | Assert exact path                                                |
-| `assertReaches(machine, events, tag)`      | Assert final state                                               |
-| `assertNeverReaches(machine, events, tag)` | Assert state never visited                                       |
+| Method                                   | Purpose                                                                                                 |
+| ---------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| `Machine.spawn(machine)`                 | Single actor, no registry. Caller manages lifetime via `actor.stop`. Auto-cleans up if `Scope` present. |
+| `Machine.spawn(machine, id)`             | Same as above with custom ID                                                                            |
+| `Machine.spawn(machine, { hydrate: s })` | Restore from saved state — re-runs spawn effects for that state                                         |
+| `Machine.replay(machine, events)`        | Fold events through handlers to compute state (for event sourcing restore)                              |
+| `system.spawn(id, machine)`              | Registry, lookup by ID, bulk ops. Cleans up on system teardown.                                         |
 
 ### Actor
 
-| Method                           | Description                        |
-| -------------------------------- | ---------------------------------- |
-| `actor.send(event)`              | Queue event                        |
-| `actor.sendSync(event)`          | Fire-and-forget (sync, for UI)     |
-| `actor.snapshot`                 | Get current state                  |
-| `actor.matches(tag)`             | Check state tag                    |
-| `actor.can(event)`               | Can handle event?                  |
-| `actor.changes`                  | Stream of changes                  |
-| `actor.waitFor(State.X)`         | Wait for state (constructor or fn) |
-| `actor.awaitFinal`               | Wait final state                   |
-| `actor.sendAndWait(ev, State.X)` | Send + wait for state              |
-| `actor.subscribe(fn)`            | Sync callback                      |
-| `actor.system`                   | Access the actor's `ActorSystem`   |
-| `actor.children`                 | Child actors (`ReadonlyMap`)       |
+| Method                           | Description                                     |
+| -------------------------------- | ----------------------------------------------- |
+| `actor.send(event)`              | Fire-and-forget (queue event)                   |
+| `actor.cast(event)`              | Alias for send (OTP gen_server:cast)            |
+| `actor.call(event)`              | Request-reply, returns `ProcessEventResult`     |
+| `actor.ask<R>(event)`            | Typed domain reply from handler                 |
+| `actor.snapshot`                 | Get current state                               |
+| `actor.matches(tag)`             | Check state tag                                 |
+| `actor.can(event)`               | Can handle event?                               |
+| `actor.changes`                  | Stream of state changes                         |
+| `actor.transitions`              | Stream of `{ fromState, toState, event }` edges |
+| `actor.waitFor(State.X)`         | Wait for state (constructor or fn)              |
+| `actor.awaitFinal`               | Wait final state                                |
+| `actor.sendAndWait(ev, State.X)` | Send + wait for state                           |
+| `actor.subscribe(fn)`            | Sync callback                                   |
+| `actor.sync.send(event)`         | Sync fire-and-forget (for UI)                   |
+| `actor.sync.stop()`              | Sync stop                                       |
+| `actor.sync.snapshot()`          | Sync get state                                  |
+| `actor.sync.matches(tag)`        | Sync check state tag                            |
+| `actor.sync.can(event)`          | Sync can handle event?                          |
+| `actor.system`                   | Access the actor's `ActorSystem`                |
+| `actor.children`                 | Child actors (`ReadonlyMap`)                    |
 
 ### ActorSystem
 
@@ -334,6 +387,16 @@ See the [primer](./primer/) for comprehensive documentation:
 | `system.subscribe(fn)` | Sync callback for spawn/stop events         |
 | `system.events`        | Async `Stream<SystemEvent>` for spawn/stop  |
 
+### Testing
+
+| Function                                   | Description                                                      |
+| ------------------------------------------ | ---------------------------------------------------------------- |
+| `simulate(machine, events)`                | Run events, get all states (accepts `Machine` or `BuiltMachine`) |
+| `createTestHarness(machine)`               | Step-by-step testing (accepts `Machine` or `BuiltMachine`)       |
+| `assertPath(machine, events, path)`        | Assert exact path                                                |
+| `assertReaches(machine, events, tag)`      | Assert final state                                               |
+| `assertNeverReaches(machine, events, tag)` | Assert state never visited                                       |
+
 ## License
 
 MIT

package/dist/actor.d.ts

@@ -1,95 +1,99 @@
 import { EffectsDef, GuardsDef, MachineContext } from "./slot.js";
-import { PersistentMachine } from "./persistence/persistent-machine.js";
-import { DuplicateActorError } from "./errors.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 { Deferred, Effect, Layer, Option, Queue, Ref, Scope, ServiceMap, Stream, SubscriptionRef } from "effect";
+import { Deferred, Effect, Layer, Option, PubSub, Queue, Ref, Scope, ServiceMap, Stream, SubscriptionRef } from "effect";
 import * as effect_Tracer0 from "effect/Tracer";
 
 //#region src/actor.d.ts
-/** Queued event with optional reply channel */
-interface QueuedEvent<E> {
+/** Discriminated mailbox request */
+type QueuedEvent<E> = {
+  readonly _tag: "send";
   readonly event: E;
-  readonly reply?: Deferred.Deferred<ProcessEventResult<{
+} | {
+  readonly _tag: "call";
+  readonly event: E;
+  readonly reply: Deferred.Deferred<ProcessEventResult<{
     readonly _tag: string;
-  }>>;
-}
+  }>, ActorStoppedError>;
+} | {
+  readonly _tag: "ask";
+  readonly event: E;
+  readonly reply: Deferred.Deferred<unknown, NoReplyError | ActorStoppedError>;
+};
 /**
  * Reference to a running actor.
  */
+/**
+ * Sync projection of ActorRef for non-Effect boundaries (React hooks, framework callbacks).
+ */
+interface ActorRefSync<State extends {
+  readonly _tag: string;
+}, Event> {
+  readonly send: (event: Event) => void;
+  readonly stop: () => void;
+  readonly snapshot: () => State;
+  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> {
-  /**
-   * Unique identifier for this actor
-   */
   readonly id: string;
-  /**
-   * Send an event to the actor
-   */
+  /** Send an event (fire-and-forget). */
   readonly send: (event: Event) => Effect.Effect<void>;
+  /** Fire-and-forget alias for send (OTP gen_server:cast). */
+  readonly cast: (event: Event) => Effect.Effect<void>;
   /**
-   * Observable state of the actor
+   * Serialized request-reply (OTP gen_server:call).
+   * Event is processed through the queue; caller gets ProcessEventResult back.
    */
-  readonly state: SubscriptionRef.SubscriptionRef<State>;
+  readonly call: (event: Event) => Effect.Effect<ProcessEventResult<State>>;
   /**
-   * Stop the actor gracefully
+   * Typed request-reply. Event is processed through the queue; caller gets
+   * the domain value returned by the handler's `reply` field.
+   * Fails with NoReplyError if the handler doesn't provide a reply.
    */
+  readonly ask: <R>(event: Event) => Effect.Effect<R, NoReplyError | ActorStoppedError>;
+  /** Observable state. */
+  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)
-   */
+  /** Get current state snapshot. */
   readonly snapshot: Effect.Effect<State>;
-  /**
-   * Get current state snapshot (sync)
-   */
-  readonly snapshotSync: () => State;
-  /**
-   * Check if current state matches tag (Effect)
-   */
+  /** Check if current state matches tag. */
   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)
-   */
+  /** Check if event can be handled in current state. */
   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
-   */
+  /** 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`).
+   * 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>;
     (state: {
       readonly _tag: State["_tag"];
     }): Effect.Effect<State>;
   };
-  /**
-   * Wait for a final state (includes current snapshot)
-   */
+  /** 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`).
-   */
+  /** Send event and wait for predicate, state variant, or final state. */
   readonly sendAndWait: {
     (event: Event, predicate: (state: State) => boolean): Effect.Effect<State>;
     (event: Event, state: {
@@ -97,39 +101,13 @@ interface ActorRef<State extends {
     }): 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;
-  /**
-   * Send event and wait for the transition result (synchronous processing).
-   * The event is processed through the queue (preserving serialization)
-   * but the caller gets back the ProcessEventResult.
-   *
-   * OTP gen_server:call equivalent — use when you need to know what happened.
-   */
-  readonly dispatch: (event: Event) => Effect.Effect<ProcessEventResult<State>>;
-  /**
-   * Promise-based dispatch — send event and get back the transition result.
-   * Use at non-Effect boundaries (React event handlers, framework hooks, tests).
-   */
-  readonly dispatchPromise: (event: Event) => Promise<ProcessEventResult<State>>;
-  /**
-   * Subscribe to state changes (sync callback)
-   * Returns unsubscribe function
-   */
+  /** 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.
-   */
+  /** Sync helpers for non-Effect boundaries. */
+  readonly sync: ActorRefSync<State, Event>;
+  /** The actor system this actor belongs to. */
   readonly system: ActorSystem;
-  /**
-   * Child actors spawned via `self.spawn` in this actor's handlers.
-   * State-scoped children are auto-removed on state exit.
-   */
+  /** Child actors spawned via `self.spawn` in this actor's handlers. */
   readonly children: ReadonlyMap<string, ActorRef<AnyState, unknown>>;
 }
 /** Base type for stored actors (internal) */
@@ -159,54 +137,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
    */
@@ -230,53 +171,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
@@ -289,13 +183,13 @@ type Listeners<S> = Set<(state: S) => void>;
  */
 declare const notifyListeners: <S>(listeners: Listeners<S>, state: S) => void;
 /**
- * Build core ActorRef methods shared between regular and persistent actors.
+ * Build core ActorRef methods.
  */
 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>>) => 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
  */
@@ -303,10 +197,14 @@ 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>>;
+}, 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_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>>;
+/** 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>;
 /**
  * Default ActorSystem layer
  */
 declare const Default: Layer.Layer<ActorSystem, never, never>;
 //#endregion
-export { ActorRef, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects };
+export { ActorRef, ActorRefSync, ActorSystem, Default, Listeners, type ProcessEventError, type ProcessEventHooks, type ProcessEventResult, QueuedEvent, SystemEvent, SystemEventListener, TransitionInfo, buildActorRefCore, createActor, notifyListeners, processEventCore, resolveTransition, runSpawnEffects, settlePendingReplies };