xstate 6.0.0-alpha.3 → 6.0.0-alpha.31

package/dist/StateMachine-4e86e818.cjs.js

@@ -0,0 +1,1079 @@
+'use strict';
+
+var dist_xstateActors = require('./index-85c48a0a.cjs.js');
+
+function createSpawner(actorScope, actors, spawnedChildren) {
+  return (src, options) => {
+    const referencedSrc = Object.entries(actors).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') {
+    dist_xstateActors.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 ? dist_xstateActors.getSnapshotActorRef(snapshot) : undefined;
+  const previousSelf = sourceSelf ?? snapshotRef?.actor;
+  const baseSystem = previousSelf?.system;
+  const system = previousSelf && baseSystem ? dist_xstateActors.createSnapshotSystem(baseSystem, dist_xstateActors.isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
+  const self = dist_xstateActors.createActor(actorLogic, {
+    _inert: true,
+    ...(previousSelf ? {
+      id: previousSelf.id,
+      _sessionId: previousSelf.sessionId
+    } : {}),
+    ...(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);
+  if (!memoizedData) {
+    memoizedData = {
+      [key]: fn()
+    };
+    cache.set(object, memoizedData);
+  } else if (!(key in memoizedData)) {
+    memoizedData[key] = fn();
+  }
+  return memoizedData[key];
+}
+
+const EMPTY_OBJECT = {};
+class StateNode {
+  constructor(/** The raw config used to create the machine. */
+  config, options) {
+    this.config = config;
+    /**
+     * The relative key of the state node, which represents its location in the
+     * overall state value.
+     */
+    this.key = void 0;
+    /** The unique ID of the state node. */
+    this.id = void 0;
+    /**
+     * The type of this state node:
+     *
+     * - `'atomic'` - no child state nodes
+     * - `'compound'` - nested child state nodes (XOR)
+     * - `'parallel'` - orthogonal nested child state nodes (AND)
+     * - `'history'` - history state node
+     * - `'choice'` - pure routing decision state node
+     * - `'final'` - final state node
+     */
+    this.type = void 0;
+    /** The string path from the root machine node to this node. */
+    this.path = void 0;
+    /** The child state nodes. */
+    this.states = void 0;
+    /**
+     * The type of history on this state node. Can be:
+     *
+     * - `'shallow'` - recalls only top-level historical state value
+     * - `'deep'` - recalls historical state value at all levels
+     */
+    this.history = void 0;
+    /** The action(s) to be executed upon entering the state node. */
+    this.entry = void 0;
+    /** The action(s) to be executed upon exiting the state node. */
+    this.exit = void 0;
+    /** The parent state node. */
+    this.parent = void 0;
+    /** The root machine node. */
+    this.machine = void 0;
+    /**
+     * The meta data associated with this state node, which will be returned in
+     * State instances.
+     */
+    this.meta = void 0;
+    /**
+     * The output data sent with the `xstate.done.state` event if this is a final
+     * state node.
+     */
+    this.output = void 0;
+    /**
+     * The order this state node appears. Corresponds to the implicit document
+     * order.
+     */
+    this.order = -1;
+    this.description = void 0;
+    this.schemas = void 0;
+    this.tags = [];
+    this.transitions = void 0;
+    this.always = void 0;
+    this.invoke = void 0;
+    this.on = void 0;
+    this.after = void 0;
+    this.events = void 0;
+    this.ownEvents = void 0;
+    this.parent = options._parent;
+    this.key = options._key;
+    this.machine = options._machine;
+    this.path = this.parent ? this.parent.path.concat(this.key) : [];
+    const firstStateKey = this.config.states ? Object.keys(this.config.states)[0] : undefined;
+    this.id = this.config.id || [this.machine.id, ...this.path].join(dist_xstateActors.STATE_DELIMITER);
+    this.type = this.config.type || (firstStateKey !== undefined ? 'compound' : this.config.history ? 'history' : 'atomic');
+    this.description = this.config.description;
+    this.schemas = this.config.schemas;
+    validateStateNodeConfig(this);
+    this.order = this.machine.idMap.size;
+    this.machine.idMap.set(this.id, this);
+    this.states = this.config.states ? dist_xstateActors.mapValues(this.config.states, (stateConfig, key) => {
+      const stateNode = new StateNode(stateConfig, {
+        _parent: this,
+        _key: key,
+        _machine: this.machine
+      });
+      return stateNode;
+    }) : EMPTY_OBJECT;
+    if (this.type === 'compound' && !this.config.initial) {
+      throw new Error(`No initial state specified for compound state node "#${this.id}".`);
+    }
+
+    // History config
+    this.history = this.config.history === true ? 'shallow' : this.config.history || false;
+    this.entry = this.config.entry;
+    this.exit = this.config.exit;
+    if (this.entry) {
+      // @ts-expect-error _special is an internal marker not on the Action type
+      this.entry._special = true;
+    }
+    if (this.exit) {
+      // @ts-expect-error _special is an internal marker not on the Action type
+      this.exit._special = true;
+    }
+    this.meta = this.config.meta;
+    this.output = this.type === 'final' || !this.parent ? this.config.output : undefined;
+    this.tags = dist_xstateActors.toArray(config.tags).slice();
+    this.invoke = dist_xstateActors.toArray(this.config.invoke).map((invokeConfig, i) => {
+      const {
+        src,
+        registryKey
+      } = invokeConfig;
+      const invokeId = dist_xstateActors.createInvokeId(this.id, i);
+      const resolvedId = invokeConfig.id ?? invokeId;
+      // Referenced (string) actors keep their logical name so persisted
+      // snapshots reference `src: 'fetchUser'` rather than a positional id;
+      // only inline logic gets the synthetic source name.
+      const sourceName = typeof src === 'string' ? src : `xstate.invoke.${invokeId}`;
+      return {
+        ...invokeConfig,
+        src: sourceName,
+        logic: src,
+        id: resolvedId,
+        registryKey
+      };
+    });
+  }
+
+  /** @internal */
+  _initialize() {
+    this.after = dist_xstateActors.getDelayedTransitions(this);
+    this.transitions = formatTransitions(this);
+    if (this.type === 'choice') {
+      this.always = formatChoiceTransitions(this);
+    } else if (this.config.always) {
+      this.always = mapTransitionConfigs(this.config.always, transition => dist_xstateActors.formatTransition(this, dist_xstateActors.NULL_EVENT, transition));
+    }
+    for (const key of Object.keys(this.states)) {
+      this.states[key]._initialize();
+    }
+    this._refreshEventMetadata();
+  }
+
+  /** @internal */
+  _refreshEventMetadata() {
+    const on = {};
+    const ownEvents = [];
+    for (const [descriptor, transitions] of this.transitions) {
+      on[descriptor] = transitions.slice();
+      if (transitions.some(transition => transition.target || transition.reenter || transition.to)) {
+        ownEvents.push(descriptor);
+      }
+    }
+    this.on = on;
+    this.ownEvents = ownEvents;
+    const events = new Set(ownEvents);
+    for (const state of Object.values(this.states)) {
+      for (const event of state.events) {
+        events.add(event);
+      }
+    }
+    this.events = Array.from(events);
+  }
+  get initial() {
+    return memo(this, 'initial', () => formatInitialTransition(this, this.config.initial));
+  }
+
+  /** @internal */
+  next(snapshot, event, self) {
+    const candidates = memo(this, `candidates-${dist_xstateActors.getEventDescriptorKey(event)}`, () => dist_xstateActors.getCandidates(this, event));
+    for (const candidate of candidates) {
+      const guardPassed = dist_xstateActors.evaluateCandidate(candidate, event, snapshot, this, self);
+      if (guardPassed) {
+        return [candidate];
+      }
+    }
+    return undefined;
+  }
+}
+function validateStateNodeConfig(stateNode) {
+  const config = stateNode.config;
+  if (stateNode.type === 'history' && !(typeof config.target === 'string' && config.target.trim().length > 0 || Array.isArray(config.target) && config.target.length > 0 && config.target.every(target => typeof target === 'string' && target.trim().length > 0))) {
+    throw new Error(`Missing history target on "${stateNode.id}"`);
+  }
+  if (stateNode.type !== 'choice') {
+    return;
+  }
+  if (typeof config.choice !== 'function') {
+    throw new Error(`Missing \`choice\` function on "${stateNode.id}"`);
+  }
+}
+function formatChoiceTransitions(stateNode) {
+  const choice = stateNode.config.choice;
+  const validateChoiceResult = result => {
+    if (!result || result.target === undefined) {
+      throw new Error(`Choice "${stateNode.id}" has no target`);
+    }
+    return result;
+  };
+  return [dist_xstateActors.formatTransition(stateNode, dist_xstateActors.NULL_EVENT, {
+    to: args => validateChoiceResult(choice(args))
+  })];
+}
+function mapTransitionConfigs(transitionsConfig, mapper) {
+  const transitionConfigs = dist_xstateActors.toTransitionConfigArray(transitionsConfig);
+  const transitions = new Array(transitionConfigs.length);
+  for (let i = 0; i < transitionConfigs.length; i++) {
+    transitions[i] = mapper(transitionConfigs[i]);
+  }
+  return transitions;
+}
+function formatTransitions(stateNode) {
+  const transitions = new Map();
+  const addTransitions = (descriptor, additions) => {
+    transitions.set(descriptor, [...(transitions.get(descriptor) ?? []), ...additions]);
+  };
+  if (stateNode.config.on) {
+    for (const descriptor of Object.keys(stateNode.config.on)) {
+      if (descriptor === dist_xstateActors.NULL_EVENT) {
+        throw new Error('Null event transition key');
+      }
+      const transitionsConfig = stateNode.config.on[descriptor];
+      transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
+    }
+  }
+  if (stateNode.config.onDone) {
+    const descriptor = 'xstate.done.state';
+    addTransitions(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => dist_xstateActors.formatTransition(stateNode, descriptor, {
+      ...transition,
+      matches: {
+        ...transition.matches,
+        stateId: stateNode.id
+      }
+    })));
+  }
+  if (stateNode.config.onError) {
+    const descriptor = 'xstate.error.*';
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
+  }
+  const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventId, actorId) => dist_xstateActors.formatTransition(stateNode, descriptor, {
+    matches: {
+      actorId
+    },
+    _eventMatcher: (event, snapshot) => dist_xstateActors.matchesActorSession(event, snapshot, actorId),
+    to: (_args, enq) => {
+      enq.cancel(timeoutEventId);
+      return {};
+    }
+  });
+  const formatInvokeCompletionTransition = (descriptor, transitionConfig, timeoutEventId) => {
+    const {
+      target,
+      to,
+      reenter,
+      ...rest
+    } = transitionConfig;
+    return dist_xstateActors.formatTransition(stateNode, descriptor, {
+      ...rest,
+      reenter,
+      to: (args, enq) => {
+        if (to) {
+          let didEnqueue = false;
+          const trackingEnqueue = new Proxy(enq, {
+            apply(target, thisArg, argArray) {
+              didEnqueue = true;
+              return Reflect.apply(target, thisArg, argArray);
+            },
+            get(target, prop, receiver) {
+              const value = Reflect.get(target, prop, receiver);
+              if (typeof value !== 'function') {
+                return value;
+              }
+              return (...argArray) => {
+                didEnqueue = true;
+                return value.apply(target, argArray);
+              };
+            }
+          });
+          const result = to(args, trackingEnqueue);
+          if (result !== undefined || didEnqueue) {
+            enq.cancel(timeoutEventId);
+          }
+          return result;
+        }
+        enq.cancel(timeoutEventId);
+        return {
+          target,
+          reenter
+        };
+      }
+    });
+  };
+  for (const invokeDef of stateNode.invoke) {
+    const withInvokeMatch = transition => ({
+      ...transition,
+      matches: {
+        ...transition.matches,
+        actorId: invokeDef.id
+      },
+      _eventMatcher: (event, snapshot) => dist_xstateActors.matchesActorSession(event, snapshot, invokeDef.id)
+    });
+    const invokeTimeoutEventId = invokeDef.timeout !== undefined ? dist_xstateActors.createInvokeTimeoutEventId(invokeDef.id) : undefined;
+    if (invokeDef.onDone) {
+      const descriptor = 'xstate.done.actor';
+      const invokeDoneTransitions = mapTransitionConfigs(invokeDef.onDone, rawTransition => {
+        const transition = withInvokeMatch(rawTransition);
+        return invokeTimeoutEventId ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventId) : dist_xstateActors.formatTransition(stateNode, descriptor, transition);
+      });
+      if (invokeTimeoutEventId) {
+        invokeDoneTransitions.push(createCancelInvokeTimeoutTransition(descriptor, invokeTimeoutEventId, invokeDef.id));
+      }
+      addTransitions(descriptor, invokeDoneTransitions);
+    } else if (invokeTimeoutEventId) {
+      const descriptor = 'xstate.done.actor';
+      addTransitions(descriptor, [createCancelInvokeTimeoutTransition(descriptor, invokeTimeoutEventId, invokeDef.id)]);
+    }
+    if (invokeDef.onError) {
+      const descriptor = 'xstate.error.actor';
+      addTransitions(descriptor, mapTransitionConfigs(invokeDef.onError, rawTransition => {
+        const transition = withInvokeMatch(rawTransition);
+        return invokeTimeoutEventId ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventId) : dist_xstateActors.formatTransition(stateNode, descriptor, transition);
+      }));
+    }
+    if (invokeDef.onSnapshot) {
+      const descriptor = 'xstate.snapshot.actor';
+      addTransitions(descriptor, mapTransitionConfigs(invokeDef.onSnapshot, transition => dist_xstateActors.formatTransition(stateNode, descriptor, withInvokeMatch(transition))));
+    }
+  }
+  for (const delayedTransition of stateNode.after) {
+    let existing = transitions.get(delayedTransition.eventType);
+    if (!existing) {
+      existing = [];
+      transitions.set(delayedTransition.eventType, existing);
+    }
+    existing.push(delayedTransition);
+  }
+  return transitions;
+}
+function formatInitialTransition(stateNode, _target) {
+  const targetString = typeof _target === 'object' && _target !== null ? _target.target : _target;
+  const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
+  const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
+  if (!resolvedTarget && targetString) {
+    throw new Error(`Initial state "${targetString}" not found on "#${stateNode.id}"`);
+  }
+  const transition = {
+    source: stateNode,
+    target: resolvedTarget ? [resolvedTarget] : undefined,
+    input
+  };
+  return transition;
+}
+
+const STATE_IDENTIFIER = '#';
+let emptyCanActor;
+let emptyCanActorScope;
+function getEmptyCanActor() {
+  // A minimal inert actor used purely as the `self`/`parent` argument when
+  // dry-running transitions for `snapshot.can(...)`. Intentionally not built
+  // on `createLogic` so `can()` does not pull that machinery into bundles.
+  return emptyCanActor ??= dist_xstateActors.createActor({
+    transition: snapshot => [snapshot, []],
+    initialTransition: () => [{
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }, []],
+    getInitialSnapshot: () => ({
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }),
+    getPersistedSnapshot: snapshot => snapshot
+  });
+}
+function getEmptyCanActorScope() {
+  if (emptyCanActorScope) {
+    return emptyCanActorScope;
+  }
+  const actor = getEmptyCanActor();
+  emptyCanActorScope = {
+    self: actor,
+    logger: () => {},
+    id: '',
+    sessionId: '',
+    defer: () => {},
+    system: actor.system,
+    stopChild: () => {},
+    emit: () => {},
+    actionExecutor: () => {}
+  };
+  return emptyCanActorScope;
+}
+class StateMachine {
+  constructor(/** The raw config used to create the machine. */
+  config, sources, validator) {
+    this.config = config;
+    this.validator = validator;
+    /** The machine's own version. */
+    this.version = void 0;
+    this.schemas = void 0;
+    this.sources = void 0;
+    /** Runtime options for machine execution. */
+    this.options = void 0;
+    /** @internal */
+    this.idMap = new Map();
+    this.root = void 0;
+    this.id = void 0;
+    this.states = void 0;
+    this.events = void 0;
+    this.internalEventDescriptors = void 0;
+    /**
+     * The original JSON definition this machine was created from (set by
+     * `createMachineFromConfig`), if any. Used by `serializeMachine` for lossless
+     * round-trips.
+     *
+     * @internal
+     */
+    this._json = void 0;
+    this.id = config.id || '(machine)';
+    this.sources = {
+      actors: config.actors ?? {},
+      actions: config.actions ?? {},
+      delays: config.delays ?? {},
+      guards: config.guards ?? {},
+      ...sources
+    };
+    this.version = this.config.version;
+    this.schemas = this.config.schemas;
+    this.internalEventDescriptors = this.config.internalEvents ?? [];
+    this.options = {
+      maxIterations: Infinity,
+      ...this.config.options
+    };
+    this.transition = this.transition.bind(this);
+    this.initialTransition = this.initialTransition.bind(this);
+    this.getInitialSnapshot = this.getInitialSnapshot.bind(this);
+    this.getPersistedSnapshot = this.getPersistedSnapshot.bind(this);
+    this.restoreSnapshot = this.restoreSnapshot.bind(this);
+    this.start = this.start.bind(this);
+    this.root = new StateNode(config, {
+      _key: this.id,
+      _machine: this
+    });
+    this.root._initialize();
+    dist_xstateActors.formatRouteTransitions(this.root);
+    this.root._refreshEventMetadata();
+    this.states = this.root.states; // TODO: remove!
+    this.events = this.root.events;
+  }
+
+  /**
+   * Clones this state machine with the provided sources.
+   *
+   * @param sources Options (`actions`, `guards`, `actors`, `delays`) to
+   *   recursively merge with the existing options.
+   * @returns A new `StateMachine` instance with the provided sources.
+   */
+  provide(sources) {
+    const {
+      actions,
+      guards,
+      actors,
+      delays
+    } = this.sources;
+    const provided = new StateMachine(this.config, {
+      actions: {
+        ...actions,
+        ...sources.actions
+      },
+      guards: {
+        ...guards,
+        ...sources.guards
+      },
+      actors: {
+        ...actors,
+        ...sources.actors
+      },
+      delays: {
+        ...delays,
+        ...sources.delays
+      }
+    }, this.validator);
+    // Providing sources does not change the serializable definition.
+    provided._json = this._json;
+    return provided;
+  }
+  resolveState(config) {
+    const resolvedStateValue = dist_xstateActors.resolveStateValue(this.root, config.value);
+    const nodeSet = dist_xstateActors.getAllStateNodes(dist_xstateActors.getStateNodes(this.root, resolvedStateValue));
+    const nodes = [...nodeSet];
+    return dist_xstateActors.createMachineSnapshot({
+      _nodes: nodes,
+      value: resolvedStateValue,
+      context: config.context || {},
+      children: {},
+      status: dist_xstateActors.isInFinalState(nodeSet, this.root) ? 'done' : config.status || 'active',
+      output: config.output,
+      error: config.error,
+      historyValue: config.historyValue
+    }, this);
+  }
+
+  /**
+   * Determines the next snapshot given the current `snapshot` and received
+   * `event`. Calculates a full macrostep from all microsteps.
+   *
+   * @param snapshot The current snapshot
+   * @param event The received event
+   */
+  transition(snapshot, event, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'event',
+        logic: this,
+        event,
+        eventOrigin: actorScope && actorScope.self._lastSourceRef ? 'actor' : 'external'
+      });
+    }
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
+    const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);
+    if (fastSnapshot) {
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
+      }
+      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      if (this.validator) {
+        dist_xstateActors.assertValid(this.validator, {
+          kind: 'result',
+          logic: this,
+          snapshot: returnedSnapshot,
+          effects: []
+        });
+      }
+      return [returnedSnapshot, []];
+    }
+    const {
+      snapshot: nextSnapshot,
+      microsteps
+    } = dist_xstateActors.macrostep(snapshot, event, resolvedActorScope, []);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
+    }
+    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+    const effects = this._collectEffects(microsteps);
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'result',
+        logic: this,
+        snapshot: returnedSnapshot,
+        effects
+      });
+    }
+    return [returnedSnapshot, effects];
+  }
+  _collectEffects(microsteps) {
+    return microsteps.flatMap(([, actions]) => actions);
+  }
+  _attachPureActorRef(snapshot, actorScope) {
+    if (isInertActorScope(actorScope)) {
+      return snapshot;
+    }
+    dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
+    return snapshot;
+  }
+  _transitionFast(snapshot, event, actorScope) {
+    if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
+      return undefined;
+    }
+    const sourceNode = this.root.states[snapshot.value];
+    if (!sourceNode || sourceNode.type !== 'atomic' || sourceNode.exit || sourceNode.invoke.length || sourceNode.always?.length || sourceNode.after?.length) {
+      return undefined;
+    }
+    const transitions = sourceNode.transitions.get(event.type);
+    if (transitions?.length !== 1) {
+      return undefined;
+    }
+    const selected = transitions[0];
+    if (selected.guard || selected.actions || selected.to || selected.reenter || selected.input || typeof selected.context === 'function' || selected.target && selected.target.length !== 1) {
+      return undefined;
+    }
+    const targetNode = selected.target?.[0] ?? sourceNode;
+    const stateChanged = targetNode !== sourceNode;
+    if (targetNode.parent !== this.root || targetNode.type !== 'atomic' || stateChanged && (targetNode.entry || targetNode.invoke.length || targetNode.always?.length || targetNode.after?.length)) {
+      return undefined;
+    }
+    const context = selected.context !== undefined ? {
+      ...snapshot.context,
+      ...selected.context
+    } : snapshot.context;
+    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+    collectedMicrosteps.push(selected);
+    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    return dist_xstateActors.cloneMachineSnapshot(snapshot, {
+      ...(context !== snapshot.context ? {
+        context
+      } : {}),
+      ...(stateChanged ? {
+        _nodes: [this.root, targetNode]
+      } : {})
+    });
+  }
+
+  /**
+   * Determines the next state given the current `state` and `event`. Calculates
+   * a microstep.
+   *
+   * @param state The current state
+   * @param event The received event
+   */
+  microstep(snapshot, event, actorScope) {
+    const {
+      microsteps
+    } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
+    const snapshots = new Array(microsteps.length);
+    for (let i = 0; i < microsteps.length; i++) {
+      snapshots[i] = microsteps[i][0];
+    }
+    return snapshots;
+  }
+  getTransitionData(snapshot, event, self) {
+    return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
+  }
+  isInternalEventType(eventType) {
+    if (eventType === dist_xstateActors.XSTATE_TIMER) {
+      return true;
+    }
+    for (const descriptor of this.internalEventDescriptors) {
+      if (dist_xstateActors.matchesEventDescriptor(eventType, descriptor)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Determines whether sending the `event` to the given snapshot would select a
+   * non-forbidden transition. Backs `snapshot.can(...)`; lives here so that
+   * non-machine bundles don't pay for the transition-resolution machinery.
+   *
+   * @internal
+   */
+  _canTransition(snapshot, event) {
+    const emptyActor = getEmptyCanActor();
+    const emptyActorScope = getEmptyCanActorScope();
+    const transitionData = this.getTransitionData(snapshot, event, emptyActor);
+    if (!transitionData?.length) {
+      return false;
+    }
+
+    // Check that at least one transition is not forbidden
+    for (const transition of transitionData) {
+      if (transition.target !== undefined) {
+        return true;
+      }
+      const res = dist_xstateActors.getTransitionResult(transition, snapshot, event, emptyActorScope, {
+        resolveActions: false
+      });
+      if (res.targets?.length || res.context || dist_xstateActors.hasEffect(transition, snapshot.context, event, snapshot, emptyActor)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns the error event that the actor should transition with to recover
+   * from an execution error, if any active state node declares `onError`.
+   *
+   * @internal
+   */
+  getExecutionErrorEvent(snapshot, error) {
+    if (snapshot?.status !== 'active' || !snapshot._nodes?.some(stateNode => stateNode.config.onError)) {
+      return undefined;
+    }
+    return dist_xstateActors.createErrorPlatformEvent('execution', error);
+  }
+
+  /**
+   * The initial state _before_ evaluating any microsteps. This "pre-initial"
+   * state is provided to initial actions executed in the initial state.
+   *
+   * @internal
+   */
+  _getPreInitialState(actorScope, initEvent) {
+    const {
+      context
+    } = this.config;
+    const preInitial = dist_xstateActors.createMachineSnapshot({
+      context: typeof context !== 'function' && context ? context : {},
+      _nodes: [this.root],
+      children: {},
+      status: 'active'
+    }, this, actorScope.self);
+    if (typeof context === 'function') {
+      const children = {};
+      const spawn = createSpawner(actorScope, this.sources.actors, children);
+      const resolvedContext = context({
+        spawn,
+        input: initEvent.input,
+        self: actorScope.self,
+        actors: this.sources.actors
+      });
+      const [nextState] = dist_xstateActors.resolveActionsWithContext(preInitial, initEvent, actorScope, []);
+      if (resolvedContext) {
+        nextState.context = resolvedContext;
+      }
+      if (Object.keys(children).length > 0) {
+        nextState.children = {
+          ...nextState.children,
+          ...children
+        };
+      }
+      return nextState;
+    }
+    return preInitial;
+  }
+
+  /**
+   * Returns the initial `State` instance, with reference to `self` as an
+   * `ActorRef`.
+   */
+  getInitialSnapshot(actorScope, input) {
+    return this.initialTransition(input, actorScope)[0];
+  }
+  initialTransition(input, actorScope) {
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'input',
+        logic: this,
+        input
+      });
+    }
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
+    const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
+    const internalQueue = [];
+    const preInitialState = this._getPreInitialState(resolvedActorScope, initEvent);
+    const contextSpawnEffects = Object.values(preInitialState.children).filter(Boolean).map(actor => dist_xstateActors.createSpawnEffect(actor));
+    const finalizeInitialResult = (macroState, microsteps) => {
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+      }
+      const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
+      const effects = this._collectEffects(microsteps);
+      if (this.validator) {
+        dist_xstateActors.assertValid(this.validator, {
+          kind: 'result',
+          logic: this,
+          snapshot: returnedSnapshot,
+          effects
+        });
+      }
+      return [returnedSnapshot, effects];
+    };
+    try {
+      const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
+      const {
+        snapshot: macroState,
+        microsteps
+      } = dist_xstateActors.macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]);
+      return finalizeInitialResult(macroState, microsteps);
+    } catch (err) {
+      if (!this.root.config.onError) {
+        throw err;
+      }
+      const errorEvent = dist_xstateActors.createErrorPlatformEvent('execution', err);
+      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
+      return finalizeInitialResult(errorMacrostep.snapshot, errorMacrostep.microsteps);
+    }
+  }
+  start(snapshot) {
+    // Start rehydrated children that were active when persisted. Freshly
+    // invoked/spawned children are NOT started here — they start via deferred
+    // `@xstate.start` actions so sync start errors route to `onError`.
+    if (!snapshot?.children) {
+      return;
+    }
+    for (const child of Object.values(snapshot.children)) {
+      if (child._rehydrated && child.getSnapshot?.().status === 'active') {
+        child.start();
+      }
+    }
+  }
+  getStateNodeById(stateId) {
+    const fullPath = dist_xstateActors.toStatePath(stateId);
+    const relativePath = fullPath.slice(1);
+    const resolvedStateId = dist_xstateActors.isStateId(fullPath[0]) ? fullPath[0].slice(STATE_IDENTIFIER.length) : fullPath[0];
+    const stateNode = this.idMap.get(resolvedStateId);
+    if (!stateNode) {
+      throw new Error(`Child state node '#${resolvedStateId}' does not exist on machine '${this.id}'`);
+    }
+    return dist_xstateActors.getStateNodeByPath(stateNode, relativePath);
+  }
+  getPersistedSnapshot(snapshot, options) {
+    return dist_xstateActors.getPersistedSnapshot(snapshot, options);
+  }
+  restoreSnapshot(snapshot, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
+    const persistedMachine = snapshot.machine;
+    const legacyPersistedVersion = snapshot.version;
+    const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
+    if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {
+      throw new Error(`Persisted snapshot version '${legacyPersistedVersion}' conflicts with machine version '${persistedMachine.version}'.`);
+    }
+    if (persistedMachine && typeof persistedMachine.id === 'string' && persistedMachine.id !== this.id) {
+      throw new Error(`Machine ID mismatch: persisted snapshot machine '${persistedMachine.id}' does not match '${this.id}'.`);
+    }
+    if (persistedVersion !== this.version) {
+      const migrate = this.config.migrate;
+      if (typeof migrate !== 'function') {
+        throw new Error(`Persisted snapshot version '${persistedVersion}' does not match machine version '${this.version}'.`);
+      }
+      snapshot = migrate(snapshot, persistedVersion);
+    }
+    const snapshotData = snapshot;
+    const children = {};
+    const snapshotChildren = snapshotData.children;
+    for (const actorId of Object.keys(snapshotChildren)) {
+      const actorData = snapshotChildren[actorId];
+      const childState = actorData.snapshot;
+      const src = actorData.src;
+      const logic = typeof src === 'string' ? dist_xstateActors.resolveReferencedActor(this, src) : src;
+      if (!logic) {
+        const sourceId = typeof src === 'string' ? src : '<unknown>';
+        throw new Error(`Unable to restore child actor '${actorId}': child source '${sourceId}' is not provided in machine '${this.id}'.`);
+      }
+      const actor = resolvedActorScope.system.createActorRef(logic, {
+        id: actorId,
+        parent: resolvedActorScope.self,
+        syncSnapshot: actorData.syncSnapshot,
+        snapshot: childState,
+        src,
+        registryKey: actorData.registryKey
+      });
+      // Mark so `start()` knows to start this child (freshly invoked/spawned
+      // children are started via deferred `@xstate.start` actions instead).
+      actor._rehydrated = true;
+      children[actorId] = actor;
+    }
+    const timers = {};
+    const persistedTimers = snapshotData.timers ?? {};
+    for (const [id, timer] of Object.entries(persistedTimers)) {
+      let event = timer.event;
+      if (event.type === 'xstate.timeout.actor') {
+        const actorId = event.actorId;
+        const child = children[actorId];
+        if (child) {
+          event = dist_xstateActors.createInvokeTimeoutEvent(actorId, child.sessionId);
+        }
+      }
+      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,
+        event,
+        target
+      };
+    }
+    const reviveHistoryValue = historyValue => {
+      if (!historyValue || typeof historyValue !== 'object') {
+        return {};
+      }
+      const revived = {};
+      for (const key of Object.keys(historyValue)) {
+        const arr = historyValue[key];
+        for (const item of arr) {
+          let resolved;
+          if (item instanceof StateNode) {
+            resolved = item;
+          } else {
+            try {
+              resolved = this.root.machine.getStateNodeById(item.id);
+            } catch {
+            }
+          }
+          if (!resolved) {
+            continue;
+          }
+          revived[key] ??= [];
+          revived[key].push(resolved);
+        }
+      }
+      return revived;
+    };
+    const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
+    const nodes = Array.from(dist_xstateActors.getAllStateNodes(dist_xstateActors.getStateNodes(this.root, snapshotData.value)));
+    const {
+      version: _persistedSnapshotVersion,
+      ...persistedRest
+    } = snapshot;
+    const restoredSnapshot = dist_xstateActors.createMachineSnapshot({
+      ...persistedRest,
+      children,
+      timers,
+      _nodes: nodes,
+      value: snapshotData.value,
+      historyValue: revivedHistoryValue,
+      _stateInputs: snapshotData.stateInputs ?? {}
+    }, this, resolvedActorScope.self);
+    const seen = new WeakSet();
+    function reviveContext(contextPart) {
+      if (seen.has(contextPart)) {
+        return;
+      }
+      seen.add(contextPart);
+      for (const key of Object.keys(contextPart)) {
+        const value = contextPart[key];
+        if (value && typeof value === 'object') {
+          if ('xstate$$type' in value && value.xstate$$type === dist_xstateActors.$$ACTOR_TYPE) {
+            contextPart[key] = children[value.id];
+            continue;
+          }
+          reviveContext(value);
+        }
+      }
+    }
+    reviveContext(restoredSnapshot.context);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
+      return attachSnapshotActorRef(this, resolvedActorScope, restoredSnapshot);
+    }
+    return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
+  }
+}
+
+exports.StateMachine = StateMachine;
+exports.StateNode = StateNode;
+exports.attachSnapshotActorRef = attachSnapshotActorRef;
+exports.createInertActorScope = createInertActorScope;
+exports.getInitialSnapshot = getInitialSnapshot;
+exports.getNextSnapshot = getNextSnapshot;
+exports.setInertActorScopeSnapshot = setInertActorScopeSnapshot;