xstate 5.25.1 → 5.27.0

package/dist/{raise-13a60c49.development.esm.js → raise-a7794093.development.esm.js}

@@ -1575,7 +1575,9 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
-const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
+function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+}
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
 }
@@ -2118,45 +2120,65 @@ function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
   }
   return true;
 }
+function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
+  return microstep([{
+    target: [...getInitialStateNodes(root)],
+    source: root,
+    reenter: true,
+    actions: [],
+    eventType: null,
+    toJSON: null
+  }], preInitialState, actorScope, initEvent, true, internalQueue);
+}
 
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
+  const actions = [];
   if (!transitions.length) {
-    return currentSnapshot;
+    return [currentSnapshot, actions];
   }
-  const mutStateNodeSet = new Set(currentSnapshot._nodes);
-  let historyValue = currentSnapshot.historyValue;
-  const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
-  let nextState = currentSnapshot;
+  const originalExecutor = actorScope.actionExecutor;
+  actorScope.actionExecutor = action => {
+    actions.push(action);
+    originalExecutor(action);
+  };
+  try {
+    const mutStateNodeSet = new Set(currentSnapshot._nodes);
+    let historyValue = currentSnapshot.historyValue;
+    const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
+    let nextState = currentSnapshot;
 
-  // Exit states
-  if (!isInitial) {
-    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
-  }
+    // Exit states
+    if (!isInitial) {
+      [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
+    }
 
-  // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue, undefined);
+    // Execute transition content
+    nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue, undefined);
 
-  // Enter states
-  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
-  const nextStateNodes = [...mutStateNodeSet];
-  if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue, undefined);
-  }
+    // Enter states
+    nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
+    const nextStateNodes = [...mutStateNodeSet];
+    if (nextState.status === 'done') {
+      nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue, undefined);
+    }
 
-  // eslint-disable-next-line no-useless-catch
-  try {
-    if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) {
-      return nextState;
+    // eslint-disable-next-line no-useless-catch
+    try {
+      if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) {
+        return [nextState, actions];
+      }
+      return [cloneMachineSnapshot(nextState, {
+        _nodes: nextStateNodes,
+        historyValue
+      }), actions];
+    } catch (e) {
+      // TODO: Refactor this once proper error handling is implemented.
+      // See https://github.com/statelyai/rfcs/pull/4
+      throw e;
     }
-    return cloneMachineSnapshot(nextState, {
-      _nodes: nextStateNodes,
-      historyValue
-    });
-  } catch (e) {
-    // TODO: Refactor this once proper error handling is implemented.
-    // See https://github.com/statelyai/rfcs/pull/4
-    throw e;
+  } finally {
+    actorScope.actionExecutor = originalExecutor;
   }
 }
 function getMachineOutput(snapshot, event, actorScope, rootNode, rootCompletionNode) {
@@ -2416,16 +2438,16 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
   }
   let nextSnapshot = snapshot;
-  const microstates = [];
-  function addMicrostate(microstate, event, transitions) {
+  const microsteps = [];
+  function addMicrostep(step, event, transitions) {
     actorScope.system._sendInspectionEvent({
       type: '@xstate.microstep',
       actorRef: actorScope.self,
       event,
-      snapshot: microstate,
+      snapshot: step[0],
       _transitions: transitions
     });
-    microstates.push(microstate);
+    microsteps.push(step);
   }
 
   // Handle stop event
@@ -2433,10 +2455,10 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
     nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), {
       status: 'stopped'
     });
-    addMicrostate(nextSnapshot, event, []);
+    addMicrostep([nextSnapshot, []], event, []);
     return {
       snapshot: nextSnapshot,
-      microstates
+      microsteps
     };
   }
   let nextEvent = event;
@@ -2455,16 +2477,17 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
         status: 'error',
         error: currentEvent.error
       });
-      addMicrostate(nextSnapshot, currentEvent, []);
+      addMicrostep([nextSnapshot, []], currentEvent, []);
       return {
         snapshot: nextSnapshot,
-        microstates
+        microsteps
       };
     }
