xstate 6.0.0-alpha.21 → 6.0.0-alpha.23

package/dist/{StateMachine-e25dd61f.development.esm.js → StateMachine-d2247245.development.esm.js}

@@ -1,54 +1,125 @@
-import { P as ProcessingStatus, H as resolveReferencedActor, e as createActor, S as STATE_DELIMITER, I as mapValues, t as toArray, J as createInvokeId, K as getDelayedTransitions, L as evaluateCandidate, M as formatTransition, N as NULL_EVENT, O as toTransitionConfigArray, Q as createInvokeTimeoutEvent, R as getCandidates, U as formatRouteTransitions, V as resolveStateValue, W as getAllStateNodes, l as getStateNodes, Y as createMachineSnapshot, Z as isInFinalState, f as macrostep, d as deriveDeferredStarts, _ as cloneMachineSnapshot, $ as transitionNode, m as matchesEventDescriptor, a0 as getTransitionResult, a1 as hasEffect, a2 as createErrorPlatformEvent, r as resolveActionsWithContext, g as createInitEvent, h as initialMicrostep, a3 as toStatePath, a4 as isStateId, a5 as getStateNodeByPath, a6 as getPersistedSnapshot, a7 as $$ACTOR_TYPE } from './index-d39fb138.development.esm.js';
+import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as evaluateCandidate, V as formatTransition, W as NULL_EVENT, Y as toTransitionConfigArray, Z as createInvokeTimeoutEvent, _ as getCandidates, $ as formatRouteTransitions, a0 as resolveStateValue, a1 as getAllStateNodes, s as getStateNodes, a2 as createMachineSnapshot, a3 as isInFinalState, j as macrostep, a4 as cloneMachineSnapshot, a5 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a6 as getTransitionResult, a7 as hasEffect, a8 as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, a9 as toStatePath, aa as isStateId, ab as getStateNodeByPath, ac as getPersistedSnapshot, ad as resolveReferencedActor, ae as $$ACTOR_TYPE } from './index-f5407323.development.esm.js';
 
