xstate 5.6.2 → 5.7.0

package/dist/declarations/src/system.d.ts

@@ -1,4 +1,5 @@
-import { AnyEventObject, ActorSystemInfo, AnyActorRef, Observer, Snapshot, EventObject } from "./types.js";
+import { InspectionEvent } from "./inspection.js";
+import { ActorSystemInfo, AnyActorRef, Observer, EventObject } from "./types.js";
 export interface ScheduledEvent {
     id: string;
     event: EventObject;
@@ -30,27 +31,3 @@ export declare function createSystem<T extends ActorSystemInfo>(rootActor: AnyAc
     clock: Clock;
     snapshot?: unknown;
 }): ActorSystem<T>;
-export interface BaseInspectionEventProperties {
-    rootId: string;
-    /**
-     * The relevant actorRef for the inspection event.
-     * - For snapshot events, this is the `actorRef` of the snapshot.
-     * - For event events, this is the target `actorRef` (recipient of event).
-     * - For actor events, this is the `actorRef` of the registered actor.
-     */
-    actorRef: AnyActorRef;
-}
-export interface InspectedSnapshotEvent extends BaseInspectionEventProperties {
-    type: '@xstate.snapshot';
-    event: AnyEventObject;
-    snapshot: Snapshot<unknown>;
-}
-export interface InspectedEventEvent extends BaseInspectionEventProperties {
-    type: '@xstate.event';
-    sourceRef: AnyActorRef | undefined;
-    event: AnyEventObject;
-}
-export interface InspectedActorEvent extends BaseInspectionEventProperties {
-    type: '@xstate.actor';
-}
-export type InspectionEvent = InspectedSnapshotEvent | InspectedEventEvent | InspectedActorEvent;

package/dist/declarations/src/types.d.ts

@@ -6,7 +6,8 @@ import { PromiseActorLogic } from "./actors/promise.js";
 import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
 import type { Actor } from "./createActor.js";
 import { Spawner } from "./spawn.js";