-    nextSnapshot = microstep(transitions, snapshot, actorScope, nextEvent, false,
+    const step = microstep(transitions, snapshot, actorScope, nextEvent, false,
     // isInitial
     internalQueue);
-    addMicrostate(nextSnapshot, currentEvent, transitions);
+    nextSnapshot = step[0];
+    addMicrostep(step, currentEvent, transitions);
   }
   let shouldSelectEventlessTransitions = true;
   while (nextSnapshot.status === 'active') {
@@ -2480,16 +2503,17 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
       nextEvent = internalQueue.shift();
       enabledTransitions = selectTransitions(nextEvent, nextSnapshot);
     }
-    nextSnapshot = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+    const step = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+    nextSnapshot = step[0];
     shouldSelectEventlessTransitions = nextSnapshot !== previousState;
-    addMicrostate(nextSnapshot, nextEvent, enabledTransitions);
+    addMicrostep(step, nextEvent, enabledTransitions);
   }
   if (nextSnapshot.status !== 'active') {
     stopChildren(nextSnapshot, nextEvent, actorScope);
   }
   return {
     snapshot: nextSnapshot,
-    microstates
+    microsteps
   };
 }
 function stopChildren(nextState, event, actorScope) {
@@ -2741,4 +2765,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, formatInitialTransition as B, getCandidates as C, resolveStateValue as D, getAllStateNodes as E, createMachineSnapshot as F, isInFinalState as G, macrostep as H, transitionNode as I, resolveActionsAndContext as J, createInitEvent as K, microstep as L, getInitialStateNodes as M, NULL_EVENT as N, toStatePath as O, isStateId as P, getStateNodeByPath as Q, getPersistedSnapshot as R, STATE_DELIMITER as S, resolveReferencedActor as T, executingCustomAction as U, XSTATE_ERROR as V, createErrorActorEvent as W, XSTATE_STOP as X, ProcessingStatus as Y, cloneMachineSnapshot as Z, cancel as a, spawnChild as b, createActor as c, and as d, stateIn as e, isMachineSnapshot as f, getStateNodes as g, getAllOwnEventDescriptors as h, interpret as i, matchesState as j, toObserver as k, stop as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, mapValues as q, raise as r, stopChild as s, toArray as t, formatTransitions as u, toTransitionConfigArray as v, formatTransition as w, evaluateGuard as x, createInvokeId as y, getDelayedTransitions as z };
+export { $$ACTOR_TYPE as $, Actor as A, toTransitionConfigArray as B, formatTransition as C, evaluateGuard as D, createInvokeId as E, getDelayedTransitions as F, formatInitialTransition as G, getCandidates as H, resolveStateValue as I, getAllStateNodes as J, createMachineSnapshot as K, isInFinalState as L, transitionNode as M, NULL_EVENT as N, resolveActionsAndContext as O, toStatePath as P, isStateId as Q, getStateNodeByPath as R, STATE_DELIMITER as S, getPersistedSnapshot as T, resolveReferencedActor as U, executingCustomAction as V, XSTATE_ERROR as W, XSTATE_STOP as X, createErrorActorEvent as Y, ProcessingStatus as Z, cloneMachineSnapshot as _, cancel as a, spawnChild as b, createActor as c, macrostep as d, createInitEvent as e, isAtomicStateNode as f, getProperAncestors as g, interpret as h, initialMicrostep as i, and as j, stateIn as k, isMachineSnapshot as l, matchesEventDescriptor as m, not as n, or as o, getStateNodes as p, getAllOwnEventDescriptors as q, raise as r, stopChild as s, toArray as t, matchesState as u, pathToStateValue as v, toObserver as w, stop as x, mapValues as y, formatTransitions as z };

package/dist/{raise-f5c7cb5b.esm.js → raise-e5d81555.esm.js}

@@ -1533,7 +1533,9 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
-const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
+function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+}
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
 }
@@ -2071,45 +2073,65 @@ function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
   }
   return true;
 }
+function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
+  return microstep([{
+    target: [...getInitialStateNodes(root)],
+    source: root,
+    reenter: true,
+    actions: [],
+    eventType: null,
+    toJSON: null
+  }], preInitialState, actorScope, initEvent, true, internalQueue);
+}
 
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
+  const actions = [];
   if (!transitions.length) {
-    return currentSnapshot;
+    return [currentSnapshot, actions];
   }
