xstate 5.32.1 → 6.0.0-alpha.1

package/dist/StateMachine-47e60715.esm.js

@@ -0,0 +1,720 @@
+import { P as ProcessingStatus, G as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, n as getStateNodes, W as createMachineSnapshot, X as isInFinalState, a as macrostep, Y as transitionNode, m as matchesEventDescriptor, Z as resolveAndExecuteActionsWithContext, b as createInitEvent, d as initialMicrostep, _ as toStatePath, $ as isStateId, a0 as getStateNodeByPath, a1 as getPersistedSnapshot, a2 as $$ACTOR_TYPE } from './index-688701ed.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,
+        systemId: options?.systemId
+      });
+      spawnedChildren[actor.id] = actor;
+      return actor;
+    } else {
+      const actor = createActor(src, {
+        id: options?.id,
+        parent: actorScope.self,
+        syncSnapshot: options?.syncSnapshot,
+        input: options?.input,
+        src,
+        systemId: options?.systemId
+      });
+      return actor;
+    }
+  };
+  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();
+    });
+    return actor;
+  };
+}
+
+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 = {};
+const CHOICE_CONFIG_KEYS = ['invoke', 'after', 'on', 'entry', 'exit', 'always', 'states', 'initial', 'onDone', 'timeout', 'onTimeout', 'history', 'target', 'output'];
+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._id_" 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.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(STATE_DELIMITER);
+    this.type = this.config.type || (firstStateKey !== undefined ? 'compound' : this.config.history ? 'history' : 'atomic');
+    this.description = this.config.description;
+    validateStateNodeConfig(this);
+    this.order = this.machine.idMap.size;
+    this.machine.idMap.set(this.id, this);
+    this.states = this.config.states ? 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 = toArray(config.tags).slice();
+    this.invoke = toArray(this.config.invoke).map((invokeConfig, i) => {
+      const {
+        src,
+        systemId
+      } = invokeConfig;
+      const invokeId = 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,
+        systemId
+      };
+    });
+  }
+
+  /** @internal */
+  _initialize() {
+    this.after = 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 => formatTransition(this, 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 eventType = event.type;
+    const candidates = memo(this, `candidates-${eventType}`, () => getCandidates(this, eventType));
+    for (const candidate of candidates) {
+      const guardPassed = evaluateCandidate(candidate, event, snapshot, this, self);
+      if (guardPassed) {
+        return [candidate];
+      }
+    }
+    return undefined;
+  }
+}
+function validateStateNodeConfig(stateNode) {
+  const config = stateNode.config;
+  if (stateNode.type !== 'choice') {
+    if (config.choice !== undefined) {
+      throw new Error(`State "${stateNode.id}" has \`choice\`, but \`choice\` can only be used with \`type: 'choice'\`.`);
+    }
+    return;
+  }
+  if (typeof config.choice !== 'function') {
+    throw new Error(`Choice state "${stateNode.id}" must declare a \`choice\` function.`);
+  }
+  for (const key of CHOICE_CONFIG_KEYS) {
+    if (config[key] !== undefined) {
+      throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\`.`);
+    }
+  }
+}
+function formatChoiceTransitions(stateNode) {
+  const choice = stateNode.config.choice;
+  const validateChoiceResult = result => {
+    if (!result || result.target === undefined) {
+      throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
+    }
+    for (const key of ['actions', 'to', 'context']) {
+      if (result[key] !== undefined) {
+        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
+      }
+    }
+    return result;
+  };
+  return [formatTransition(stateNode, NULL_EVENT, {
+    to: args => validateChoiceResult(choice(args))
+  })];
+}
+function mapTransitionConfigs(transitionsConfig, mapper) {
+  const transitionConfigs = 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();
+  if (stateNode.config.on) {
+    for (const descriptor of Object.keys(stateNode.config.on)) {
+      if (descriptor === NULL_EVENT) {
+        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+      }
+      const transitionsConfig = stateNode.config.on[descriptor];
+      transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => formatTransition(stateNode, descriptor, transition)));
+    }
+  }
+  if (stateNode.config.onDone) {
+    const descriptor = `xstate.done.state.${stateNode.id}`;
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => formatTransition(stateNode, descriptor, transition)));
+  }
+  const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventType) => formatTransition(stateNode, descriptor, {
+    to: (_args, enq) => {
+      enq.cancel(timeoutEventType);
+      return {};
+    }
+  });
+  const formatInvokeCompletionTransition = (descriptor, transitionConfig, timeoutEventType) => {
+    const {
+      target,
+      to,
+      reenter,
+      ...rest
+    } = transitionConfig;
+    return 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(timeoutEventType);
+          }
+          return result;
+        }
+        enq.cancel(timeoutEventType);
+        return {
+          target,
+          reenter
+        };
+      }
+    });
+  };
+  for (const invokeDef of stateNode.invoke) {
+    const invokeTimeoutEventType = invokeDef.timeout !== undefined ? createInvokeTimeoutEvent(invokeDef.id).type : undefined;
+    if (invokeDef.onDone) {
+      const descriptor = `xstate.done.actor.${invokeDef.id}`;
+      const invokeDoneTransitions = mapTransitionConfigs(invokeDef.onDone, transition => invokeTimeoutEventType ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventType) : formatTransition(stateNode, descriptor, transition));
+      if (invokeTimeoutEventType) {
+        invokeDoneTransitions.push(createCancelInvokeTimeoutTransition(descriptor, invokeTimeoutEventType));
+      }
+      transitions.set(descriptor, invokeDoneTransitions);
+    } else if (invokeTimeoutEventType) {
+      const descriptor = `xstate.done.actor.${invokeDef.id}`;
+      transitions.set(descriptor, [createCancelInvokeTimeoutTransition(descriptor, invokeTimeoutEventType)]);
+    }
+    if (invokeDef.onError) {
+      const descriptor = `xstate.error.actor.${invokeDef.id}`;
+      transitions.set(descriptor, mapTransitionConfigs(invokeDef.onError, transition => invokeTimeoutEventType ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventType) : formatTransition(stateNode, descriptor, transition)));
+    }
+    if (invokeDef.onSnapshot) {
+      const descriptor = `xstate.snapshot.${invokeDef.id}`;
+      transitions.set(descriptor, mapTransitionConfigs(invokeDef.onSnapshot, transition => formatTransition(stateNode, descriptor, 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 node "${targetString}" not found on parent state node #${stateNode.id}`);
+  }
+  const transition = {
+    source: stateNode,
+    target: resolvedTarget ? [resolvedTarget] : undefined,
+    input
+  };
+  return transition;
+}
+
+const STATE_IDENTIFIER = '#';
+class StateMachine {
+  constructor(/** The raw config used to create the machine. */
+  config, implementations) {
+    this.config = config;
+    /** The machine's own version. */
+    this.version = void 0;
+    this.schemas = void 0;
+    this.implementations = 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.implementations = {
+      actors: config.actors ?? {},
+      actions: config.actions ?? {},
+      delays: config.delays ?? {},
+      guards: config.guards ?? {},
+      ...implementations
+    };
+    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.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();
+    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 implementations.
+   *
+   * @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
+   *   recursively merge with the existing options.
+   * @returns A new `StateMachine` instance with the provided implementations.
+   */
+  provide(implementations) {
+    const {
+      actions,
+      guards,
+      actors,
+      delays
+    } = this.implementations;
+    const provided = new StateMachine(this.config, {
+      actions: {
+        ...actions,
+        ...implementations.actions
+      },
+      guards: {
+        ...guards,
+        ...implementations.guards
+      },
+      actors: {
+        ...actors,
+        ...implementations.actors
+      },
+      delays: {
+        ...delays,
+        ...implementations.delays
+      }
+    });
+    // Providing implementations does not change the serializable definition.
+    provided._json = this._json;
+    return provided;
+  }
+  resolveState(config) {
+    const resolvedStateValue = resolveStateValue(this.root, config.value);
+    const nodeSet = getAllStateNodes(getStateNodes(this.root, resolvedStateValue));
+    const nodes = [...nodeSet];
+    return createMachineSnapshot({
+      _nodes: nodes,
+      value: resolvedStateValue,
+      context: config.context || {},
+      children: {},
+      status: 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) {
+    return macrostep(snapshot, event, actorScope, []).snapshot;
+  }
+
+  /**
+   * 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
+    } = 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 transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
+  }
+  isInternalEventType(eventType) {
+    for (const descriptor of this.internalEventDescriptors) {
+      if (matchesEventDescriptor(eventType, descriptor)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * 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 = createMachineSnapshot({
+      context: typeof context !== 'function' && context ? context : {},
+      _nodes: [this.root],
+      children: {},
+      status: 'active'
+    }, this);
+    if (typeof context === 'function') {
+      const children = {};
+      const spawn = createSpawner(actorScope, preInitial, initEvent, children);
+      const resolvedContext = context({
+        spawn,
+        input: initEvent.input,
+        self: actorScope.self,
+        actors: this.implementations.actors
+      });
+      const nextState = resolveAndExecuteActionsWithContext(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) {
+    const initEvent = createInitEvent(input); // TODO: fix;
+    const internalQueue = [];
+    const preInitialState = this._getPreInitialState(actorScope, initEvent);
+    const [nextState] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+    const {
+      snapshot: macroState
+    } = macrostep(nextState, initEvent, actorScope, internalQueue);
+    return macroState;
+  }
+  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 = toStatePath(stateId);
+    const relativePath = fullPath.slice(1);
+    const resolvedStateId = 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 getStateNodeByPath(stateNode, relativePath);
+  }
+  getPersistedSnapshot(snapshot, options) {
+    return getPersistedSnapshot(snapshot, options);
+  }
+  restoreSnapshot(snapshot, _actorScope) {
+    const persistedVersion = snapshot.version;
+    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' ? resolveReferencedActor(this, src) : src;
+      if (!logic) {
+        continue;
+      }
+      const actor = createActor(logic, {
+        id: actorId,
+        parent: _actorScope.self,
+        syncSnapshot: actorData.syncSnapshot,
+        snapshot: childState,
+        src,
+        systemId: actorData.systemId
+      });
+      // 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 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(getAllStateNodes(getStateNodes(this.root, snapshotData.value)));
+    const {
+      version: _persistedSnapshotVersion,
+      ...persistedRest
+    } = snapshot;
+    const restoredSnapshot = createMachineSnapshot({
+      ...persistedRest,
+      children,
+      _nodes: nodes,
+      value: snapshotData.value,
+      historyValue: revivedHistoryValue
+    }, this);
+    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 === $$ACTOR_TYPE) {
+            contextPart[key] = children[value.id];
+            continue;
+          }
+          reviveContext(value);
+        }
+      }
+    }
+    reviveContext(restoredSnapshot.context);
+    return restoredSnapshot;
+  }
+}
+
+export { StateMachine as S, StateNode as a };