-import { AnyActorSystem, InspectionEvent, Clock } from './system.js';
+import { AnyActorSystem, Clock } from './system.js';
+import { InspectionEvent } from "./inspection.js";
 import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from "./typegenTypes.js";
 export type Identity<T> = {
     [K in keyof T]: T[K];

package/dist/{log-75c83841.development.cjs.js → log-9b34dd45.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-d7d9caaa.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-0ce4ccae.development.cjs.js');
 
 // it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
 // but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)

package/dist/{log-c5c46d15.cjs.js → log-c2d7ade7.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-540fdaf2.cjs.js');
+var guards_dist_xstateGuards = require('./raise-932934e8.cjs.js');
 
 // it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
 // but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)

package/dist/{log-edca19d9.development.esm.js → log-dc9ca1e2.development.esm.js}

@@ -1,4 +1,4 @@
-import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as XSTATE_ERROR, W as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-2fdbadc6.development.esm.js';
+import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as XSTATE_ERROR, W as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-4593d184.development.esm.js';
 
 // it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
 // but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)

package/dist/{log-b6ecfc82.esm.js → log-f78f0918.esm.js}

@@ -1,4 +1,4 @@
-import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as XSTATE_ERROR, W as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-309d511a.esm.js';
+import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as XSTATE_ERROR, W as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-6420fe44.esm.js';
 
 // it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
 // but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)

package/dist/{raise-d7d9caaa.development.cjs.js → raise-0ce4ccae.development.cjs.js}

@@ -136,7 +136,7 @@ function createSystem(rootActor, options) {
   const children = new Map();
   const keyedActors = new Map();
   const reverseKeyedActors = new WeakMap();
-  const observers = new Set();
+  const inspectionObservers = new Set();
   const timerMap = {};
   const clock = options.clock;
   const scheduler = {
@@ -174,6 +174,16 @@ function createSystem(rootActor, options) {
       }
     }
   };
+  const sendInspectionEvent = event => {
+    if (!inspectionObservers.size) {
+      return;
+    }
+    const resolvedInspectionEvent = {
+      ...event,
+      rootId: rootActor.sessionId
+    };
+    inspectionObservers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+  };
   const system = {
     _snapshot: {
       _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
@@ -203,15 +213,9 @@ function createSystem(rootActor, options) {
       reverseKeyedActors.set(actorRef, systemId);
     },
     inspect: observer => {
-      observers.add(observer);
-    },
-    _sendInspectionEvent: event => {
-      const resolvedInspectionEvent = {
-        ...event,
-        rootId: rootActor.sessionId
-      };
-      observers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+      inspectionObservers.add(observer);
     },
+    _sendInspectionEvent: sendInspectionEvent,
     _relay: (source, target, event) => {
       system._sendInspectionEvent({
         type: '@xstate.event',
@@ -230,16 +234,16 @@ function createSystem(rootActor, options) {
       };
     },
     start: () => {
-      const scheduledEvets = system._snapshot._scheduledEvents;
+      const scheduledEvents = system._snapshot._scheduledEvents;
       system._snapshot._scheduledEvents = {};
-      for (const scheduledId in scheduledEvets) {
+      for (const scheduledId in scheduledEvents) {
         const {
           source,
           target,
           event,
           delay,
           id
-        } = scheduledEvets[scheduledId];
+        } = scheduledEvents[scheduledId];
         scheduler.schedule(source, target, event, delay, id);
       }
     }
@@ -1790,7 +1794,11 @@ function getStateNodeByPath(stateNode, statePath) {
  */
 function getStateNodes(stateNode, stateValue) {
   if (typeof stateValue === 'string') {
-    return [stateNode, stateNode.states[stateValue]];
+    const childStateNode = stateNode.states[stateValue];
+    if (!childStateNode) {
+      throw new Error(`State '${stateValue}' does not exist on '${stateNode.id}'`);
+    }
+    return [stateNode, childStateNode];
   }
   const childStateKeys = Object.keys(stateValue);
   const childStateNodes = childStateKeys.map(subStateKey => getStateNode(stateNode, subStateKey)).filter(Boolean);
@@ -2203,7 +2211,7 @@ function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNod
   }
   return [nextSnapshot, changedHistory || historyValue];
 }
-function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, actions, extra, retries) {
+function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, extra, retries) {
   const {
     machine
   } = currentSnapshot;
@@ -2228,12 +2236,23 @@ function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, acti
       context: intermediateSnapshot.context,
       event
     }) : action.params : undefined;
+    function executeAction() {
+      actorScope.system._sendInspectionEvent({
+        type: '@xstate.action',
+        actorRef: actorScope.self,
+        action: {
+          type: typeof action === 'string' ? action : typeof action === 'object' ? action.type : action.name || '(anonymous)',
+          params: actionParams
+        }
+      });
+      resolvedAction(actionArgs, actionParams);
+    }
     if (!('resolve' in resolvedAction)) {
       if (actorScope.self._processingStatus === ProcessingStatus.Running) {
-        resolvedAction(actionArgs, actionParams);
+        executeAction();
       } else {
         actorScope.defer(() => {
-          resolvedAction(actionArgs, actionParams);
+          executeAction();
         });
       }
       continue;
@@ -2254,14 +2273,14 @@ function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, acti
       }
     }
     if (actions) {
-      intermediateSnapshot = resolveActionsAndContextWorker(intermediateSnapshot, event, actorScope, actions, extra, retries);
+      intermediateSnapshot = resolveAndExecuteActionsWithContext(intermediateSnapshot, event, actorScope, actions, extra, retries);
     }
   }
   return intermediateSnapshot;
 }
 function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentSnapshot, event, actorScope, actions, {
+  const nextState = resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, {
     internalQueue,
     deferredActorIds
   }, retries);
@@ -2275,17 +2294,27 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
   }
   let nextSnapshot = snapshot;
-  const states = [];
+  const microstates = [];
+  function addMicrostate(microstate, event, transitions) {
+    actorScope.system._sendInspectionEvent({
+      type: '@xstate.microstep',
+      actorRef: actorScope.self,
+      event,
+      snapshot: microstate,
+      _transitions: transitions
+    });
+    microstates.push(microstate);
+  }
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
     nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), {
       status: 'stopped'
     });
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, event, []);
     return {
       snapshot: nextSnapshot,
-      microstates: states
+      microstates
     };
   }
   let nextEvent = event;
@@ -2304,16 +2333,16 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
         status: 'error',
         error: currentEvent.error
       });