-  const mutStateNodeSet = new Set(currentSnapshot._nodes);
-  let historyValue = currentSnapshot.historyValue;
-  const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
-  let nextState = currentSnapshot;
+  const originalExecutor = actorScope.actionExecutor;
+  actorScope.actionExecutor = action => {
+    actions.push(action);
+    originalExecutor(action);
+  };
+  try {
+    const mutStateNodeSet = new Set(currentSnapshot._nodes);
+    let historyValue = currentSnapshot.historyValue;
+    const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
+    let nextState = currentSnapshot;
 
-  // Exit states
-  if (!isInitial) {
-    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
-  }
+    // Exit states
+    if (!isInitial) {
+      [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
+    }
 
-  // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue, undefined);
+    // Execute transition content
+    nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue, undefined);
 
-  // Enter states
-  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
-  const nextStateNodes = [...mutStateNodeSet];
-  if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue, undefined);
-  }
+    // Enter states
+    nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
+    const nextStateNodes = [...mutStateNodeSet];
+    if (nextState.status === 'done') {
+      nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue, undefined);
+    }
 
-  // eslint-disable-next-line no-useless-catch
-  try {
-    if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) {
-      return nextState;
+    // eslint-disable-next-line no-useless-catch
+    try {
+      if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) {
+        return [nextState, actions];
+      }
+      return [cloneMachineSnapshot(nextState, {
+        _nodes: nextStateNodes,
+        historyValue
+      }), actions];
+    } catch (e) {
+      // TODO: Refactor this once proper error handling is implemented.
+      // See https://github.com/statelyai/rfcs/pull/4
+      throw e;
     }
-    return cloneMachineSnapshot(nextState, {
-      _nodes: nextStateNodes,
-      historyValue
-    });
-  } catch (e) {
-    // TODO: Refactor this once proper error handling is implemented.
-    // See https://github.com/statelyai/rfcs/pull/4
-    throw e;
+  } finally {
+    actorScope.actionExecutor = originalExecutor;
   }
 }
 function getMachineOutput(snapshot, event, actorScope, rootNode, rootCompletionNode) {
@@ -2366,16 +2388,16 @@ function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, i
 }
 function macrostep(snapshot, event, actorScope, internalQueue) {
   let nextSnapshot = snapshot;
-  const microstates = [];
-  function addMicrostate(microstate, event, transitions) {
+  const microsteps = [];
+  function addMicrostep(step, event, transitions) {
     actorScope.system._sendInspectionEvent({
       type: '@xstate.microstep',
       actorRef: actorScope.self,
       event,
-      snapshot: microstate,
+      snapshot: step[0],
       _transitions: transitions
     });
-    microstates.push(microstate);
+    microsteps.push(step);
   }
 
   // Handle stop event
@@ -2383,10 +2405,10 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
     nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), {
       status: 'stopped'
     });
-    addMicrostate(nextSnapshot, event, []);
+    addMicrostep([nextSnapshot, []], event, []);
     return {
       snapshot: nextSnapshot,
-      microstates
+      microsteps
     };
   }
   let nextEvent = event;
@@ -2405,16 +2427,17 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
         status: 'error',
         error: currentEvent.error
       });
-      addMicrostate(nextSnapshot, currentEvent, []);
+      addMicrostep([nextSnapshot, []], currentEvent, []);
       return {
         snapshot: nextSnapshot,
-        microstates
+        microsteps
       };
     }
-    nextSnapshot = microstep(transitions, snapshot, actorScope, nextEvent, false,
+    const step = microstep(transitions, snapshot, actorScope, nextEvent, false,
     // isInitial
     internalQueue);
-    addMicrostate(nextSnapshot, currentEvent, transitions);
+    nextSnapshot = step[0];
+    addMicrostep(step, currentEvent, transitions);
   }
   let shouldSelectEventlessTransitions = true;
   while (nextSnapshot.status === 'active') {
@@ -2430,16 +2453,17 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
       nextEvent = internalQueue.shift();
       enabledTransitions = selectTransitions(nextEvent, nextSnapshot);
     }
-    nextSnapshot = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+    const step = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+    nextSnapshot = step[0];
     shouldSelectEventlessTransitions = nextSnapshot !== previousState;
