xstate 5.0.0-beta.52 → 5.0.0-beta.54

package/dist/{raise-367eeb6f.cjs.js → raise-5f22d333.cjs.js}

@@ -100,10 +100,10 @@ function createDoneActorEvent(invokeId, output) {
     output
   };
 }
-function createErrorActorEvent(id, data) {
+function createErrorActorEvent(id, error) {
   return {
     type: `xstate.error.actor.${id}`,
-    data
+    error
   };
 }
 function createInitEvent(input) {
@@ -351,7 +351,7 @@ class Actor {
     /**
      * The current internal state of the actor.
      */
-    this._state = void 0;
+    this._snapshot = void 0;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
      */
@@ -441,19 +441,19 @@ class Actor {
       this._systemId = systemId;
       this.system._set(systemId, this);
     }
-    this._initState(options?.state);
-    if (systemId && this._state.status !== 'active') {
+    this._initState(options?.snapshot ?? options?.state);
+    if (systemId && this._snapshot.status !== 'active') {
       this.system._unregister(this);
     }
   }
   _initState(persistedState) {
     try {
-      this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
+      this._snapshot = persistedState ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
     } catch (err) {
-      // if we get here then it means that we assign a value to this._state that is not of the correct type
+      // if we get here then it means that we assign a value to this._snapshot that is not of the correct type
       // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible
       // so right now this is a lie of sorts
-      this._state = {
+      this._snapshot = {
         status: 'error',
         output: undefined,
         error: err
@@ -462,7 +462,7 @@ class Actor {
   }
   update(snapshot, event) {
     // Update state
-    this._state = snapshot;
+    this._snapshot = snapshot;
 
     // Execute deferred effects
     let deferredFn;
@@ -476,14 +476,14 @@ class Actor {
         // no "builtin deferred" should actually throw an error since they are either safe
         // or the control flow is passed through the mailbox and errors should be caught by the `_process` used by the mailbox
         this._deferred.length = 0;
-        this._state = {
+        this._snapshot = {
           ...snapshot,
           status: 'error',
           error: err
         };
       }
     }
-    switch (this._state.status) {
+    switch (this._snapshot.status) {
       case 'active':
         for (const observer of this.observers) {
           try {
@@ -509,13 +509,13 @@ class Actor {
         }
         this._stopProcedure();
         this._complete();
-        this._doneEvent = createDoneActorEvent(this.id, this._state.output);
+        this._doneEvent = createDoneActorEvent(this.id, this._snapshot.output);
         if (this._parent) {
           this.system._relay(this, this._parent, this._doneEvent);
         }
         break;
       case 'error':
-        this._error(this._state.error);
+        this._error(this._snapshot.error);
         break;
     }
     this.system._sendInspectionEvent({
@@ -628,24 +628,24 @@ class Actor {
       actorRef: this,
       event: initEvent
     });
-    const status = this._state.status;
+    const status = this._snapshot.status;
     switch (status) {
       case 'done':
         // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
         // we still need to complete observers, flush deferreds etc
-        this.update(this._state, initEvent);
+        this.update(this._snapshot, initEvent);
         // TODO: rethink cleanup of observers, mailbox, etc
         return this;
       case 'error':
-        this._error(this._state.error);
+        this._error(this._snapshot.error);
         return this;
     }
     if (this.logic.start) {
       try {
-        this.logic.start(this._state, this._actorScope);
+        this.logic.start(this._snapshot, this._actorScope);
       } catch (err) {
-        this._state = {
-          ...this._state,
+        this._snapshot = {
+          ...this._snapshot,
           status: 'error',
           error: err
         };
@@ -657,7 +657,7 @@ class Actor {
     // TODO: this notifies all subscribers but usually this is redundant
     // there is no real change happening here
     // we need to rethink if this needs to be refactored
-    this.update(this._state, initEvent);
+    this.update(this._snapshot, initEvent);
     if (this.options.devTools) {
       this.attachDevTools();
     }
@@ -668,7 +668,7 @@ class Actor {
     let nextState;
     let caughtError;
     try {
-      nextState = this.logic.transition(this._state, event, this._actorScope);
+      nextState = this.logic.transition(this._snapshot, event, this._actorScope);
     } catch (err) {
       // we wrap it in a box so we can rethrow it later even if falsy value gets caught here
       caughtError = {
@@ -679,8 +679,8 @@ class Actor {
       const {
         err
       } = caughtError;
-      this._state = {
-        ...this._state,
+      this._snapshot = {
+        ...this._snapshot,
         status: 'error',
         error: err
       };
@@ -860,8 +860,8 @@ class Actor {
    * @see https://stately.ai/docs/persistence
    */
 
-  getPersistedState(options) {
-    return this.logic.getPersistedState(this._state, options);
+  getPersistedSnapshot(options) {
+    return this.logic.getPersistedSnapshot(this._snapshot, options);
   }
   [symbolObservable]() {
     return this;
@@ -879,10 +879,10 @@ class Actor {
    * Note that some actors, such as callback actors generated with `fromCallback`, will not emit snapshots.
    *
    * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
-   * @see {@link Actor.getPersistedState} to persist the internal state of an actor (which is more than just a snapshot).
+   * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
    */
   getSnapshot() {
-    return this._state;
+    return this._snapshot;
   }
 }
 
@@ -935,11 +935,11 @@ const interpret = createActor;
  * @deprecated Use `Actor` instead.
  */
 
-function resolveCancel(_, state, actionArgs, actionParams, {
+function resolveCancel(_, snapshot, actionArgs, actionParams, {
   sendId
 }) {
   const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs, actionParams) : sendId;
-  return [state, resolvedSendId];
+  return [snapshot, resolvedSendId];
 }
 function executeCancel(actorScope, resolvedSendId) {
   actorScope.self.cancel(resolvedSendId);
@@ -961,14 +961,14 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
+function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, {
   id,
   systemId,
   src,
   input,
   syncSnapshot
 }) {
-  const logic = typeof src === 'string' ? resolveReferencedActor(state.machine, src) : src;
+  const logic = typeof src === 'string' ? resolveReferencedActor(snapshot.machine, src) : src;
   const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
   if (logic) {
@@ -979,15 +979,15 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
       syncSnapshot,
       systemId,
       input: typeof input === 'function' ? input({
-        context: state.context,
+        context: snapshot.context,
         event: actionArgs.event,
         self: actorScope?.self
       }) : input
     });
   }
-  return [cloneMachineSnapshot(state, {
+  return [cloneMachineSnapshot(snapshot, {
     children: {
-      ...state.children,
+      ...snapshot.children,
       [resolvedId]: actorRef
     }
   }), {
@@ -1017,7 +1017,7 @@ function spawnChild(...[src, {
 } = {}]) {
   function spawnChild(args, params) {
   }
-  spawnChild.type = 'xstate.spawnChild';
+  spawnChild.type = 'snapshot.spawnChild';
   spawnChild.id = id;
   spawnChild.systemId = systemId;
   spawnChild.src = src;
@@ -1028,19 +1028,19 @@ function spawnChild(...[src, {
   return spawnChild;
 }
 
-function resolveStop(_, state, args, actionParams, {
+function resolveStop(_, snapshot, args, actionParams, {
   actorRef
 }) {
   const actorRefOrString = typeof actorRef === 'function' ? actorRef(args, actionParams) : actorRef;
-  const resolvedActorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
-  let children = state.children;
+  const resolvedActorRef = typeof actorRefOrString === 'string' ? snapshot.children[actorRefOrString] : actorRefOrString;
+  let children = snapshot.children;
   if (resolvedActorRef) {
     children = {
       ...children
     };
     delete children[resolvedActorRef.id];
   }
-  return [cloneMachineSnapshot(state, {
+  return [cloneMachineSnapshot(snapshot, {
     children
   }), resolvedActorRef];
 }
@@ -1090,14 +1090,14 @@ function stopChild(actorRef) {
  */
 const stop = stopChild;
 
-function checkStateIn(state, _, {
+function checkStateIn(snapshot, _, {
   stateValue
 }) {
   if (typeof stateValue === 'string' && isStateId(stateValue)) {
-    const target = state.machine.getStateNodeById(stateValue);
-    return state._nodes.some(sn => sn === target);
+    const target = snapshot.machine.getStateNodeById(stateValue);
+    return snapshot._nodes.some(sn => sn === target);
   }
-  return state.matches(stateValue);
+  return snapshot.matches(stateValue);
 }
 function stateIn(stateValue) {
   function stateIn(args, params) {
@@ -1107,13 +1107,13 @@ function stateIn(stateValue) {
   stateIn.stateValue = stateValue;
   return stateIn;
 }
-function checkNot(state, {
+function checkNot(snapshot, {
   context,
   event
 }, {
   guards
 }) {
-  return !evaluateGuard(guards[0], context, event, state);
+  return !evaluateGuard(guards[0], context, event, snapshot);
 }
 function not(guard) {
   function not(args, params) {
@@ -1123,13 +1123,13 @@ function not(guard) {
   not.guards = [guard];
   return not;
 }
-function checkAnd(state, {
+function checkAnd(snapshot, {
   context,
   event
 }, {
   guards
 }) {
-  return guards.every(guard => evaluateGuard(guard, context, event, state));
+  return guards.every(guard => evaluateGuard(guard, context, event, snapshot));
 }
 function and(guards) {
   function and(args, params) {
@@ -1139,13 +1139,13 @@ function and(guards) {
   and.guards = guards;
   return and;
 }
-function checkOr(state, {
+function checkOr(snapshot, {
   context,
   event
 }, {
   guards
 }) {
-  return guards.some(guard => evaluateGuard(guard, context, event, state));
+  return guards.some(guard => evaluateGuard(guard, context, event, snapshot));
 }
 function or(guards) {
   function or(args, params) {
@@ -1157,17 +1157,17 @@ function or(guards) {
 }
 
 // TODO: throw on cycles (depth check should be enough)
-function evaluateGuard(guard, context, event, state) {
+function evaluateGuard(guard, context, event, snapshot) {
   const {
     machine
-  } = state;
+  } = snapshot;
   const isInline = typeof guard === 'function';
   const resolved = isInline ? guard : machine.implementations.guards[typeof guard === 'string' ? guard : guard.type];
   if (!isInline && !resolved) {
     throw new Error(`Guard '${typeof guard === 'string' ? guard : guard.type}' is not implemented.'.`);
   }
   if (typeof resolved !== 'function') {
-    return evaluateGuard(resolved, context, event, state);
+    return evaluateGuard(resolved, context, event, snapshot);
   }
   const guardArgs = {
     context,
@@ -1184,7 +1184,7 @@ function evaluateGuard(guard, context, event, state) {
     return resolved(guardArgs, guardParams);
   }
   const builtinGuard = resolved;
-  return builtinGuard.check(state, guardArgs, resolved // this holds all params
+  return builtinGuard.check(snapshot, guardArgs, resolved // this holds all params
   );
 }
 
@@ -1573,24 +1573,24 @@ function getStateNodes(stateNode, stateValue) {
     return allSubStateNodes.concat(subStateNodes);
   }, []));
 }
-function transitionAtomicNode(stateNode, stateValue, state, event) {
+function transitionAtomicNode(stateNode, stateValue, snapshot, event) {
   const childStateNode = getStateNode(stateNode, stateValue);
-  const next = childStateNode.next(state, event);
+  const next = childStateNode.next(snapshot, event);
   if (!next || !next.length) {
-    return stateNode.next(state, event);
+    return stateNode.next(snapshot, event);
   }
   return next;
 }
-function transitionCompoundNode(stateNode, stateValue, state, event) {
+function transitionCompoundNode(stateNode, stateValue, snapshot, event) {
   const subStateKeys = Object.keys(stateValue);
   const childStateNode = getStateNode(stateNode, subStateKeys[0]);
-  const next = transitionNode(childStateNode, stateValue[subStateKeys[0]], state, event);
+  const next = transitionNode(childStateNode, stateValue[subStateKeys[0]], snapshot, event);
   if (!next || !next.length) {
-    return stateNode.next(state, event);
+    return stateNode.next(snapshot, event);
   }
   return next;
 }
-function transitionParallelNode(stateNode, stateValue, state, event) {
+function transitionParallelNode(stateNode, stateValue, snapshot, event) {
   const allInnerTransitions = [];
   for (const subStateKey of Object.keys(stateValue)) {
     const subStateValue = stateValue[subStateKey];
@@ -1598,29 +1598,29 @@ function transitionParallelNode(stateNode, stateValue, state, event) {
       continue;
     }
     const subStateNode = getStateNode(stateNode, subStateKey);
-    const innerTransitions = transitionNode(subStateNode, subStateValue, state, event);
+    const innerTransitions = transitionNode(subStateNode, subStateValue, snapshot, event);
     if (innerTransitions) {
       allInnerTransitions.push(...innerTransitions);
     }
   }
   if (!allInnerTransitions.length) {
-    return stateNode.next(state, event);
+    return stateNode.next(snapshot, event);
   }
   return allInnerTransitions;
 }
-function transitionNode(stateNode, stateValue, state, event) {
+function transitionNode(stateNode, stateValue, snapshot, event) {
   // leaf node
   if (typeof stateValue === 'string') {
-    return transitionAtomicNode(stateNode, stateValue, state, event);
+    return transitionAtomicNode(stateNode, stateValue, snapshot, event);
   }
 
   // compound node
   if (Object.keys(stateValue).length === 1) {
-    return transitionCompoundNode(stateNode, stateValue, state, event);
+    return transitionCompoundNode(stateNode, stateValue, snapshot, event);
   }
 
   // parallel node
-  return transitionParallelNode(stateNode, stateValue, state, event);
+  return transitionParallelNode(stateNode, stateValue, snapshot, event);
 }
 function getHistoryNodes(stateNode) {
   return Object.keys(stateNode.states).map(key => stateNode.states[key]).filter(sn => sn.type === 'history');
@@ -1752,14 +1752,14 @@ function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
  */
-function microstep(transitions, currentState, actorScope, event, isInitial, internalQueue) {
+function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
   if (!transitions.length) {
-    return currentState;
+    return currentSnapshot;
   }
-  const mutStateNodeSet = new Set(currentState._nodes);
-  let historyValue = currentState.historyValue;
+  const mutStateNodeSet = new Set(currentSnapshot._nodes);
+  let historyValue = currentSnapshot.historyValue;
   const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
-  let nextState = currentState;
+  let nextState = currentSnapshot;
 
   // Exit states
   if (!isInitial) {
@@ -1776,7 +1776,7 @@ function microstep(transitions, currentState, actorScope, event, isInitial, inte
     nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    if (historyValue === currentState.historyValue && areStateNodeCollectionsEqual(currentState._nodes, mutStateNodeSet)) {
+    if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) {
       return nextState;
     }
     return cloneMachineSnapshot(nextState, {
@@ -1789,15 +1789,15 @@ function microstep(transitions, currentState, actorScope, event, isInitial, inte
     throw e;
   }
 }
-function getMachineOutput(state, event, actorScope, rootNode, rootCompletionNode) {
+function getMachineOutput(snapshot, event, actorScope, rootNode, rootCompletionNode) {
   if (!rootNode.output) {
     return;
   }
-  const doneStateEvent = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, state.context, event, actorScope.self) : undefined);
-  return resolveOutput(rootNode.output, state.context, doneStateEvent, actorScope.self);
+  const doneStateEvent = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, snapshot.context, event, actorScope.self) : undefined);
+  return resolveOutput(rootNode.output, snapshot.context, doneStateEvent, actorScope.self);
 }
-function enterStates(currentState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial) {
-  let nextState = currentState;
+function enterStates(currentSnapshot, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial) {
+  let nextSnapshot = currentSnapshot;
   const statesToEnter = new Set();
   // those are states that were directly targeted or indirectly targeted by the explicit target
   // in other words, those are states for which initial actions should be executed
@@ -1807,7 +1807,7 @@ function enterStates(currentState, event, actorScope, filteredTransitions, mutSt
 
   // In the initial state, the root state node is "entered".
   if (isInitial) {
-    statesForDefaultEntry.add(currentState.machine.root);
+    statesForDefaultEntry.add(currentSnapshot.machine.root);
   }
   const completedNodes = new Set();
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
@@ -1826,13 +1826,13 @@ function enterStates(currentState, event, actorScope, filteredTransitions, mutSt
       const initialActions = stateNodeToEnter.initial.actions;
       actions.push(...initialActions);
     }
-    nextState = resolveActionsAndContext(nextState, event, actorScope, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
+    nextSnapshot = resolveActionsAndContext(nextSnapshot, event, actorScope, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
       let ancestorMarker = parent?.type === 'parallel' ? parent : parent?.parent;
       let rootCompletionNode = ancestorMarker || stateNodeToEnter;
       if (parent?.type === 'compound') {
-        internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self) : undefined));
+        internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextSnapshot.context, event, actorScope.self) : undefined));
       }
       while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutStateNodeSet, ancestorMarker)) {
         completedNodes.add(ancestorMarker);
@@ -1843,13 +1843,13 @@ function enterStates(currentState, event, actorScope, filteredTransitions, mutSt
       if (ancestorMarker) {
         continue;
       }
-      nextState = cloneMachineSnapshot(nextState, {
+      nextSnapshot = cloneMachineSnapshot(nextSnapshot, {
         status: 'done',
-        output: getMachineOutput(nextState, event, actorScope, nextState.machine.root, rootCompletionNode)
+        output: getMachineOutput(nextSnapshot, event, actorScope, nextSnapshot.machine.root, rootCompletionNode)
       });
     }
   }
-  return nextState;
+  return nextSnapshot;
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
@@ -1944,8 +1944,8 @@ function addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultE
 function addProperAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
   addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, getProperAncestors(stateNode, toStateNode));
 }
-function exitStates(currentState, event, actorScope, transitions, mutStateNodeSet, historyValue, internalQueue) {
-  let nextState = currentState;
+function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNodeSet, historyValue, internalQueue) {
+  let nextSnapshot = currentSnapshot;
   const statesToExit = computeExitSet(transitions, mutStateNodeSet, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
   let changedHistory;
@@ -1968,16 +1968,16 @@ function exitStates(currentState, event, actorScope, transitions, mutStateNodeSe
     }
   }
   for (const s of statesToExit) {
-    nextState = resolveActionsAndContext(nextState, event, actorScope, [...s.exit, ...s.invoke.map(def => stopChild(def.id))], internalQueue);
+    nextSnapshot = resolveActionsAndContext(nextSnapshot, event, actorScope, [...s.exit, ...s.invoke.map(def => stopChild(def.id))], internalQueue);
     mutStateNodeSet.delete(s);
   }
-  return [nextState, changedHistory || historyValue];
+  return [nextSnapshot, changedHistory || historyValue];
 }
-function resolveActionsAndContextWorker(currentState, event, actorScope, actions, extra, retries) {
+function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, actions, extra, retries) {
   const {
     machine
-  } = currentState;
-  let intermediateState = currentState;
+  } = currentSnapshot;
+  let intermediateSnapshot = currentSnapshot;
   for (const action of actions) {
     const isInline = typeof action === 'function';
     const resolvedAction = isInline ? action :
@@ -1989,13 +1989,13 @@ function resolveActionsAndContextWorker(currentState, event, actorScope, actions
       continue;
     }
     const actionArgs = {
-      context: intermediateState.context,
+      context: intermediateSnapshot.context,
       event,
       self: actorScope?.self,
       system: actorScope?.system
     };
     const actionParams = isInline || typeof action === 'string' ? undefined : 'params' in action ? typeof action.params === 'function' ? action.params({
-      context: intermediateState.context,
+      context: intermediateSnapshot.context,
       event
     }) : action.params : undefined;
     if (!('resolve' in resolvedAction)) {
@@ -2009,10 +2009,10 @@ function resolveActionsAndContextWorker(currentState, event, actorScope, actions
       continue;
     }
     const builtinAction = resolvedAction;
-    const [nextState, params, actions] = builtinAction.resolve(actorScope, intermediateState, actionArgs, actionParams, resolvedAction,
+    const [nextState, params, actions] = builtinAction.resolve(actorScope, intermediateSnapshot, actionArgs, actionParams, resolvedAction,
     // this holds all params
     extra);
-    intermediateState = nextState;
+    intermediateSnapshot = nextState;
     if ('retryResolve' in builtinAction) {
       retries?.push([builtinAction, params]);
     }
@@ -2024,14 +2024,14 @@ function resolveActionsAndContextWorker(currentState, event, actorScope, actions
       }
     }
     if (actions) {
-      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorScope, actions, extra, retries);
+      intermediateSnapshot = resolveActionsAndContextWorker(intermediateSnapshot, event, actorScope, actions, extra, retries);
     }
   }
-  return intermediateState;
+  return intermediateSnapshot;
 }
-function resolveActionsAndContext(currentState, event, actorScope, actions, internalQueue, deferredActorIds) {
+function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentState, event, actorScope, actions, {
+  const nextState = resolveActionsAndContextWorker(currentSnapshot, event, actorScope, actions, {
     internalQueue,
     deferredActorIds
   }, retries);
@@ -2040,18 +2040,18 @@ function resolveActionsAndContext(currentState, event, actorScope, actions, inte
   });
   return nextState;
 }
-function macrostep(state, event, actorScope, internalQueue = []) {
-  let nextState = state;
+function macrostep(snapshot, event, actorScope, internalQueue = []) {
+  let nextSnapshot = snapshot;
   const states = [];
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
-    nextState = cloneMachineSnapshot(stopChildren(nextState, event, actorScope), {
+    nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), {
       status: 'stopped'
     });
-    states.push(nextState);
+    states.push(nextSnapshot);
     return {
-      state: nextState,
+      snapshot: nextSnapshot,
       microstates: states
     };
   }
@@ -2062,47 +2062,47 @@ function macrostep(state, event, actorScope, internalQueue = []) {
   if (nextEvent.type !== XSTATE_INIT) {
     const currentEvent = nextEvent;
     const isErr = isErrorActorEvent(currentEvent);
-    const transitions = selectTransitions(currentEvent, nextState);
+    const transitions = selectTransitions(currentEvent, nextSnapshot);
     if (isErr && !transitions.length) {
       // TODO: we should likely only allow transitions selected by very explicit descriptors
       // `*` shouldn't be matched, likely `xstate.error.*` shouldnt be either
       // similarly `xstate.error.actor.*` and `xstate.error.actor.todo.*` have to be considered too
-      nextState = cloneMachineSnapshot(state, {
+      nextSnapshot = cloneMachineSnapshot(snapshot, {
         status: 'error',
-        error: currentEvent.data
+        error: currentEvent.error
       });
-      states.push(nextState);
+      states.push(nextSnapshot);
       return {
-        state: nextState,
+        snapshot: nextSnapshot,
         microstates: states
       };
     }
-    nextState = microstep(transitions, state, actorScope, nextEvent, false, internalQueue);
-    states.push(nextState);
+    nextSnapshot = microstep(transitions, snapshot, actorScope, nextEvent, false, internalQueue);
+    states.push(nextSnapshot);
   }
   let shouldSelectEventlessTransitions = true;
-  while (nextState.status === 'active') {
-    let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextState, nextEvent) : [];
+  while (nextSnapshot.status === 'active') {
+    let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextSnapshot, nextEvent) : [];
 
     // eventless transitions should always be selected after selecting *regular* transitions
     // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
-    const previousState = enabledTransitions.length ? nextState : undefined;
+    const previousState = enabledTransitions.length ? nextSnapshot : undefined;
     if (!enabledTransitions.length) {
       if (!internalQueue.length) {
         break;
       }
       nextEvent = internalQueue.shift();
-      enabledTransitions = selectTransitions(nextEvent, nextState);
+      enabledTransitions = selectTransitions(nextEvent, nextSnapshot);
     }
-    nextState = microstep(enabledTransitions, nextState, actorScope, nextEvent, false, internalQueue);
-    shouldSelectEventlessTransitions = nextState !== previousState;
-    states.push(nextState);
+    nextSnapshot = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+    shouldSelectEventlessTransitions = nextSnapshot !== previousState;
+    states.push(nextSnapshot);
   }
-  if (nextState.status !== 'active') {
-    stopChildren(nextState, nextEvent, actorScope);
+  if (nextSnapshot.status !== 'active') {
+    stopChildren(nextSnapshot, nextEvent, actorScope);
   }
   return {
-    state: nextState,
+    snapshot: nextSnapshot,
     microstates: states
   };
 }
@@ -2200,13 +2200,13 @@ function createMachineSnapshot(config, machine) {
     toJSON: machineSnapshotToJSON
   };
 }
-function cloneMachineSnapshot(state, config = {}) {
+function cloneMachineSnapshot(snapshot, config = {}) {
   return createMachineSnapshot({
-    ...state,
+    ...snapshot,
     ...config
-  }, state.machine);
+  }, snapshot.machine);
 }
-function getPersistedState(state, options) {
+function getPersistedSnapshot(snapshot, options) {
   const {
     _nodes: nodes,
     tags,
@@ -2219,12 +2219,12 @@ function getPersistedState(state, options) {
     getMeta,
     toJSON,
     ...jsonValues
-  } = state;
+  } = snapshot;
   const childrenJson = {};
   for (const id in children) {
     const child = children[id];
     childrenJson[id] = {
-      state: child.getPersistedState(options),
+      snapshot: child.getPersistedSnapshot(options),
       src: child.src,
       systemId: child._systemId,
       syncSnapshot: child._syncSnapshot
@@ -2264,14 +2264,14 @@ function persistContext(contextPart) {
   return copy ?? contextPart;
 }
 
-function resolveRaise(_, state, args, actionParams, {
+function resolveRaise(_, snapshot, args, actionParams, {
   event: eventOrExpr,
   id,
   delay
 }, {
   internalQueue
 }) {
-  const delaysMap = state.machine.implementations.delays;
+  const delaysMap = snapshot.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
   }
@@ -2286,7 +2286,7 @@ function resolveRaise(_, state, args, actionParams, {
   if (typeof resolvedDelay !== 'number') {
     internalQueue.push(resolvedEvent);
   }
-  return [state, {
+  return [snapshot, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay
@@ -2340,7 +2340,7 @@ exports.getAllStateNodes = getAllStateNodes;
 exports.getCandidates = getCandidates;
 exports.getDelayedTransitions = getDelayedTransitions;
 exports.getInitialStateNodes = getInitialStateNodes;
-exports.getPersistedState = getPersistedState;
+exports.getPersistedSnapshot = getPersistedSnapshot;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.interpret = interpret;