xstate 5.0.0-beta.51 → 5.0.0-beta.53

package/dist/{raise-4742bf04.esm.js → raise-be2f20bc.esm.js}

@@ -64,9 +64,8 @@ const XSTATE_STOP = 'xstate.stop';
  * @param id The state node ID where this event is handled
  */
 function createAfterEvent(delayRef, id) {
-  const idSuffix = id ? `#${id}` : '';
   return {
-    type: `xstate.after(${delayRef})${idSuffix}`
+    type: `xstate.after.${delayRef}.${id}`
   };
 }
 
@@ -298,16 +297,17 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   };
 }
 function createInvokeId(stateNodeId, index) {
-  return `${stateNodeId}[${index}]`;
+  return `${index}.${stateNodeId}`;
 }
 function resolveReferencedActor(machine, src) {
-  if (src.startsWith('xstate#')) {
-    const [, indexStr] = src.match(/\[(\d+)\]$/);
-    const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
-    const invokeConfig = node.config.invoke;
-    return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
+  const match = src.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+  if (!match) {
+    return machine.implementations.actors[src];
   }
-  return machine.implementations.actors[src];
+  const [, indexStr, nodeId] = match;
+  const node = machine.getStateNodeById(nodeId);
+  const invokeConfig = node.config.invoke;
+  return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
 }
 function getAllOwnEventDescriptors(snapshot) {
   return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])];
@@ -349,7 +349,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.
      */
@@ -439,19 +439,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
@@ -460,7 +460,7 @@ class Actor {
   }
   update(snapshot, event) {
     // Update state
-    this._state = snapshot;
+    this._snapshot = snapshot;
 
     // Execute deferred effects
     let deferredFn;
@@ -474,14 +474,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 {
@@ -507,13 +507,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({
@@ -626,24 +626,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
         };
@@ -655,7 +655,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();
     }
@@ -666,7 +666,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 = {
@@ -677,8 +677,8 @@ class Actor {
       const {
         err
       } = caughtError;
-      this._state = {
-        ...this._state,
+      this._snapshot = {
+        ...this._snapshot,
         status: 'error',
         error: err
       };
@@ -858,8 +858,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;
@@ -877,10 +877,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;
   }
 }
 
@@ -933,11 +933,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);
@@ -959,14 +959,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) {
@@ -977,15 +977,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
     }
   }), {
@@ -1015,7 +1015,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;
@@ -1026,19 +1026,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];
 }
@@ -1088,14 +1088,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) {
@@ -1105,13 +1105,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) {
@@ -1121,13 +1121,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) {
@@ -1137,13 +1137,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) {
@@ -1155,17 +1155,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,
@@ -1182,7 +1182,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
   );
 }
 
@@ -1571,24 +1571,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];
@@ -1596,29 +1596,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');
@@ -1750,14 +1750,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) {
@@ -1774,7 +1774,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, {
@@ -1787,15 +1787,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
@@ -1805,7 +1805,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)) {
@@ -1824,13 +1824,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);
@@ -1841,13 +1841,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) {
@@ -1942,8 +1942,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;
@@ -1966,16 +1966,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 :
@@ -1987,13 +1987,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)) {
@@ -2007,10 +2007,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]);
     }
@@ -2022,14 +2022,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);
@@ -2038,18 +2038,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
     };
   }
@@ -2060,47 +2060,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
       });
-      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
   };
 }
@@ -2198,13 +2198,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,
@@ -2217,12 +2217,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
@@ -2262,14 +2262,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`);
   }
@@ -2284,7 +2284,7 @@ function resolveRaise(_, state, args, actionParams, {
   if (typeof resolvedDelay !== 'number') {
     internalQueue.push(resolvedEvent);
   }
-  return [state, {
+  return [snapshot, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay
@@ -2314,4 +2314,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, interpret as B, isMachineSnapshot as C, matchesState as D, pathToStateValue as E, toObserver as F, getAllOwnEventDescriptors as G, and as H, not as I, or as J, stateIn as K, cancel as L, raise as M, NULL_EVENT as N, spawnChild as O, stop as P, stopChild as Q, ProcessingStatus as R, STATE_DELIMITER as S, cloneMachineSnapshot as T, XSTATE_ERROR as U, createErrorActorEvent as V, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, macrostep as n, transitionNode as o, resolveActionsAndContext as p, createInitEvent as q, resolveStateValue as r, microstep as s, toArray as t, getInitialStateNodes as u, isStateId as v, getStateNodeByPath as w, getPersistedState as x, resolveReferencedActor as y, createActor as z };
+export { $$ACTOR_TYPE as $, Actor as A, interpret as B, isMachineSnapshot as C, matchesState as D, pathToStateValue as E, toObserver as F, getAllOwnEventDescriptors as G, and as H, not as I, or as J, stateIn as K, cancel as L, raise as M, NULL_EVENT as N, spawnChild as O, stop as P, stopChild as Q, ProcessingStatus as R, STATE_DELIMITER as S, cloneMachineSnapshot as T, XSTATE_ERROR as U, createErrorActorEvent as V, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, macrostep as n, transitionNode as o, resolveActionsAndContext as p, createInitEvent as q, resolveStateValue as r, microstep as s, toArray as t, getInitialStateNodes as u, isStateId as v, getStateNodeByPath as w, getPersistedSnapshot as x, resolveReferencedActor as y, createActor as z };