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

package/dist/{raise-9dd3e757.development.cjs.js → raise-57f3c654.development.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) {
@@ -354,7 +354,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.
      */
@@ -444,19 +444,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
@@ -465,7 +465,7 @@ class Actor {
   }
   update(snapshot, event) {
     // Update state
-    this._state = snapshot;
+    this._snapshot = snapshot;
 
     // Execute deferred effects
     let deferredFn;
@@ -479,14 +479,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 {
@@ -512,13 +512,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({
@@ -631,24 +631,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
         };
@@ -660,7 +660,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();
     }
@@ -671,7 +671,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 = {
@@ -682,8 +682,8 @@ class Actor {
       const {
         err
       } = caughtError;
-      this._state = {
-        ...this._state,
+      this._snapshot = {
+        ...this._snapshot,
         status: 'error',
         error: err
       };
@@ -871,8 +871,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;
@@ -890,10 +890,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;
   }
 }
 
@@ -946,11 +946,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);
@@ -975,14 +975,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) {
@@ -993,7 +993,7 @@ 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
@@ -1002,9 +1002,9 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   if (!actorRef) {
     console.warn(`Actor type '${src}' not found in machine '${actorScope.id}'.`);
   }
-  return [cloneMachineSnapshot(state, {
+  return [cloneMachineSnapshot(snapshot, {
     children: {
-      ...state.children,
+      ...snapshot.children,
       [resolvedId]: actorRef
     }
   }), {
@@ -1037,7 +1037,7 @@ function spawnChild(...[src, {
       throw new Error(`This isn't supposed to be called`);
     }
   }
-  spawnChild.type = 'xstate.spawnChild';
+  spawnChild.type = 'snapshot.spawnChild';
   spawnChild.id = id;
   spawnChild.systemId = systemId;
   spawnChild.src = src;
@@ -1048,19 +1048,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];
 }
@@ -1113,14 +1113,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) {
@@ -1132,13 +1132,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) {
@@ -1150,13 +1150,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) {
@@ -1168,13 +1168,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) {
@@ -1188,17 +1188,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,
@@ -1215,7 +1215,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
   );
 }
 
@@ -1615,24 +1615,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];
@@ -1640,29 +1640,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');
@@ -1794,14 +1794,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) {
@@ -1818,7 +1818,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, {
@@ -1831,15 +1831,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
@@ -1849,7 +1849,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)) {
@@ -1868,13 +1868,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);
@@ -1885,13 +1885,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) {
@@ -1986,8 +1986,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;
@@ -2010,16 +2010,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 :
@@ -2031,13 +2031,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)) {
@@ -2051,10 +2051,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]);
     }
@@ -2066,14 +2066,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);
@@ -2082,21 +2082,21 @@ function resolveActionsAndContext(currentState, event, actorScope, actions, inte
   });
   return nextState;
 }
-function macrostep(state, event, actorScope, internalQueue = []) {
+function macrostep(snapshot, event, actorScope, internalQueue = []) {
   if (event.type === WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
   }
-  let nextState = state;
+  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
     };
   }
@@ -2107,47 +2107,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
   };
 }
@@ -2248,13 +2248,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,
@@ -2267,7 +2267,7 @@ function getPersistedState(state, options) {
     getMeta,
     toJSON,
     ...jsonValues
-  } = state;
+  } = snapshot;
   const childrenJson = {};
   for (const id in children) {
     const child = children[id];
@@ -2275,7 +2275,7 @@ function getPersistedState(state, options) {
       throw new Error('An inline child actor cannot be persisted.');
     }
     childrenJson[id] = {
-      state: child.getPersistedState(options),
+      snapshot: child.getPersistedSnapshot(options),
       src: child.src,
       systemId: child._systemId,
       syncSnapshot: child._syncSnapshot
@@ -2315,14 +2315,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`);
   }
@@ -2337,7 +2337,7 @@ function resolveRaise(_, state, args, actionParams, {
   if (typeof resolvedDelay !== 'number') {
     internalQueue.push(resolvedEvent);
   }
-  return [state, {
+  return [snapshot, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay
@@ -2394,7 +2394,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;