-      states.push(nextSnapshot);
+      addMicrostate(nextSnapshot, currentEvent, []);
       return {
         snapshot: nextSnapshot,
-        microstates: states
+        microstates
       };
     }
     nextSnapshot = microstep(transitions, snapshot, actorScope, nextEvent, false,
     // isInitial
     internalQueue);
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, currentEvent, transitions);
   }
   let shouldSelectEventlessTransitions = true;
   while (nextSnapshot.status === 'active') {
@@ -2331,14 +2360,14 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
     }
     nextSnapshot = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
     shouldSelectEventlessTransitions = nextSnapshot !== previousState;
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, nextEvent, enabledTransitions);
   }
   if (nextSnapshot.status !== 'active') {
     stopChildren(nextSnapshot, nextEvent, actorScope);
   }
   return {
     snapshot: nextSnapshot,
-    microstates: states
+    microstates
   };
 }
 function stopChildren(nextState, event, actorScope) {

package/dist/{raise-2fdbadc6.development.esm.js → raise-4593d184.development.esm.js}

@@ -134,7 +134,7 @@ function createSystem(rootActor, options) {
   const children = new Map();
   const keyedActors = new Map();
   const reverseKeyedActors = new WeakMap();
-  const observers = new Set();
+  const inspectionObservers = new Set();
   const timerMap = {};
   const clock = options.clock;
   const scheduler = {
@@ -172,6 +172,16 @@ function createSystem(rootActor, options) {
       }
     }
   };
+  const sendInspectionEvent = event => {
+    if (!inspectionObservers.size) {
+      return;
+    }
+    const resolvedInspectionEvent = {
+      ...event,
+      rootId: rootActor.sessionId
+    };
+    inspectionObservers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+  };
   const system = {
     _snapshot: {
       _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
@@ -201,15 +211,9 @@ function createSystem(rootActor, options) {
       reverseKeyedActors.set(actorRef, systemId);
     },
     inspect: observer => {
-      observers.add(observer);
-    },
-    _sendInspectionEvent: event => {
-      const resolvedInspectionEvent = {
-        ...event,
-        rootId: rootActor.sessionId
-      };
-      observers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+      inspectionObservers.add(observer);
     },
+    _sendInspectionEvent: sendInspectionEvent,
     _relay: (source, target, event) => {
       system._sendInspectionEvent({
         type: '@xstate.event',
@@ -228,16 +232,16 @@ function createSystem(rootActor, options) {
       };
     },
     start: () => {
-      const scheduledEvets = system._snapshot._scheduledEvents;
+      const scheduledEvents = system._snapshot._scheduledEvents;
       system._snapshot._scheduledEvents = {};
-      for (const scheduledId in scheduledEvets) {
+      for (const scheduledId in scheduledEvents) {
         const {
           source,
           target,
           event,
           delay,
           id
-        } = scheduledEvets[scheduledId];
+        } = scheduledEvents[scheduledId];
         scheduler.schedule(source, target, event, delay, id);
       }
     }
@@ -1788,7 +1792,11 @@ function getStateNodeByPath(stateNode, statePath) {
  */
 function getStateNodes(stateNode, stateValue) {
   if (typeof stateValue === 'string') {
-    return [stateNode, stateNode.states[stateValue]];
+    const childStateNode = stateNode.states[stateValue];
+    if (!childStateNode) {
+      throw new Error(`State '${stateValue}' does not exist on '${stateNode.id}'`);
+    }
+    return [stateNode, childStateNode];
   }
   const childStateKeys = Object.keys(stateValue);
   const childStateNodes = childStateKeys.map(subStateKey => getStateNode(stateNode, subStateKey)).filter(Boolean);
@@ -2201,7 +2209,7 @@ function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNod
   }
   return [nextSnapshot, changedHistory || historyValue];
 }
-function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, actions, extra, retries) {
+function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, extra, retries) {
   const {
     machine
   } = currentSnapshot;
@@ -2226,12 +2234,23 @@ function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, acti
       context: intermediateSnapshot.context,
       event
     }) : action.params : undefined;
+    function executeAction() {
+      actorScope.system._sendInspectionEvent({
+        type: '@xstate.action',
+        actorRef: actorScope.self,
+        action: {
+          type: typeof action === 'string' ? action : typeof action === 'object' ? action.type : action.name || '(anonymous)',
+          params: actionParams
+        }
+      });
+      resolvedAction(actionArgs, actionParams);
+    }
     if (!('resolve' in resolvedAction)) {
       if (actorScope.self._processingStatus === ProcessingStatus.Running) {
-        resolvedAction(actionArgs, actionParams);
+        executeAction();
       } else {
         actorScope.defer(() => {
-          resolvedAction(actionArgs, actionParams);
+          executeAction();
         });
       }
       continue;
@@ -2252,14 +2271,14 @@ function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, acti
       }
     }
     if (actions) {
-      intermediateSnapshot = resolveActionsAndContextWorker(intermediateSnapshot, event, actorScope, actions, extra, retries);
+      intermediateSnapshot = resolveAndExecuteActionsWithContext(intermediateSnapshot, event, actorScope, actions, extra, retries);
     }
   }
   return intermediateSnapshot;
 }
 function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentSnapshot, event, actorScope, actions, {
+  const nextState = resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, {
     internalQueue,
     deferredActorIds
   }, retries);