-function createSpawner(actorScope, {
-  machine,
-  context
-}, event, spawnedChildren) {
-  const spawn = (src, options) => {
-    if (typeof src === 'string') {
-      const logic = resolveReferencedActor(machine, src);
-      if (!logic) {
-        throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
-      }
-      const actor = createActor(logic, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: typeof options?.input === 'function' ? options.input({
-          context,
-          event,
-          self: actorScope.self
-        }) : options?.input,
-        src,
-        registryKey: options?.registryKey
-      });
-      spawnedChildren[actor.id] = actor;
-      return actor;
-    } else {
-      const actor = createActor(src, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: options?.input,
-        src,
-        registryKey: options?.registryKey
-      });
-      return actor;
-    }
-  };
+function createSpawner(actorScope, actorSources, spawnedChildren) {
   return (src, options) => {
-    const actor = spawn(src, options); // TODO: fix types
-    spawnedChildren[actor.id] = actor;
-    actorScope.defer(() => {
-      if (actor._processingStatus === ProcessingStatus.Stopped) {
-        return;
-      }
-      actor.start();
+    const referencedSrc = Object.entries(actorSources).find(([, logic]) => logic === src)?.[0];
+    const actor = actorScope.system.createActorRef(src, {
+      id: options?.id,
+      parent: actorScope.self,
+      syncSnapshot: options?.syncSnapshot,
+      input: options?.input,
+      src: referencedSrc ?? src,
+      registryKey: options?.registryKey
     });
+    spawnedChildren[actor.id] = actor;
     return actor;
   };
 }
 
+/** @internal */
+function setInertActorScopeSnapshot(actorScope, snapshot, attachActorRef = true) {
+  actorScope.self._snapshot = snapshot;
+  if (attachActorRef && snapshot && typeof snapshot === 'object') {
+    setSnapshotActorRef(snapshot, actorScope.self);
+  }
+  return snapshot;
+}
+
+/** @internal */
+function isInertActorScope(actorScope) {
+  return !!actorScope.self.options?._inert;
+}
+
+/** @internal */
+function attachSnapshotActorRef(actorLogic, actorScope, snapshot) {
+  const snapshotScope = createInertActorScope(actorLogic, snapshot, actorScope.self);
+  return setInertActorScopeSnapshot(snapshotScope, snapshot);
+}
+
+/** @internal */
+function createInertActorScope(actorLogic, snapshot, sourceSelf) {
+  const snapshotRef = snapshot ? getSnapshotActorRef(snapshot) : undefined;
+  const previousSelf = sourceSelf ?? snapshotRef?.actor;
+  const baseSystem = previousSelf?.system;
+  const system = previousSelf && baseSystem ? createSnapshotSystem(baseSystem, previousSelf, isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
+  const self = createActor(actorLogic, {
+    _inert: true,
+    ...(previousSelf ? {
+      id: previousSelf.id
+    } : {}),
+    ...(system ? {
+      _systemRef: {
+        current: system
+      }
+    } : {})
+  });
+  if (previousSelf?._parent) {
+    self._parent = previousSelf._parent;
+  }
+  if (snapshot) {
+    self._snapshot = snapshot;
+  }
+  const actorScope = {
+    self: self,
+    defer: () => {},
+    id: self.id,
+    logger: self.system._logger,
+    sessionId: self.sessionId,
+    stopChild: child => child._stop(),
+    system: self.system,
+    emit: event => self.system.emitEvent(self, event),
+    actionExecutor: () => {}
+  };
+  return actorScope;
+}
+
+/** @deprecated Use `initialTransition(…)` instead. */
+function getInitialSnapshot(actorLogic, ...[input]) {
+  const actorScope = createInertActorScope(actorLogic);
+  return actorLogic.initialTransition(input, actorScope)[0];
+}
+
+/**
+ * Determines the next snapshot for the given `actorLogic` based on the given
+ * `snapshot` and `event`.
+ *
+ * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
+ * used.
+ *
+ * @deprecated Use `transition(…)` instead.
+ * @example
+ *
+ * ```ts
+ * import { getNextSnapshot } from 'xstate';
+ * import { trafficLightMachine } from './trafficLightMachine.ts';
+ *
+ * const nextSnapshot = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   undefined, // snapshot (or initial state if undefined)
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot.value);
+ * // => 'yellow'
+ *
+ * const nextSnapshot2 = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   nextSnapshot, // snapshot
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot2.value);
+ * // =>'red'
+ * ```
+ */
+function getNextSnapshot(actorLogic, snapshot, event) {
+  const actorScope = createInertActorScope(actorLogic, snapshot);
+  const transitionResult = actorLogic.transition(snapshot, event, actorScope);
+  const nextSnapshot = Array.isArray(transitionResult) ? transitionResult[0] : transitionResult;
+  setInertActorScopeSnapshot(actorScope, nextSnapshot, false);
+  return nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(actorLogic, actorScope, nextSnapshot);
+}
+
 const cache = new WeakMap();
 function memo(object, key, fn) {
   let memoizedData = cache.get(object);
@@ -570,19 +641,37 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
+    const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);
     if (fastSnapshot) {
-      return [fastSnapshot, []];
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
+      }
+      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      return [returnedSnapshot, []];
     }
     const {
       snapshot: nextSnapshot,
       microsteps
-    } = macrostep(snapshot, event, actorScope, []);
-    return [nextSnapshot, this._collectEffects(microsteps)];
+    } = macrostep(snapshot, event, resolvedActorScope, []);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
+    }
+    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+    return [returnedSnapshot, this._collectEffects(microsteps)];
+  }
+  _collectEffects(microsteps) {
+    return microsteps.flatMap(([, actions]) => actions);
   }
