xstate 5.26.0 → 5.27.0

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

@@ -2120,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) {
@@ -2418,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
@@ -2435,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;
@@ -2457,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') {
@@ -2482,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) {
@@ -2743,4 +2765,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, createInvokeId as B, getDelayedTransitions as C, formatInitialTransition as D, getCandidates as E, resolveStateValue as F, getAllStateNodes as G, createMachineSnapshot as H, isInFinalState as I, macrostep as J, transitionNode as K, resolveActionsAndContext as L, createInitEvent as M, NULL_EVENT as N, microstep as O, getInitialStateNodes as P, toStatePath as Q, isStateId as R, STATE_DELIMITER as S, getStateNodeByPath as T, getPersistedSnapshot as U, resolveReferencedActor as V, executingCustomAction as W, XSTATE_STOP as X, XSTATE_ERROR as Y, createErrorActorEvent as Z, ProcessingStatus as _, cancel as a, cloneMachineSnapshot as a0, spawnChild as b, createActor as c, interpret as d, and as e, stateIn as f, getProperAncestors as g, isMachineSnapshot as h, isAtomicStateNode as i, getStateNodes as j, getAllOwnEventDescriptors as k, matchesState as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, toObserver as q, raise as r, stopChild as s, toArray as t, stop as u, mapValues as v, formatTransitions as w, toTransitionConfigArray as x, formatTransition as y, evaluateGuard 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-f11495d1.esm.js → raise-e5d81555.esm.js}

@@ -2073,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) {
@@ -2368,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
@@ -2385,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;
@@ -2407,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') {
@@ -2432,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) {
@@ -2681,4 +2703,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, createInvokeId as B, getDelayedTransitions as C, formatInitialTransition as D, getCandidates as E, resolveStateValue as F, getAllStateNodes as G, createMachineSnapshot as H, isInFinalState as I, macrostep as J, transitionNode as K, resolveActionsAndContext as L, createInitEvent as M, NULL_EVENT as N, microstep as O, getInitialStateNodes as P, toStatePath as Q, isStateId as R, STATE_DELIMITER as S, getStateNodeByPath as T, getPersistedSnapshot as U, resolveReferencedActor 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, interpret as d, and as e, stateIn as f, getProperAncestors as g, isMachineSnapshot as h, isAtomicStateNode as i, getStateNodes as j, getAllOwnEventDescriptors as k, matchesState as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, toObserver as q, raise as r, stopChild as s, toArray as t, stop as u, mapValues as v, formatTransitions as w, toTransitionConfigArray as x, formatTransition as y, evaluateGuard 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-e47e3273.development.cjs.js → raise-ecea0c53.development.cjs.js}

@@ -2122,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) {
@@ -2420,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
@@ -2437,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;
@@ -2459,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') {
@@ -2484,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) {
@@ -2768,11 +2790,11 @@ 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;
@@ -2782,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;

package/dist/xstate.cjs.js

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.cjs.js');
-var guards_dist_xstateGuards = require('./raise-df325116.cjs.js');
-var StateMachine = require('./StateMachine-29d33e13.cjs.js');
-var assign = require('./assign-9271e302.cjs.js');
-var log = require('./log-fe39762e.cjs.js');
+var guards_dist_xstateGuards = require('./raise-3a84be1f.cjs.js');
+var StateMachine = require('./StateMachine-e93afc18.cjs.js');
+var assign = require('./assign-e36553db.cjs.js');
+var log = require('./log-e54c2eff.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 /**
@@ -338,6 +338,39 @@ function initialTransition(logic, ...[input]) {
   return [nextSnapshot, executableActions];
 }
 
+/**
+ * Given a state `machine`, a `snapshot`, and an `event`, returns an array of
+ * microsteps, where each microstep is a tuple of `[snapshot, actions]`.
+ *
+ * This is a pure function that does not execute `actions`.
+ */
+function getMicrosteps(machine, snapshot, event) {
+  const actorScope = createInertActorScope(machine);
+  const {
+    microsteps
+  } = guards_dist_xstateGuards.macrostep(snapshot, event, actorScope, []);
+  return microsteps;
+}
+
+/**
+ * Given a state `machine` and optional `input`, returns an array of microsteps
+ * from the initial transition, where each microstep is a tuple of `[snapshot,
+ * actions]`.
+ *
+ * This is a pure function that does not execute `actions`.
+ */
+function getInitialMicrosteps(machine, ...[input]) {
+  const actorScope = createInertActorScope(machine);
+  const initEvent = guards_dist_xstateGuards.createInitEvent(input);
+  const internalQueue = [];
+  const preInitialSnapshot = machine._getPreInitialState(actorScope, initEvent, internalQueue);
+  const first = guards_dist_xstateGuards.initialMicrostep(machine.root, preInitialSnapshot, actorScope, initEvent, internalQueue);
+  const {
+    microsteps
+  } = guards_dist_xstateGuards.macrostep(first[0], initEvent, actorScope, internalQueue);
+  return [first, ...microsteps];
+}
+
 /**
  * Gets all potential next transitions from the current state.
  *
@@ -532,7 +565,9 @@ exports.sendTo = log.sendTo;
 exports.SimulatedClock = SimulatedClock;
 exports.assertEvent = assertEvent;
 exports.createMachine = createMachine;
+exports.getInitialMicrosteps = getInitialMicrosteps;
 exports.getInitialSnapshot = getInitialSnapshot;
+exports.getMicrosteps = getMicrosteps;
 exports.getNextSnapshot = getNextSnapshot;
 exports.getNextTransitions = getNextTransitions;
 exports.initialTransition = initialTransition;

package/dist/xstate.cjs.mjs

@@ -20,7 +20,9 @@ export {
   fromObservable,
   fromPromise,
   fromTransition,
+  getInitialMicrosteps,
   getInitialSnapshot,
+  getMicrosteps,
   getNextSnapshot,
   getNextTransitions,
   getStateNodes,