@@ -2273,17 +2292,27 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
   }
   let nextSnapshot = snapshot;
-  const states = [];
+  const microstates = [];
+  function addMicrostate(microstate, event, transitions) {
+    actorScope.system._sendInspectionEvent({
+      type: '@xstate.microstep',
+      actorRef: actorScope.self,
+      event,
+      snapshot: microstate,
+      _transitions: transitions
+    });
+    microstates.push(microstate);
+  }
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
     nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), {
       status: 'stopped'
     });
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, event, []);
     return {
       snapshot: nextSnapshot,
-      microstates: states
+      microstates
     };
   }
   let nextEvent = event;
@@ -2302,16 +2331,16 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
         status: 'error',
         error: currentEvent.error
       });
-      states.push(nextSnapshot);
+      addMicrostate(nextSnapshot, currentEvent, []);
       return {
         snapshot: nextSnapshot,
-        microstates: states
+        microstates
       };
     }
     nextSnapshot = microstep(transitions, snapshot, actorScope, nextEvent, false,
     // isInitial
     internalQueue);
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, currentEvent, transitions);
   }
   let shouldSelectEventlessTransitions = true;
   while (nextSnapshot.status === 'active') {
@@ -2329,14 +2358,14 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
     }
     nextSnapshot = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
     shouldSelectEventlessTransitions = nextSnapshot !== previousState;
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, nextEvent, enabledTransitions);
   }
   if (nextSnapshot.status !== 'active') {
     stopChildren(nextSnapshot, nextEvent, actorScope);
   }
   return {
     snapshot: nextSnapshot,
-    microstates: states
+    microstates
   };
 }
 function stopChildren(nextState, event, actorScope) {

package/dist/{raise-309d511a.esm.js → raise-6420fe44.esm.js}

@@ -134,7 +134,7 @@ function createSystem(rootActor, options) {
   const children = new Map();
   const keyedActors = new Map();
   const reverseKeyedActors = new WeakMap();
-  const observers = new Set();
+  const inspectionObservers = new Set();
   const timerMap = {};
   const clock = options.clock;
   const scheduler = {
@@ -172,6 +172,16 @@ function createSystem(rootActor, options) {
       }
     }
   };
+  const sendInspectionEvent = event => {
+    if (!inspectionObservers.size) {
+      return;
+    }
+    const resolvedInspectionEvent = {
+      ...event,
+      rootId: rootActor.sessionId
+    };
+    inspectionObservers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+  };
   const system = {
     _snapshot: {
       _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
@@ -201,15 +211,9 @@ function createSystem(rootActor, options) {
       reverseKeyedActors.set(actorRef, systemId);
     },
     inspect: observer => {
-      observers.add(observer);
-    },
-    _sendInspectionEvent: event => {
-      const resolvedInspectionEvent = {
-        ...event,
-        rootId: rootActor.sessionId
-      };
-      observers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+      inspectionObservers.add(observer);
     },
+    _sendInspectionEvent: sendInspectionEvent,
     _relay: (source, target, event) => {
       system._sendInspectionEvent({
         type: '@xstate.event',
@@ -228,16 +232,16 @@ function createSystem(rootActor, options) {
       };
     },
     start: () => {
-      const scheduledEvets = system._snapshot._scheduledEvents;
+      const scheduledEvents = system._snapshot._scheduledEvents;
       system._snapshot._scheduledEvents = {};
-      for (const scheduledId in scheduledEvets) {
+      for (const scheduledId in scheduledEvents) {
         const {
           source,
           target,
           event,
           delay,
           id
-        } = scheduledEvets[scheduledId];
+        } = scheduledEvents[scheduledId];
         scheduler.schedule(source, target, event, delay, id);
       }
     }
@@ -1743,7 +1747,11 @@ function getStateNodeByPath(stateNode, statePath) {
  */
 function getStateNodes(stateNode, stateValue) {
   if (typeof stateValue === 'string') {
-    return [stateNode, stateNode.states[stateValue]];
+    const childStateNode = stateNode.states[stateValue];
+    if (!childStateNode) {
+      throw new Error(`State '${stateValue}' does not exist on '${stateNode.id}'`);
+    }
+    return [stateNode, childStateNode];
   }
   const childStateKeys = Object.keys(stateValue);
   const childStateNodes = childStateKeys.map(subStateKey => getStateNode(stateNode, subStateKey)).filter(Boolean);
@@ -2156,7 +2164,7 @@ function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNod
   }
   return [nextSnapshot, changedHistory || historyValue];
 }
-function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, actions, extra, retries) {
+function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, extra, retries) {
   const {
     machine
   } = currentSnapshot;
@@ -2181,12 +2189,23 @@ function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, acti
       context: intermediateSnapshot.context,
       event
     }) : action.params : undefined;
+    function executeAction() {
+      actorScope.system._sendInspectionEvent({
+        type: '@xstate.action',
+        actorRef: actorScope.self,
+        action: {
+          type: typeof action === 'string' ? action : typeof action === 'object' ? action.type : action.name || '(anonymous)',
+          params: actionParams
+        }
+      });
+      resolvedAction(actionArgs, actionParams);
+    }
     if (!('resolve' in resolvedAction)) {
       if (actorScope.self._processingStatus === ProcessingStatus.Running) {
-        resolvedAction(actionArgs, actionParams);
+        executeAction();
       } else {
         actorScope.defer(() => {
-          resolvedAction(actionArgs, actionParams);
+          executeAction();
         });
       }
       continue;
@@ -2207,14 +2226,14 @@ function resolveActionsAndContextWorker(currentSnapshot, event, actorScope, acti
       }
     }
     if (actions) {
-      intermediateSnapshot = resolveActionsAndContextWorker(intermediateSnapshot, event, actorScope, actions, extra, retries);
+      intermediateSnapshot = resolveAndExecuteActionsWithContext(intermediateSnapshot, event, actorScope, actions, extra, retries);
     }
   }
   return intermediateSnapshot;
 }
 function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentSnapshot, event, actorScope, actions, {
+  const nextState = resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, {
     internalQueue,
     deferredActorIds
   }, retries);
@@ -2225,17 +2244,27 @@ function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, i
 }
 function macrostep(snapshot, event, actorScope, internalQueue = []) {
   let nextSnapshot = snapshot;
-  const states = [];
+  const microstates = [];
+  function addMicrostate(microstate, event, transitions) {
+    actorScope.system._sendInspectionEvent({
+      type: '@xstate.microstep',
+      actorRef: actorScope.self,
+      event,
+      snapshot: microstate,
+      _transitions: transitions
+    });
+    microstates.push(microstate);
+  }
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
     nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), {
       status: 'stopped'
     });
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, event, []);
     return {
       snapshot: nextSnapshot,
-      microstates: states
+      microstates
     };
   }
   let nextEvent = event;
@@ -2254,16 +2283,16 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
         status: 'error',
         error: currentEvent.error
       });
-      states.push(nextSnapshot);
+      addMicrostate(nextSnapshot, currentEvent, []);
       return {
         snapshot: nextSnapshot,
-        microstates: states
+        microstates
       };
     }
     nextSnapshot = microstep(transitions, snapshot, actorScope, nextEvent, false,
     // isInitial
     internalQueue);
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, currentEvent, transitions);
   }
   let shouldSelectEventlessTransitions = true;
   while (nextSnapshot.status === 'active') {
@@ -2281,14 +2310,14 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
     }
     nextSnapshot = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
     shouldSelectEventlessTransitions = nextSnapshot !== previousState;
-    states.push(nextSnapshot);
+    addMicrostate(nextSnapshot, nextEvent, enabledTransitions);
   }
   if (nextSnapshot.status !== 'active') {
     stopChildren(nextSnapshot, nextEvent, actorScope);
   }
   return {
     snapshot: nextSnapshot,
-    microstates: states
+    microstates
   };
 }
 function stopChildren(nextState, event, actorScope) {