xstate 5.0.2 → 5.2.0

package/dist/declarations/src/index.d.ts

@@ -2,20 +2,21 @@ export * from "./actions.js";
 export * from "./actors/index.js";
 export { SimulatedClock } from "./SimulatedClock.js";
 export { type Spawner } from "./spawn.js";
+export { isMachineSnapshot, type MachineSnapshot } from "./State.js";
 export { StateMachine } from "./StateMachine.js";
 export { getStateNodes } from "./stateUtils.js";
 export * from "./typegenTypes.js";
 export * from "./types.js";
 export { waitFor } from "./waitFor.js";
-import { Actor, createActor, interpret, Interpreter } from "./interpreter.js";
 import { createMachine } from "./createMachine.js";
-export { type MachineSnapshot, isMachineSnapshot } from "./State.js";
+import { Actor, createActor, interpret, Interpreter } from "./interpreter.js";
 import { StateNode } from "./StateNode.js";
-export { matchesState, pathToStateValue, toObserver, getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors } from "./utils.js";
-export { Actor, createActor, createMachine, interpret, StateNode, type Interpreter };
-export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./system.js";
 export { and, not, or, stateIn } from "./guards.js";
 export { setup } from "./setup.js";
+export type { ActorSystem, InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./system.js";
+export { toPromise } from "./toPromise.js";
+export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, pathToStateValue, toObserver } from "./utils.js";
+export { Actor, createActor, createMachine, interpret, StateNode, type Interpreter };
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

package/dist/declarations/src/interpreter.d.ts

@@ -1,16 +1,13 @@
 import { symbolObservable } from "./symbolObservable.js";
+import { AnyActorSystem, Clock } from "./system.js";
 import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