-  _collectEffects(microsteps, initialActions = []) {
-    const effects = [...initialActions, ...microsteps.flatMap(([, actions]) => actions)];
-    return [...effects, ...deriveDeferredStarts(effects)];
+  _attachPureActorRef(snapshot, actorScope) {
+    if (isInertActorScope(actorScope)) {
+      return snapshot;
+    }
+    return attachSnapshotActorRef(this, actorScope, snapshot);
   }
   _transitionFast(snapshot, event, actorScope) {
     if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
@@ -643,6 +732,9 @@ class StateMachine {
     return transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
   }
   isInternalEventType(eventType) {
+    if (eventType === XSTATE_TIMER) {
+      return true;
+    }
     for (const descriptor of this.internalEventDescriptors) {
       if (matchesEventDescriptor(eventType, descriptor)) {
         return true;
@@ -709,10 +801,10 @@ class StateMachine {
       _nodes: [this.root],
       children: {},
       status: 'active'
-    }, this);
+    }, this, actorScope.self);
     if (typeof context === 'function') {
       const children = {};
-      const spawn = createSpawner(actorScope, preInitial, initEvent, children);
+      const spawn = createSpawner(actorScope, this.implementations.actorSources, children);
       const resolvedContext = context({
         spawn,
         input: initEvent.input,
@@ -742,30 +834,37 @@ class StateMachine {
     return this.initialTransition(input, actorScope)[0];
   }
   initialTransition(input, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const initEvent = createInitEvent(input); // TODO: fix;
     const internalQueue = [];
-    const preInitialState = this._getPreInitialState(actorScope, initEvent);
+    const preInitialState = this._getPreInitialState(resolvedActorScope, initEvent);
+    const contextSpawnEffects = Object.values(preInitialState.children).filter(Boolean).map(actor => createSpawnEffect(actor));
     let nextState;
     let initialActions = [];
     let microsteps = [];
     let macroState;
     try {
-      [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      [nextState, initialActions] = initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
       ({
         snapshot: macroState,
         microsteps
-      } = macrostep(nextState, initEvent, actorScope, internalQueue));
+      } = macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]));
     } catch (err) {
       if (!this.root.config.onError) {
         throw err;
       }
       const errorEvent = createErrorPlatformEvent('execution', err);
-      const errorMacrostep = macrostep(preInitialState, errorEvent, actorScope, []);
+      const errorMacrostep = macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
       macroState = errorMacrostep.snapshot;
       microsteps = errorMacrostep.microsteps;
       initialActions = [];
     }
-    return [macroState, this._collectEffects(microsteps, initialActions)];
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+    }
+    const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
+    return [returnedSnapshot, this._collectEffects(microsteps)];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly
@@ -793,7 +892,9 @@ class StateMachine {
   getPersistedSnapshot(snapshot, options) {
     return getPersistedSnapshot(snapshot, options);
   }
-  restoreSnapshot(snapshot, _actorScope) {
+  restoreSnapshot(snapshot, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const persistedVersion = snapshot.version;
     if (persistedVersion !== this.version) {
       const migrate = this.config.migrate;
@@ -813,9 +914,9 @@ class StateMachine {
       if (!logic) {
         continue;
       }
-      const actor = createActor(logic, {
+      const actor = resolvedActorScope.system.createActorRef(logic, {
         id: actorId,
-        parent: _actorScope.self,
+        parent: resolvedActorScope.self,
         syncSnapshot: actorData.syncSnapshot,
         snapshot: childState,
         src,
@@ -826,6 +927,19 @@ class StateMachine {
       actor._rehydrated = true;
       children[actorId] = actor;
     }
+    const timers = {};
+    const persistedTimers = snapshotData.timers ?? {};
+    for (const [id, timer] of Object.entries(persistedTimers)) {
+      const target = typeof timer.target === 'string' ? timer.target === 'self' ? 'self' : children[timer.target] : resolvedActorScope.self._parent;
+      if (!target) {
+        const targetDescription = typeof timer.target === 'string' ? timer.target : timer.target.type;
+        throw new Error(`Unable to restore timer '${id}': target actor '${targetDescription}' is unavailable.`);
+      }
+      timers[id] = {
+        ...timer,
+        target
+      };
+    }
     const reviveHistoryValue = historyValue => {
       if (!historyValue || typeof historyValue !== 'object') {
         return {};
@@ -864,11 +978,12 @@ class StateMachine {
     const restoredSnapshot = createMachineSnapshot({
       ...persistedRest,
       children,
+      timers,
       _nodes: nodes,
       value: snapshotData.value,
       historyValue: revivedHistoryValue,
       _stateInputs: snapshotData.stateInputs ?? {}
-    }, this);
+    }, this, resolvedActorScope.self);
     const seen = new WeakSet();
     function reviveContext(contextPart) {
       if (seen.has(contextPart)) {
@@ -887,8 +1002,12 @@ class StateMachine {
       }
     }
     reviveContext(restoredSnapshot.context);
-    return restoredSnapshot;
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
+      return attachSnapshotActorRef(this, resolvedActorScope, restoredSnapshot);
+    }
+    return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
   }
 }
 
-export { StateMachine as S, StateNode as a };
+export { StateMachine as S, attachSnapshotActorRef as a, getNextSnapshot as b, createInertActorScope as c, StateNode as d, getInitialSnapshot as g, setInertActorScopeSnapshot as s };

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

@@ -1,4 +1,4 @@
-import type { AnyMachineSnapshot, AnyStateMachine, EventObject, HistoryValue, MachineContext, StateConfig, StateValue, StateValueMap, AnyActorRef, Snapshot, MetaObject, StateSchema, StateId, StateIdInputs, StateContextFromStateValue, SnapshotStatus, AnyStateNode } from "./types.js";
+import type { AnyMachineSnapshot, AnyStateMachine, AnyActor, EventObject, HistoryValue, MachineContext, StateConfig, StateValue, StateValueMap, AnyActorRef, Snapshot, MetaObject, StateSchema, StateId, StateIdInputs, StateContextFromStateValue, SnapshotStatus, AnyStateNode, LogicalTimer } from "./types.js";
 export declare function isMachineSnapshot(value: unknown): value is AnyMachineSnapshot;
 type Values<T> = T[keyof T];
 type MatchingObjectStateValue<TStateValue extends Record<string, unknown>, TTestStateValue extends Record<string, unknown>> = false extends Values<{
@@ -45,6 +45,8 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
     _nodes: Array<AnyStateNode>;
     /** An object mapping actor names to spawned/invoked actors. */
     children: TChildren;
+    /** Pending logical timers owned by this machine snapshot. */
+    timers: Readonly<Record<string, LogicalTimer>>;
     /**
      * Whether the current state value is a subset of the given partial state
      * value.
@@ -98,7 +100,7 @@ interface StoppedMachineSnapshot<TContext extends MachineContext, TEvent extends
     error: undefined;
 }
 export type MachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> = ActiveMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | DoneMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | ErrorMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | StoppedMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
-export declare function createMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TMeta extends MetaObject, TStateSchema extends StateSchema>(config: StateConfig<TContext, TEvent>, machine: AnyStateMachine): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, undefined, TMeta, TStateSchema>;
+export declare function createMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TMeta extends MetaObject, TStateSchema extends StateSchema>(config: StateConfig<TContext, TEvent>, machine: AnyStateMachine, actorRef?: AnyActor): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, undefined, TMeta, TStateSchema>;
 export declare function cloneMachineSnapshot<TState extends AnyMachineSnapshot>(snapshot: TState, config?: Partial<StateConfig<any, any>>): TState;
 export declare function getPersistedSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject>(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any>, options?: unknown): Snapshot<unknown>;
 export {};

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

@@ -62,8 +62,9 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param snapshot The current snapshot
      * @param event The received event
      */
-    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
+    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope?: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
     private _collectEffects;
+    private _attachPureActorRef;
     private _transitionFast;
     /**
      * Determines the next state given the current `state` and `event`. Calculates
@@ -79,11 +80,11 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * Returns the initial `State` instance, with reference to `self` as an
      * `ActorRef`.
      */
-    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
-    initialTransition(input: TInput | undefined, actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
+    getInitialSnapshot(actorScope?: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+    initialTransition(input: TInput | undefined, actorScope?: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
     start(snapshot?: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, options?: unknown): Snapshot<unknown>;
-    restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+    restoreSnapshot(snapshot: Snapshot<unknown>, actorScope?: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
 }
 export {};

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

@@ -1,15 +1,17 @@
-import { AnyActor, AnyActorScope, EventObject } from "./types.js";
+import { type ActorTermination, AnyActor, AnyActorScope, EventObject } from "./types.js";
+export declare function assertSendToEvent(event: EventObject): void;
 export declare const builtInActions: {
-    "@xstate.spawn": (_actor: AnyActor) => void;
-    "@xstate.start": (actor: AnyActor) => void;
-    "@xstate.raise": (actorScope: AnyActorScope, event: EventObject, options: {
+    "@xstate.spawn": (actor: AnyActor) => any;
+    "@xstate.start": (actor: AnyActor) => any;
+    "@xstate.raise": (actorScope: AnyActorScope, _event: EventObject, options: {
         id?: string;
         delay?: number;
-    }) => void;
+    }) => void | PromiseLike<void>;
     "@xstate.sendTo": (actorScope: AnyActorScope, actor: AnyActor, event: EventObject, options: {
         id?: string;
         delay?: number;
-    }) => void;
-    "@xstate.cancel": (actorScope: AnyActorScope, sendId: string) => void;
-    "@xstate.stop": (actorScope: AnyActorScope, actor: AnyActor) => void;
+    }) => void | PromiseLike<void>;
+    "@xstate.cancel": (actorScope: AnyActorScope, sendId: string) => void | PromiseLike<void>;
+    "@xstate.stop": (actorScope: AnyActorScope, actor: AnyActor) => void | PromiseLike<void>;
+    "@xstate.terminate": (actor: AnyActor, termination: ActorTermination) => any;
 };

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

@@ -1,6 +1,6 @@
 import { StandardSchemaV1 } from "../schema.types.js";
-import { AnyActorSystem } from "../system.js";
-import { ActorLogic, ActorRefFromLogic, ActorScope, EventObject, NonReducibleUnknown, Snapshot } from "../types.js";
+import { ActorSystemRuntime, AnyActorSystem } from "../system.js";
+import { ActorLogic, ActorRefFromLogic, ActorScope, EventObject, ExecutableActionObject, NonReducibleUnknown, Snapshot } from "../types.js";
 export type LogicSnapshot<TContext, TOutput, TInput> = Snapshot<TOutput> & {
     context: TContext;
     input: TInput | undefined;
@@ -22,29 +22,14 @@ export interface LogicArgs<TContext, TEvent extends EventObject, TInput> {
     system: AnyActorSystem;
     self: LogicActorRef<TContext, unknown, TEvent, TInput>;
 }
-export type LogicEffect<TEvent extends EventObject, TEmitted extends EventObject> = {
-    type: 'emit';
-    event: TEmitted;
-} | {
-    type: 'sendBack';
-    event: EventObject;
-} | {
-    type: 'raise';
-    event: TEvent;
-} | {
-    type: 'effect';
-    key?: string;
-    exec: () => void | (() => void);
-} | {
-    type: 'cleanupEffects';
-};
+export type LogicEffect<_TEvent extends EventObject, _TEmitted extends EventObject> = ExecutableActionObject;
 export interface LogicEnqueue<TEvent extends EventObject, TEmitted extends EventObject> {
     emit: (emitted: TEmitted) => void;
     sendBack: (event: EventObject) => void;
     raise: (event: TEvent) => void;
     effect: {
-        (exec: () => void | (() => void)): void;
-        (key: string, exec: () => void | (() => void)): void;
+        (exec: (runtime?: Partial<ActorSystemRuntime>) => void | (() => void)): void;
+        (key: string, exec: (runtime?: Partial<ActorSystemRuntime>) => void | (() => void)): void;
     };
 }
 export type LogicPatch<TContext, TOutput, TInput> = Partial<{
@@ -82,7 +67,6 @@ export type LogicActorRef<TContext, TOutput, TEvent extends EventObject, TInput>
 export declare const XSTATE_LOGIC_EFFECT_RESOLVE = "xstate.logic.effect.resolve";
 export declare const XSTATE_LOGIC_EFFECT_REJECT = "xstate.logic.effect.reject";
 export declare const XSTATE_LOGIC_EFFECT_START = "xstate.logic.effect.start";
-export declare function executeLogicEffects(effects: readonly unknown[] | undefined, actorScope: ActorScope<any, any, any, any>): void;
 export declare function createLogic<TContext, const TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1, TEvent extends EventObject = EventObject, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema, TOutputSchema> & {
     schemas: {
         input: TInputSchema;

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

@@ -56,7 +56,9 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
      */
     constructor(logic: TLogic, options?: ActorOptions<TLogic>);
     private _deferred;
-    private _pendingEffects?;
+    private _restored;
+    /** Associates each live snapshot with this actor for later pure transitions. */
+    private _setSnapshot;
     private _setErrorSnapshot;
     /** Recover via the logic's error event if possible; otherwise error out. */
     private _recoverOrError;

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

@@ -1,10 +1,12 @@
 import { createTransitionEnqueue } from "./transitionActions.js";
-import type { ActorLogic, EventObject, MachineContext, NonReducibleUnknown, Snapshot } from "./types.js";
+import type { ActorLogic, EventObject, MachineContext, LogicalTimer, NonReducibleUnknown, Snapshot } from "./types.js";
 export type FSMSnapshot<TContext extends MachineContext, TState extends string, TInput = unknown> = Snapshot<undefined> & {
     value: TState;
     context: TContext;
     input: TInput | undefined;
     children: {};
+    timers: Record<string, LogicalTimer>;
+    _nextTimerId: number;
     _stateInput: Record<string, unknown> | undefined;
     machine: {
         id: string;

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

@@ -18,13 +18,13 @@ export { isMachineSnapshot, type MachineSnapshot } from "./State.js";
 export { StateMachine } from "./StateMachine.js";
 export { StateNode } from "./StateNode.js";
 export { getStateNodes } from "./stateUtils.js";
-export type { ActorSystem, AnyActorSystem } from "./system.js";
+export type { ActorSystem, ActorSystemRuntime, AnyActorSystem } from "./system.js";
 export { toPromise } from "./toPromise.js";
 export * from "./types.js";
 export type { Next_MachineConfig as MachineConfig, Next_StateNodeConfig as StateNodeConfig, Next_InvokeConfig as InvokeConfig, Next_TransitionConfigOrTarget as TransitionConfigOrTarget, Implementations, InferEvents, WidenLiterals } from "./types.v6.js";
 export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, checkStateIn, pathToStateValue, toObserver } from "./utils.js";
 export { transition, initialTransition, getMicrosteps, getInitialMicrosteps, getNextTransitions } from "./transition.js";
-export { isBuiltInExecutableAction } from "./transitionActions.js";
+export { executeEffects, isBuiltInExecutableAction } from "./transitionActions.js";
 export { waitFor } from "./waitFor.js";
 declare global {
     interface SymbolConstructor {

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

@@ -1,12 +1,12 @@
-import { ActorFromLogic, AnyActorLogic, AnyActorRef, AnyActorScope, AnyEventObject, AnyMachineSnapshot, ConditionalRequired, InputFrom, IsNotNever, RegistryKeyForLogic, SystemRegistry, type RequiredLogicInput } from "./types.js";
+import { ActorFromLogic, AnyActorLogic, AnyActorRef, AnyActorScope, ConditionalRequired, InputFrom, IsNotNever, RegistryKeyForLogic, SystemRegistry, type RequiredLogicInput } from "./types.js";
 export type Spawner<TSystemRegistry extends SystemRegistry = SystemRegistry> = <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[
     options?: {
         id?: string;
         registryKey?: RegistryKeyForLogic<TLogic, TSystemRegistry>;
-        input?: TLogic extends string ? unknown : InputFrom<TLogic>;
+        input?: InputFrom<TLogic>;
         syncSnapshot?: boolean;
     } & {
         [K in RequiredLogicInput<TLogic>]: unknown;
     }
 ], IsNotNever<RequiredLogicInput<TLogic>>>) => ActorFromLogic<TLogic>;
-export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyMachineSnapshot, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner;
+export declare function createSpawner(actorScope: AnyActorScope, actorSources: Record<string, AnyActorLogic>, spawnedChildren: Record<string, AnyActorRef>): Spawner;

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

@@ -50,7 +50,7 @@ export declare function getTransitionResult(transition: Pick<AnyTransitionDefini
     internalEvents: EventObject[] | undefined;
     input: Record<string, unknown> | undefined;
 };
-export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue: AnyEventObject[]): {
+export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue: AnyEventObject[], initialMicrosteps?: Microstep[]): {
     snapshot: typeof snapshot;
     microsteps: Microstep[];
 };

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

@@ -1,29 +1,54 @@
 import { InspectionEvent } from "./inspection.js";
-import { ActorSystemInfo, AnyActor, Observer, EventObject, Subscription, TimersRestoreStrategy } from "./types.js";
-interface ScheduledEvent {
+import { AnyEventObject, ActorTermination, ActorSystemInfo, AnyActor, Observer, EventObject, Subscription } from "./types.js";
+interface ScheduledTimer {
     id: string;
-    event: EventObject;
-    startedAt: number;
+    scheduledAt: number;
+    dueAt: number;
     delay: number;
     source: AnyActor;
-    target: AnyActor;
 }
 export interface Clock {
     setTimeout(fn: (...args: any[]) => void, timeout: number): any;
     clearTimeout(id: any): void;
 }
 interface Scheduler {
-    schedule(source: AnyActor, target: AnyActor, event: EventObject, delay: number, id: string | undefined): void;
+    schedule(source: AnyActor, id: string, delay: number): void;
     cancel(source: AnyActor, id: string): void;
     cancelAll(actor: AnyActor): void;
 }
-export interface ActorSystem<T extends ActorSystemInfo> {
+/**
+ * Runtime operations used to execute effects.
+ *
+ * An external interpreter can override these operations while the default actor
+ * system provides the local in-memory implementation.
+ */
+export interface ActorSystemRuntime {
+    /** Publishes a newly created actor to the runtime. */
+    spawnActor(source: AnyActor | undefined, actor: AnyActor): void | PromiseLike<void>;
+    /** Starts an actor. */
+    startActor(actor: AnyActor): void | PromiseLike<void>;
+    /** Stops an actor without producing a completion result. */
+    stopActor(actor: AnyActor): void | PromiseLike<void>;
+    /** Completes or errors an actor and publishes its terminal result. */
+    terminateActor(actor: AnyActor, termination: ActorTermination): void | PromiseLike<void>;
+    /** Delivers an event between actors. */
+    sendEvent(source: AnyActor | undefined, target: AnyActor, event: AnyEventObject): void | PromiseLike<void>;
+    /** Publishes an emitted event. */
+    emitEvent(source: AnyActor, event: EventObject): void | PromiseLike<void>;
+    /** Schedules a logical timer. */
+    scheduleTimer(source: AnyActor, id: string, delay: number): void | PromiseLike<void>;
+    /** Cancels one logical timer. */
+    cancelTimer(source: AnyActor, id: string): void | PromiseLike<void>;
+    /** Cancels all logical timers owned by an actor. */
+    cancelAllTimers(source: AnyActor): void | PromiseLike<void>;
+}
+export interface ActorSystem<T extends ActorSystemInfo> extends ActorSystemRuntime {
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
     getAll: () => Partial<T['actors']>;
     inspect: (observer: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void)) => Subscription;
     scheduler: Scheduler;
     getSnapshot: () => {
-        _scheduledEvents: Record<string, ScheduledEvent>;
+        _scheduledTimers: Record<string, ScheduledTimer>;
     };
     start: () => void;
     _clock: Clock;
@@ -34,6 +59,6 @@ export declare function createRuntimeSystem<T extends ActorSystemInfo>(rootActor
     clock: Clock;
     logger: (...args: any[]) => void;
     snapshot?: unknown;
-    timers?: TimersRestoreStrategy;
+    createActorRef: ActorSystem<T>['createActorRef'];
 }): ActorSystem<T>;
 export {};

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

@@ -1,6 +1,8 @@
-import type { AnyAction, AnyActorScope, AnyEventObject, AnyMachineSnapshot, EnqueueObject, EventObject, ExecutableActionObject, MachineContext, SpecialExecutableAction, StartExecutableActionObject } from "./types.js";
+import type { ActorSystemRuntime } from "./system.js";
+import type { AnyAction, AnyActor, AnyActorScope, AnyEventObject, AnyMachineSnapshot, EnqueueObject, EventObject, ExecutableActionObject, MachineContext, SpecialExecutableAction, SpawnExecutableActionObject, StartExecutableActionObject } from "./types.js";
 export declare function mergeContextPatch(context: MachineContext, patch: MachineContext): MachineContext;
 export declare function createTransitionEnqueue(actorScope: AnyActorScope, actions: any[], internalEvents: EventObject[], actorSubscriptions?: boolean, createActors?: boolean): EnqueueObject<any, any>;
+export declare function createSpawnEffect(actor: AnyActor): SpawnExecutableActionObject;
 /**
  * Attached (listener/subscription) starts are ordered before child starts so
  * that a listener/subscription captures events emitted synchronously as its
@@ -8,5 +10,7 @@ export declare function createTransitionEnqueue(actorScope: AnyActorScope, actio
  */
 export declare function deriveDeferredStarts(effects: ReadonlyArray<ExecutableActionObject>): StartExecutableActionObject[];
 export declare function isBuiltInExecutableAction(action: ExecutableActionObject): action is SpecialExecutableAction;
+/** Executes transition effects sequentially, awaiting each runtime operation. */
+export declare function executeEffects(effects: readonly ExecutableActionObject[], runtime?: Partial<ActorSystemRuntime>): Promise<void>;
 export declare function resolveActionsWithContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: AnyAction[]): [AnyMachineSnapshot, ExecutableActionObject[]];
 export declare function createEnqueueObject(props: Partial<EnqueueObject<any, any>>, action: <T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>) => void): EnqueueObject<any, any>;