-    addMicrostate(nextSnapshot, nextEvent, enabledTransitions);
+    addMicrostep(step, nextEvent, enabledTransitions);
   }
   if (nextSnapshot.status !== 'active') {
     stopChildren(nextSnapshot, nextEvent, actorScope);
   }
   return {
     snapshot: nextSnapshot,
-    microstates
+    microsteps
   };
 }
 function stopChildren(nextState, event, actorScope) {
@@ -2679,4 +2703,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, formatInitialTransition as B, getCandidates as C, resolveStateValue as D, getAllStateNodes as E, createMachineSnapshot as F, isInFinalState as G, macrostep as H, transitionNode as I, resolveActionsAndContext as J, createInitEvent as K, microstep as L, getInitialStateNodes as M, NULL_EVENT as N, toStatePath as O, isStateId as P, getStateNodeByPath as Q, getPersistedSnapshot as R, STATE_DELIMITER as S, resolveReferencedActor as T, XSTATE_ERROR as U, createErrorActorEvent as V, ProcessingStatus as W, XSTATE_STOP as X, cloneMachineSnapshot as Y, cancel as a, spawnChild as b, createActor as c, and as d, stateIn as e, isMachineSnapshot as f, getStateNodes as g, getAllOwnEventDescriptors as h, interpret as i, matchesState as j, toObserver as k, stop as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, mapValues as q, raise as r, stopChild as s, toArray as t, formatTransitions as u, toTransitionConfigArray as v, formatTransition as w, evaluateGuard as x, createInvokeId as y, getDelayedTransitions as z };
+export { $$ACTOR_TYPE as $, Actor as A, toTransitionConfigArray as B, formatTransition as C, evaluateGuard as D, createInvokeId as E, getDelayedTransitions as F, formatInitialTransition as G, getCandidates as H, resolveStateValue as I, getAllStateNodes as J, createMachineSnapshot as K, isInFinalState as L, transitionNode as M, NULL_EVENT as N, resolveActionsAndContext as O, toStatePath as P, isStateId as Q, getStateNodeByPath as R, STATE_DELIMITER as S, getPersistedSnapshot as T, resolveReferencedActor as U, XSTATE_ERROR as V, createErrorActorEvent as W, XSTATE_STOP as X, ProcessingStatus as Y, cloneMachineSnapshot as Z, cancel as a, spawnChild as b, createActor as c, macrostep as d, createInitEvent as e, isAtomicStateNode as f, getProperAncestors as g, interpret as h, initialMicrostep as i, and as j, stateIn as k, isMachineSnapshot as l, matchesEventDescriptor as m, not as n, or as o, getStateNodes as p, getAllOwnEventDescriptors as q, raise as r, stopChild as s, toArray as t, matchesState as u, pathToStateValue as v, toObserver as w, stop as x, mapValues as y, formatTransitions as z };

package/dist/{raise-ed7c6f3d.development.cjs.js → raise-ecea0c53.development.cjs.js}

@@ -1577,7 +1577,9 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
-const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
+function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+}
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
 }
@@ -2120,45 +2122,65 @@ function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
   }
   return true;
 }
+function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
+  return microstep([{
+    target: [...getInitialStateNodes(root)],
+    source: root,
+    reenter: true,
+    actions: [],
+    eventType: null,
+    toJSON: null
+  }], preInitialState, actorScope, initEvent, true, internalQueue);
+}
 
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
+  const actions = [];
   if (!transitions.length) {
-    return currentSnapshot;
+    return [currentSnapshot, actions];
   }
-  const mutStateNodeSet = new Set(currentSnapshot._nodes);
-  let historyValue = currentSnapshot.historyValue;
-  const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
-  let nextState = currentSnapshot;
+  const originalExecutor = actorScope.actionExecutor;
+  actorScope.actionExecutor = action => {
+    actions.push(action);
+    originalExecutor(action);
+  };
+  try {
+    const mutStateNodeSet = new Set(currentSnapshot._nodes);
+    let historyValue = currentSnapshot.historyValue;
+    const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
+    let nextState = currentSnapshot;
 
-  // Exit states
-  if (!isInitial) {
-    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
-  }
+    // Exit states
+    if (!isInitial) {
+      [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
+    }
 
-  // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue, undefined);
+    // Execute transition content
+    nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue, undefined);
 
-  // Enter states
-  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
-  const nextStateNodes = [...mutStateNodeSet];
-  if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue, undefined);
-  }
+    // Enter states
+    nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
+    const nextStateNodes = [...mutStateNodeSet];
+    if (nextState.status === 'done') {
+      nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue, undefined);
+    }
 
