xstate 5.0.1 → 5.1.0

package/dist/declarations/src/actors/promise.d.ts

@@ -1,24 +1,13 @@
-import { XSTATE_STOP } from "../constants.js";
-import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem, NonReducibleUnknown, Snapshot } from "../types.js";
+import { AnyActorSystem } from "../system.js";
+import { ActorLogic, ActorRefFrom, NonReducibleUnknown, Snapshot } from "../types.js";
 export type PromiseSnapshot<TOutput, TInput> = Snapshot<TOutput> & {
     input: TInput | undefined;
 };
-declare const XSTATE_PROMISE_RESOLVE = "xstate.promise.resolve";
-declare const XSTATE_PROMISE_REJECT = "xstate.promise.reject";
-export type PromiseActorEvents<T> = {
-    type: typeof XSTATE_PROMISE_RESOLVE;
-    data: T;
-} | {
-    type: typeof XSTATE_PROMISE_REJECT;
-    data: any;
-} | {
-    type: typeof XSTATE_STOP;
-};
 export type PromiseActorLogic<TOutput, TInput = unknown> = ActorLogic<PromiseSnapshot<TOutput, TInput>, {
     type: string;
     [k: string]: unknown;
 }, TInput, // input
-ActorSystem<any>>;
+AnyActorSystem>;
 export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, unknown>>;
 /**
  * An actor logic creator which returns promise logic as defined by an async process that resolves or rejects after some time.
@@ -78,4 +67,3 @@ export declare function fromPromise<TOutput, TInput = NonReducibleUnknown>(promi
      */
     self: PromiseActorRef<TOutput>;
 }) => PromiseLike<TOutput>): PromiseActorLogic<TOutput, TInput>;
-export {};

package/dist/declarations/src/actors/transition.d.ts

@@ -1,4 +1,5 @@
-import { ActorLogic, ActorScope, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot, NonReducibleUnknown } from "../types.js";
+import { AnyActorSystem } from "../system.js";
+import { ActorLogic, ActorRefFrom, ActorScope, EventObject, NonReducibleUnknown, Snapshot } from "../types.js";
 export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
     context: TContext;
 };