-import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, SnapshotFrom, Snapshot } from "./types.js";
-import { ActorRef, EventObject, InteropSubscribable, ActorOptions, Observer, Subscription } from "./types.js";
+import type { AnyActorLogic, AnyStateMachine, EventFromLogic, Snapshot, SnapshotFrom } from "./types.js";
+import { ActorOptions, ActorRef, EventObject, InteropSubscribable, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
 export type SnapshotListener<TLogic extends AnyActorLogic> = (snapshot: SnapshotFrom<TLogic>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;
 export type ErrorListener = (error: any) => void;
-export interface Clock {
-    setTimeout(fn: (...args: any[]) => void, timeout: number): any;
-    clearTimeout(id: any): void;
-}
 export declare enum ProcessingStatus {
     NotStarted = 0,
     Running = 1,
@@ -35,7 +32,6 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
      */
     id: string;
     private mailbox;
-    private delayedEventsMap;
     private observers;
     private logger;
     _parent?: ActorRef<any, any>;
@@ -50,7 +46,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
     /**
      * The system to which this actor belongs.
      */
-    system: ActorSystem<any>;
+    system: AnyActorSystem;
     private _doneEvent?;
     src: string | AnyActorLogic;
     /**

package/dist/declarations/src/spawn.d.ts

@@ -11,9 +11,10 @@ type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TA
         [K in RequiredActorOptions<TActor>]: unknown;
     }
 ], IsNotNever<RequiredActorOptions<TActor>>> : never;
-export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>) => ActorRefFrom<(TActor & {
+type GetConcreteLogic<TActor extends ProvidedActor, TSrc extends TActor['src']> = Extract<TActor, {
     src: TSrc;
-})['logic']> : <TLogic extends AnyActorLogic | string>(src: TLogic, options?: {
+}>['logic'];
+export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>) => ActorRefFrom<GetConcreteLogic<TActor, TSrc>> : <TLogic extends AnyActorLogic | string>(src: TLogic, options?: {
     id?: string;
     systemId?: string;
     input?: unknown;

package/dist/declarations/src/system.d.ts

@@ -1,5 +1,35 @@
-import { AnyEventObject, ActorSystem, ActorSystemInfo, AnyActorRef, Snapshot } from "./types.js";
-export declare function createSystem<T extends ActorSystemInfo>(rootActor: AnyActorRef): ActorSystem<T>;
+import { AnyEventObject, ActorSystemInfo, AnyActorRef, Observer, Snapshot, EventObject } from "./types.js";
+export interface ScheduledEvent {
+    id: string;
+    event: EventObject;
+    startedAt: number;
+    delay: number;
+    source: AnyActorRef;
+    target: AnyActorRef;
+}
+export interface Clock {
+    setTimeout(fn: (...args: any[]) => void, timeout: number): any;
+    clearTimeout(id: any): void;
+}
+export interface Scheduler {
+    schedule(source: AnyActorRef, target: AnyActorRef, event: EventObject, delay: number, id: string | undefined): void;
+    cancel(source: AnyActorRef, id: string): void;
+    cancelAll(actorRef: AnyActorRef): void;
+}
+export interface ActorSystem<T extends ActorSystemInfo> {
+    get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
+    inspect: (observer: Observer<InspectionEvent>) => void;
+    scheduler: Scheduler;
+    getSnapshot: () => {
+        _scheduledEvents: Record<string, ScheduledEvent>;
+    };
+    start: () => void;
+}
+export type AnyActorSystem = ActorSystem<any>;
+export declare function createSystem<T extends ActorSystemInfo>(rootActor: AnyActorRef, options: {
+    clock: Clock;
+    snapshot?: unknown;
+}): ActorSystem<T>;
 export interface BaseInspectionEventProperties {
     rootId: string;
     /**

package/dist/declarations/src/toPromise.d.ts

@@ -0,0 +1,24 @@
+import { AnyActorRef, OutputFrom } from "./types.js";
+/**
+ * Returns a promise that resolves to the `output` of the actor when it is done.
+ *
+ * @example
+ * ```ts
+ * const machine = createMachine({
+ *   // ...
+ *   output: {
+ *     count: 42
+ *   }
+ * });
+ *
+ * const actor = createActor(machine);
+ *
+ * actor.start();
+ *
+ * const output = await toPromise(actor);
+ *
+ * console.log(output);
+ * // logs { count: 42 }
+ * ```
+ */
+export declare function toPromise<T extends AnyActorRef>(actor: T): Promise<OutputFrom<T>>;

package/dist/declarations/src/types.d.ts

@@ -1,13 +1,13 @@
-import type { StateNode } from "./StateNode.js";
 import type { MachineSnapshot } from "./State.js";
-import type { Clock, Actor } from "./interpreter.js";
 import type { StateMachine } from "./StateMachine.js";
-import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from "./typegenTypes.js";
+import type { StateNode } from "./StateNode.js";
+import { AssignArgs } from "./actions/assign.js";
 import { PromiseActorLogic } from "./actors/promise.js";
 import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
+import type { Actor } from "./interpreter.js";
 import { Spawner } from "./spawn.js";
-import { AssignArgs } from "./actions/assign.js";
-import { InspectionEvent } from './system.js';
+import { AnyActorSystem, InspectionEvent, Clock } from './system.js';
+import { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from "./typegenTypes.js";
 export type Identity<T> = {
     [K in keyof T]: T[K];
 };
@@ -82,7 +82,7 @@ export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent ex
     event: TExpressionEvent;
     self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
     StateValue, string, unknown>, TEvent>;
-    system: ActorSystem<any>;
+    system: AnyActorSystem;
 }
 export type MachineContext = Record<string, any>;
 export interface ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
@@ -90,6 +90,8 @@ export interface ActionArgs<TContext extends MachineContext, TExpressionEvent ex
 export type InputFrom<T> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TSystem> ? TInput : never;
 export type OutputFrom<T> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem> ? (TSnapshot & {
     status: 'done';
+})['output'] : T extends ActorRef<infer TSnapshot, infer _TEvent> ? (TSnapshot & {
+    status: 'done';
 })['output'] : never;
 export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
     (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
@@ -746,7 +748,7 @@ export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends Ev
     stop: () => void;
     toJSON?: () => any;
     _parent?: ActorRef<any, any>;
-    system?: ActorSystem<any>;
+    system: AnyActorSystem;
     src: string | AnyActorLogic;
 }
 export type AnyActorRef = ActorRef<any, any>;
@@ -756,7 +758,7 @@ export type DevToolsAdapter = (service: AnyActor) => void;
 /**
  * @deprecated Use `Actor<T>` instead.
  */
-export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TStateValue, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, ActorSystem<any>>> : never;
+export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TStateValue, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, AnyActorSystem>> : never;
 export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, // context
 any, // event
@@ -769,7 +771,7 @@ any, // tag
 any, // input
 any, // output
 infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
-export interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+export interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TSystem extends AnyActorSystem = AnyActorSystem> {
     self: ActorRef<TSnapshot, TEvent>;
     id: string;
     sessionId: string;
@@ -806,7 +808,7 @@ export type Snapshot<TOutput> = {
  */
 export interface ActorLogic<in out TSnapshot extends Snapshot<unknown>, // it's invariant because it's also part of `ActorScope["self"]["getSnapshot"]`
 in out TEvent extends EventObject, // it's invariant because it's also part of `ActorScope["self"]["send"]`
-in TInput = NonReducibleUnknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem> {
     /** The initial setup/configuration used to create the actor logic. */
     config?: unknown;
     /**
@@ -851,7 +853,7 @@ export type AnyActorLogic = ActorLogic<any, // snapshot
 any, // event
 any, // input
 any>;
-export type UnknownActorLogic = ActorLogic<any, any, never, ActorSystem<any>>;
+export type UnknownActorLogic = ActorLogic<any, any, never, AnyActorSystem>;
 export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer TSnapshot, infer _> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends ActorLogic<infer _, infer __, infer ___, infer ____> ? ReturnType<R['transition']> : R extends ActorScope<infer TSnapshot, infer _, infer __> ? TSnapshot : never : never;
 export type EventFromLogic<TLogic extends ActorLogic<any, any, any, any>> = TLogic extends ActorLogic<infer _, infer TEvent, infer __, infer _____> ? TEvent : never;
 type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer _, infer TEvent> ? TEvent : never : never;
@@ -870,11 +872,6 @@ export type TagsFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TM
 export interface ActorSystemInfo {
     actors: Record<string, AnyActorRef>;
 }
-export interface ActorSystem<T extends ActorSystemInfo> {
-    get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
-    inspect: (observer: Observer<InspectionEvent>) => void;
-}
-export type AnyActorSystem = ActorSystem<any>;
 export type RequiredActorOptions<TActor extends ProvidedActor> = (undefined extends TActor['id'] ? never : 'id') | (undefined extends InputFrom<TActor['logic']> ? never : 'input');
 type ExtractLiteralString<T extends string | undefined> = T extends string ? string extends T ? never : T : never;
 type ToConcreteChildren<TActor extends ProvidedActor> = {

package/dist/{log-22e678c5.esm.js → log-5409ee89.esm.js}

@@ -1,5 +1,8 @@
-import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, U as XSTATE_ERROR, V as createErrorActorEvent, e as evaluateGuard, L as cancel, M as raise, O as spawnChild, Q as stopChild } from './raise-8bc422d1.esm.js';
+import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, U as XSTATE_ERROR, V as createErrorActorEvent, e as evaluateGuard, L as cancel, M as raise, O as spawnChild, Q as stopChild } from './raise-5d7ae4b7.esm.js';
 
+// it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
+// but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)
+// and we strive to support TS 5.0 whenever possible
 function createSpawner(actorScope, {
   machine,
   context
@@ -214,19 +217,23 @@ function retryResolveSendTo(_, snapshot, params) {
   }
 }
 function executeSendTo(actorScope, params) {
-  if (typeof params.delay === 'number') {
-    actorScope.self.delaySend(params);
-    return;
-  }
-
   // this forms an outgoing events queue
   // thanks to that the recipient actors are able to read the *updated* snapshot value of the sender
   actorScope.defer(() => {
     const {
       to,
-      event
+      event,
+      delay,
+      id
     } = params;
-    actorScope?.system._relay(actorScope.self, to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorScope.self.id, event.data) : event);
+    if (typeof delay === 'number') {
+      actorScope.system.scheduler.schedule(actorScope.self, to, event, delay, id);
+      return;
+    }
+    actorScope.system._relay(actorScope.self,
+    // at this point, in a deferred task, it should already be mutated by retryResolveSendTo
+    // if it initially started as a string
+    to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorScope.self.id, event.data) : event);
   });
 }
 /**

package/dist/{log-f196f85f.development.esm.js → log-557e5fa3.development.esm.js}

@@ -1,5 +1,8 @@
-import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, U as XSTATE_ERROR, V as createErrorActorEvent, e as evaluateGuard, L as cancel, M as raise, O as spawnChild, Q as stopChild } from './raise-89c581c4.development.esm.js';
+import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, U as XSTATE_ERROR, V as createErrorActorEvent, e as evaluateGuard, L as cancel, M as raise, O as spawnChild, Q as stopChild } from './raise-0ff85b7b.development.esm.js';
 
+// it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
+// but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)
+// and we strive to support TS 5.0 whenever possible
 function createSpawner(actorScope, {
   machine,
   context
@@ -217,19 +220,23 @@ function retryResolveSendTo(_, snapshot, params) {
   }
 }
 function executeSendTo(actorScope, params) {
-  if (typeof params.delay === 'number') {
-    actorScope.self.delaySend(params);
-    return;
-  }
-
   // this forms an outgoing events queue
   // thanks to that the recipient actors are able to read the *updated* snapshot value of the sender
   actorScope.defer(() => {
     const {
       to,
-      event
+      event,
+      delay,
+      id
     } = params;
-    actorScope?.system._relay(actorScope.self, to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorScope.self.id, event.data) : event);
+    if (typeof delay === 'number') {
+      actorScope.system.scheduler.schedule(actorScope.self, to, event, delay, id);
+      return;
+    }
+    actorScope.system._relay(actorScope.self,
+    // at this point, in a deferred task, it should already be mutated by retryResolveSendTo
+    // if it initially started as a string
+    to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorScope.self.id, event.data) : event);
   });
 }
 /**

package/dist/{log-5e226275.cjs.js → log-74467f02.cjs.js}

@@ -1,7 +1,10 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-34e25c2c.cjs.js');
+var guards_dist_xstateGuards = require('./raise-746abff7.cjs.js');
 
+// it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
+// but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)
+// and we strive to support TS 5.0 whenever possible
 function createSpawner(actorScope, {
   machine,
   context
@@ -216,19 +219,23 @@ function retryResolveSendTo(_, snapshot, params) {
   }
 }
 function executeSendTo(actorScope, params) {
-  if (typeof params.delay === 'number') {
-    actorScope.self.delaySend(params);
-    return;
-  }
-
   // this forms an outgoing events queue
   // thanks to that the recipient actors are able to read the *updated* snapshot value of the sender
   actorScope.defer(() => {
     const {
       to,
-      event
+      event,
+      delay,
+      id
     } = params;
-    actorScope?.system._relay(actorScope.self, to, event.type === guards_dist_xstateGuards.XSTATE_ERROR ? guards_dist_xstateGuards.createErrorActorEvent(actorScope.self.id, event.data) : event);
+    if (typeof delay === 'number') {
+      actorScope.system.scheduler.schedule(actorScope.self, to, event, delay, id);
+      return;
+    }
+    actorScope.system._relay(actorScope.self,
+    // at this point, in a deferred task, it should already be mutated by retryResolveSendTo
+    // if it initially started as a string
+    to, event.type === guards_dist_xstateGuards.XSTATE_ERROR ? guards_dist_xstateGuards.createErrorActorEvent(actorScope.self.id, event.data) : event);
   });
 }
 /**

package/dist/{log-641cd926.development.cjs.js → log-a56e34a9.development.cjs.js}

@@ -1,7 +1,10 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-62704519.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-6fb30f8b.development.cjs.js');
 
+// it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
+// but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)
+// and we strive to support TS 5.0 whenever possible
 function createSpawner(actorScope, {
   machine,
   context
@@ -219,19 +222,23 @@ function retryResolveSendTo(_, snapshot, params) {
   }
 }
 function executeSendTo(actorScope, params) {
-  if (typeof params.delay === 'number') {
-    actorScope.self.delaySend(params);
-    return;
-  }
-
   // this forms an outgoing events queue
   // thanks to that the recipient actors are able to read the *updated* snapshot value of the sender
   actorScope.defer(() => {
     const {
       to,
-      event
+      event,
+      delay,
+      id
     } = params;
-    actorScope?.system._relay(actorScope.self, to, event.type === guards_dist_xstateGuards.XSTATE_ERROR ? guards_dist_xstateGuards.createErrorActorEvent(actorScope.self.id, event.data) : event);
+    if (typeof delay === 'number') {
+      actorScope.system.scheduler.schedule(actorScope.self, to, event, delay, id);
+      return;
+    }
+    actorScope.system._relay(actorScope.self,
+    // at this point, in a deferred task, it should already be mutated by retryResolveSendTo
+    // if it initially started as a string
+    to, event.type === guards_dist_xstateGuards.XSTATE_ERROR ? guards_dist_xstateGuards.createErrorActorEvent(actorScope.self.id, event.data) : event);
   });
 }
 /**

package/dist/{raise-89c581c4.development.esm.js → raise-0ff85b7b.development.esm.js}

@@ -126,13 +126,56 @@ function reportUnhandledError(err) {
 
 const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
 
+function createScheduledEventId(actorRef, id) {
+  return `${actorRef.sessionId}.${id}`;
+}
 let idCounter = 0;
-function createSystem(rootActor) {
+function createSystem(rootActor, options) {
   const children = new Map();
   const keyedActors = new Map();
   const reverseKeyedActors = new WeakMap();
   const observers = new Set();
+  const timerMap = {};
+  const clock = options.clock;
+  const scheduler = {
+    schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
+      const scheduledEvent = {
+        source,
+        target,
+        event,
+        delay,
+        id,
+        startedAt: Date.now()
+      };
+      const scheduledEventId = createScheduledEventId(source, id);
+      system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
+      const timeout = clock.setTimeout(() => {
+        delete timerMap[scheduledEventId];
+        delete system._snapshot._scheduledEvents[scheduledEventId];
+        system._relay(source, target, event);
+      }, delay);
+      timerMap[scheduledEventId] = timeout;
+    },
+    cancel: (source, id) => {
+      const scheduledEventId = createScheduledEventId(source, id);
+      const timeout = timerMap[scheduledEventId];
+      delete timerMap[scheduledEventId];
+      delete system._snapshot._scheduledEvents[scheduledEventId];
+      clock.clearTimeout(timeout);
+    },
+    cancelAll: actorRef => {
+      for (const scheduledEventId in system._snapshot._scheduledEvents) {
+        const scheduledEvent = system._snapshot._scheduledEvents[scheduledEventId];
+        if (scheduledEvent.source === actorRef) {
+          scheduler.cancel(actorRef, scheduledEvent.id);
+        }
+      }
+    }
+  };
   const system = {
+    _snapshot: {
+      _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
+    },
     _bookId: () => `x:${idCounter++}`,
     _register: (sessionId, actorRef) => {
       children.set(sessionId, actorRef);
@@ -175,6 +218,28 @@ function createSystem(rootActor) {
         event
       });
       target._send(event);
+    },
+    scheduler,
+    getSnapshot: () => {
+      return {
+        _scheduledEvents: {
+          ...system._snapshot._scheduledEvents
+        }
+      };
+    },
+    start: () => {
+      const scheduledEvets = system._snapshot._scheduledEvents;
+      system._snapshot._scheduledEvents = {};
+      for (const scheduledId in scheduledEvets) {
+        const {
+          source,
+          target,
+          event,
+          delay,
+          id
+        } = scheduledEvets[scheduledId];
+        scheduler.schedule(source, target, event, delay, id);
+      }
     }
   };
   return system;
@@ -363,7 +428,6 @@ class Actor {
      */
     this.id = void 0;
     this.mailbox = new Mailbox(this._process.bind(this));
-    this.delayedEventsMap = {};
     this.observers = new Set();
     this.logger = void 0;
     /** @internal */
@@ -400,7 +464,9 @@ class Actor {
       systemId,
       inspect
     } = resolvedOptions;
-    this.system = parent?.system ?? createSystem(this);
+    this.system = parent ? parent.system : createSystem(this, {
+      clock
+    });
     if (inspect && !parent) {
       // Always inspect at the system-level
       this.system.inspect(toObserver(inspect));
@@ -581,10 +647,28 @@ class Actor {
     if (this._processingStatus !== ProcessingStatus.Stopped) {
       this.observers.add(observer);
     } else {
-      try {
-        observer.complete?.();
-      } catch (err) {
-        reportUnhandledError(err);
+      switch (this._snapshot.status) {
+        case 'done':
+          try {
+            observer.complete?.();
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+          break;
+        case 'error':
+          {
+            const err = this._snapshot.error;
+            if (!observer.error) {
+              reportUnhandledError(err);
+            } else {
+              try {
+                observer.error(err);
+              } catch (err) {
+                reportUnhandledError(err);
+              }
+            }
+            break;
+          }
       }
     }
     return {
@@ -641,6 +725,9 @@ class Actor {
         this._error(this._snapshot.error);
         return this;
     }
+    if (!this._parent) {
+      this.system.start();
+    }
     if (this.logic.start) {
       try {
         this.logic.start(this._snapshot, this._actorScope);
@@ -769,9 +856,7 @@ class Actor {
     }
 
     // Cancel all delayed events
-    for (const key of Object.keys(this.delayedEventsMap)) {
-      this.clock.clearTimeout(this.delayedEventsMap[key]);
-    }
+    this.system.scheduler.cancelAll(this);
 
     // TODO: mailbox.reset
     this.mailbox.clear();
@@ -811,35 +896,6 @@ class Actor {
     }
     this.system._relay(undefined, this, event);
   }
-
-  /**
-   * TODO: figure out a way to do this within the machine
-   * @internal
-   */
-  delaySend(params) {
-    const {
-      event,
-      id,
-      delay
-    } = params;
-    const timerId = this.clock.setTimeout(() => {
-      this.system._relay(this, params.to ?? this, event);
-    }, delay);
-
-    // TODO: consider the rehydration story here
-    if (id) {
-      this.delayedEventsMap[id] = timerId;
-    }
-  }
-
-  /**
-   * TODO: figure out a way to do this within the machine
-   * @internal
-   */
-  cancel(sendId) {
-    this.clock.clearTimeout(this.delayedEventsMap[sendId]);
-    delete this.delayedEventsMap[sendId];
-  }
   attachDevTools() {
     const {
       devTools
@@ -951,7 +1007,9 @@ function resolveCancel(_, snapshot, actionArgs, actionParams, {
   return [snapshot, resolvedSendId];
 }
 function executeCancel(actorScope, resolvedSendId) {
-  actorScope.self.cancel(resolvedSendId);
+  actorScope.defer(() => {
+    actorScope.system.scheduler.cancel(actorScope.self, resolvedSendId);
+  });
 }
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
@@ -2342,8 +2400,16 @@ function resolveRaise(_, snapshot, args, actionParams, {
   }];
 }
 function executeRaise(actorScope, params) {
-  if (typeof params.delay === 'number') {
-    actorScope.self.delaySend(params);
+  const {
+    event,
+    delay,
+    id
+  } = params;
+  if (typeof delay === 'number') {
+    actorScope.defer(() => {
+      const self = actorScope.self;
+      actorScope.system.scheduler.schedule(self, self, event, delay, id);
+    });
     return;
   }
 }
@@ -2368,4 +2434,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, interpret as B, isMachineSnapshot as C, matchesState as D, pathToStateValue as E, toObserver as F, getAllOwnEventDescriptors as G, and as H, not as I, or as J, stateIn as K, cancel as L, raise as M, NULL_EVENT as N, spawnChild as O, stop as P, stopChild as Q, ProcessingStatus as R, STATE_DELIMITER as S, cloneMachineSnapshot as T, XSTATE_ERROR as U, createErrorActorEvent as V, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, macrostep as n, transitionNode as o, resolveActionsAndContext as p, createInitEvent as q, resolveStateValue as r, microstep as s, toArray as t, getInitialStateNodes as u, isStateId as v, getStateNodeByPath as w, getPersistedSnapshot as x, resolveReferencedActor as y, createActor as z };
+export { $$ACTOR_TYPE as $, Actor as A, interpret as B, isMachineSnapshot as C, and as D, not as E, or as F, stateIn as G, getAllOwnEventDescriptors as H, matchesState as I, pathToStateValue as J, toObserver as K, cancel as L, raise as M, NULL_EVENT as N, spawnChild as O, stop as P, stopChild as Q, ProcessingStatus as R, STATE_DELIMITER as S, cloneMachineSnapshot as T, XSTATE_ERROR as U, createErrorActorEvent as V, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, macrostep as n, transitionNode as o, resolveActionsAndContext as p, createInitEvent as q, resolveStateValue as r, microstep as s, toArray as t, getInitialStateNodes as u, isStateId as v, getStateNodeByPath as w, getPersistedSnapshot as x, resolveReferencedActor as y, createActor as z };