-  // eslint-disable-next-line no-useless-catch
-  try {
-    if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) {
-      return nextState;
+    // eslint-disable-next-line no-useless-catch
+    try {
+      if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) {
+        return [nextState, actions];
+      }
+      return [cloneMachineSnapshot(nextState, {
+        _nodes: nextStateNodes,
+        historyValue
+      }), actions];
+    } catch (e) {
+      // TODO: Refactor this once proper error handling is implemented.
+      // See https://github.com/statelyai/rfcs/pull/4
+      throw e;
     }
-    return cloneMachineSnapshot(nextState, {
-      _nodes: nextStateNodes,
-      historyValue
-    });
-  } catch (e) {
-    // TODO: Refactor this once proper error handling is implemented.
-    // See https://github.com/statelyai/rfcs/pull/4
-    throw e;
+  } finally {
+    actorScope.actionExecutor = originalExecutor;
   }
 }
 function getMachineOutput(snapshot, event, actorScope, rootNode, rootCompletionNode) {
@@ -2418,16 +2440,16 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
   }
   let nextSnapshot = snapshot;
-  const microstates = [];
-  function addMicrostate(microstate, event, transitions) {
+  const microsteps = [];
+  function addMicrostep(step, event, transitions) {
     actorScope.system._sendInspectionEvent({
       type: '@xstate.microstep',
       actorRef: actorScope.self,
       event,
-      snapshot: microstate,
+      snapshot: step[0],
       _transitions: transitions
     });
-    microstates.push(microstate);
+    microsteps.push(step);
   }
 
   // Handle stop event
@@ -2435,10 +2457,10 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
     nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), {
       status: 'stopped'
     });
-    addMicrostate(nextSnapshot, event, []);
+    addMicrostep([nextSnapshot, []], event, []);
     return {
       snapshot: nextSnapshot,
-      microstates
+      microsteps
     };
   }
   let nextEvent = event;
@@ -2457,16 +2479,17 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
         status: 'error',
         error: currentEvent.error
       });
-      addMicrostate(nextSnapshot, currentEvent, []);
+      addMicrostep([nextSnapshot, []], currentEvent, []);
       return {
         snapshot: nextSnapshot,
-        microstates
+        microsteps
       };
     }
-    nextSnapshot = microstep(transitions, snapshot, actorScope, nextEvent, false,
+    const step = microstep(transitions, snapshot, actorScope, nextEvent, false,
     // isInitial
     internalQueue);
-    addMicrostate(nextSnapshot, currentEvent, transitions);
+    nextSnapshot = step[0];
+    addMicrostep(step, currentEvent, transitions);
   }
   let shouldSelectEventlessTransitions = true;
   while (nextSnapshot.status === 'active') {
@@ -2482,16 +2505,17 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
       nextEvent = internalQueue.shift();
       enabledTransitions = selectTransitions(nextEvent, nextSnapshot);
     }
-    nextSnapshot = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+    const step = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+    nextSnapshot = step[0];
     shouldSelectEventlessTransitions = nextSnapshot !== previousState;
-    addMicrostate(nextSnapshot, nextEvent, enabledTransitions);
+    addMicrostep(step, nextEvent, enabledTransitions);
   }
   if (nextSnapshot.status !== 'active') {
     stopChildren(nextSnapshot, nextEvent, actorScope);
   }
   return {
     snapshot: nextSnapshot,
-    microstates
+    microsteps
   };
 }
 function stopChildren(nextState, event, actorScope) {
@@ -2766,11 +2790,13 @@ exports.getAllOwnEventDescriptors = getAllOwnEventDescriptors;
 exports.getAllStateNodes = getAllStateNodes;
 exports.getCandidates = getCandidates;
 exports.getDelayedTransitions = getDelayedTransitions;
-exports.getInitialStateNodes = getInitialStateNodes;
 exports.getPersistedSnapshot = getPersistedSnapshot;
+exports.getProperAncestors = getProperAncestors;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
+exports.initialMicrostep = initialMicrostep;
 exports.interpret = interpret;
+exports.isAtomicStateNode = isAtomicStateNode;
 exports.isInFinalState = isInFinalState;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;
@@ -2778,7 +2804,6 @@ exports.macrostep = macrostep;
 exports.mapValues = mapValues;
 exports.matchesEventDescriptor = matchesEventDescriptor;
 exports.matchesState = matchesState;
-exports.microstep = microstep;
 exports.not = not;
 exports.or = or;
 exports.pathToStateValue = pathToStateValue;