@@ -62,7 +63,7 @@ export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefF
  * // }
  * ```
  */
-export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput extends NonReducibleUnknown>(transition: (snapshot: TContext, event: TEvent, actorScope: ActorScope<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
+export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends AnyActorSystem, TInput extends NonReducibleUnknown>(transition: (snapshot: TContext, event: TEvent, actorScope: ActorScope<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
     input: TInput;
     self: TransitionActorRef<TContext, TEvent>;
 }) => TContext)): TransitionActorLogic<TContext, TEvent, TInput>;

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

@@ -13,7 +13,7 @@ export { type MachineSnapshot, isMachineSnapshot } from "./State.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 type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent, ActorSystem } from "./system.js";
 export { and, not, or, stateIn } from "./guards.js";
 export { setup } from "./setup.js";
 declare global {

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/setup.d.ts

@@ -1,15 +1,15 @@
 import { StateMachine } from "./StateMachine.js";
 import { GuardPredicate } from "./guards.js";
 import { ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import { ActionFunction, AnyActorLogic, AnyActorRef, AnyEventObject, Cast, ConditionalRequired, DelayConfig, Invert, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateSchema, ToChildren, UnknownActorLogic, Values } from "./types.js";
+import { ActionFunction, AnyActorRef, AnyEventObject, Cast, ConditionalRequired, DelayConfig, Invert, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateSchema, ToChildren, UnknownActorLogic, Values } from "./types.js";
 type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
     [K in keyof TParameterizedMap & string]: {
         type: K;
         params: TParameterizedMap[K];
     };
 }>;
-type DefaultToAnyActors<TActors extends Record<string, AnyActorLogic>> = IsNever<keyof TActors> extends true ? Record<string, AnyActorLogic> : TActors;
-type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<Values<TChildrenMap>, AnyActorLogic>, TResolvedActors extends Record<string, AnyActorLogic> = DefaultToAnyActors<TActors>> = Values<{
+type DefaultToUnknownActorLogic<TActors extends Record<string, UnknownActorLogic>> = IsNever<keyof TActors> extends true ? Record<string, UnknownActorLogic> : TActors;
+type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<Values<TChildrenMap>, UnknownActorLogic>, TResolvedActors extends Record<string, UnknownActorLogic> = DefaultToUnknownActorLogic<TActors>> = Values<{
     [K in keyof TResolvedActors & string]: {
         src: K;
         logic: TResolvedActors[K];
@@ -35,7 +35,9 @@ type ToStateValue<T extends StateSchema> = T extends {
 export declare function setup<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
 TActors extends Record<Values<TChildrenMap>, UnknownActorLogic>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TChildrenMap extends Record<string, string> = never>({ actors, actions, guards, delays }: {
     types?: SetupTypes<TContext, TEvent, TChildrenMap, TTag, TInput, TOutput>;
-    actors?: TActors;
+    actors?: {
+        [K in keyof TActors]: TActors[K];
+    };
     actions?: {
         [K in keyof TActions]: ActionFunction<TContext, TEvent, TEvent, TActions[K], ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay>;
     };

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/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];
 };
@@ -64,12 +64,12 @@ export type MaybeLazy<T> = T | Lazy<T>;
 /**
  * The full definition of an event, with a string `type`.
  */
-export interface EventObject {
+export type EventObject = {
     /**
      * The type of event that is sent.
      */
     type: string;
-}
+};
 export interface AnyEventObject extends EventObject {
     [key: string]: any;
 }
@@ -82,13 +82,13 @@ 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> {
 }
-export type InputFrom<T extends AnyActorLogic> = 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 extends AnyActorLogic> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem> ? (TSnapshot & {
+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'] : 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> = {
@@ -452,7 +452,7 @@ export type MachineConfig<TContext extends MachineContext, TEvent extends EventO
 });
 export interface ProvidedActor {
     src: string;
-    logic: AnyActorLogic;
+    logic: UnknownActorLogic;
     id?: string;
 }
 export interface SetupTypes<TContext extends MachineContext, TEvent extends EventObject, TChildrenMap extends Record<string, string>, TTag extends string, TInput, TOutput> {
@@ -746,7 +746,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 +756,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 +769,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;
@@ -804,7 +804,9 @@ export type Snapshot<TOutput> = {
  * @template TInput - The type of the input.
  * @template TSystem - The type of the actor system.
  */
-export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = NonReducibleUnknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+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 AnyActorSystem = AnyActorSystem> {
     /** The initial setup/configuration used to create the actor logic. */
     config?: unknown;
     /**
@@ -812,10 +814,10 @@ export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends
      * to produce a new state.
      * @param snapshot - The current state.
      * @param message - The incoming message.
-     * @param ctx - The actor scope.
+     * @param actorScope - The actor scope.
      * @returns The new state.
      */
-    transition: (snapshot: TSnapshot, message: TEvent, ctx: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
+    transition: (snapshot: TSnapshot, message: TEvent, actorScope: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
     /**
      * Called to provide the initial state of the actor.
      * @param actorScope - The actor scope.
@@ -849,8 +851,7 @@ export type AnyActorLogic = ActorLogic<any, // snapshot
 any, // event
 any, // input
 any>;
-export type UnknownActorLogic = ActorLogic<any, // this is invariant and it's hard to figure out a better default than `any`
-EventObject, NonReducibleUnknown, 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;
@@ -869,11 +870,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-f196f85f.development.esm.js → log-2cbae8e5.development.esm.js}

@@ -1,4 +1,4 @@
-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-dd0e6cd2.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -217,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-22e678c5.esm.js → log-6e1b5540.esm.js}

@@ -1,4 +1,4 @@
-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-525f78b5.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -214,19 +214,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-641cd926.development.cjs.js → log-aa639ffe.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-62704519.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-23324e7c.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -219,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-5e226275.cjs.js → log-dca6710c.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-34e25c2c.cjs.js');
+var guards_dist_xstateGuards = require('./raise-9f420f96.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -216,19 +216,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-62704519.development.cjs.js → raise-23324e7c.development.cjs.js}

@@ -128,13 +128,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);
@@ -177,6 +220,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;
@@ -365,7 +430,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 */
@@ -402,7 +466,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));
@@ -643,6 +709,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);
@@ -771,9 +840,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();
@@ -813,35 +880,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
@@ -953,7 +991,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
@@ -2344,8 +2384,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;
   }
 }