xstate 5.0.0-beta.38 → 5.0.0-beta.40

package/dist/{raise-b69a3d16.development.cjs.js → raise-8325e2df.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-ed3f81f7.development.cjs.js');
+var interpreter = require('./interpreter-bae5c279.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -22,8 +22,8 @@ function resolveCancel(_, state, actionArgs, actionParams, {
   const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs, actionParams) : sendId;
   return [state, resolvedSendId];
 }
-function executeCancel(actorContext, resolvedSendId) {
-  actorContext.self.cancel(resolvedSendId);
+function executeCancel(actorScope, resolvedSendId) {
+  actorScope.self.cancel(resolvedSendId);
 }
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
@@ -45,7 +45,7 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
+function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   id,
   systemId,
   src,
@@ -64,19 +64,19 @@ function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
     actorRef = interpreter.createActor(referenced.src, {
       id: resolvedId,
       src: typeof src === 'string' ? src : undefined,
-      parent: actorContext?.self,
+      parent: actorScope?.self,
       systemId,
       input: typeof configuredInput === 'function' ? configuredInput({
         context: state.context,
         event: actionArgs.event,
-        self: actorContext?.self
+        self: actorScope?.self
       }) : configuredInput
     });
     if (syncSnapshot) {
       actorRef.subscribe({
         next: snapshot => {
           if (snapshot.status === 'active') {
-            actorContext.self.send({
+            actorScope.self.send({
               type: `xstate.snapshot.${id}`,
               snapshot
             });
@@ -87,7 +87,7 @@ function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
     }
   }
   if (!actorRef) {
-    console.warn(`Actor type '${src}' not found in machine '${actorContext.id}'.`);
+    console.warn(`Actor type '${src}' not found in machine '${actorScope.id}'.`);
   }
   return [cloneState(state, {
     children: {
@@ -99,21 +99,21 @@ function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
     actorRef
   }];
 }
-function executeSpawn(actorContext, {
+function executeSpawn(actorScope, {
   id,
   actorRef
 }) {
   if (!actorRef) {
     return;
   }
-  actorContext.defer(() => {
+  actorScope.defer(() => {
     if (actorRef.status === interpreter.ActorStatus.Stopped) {
       return;
     }
     try {
       actorRef.start?.();
     } catch (err) {
-      actorContext.self.send(interpreter.createErrorActorEvent(id, err));
+      actorScope.self.send(interpreter.createErrorActorEvent(id, err));
       return;
     }
   });
@@ -156,7 +156,7 @@ function resolveStop(_, state, args, actionParams, {
     children
   }), resolvedActorRef];
 }
-function executeStop(actorContext, actorRef) {
+function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
   }
@@ -164,20 +164,20 @@ function executeStop(actorContext, actorRef) {
   // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
   // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
   // this could throw on `systemId` collision, for example, when dealing with reentering transitions
-  actorContext.system._unregister(actorRef);
+  actorScope.system._unregister(actorRef);
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
   if (actorRef.status !== interpreter.ActorStatus.Running) {
-    actorContext.stopChild(actorRef);
+    actorScope.stopChild(actorRef);
     return;
   }
   // stopping a child enqueues a stop event in the child actor's mailbox
   // we need for all of the already enqueued events to be processed before we stop the child
   // the parent itself might want to send some events to a child (for example from exit actions on the invoking state)
   // and we don't want to ignore those events
-  actorContext.defer(() => {
-    actorContext.stopChild(actorRef);
+  actorScope.defer(() => {
+    actorScope.stopChild(actorRef);
   });
 }
 /**
@@ -762,15 +762,6 @@ function isDescendant(childStateNode, parentStateNode) {
   }
   return marker.parent === parentStateNode;
 }
-function getPathFromRootToNode(stateNode) {
-  const path = [];
-  let marker = stateNode.parent;
-  while (marker) {
-    path.unshift(marker);
-    marker = marker.parent;
-  }
-  return path;
-}
 function hasIntersection(s1, s2) {
   const set1 = new Set(s1);
   const set2 = new Set(s2);
@@ -810,17 +801,13 @@ function removeConflictingTransitions(enabledTransitions, configuration, history
   }
   return Array.from(filteredTransitions);
 }
-function findLCCA(stateNodes) {
-  const [head] = stateNodes;
-  let current = getPathFromRootToNode(head);
-  let candidates = [];
-  for (const stateNode of stateNodes) {
-    const path = getPathFromRootToNode(stateNode);
-    candidates = current.filter(sn => path.includes(sn));
-    current = candidates;
-    candidates = [];
+function findLeastCommonAncestor(stateNodes) {
+  const [head, ...tail] = stateNodes;
+  for (const ancestor of getProperAncestors(head, undefined)) {
+    if (tail.every(sn => isDescendant(sn, ancestor))) {
+      return ancestor;
+    }
   }
-  return current[current.length - 1];
 }
 function getEffectiveTargetStates(transition, historyValue) {
   if (!transition.target) {
@@ -852,8 +839,16 @@ function getTransitionDomain(transition, historyValue) {
   if (!transition.reenter && targetStates.every(target => target === transition.source || isDescendant(target, transition.source))) {
     return transition.source;
   }
-  const lcca = findLCCA(targetStates.concat(transition.source));
-  return lcca;
+  const lca = findLeastCommonAncestor(targetStates.concat(transition.source));
+  if (lca) {
+    return lca;
+  }
+
+  // at this point we know that it's a root transition since LCA couldn't be found
+  if (transition.reenter) {
+    return;
+  }
+  return transition.source.machine.root;
 }
 function computeExitSet(transitions, configuration, historyValue) {
   const statesToExit = new Set();
@@ -887,7 +882,7 @@ function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
  */
-function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
+function microstep(transitions, currentState, actorScope, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentState;
   }
@@ -898,17 +893,17 @@ function microstep(transitions, currentState, actorCtx, event, isInitial, intern
 
   // Exit states
   if (!isInitial) {
-    [nextState, historyValue] = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue, internalQueue);
+    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutConfiguration, historyValue, internalQueue);
   }
 
   // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions), internalQueue);
+  nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
-  nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
+  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
   if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
+    nextState = resolveActionsAndContext(nextState, event, actorScope, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
     if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
@@ -924,14 +919,14 @@ function microstep(transitions, currentState, actorCtx, event, isInitial, intern
     throw e;
   }
 }
-function getMachineOutput(state, event, actorCtx, rootNode, rootCompletionNode) {
+function getMachineOutput(state, event, actorScope, rootNode, rootCompletionNode) {
   if (!rootNode.output) {
     return;
   }
-  const doneStateEvent = interpreter.createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? interpreter.resolveOutput(rootCompletionNode.output, state.context, event, actorCtx.self) : undefined);
-  return interpreter.resolveOutput(rootNode.output, state.context, doneStateEvent, actorCtx.self);
+  const doneStateEvent = interpreter.createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? interpreter.resolveOutput(rootCompletionNode.output, state.context, event, actorScope.self) : undefined);
+  return interpreter.resolveOutput(rootNode.output, state.context, doneStateEvent, actorScope.self);
 }
-function enterStates(currentState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
+function enterStates(currentState, event, actorScope, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
   let nextState = currentState;
   const statesToEnter = new Set();
   // those are states that were directly targeted or indirectly targeted by the explicit target
@@ -961,13 +956,13 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       const initialActions = stateNodeToEnter.initial.actions;
       actions.push(...initialActions);
     }
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
+    nextState = resolveActionsAndContext(nextState, 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(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
+        internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self) : undefined));
       }
       while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
         completedNodes.add(ancestorMarker);
@@ -980,7 +975,7 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       }
       nextState = cloneState(nextState, {
         status: 'done',
-        output: getMachineOutput(nextState, event, actorCtx, currentState.configuration[0].machine.root, rootCompletionNode)
+        output: getMachineOutput(nextState, event, actorScope, currentState.configuration[0].machine.root, rootCompletionNode)
       });
     }
   }
@@ -1005,7 +1000,11 @@ function computeEntrySet(transitions, historyValue, statesForDefaultEntry, state
     }
     const targetStates = getEffectiveTargetStates(t, historyValue);
     for (const s of targetStates) {
-      addAncestorStatesToEnter(s, domain, statesToEnter, historyValue, statesForDefaultEntry);
+      const ancestors = getProperAncestors(s, domain);
+      if (domain?.type === 'parallel') {
+        ancestors.push(domain);
+      }
+      addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, ancestors, !t.source.parent && t.reenter ? undefined : domain);
     }
   }
 }
@@ -1018,7 +1017,7 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
         addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
       }
       for (const s of historyStateNodes) {
-        addAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
+        addProperAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
       }
     } else {
       const historyDefaultTransition = resolveHistoryDefaultTransition(stateNode);
@@ -1030,7 +1029,7 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
         addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
       }
       for (const s of historyDefaultTransition.target) {
-        addAncestorStatesToEnter(s, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
+        addProperAncestorStatesToEnter(s, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
       }
     }
   } else {
@@ -1041,7 +1040,7 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
         statesForDefaultEntry.add(initialState);
       }
       addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
-      addAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
+      addProperAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
     } else {
       if (stateNode.type === 'parallel') {
         for (const child of getChildren(stateNode).filter(sn => !isHistoryNode(sn))) {
@@ -1057,10 +1056,11 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
     }
   }
 }
-function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
-  const properAncestors = getProperAncestors(stateNode, toStateNode);
-  for (const anc of properAncestors) {
-    statesToEnter.add(anc);
+function addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, ancestors, reentrancyDomain) {
+  for (const anc of ancestors) {
+    if (!reentrancyDomain || isDescendant(anc, reentrancyDomain)) {
+      statesToEnter.add(anc);
+    }
     if (anc.type === 'parallel') {
       for (const child of getChildren(anc).filter(sn => !isHistoryNode(sn))) {
         if (![...statesToEnter].some(s => isDescendant(s, child))) {
@@ -1071,7 +1071,10 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue, internalQueue) {
+function addProperAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
+  addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, getProperAncestors(stateNode, toStateNode));
+}
+function exitStates(currentState, event, actorScope, transitions, mutConfiguration, historyValue, internalQueue) {
   let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
@@ -1095,12 +1098,12 @@ function exitStates(currentState, event, actorCtx, transitions, mutConfiguration
     }
   }
   for (const s of statesToExit) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
+    nextState = resolveActionsAndContext(nextState, event, actorScope, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
     mutConfiguration.delete(s);
   }
   return [nextState, changedHistory || historyValue];
 }
-function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
+function resolveActionsAndContextWorker(currentState, event, actorScope, actions, extra, retries) {
   const {
     machine
   } = currentState;
@@ -1118,25 +1121,25 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
     const actionArgs = {
       context: intermediateState.context,
       event,
-      self: actorCtx?.self,
-      system: actorCtx?.system
+      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,
       event
     }) : action.params : undefined;
     if (!('resolve' in resolvedAction)) {
-      if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
+      if (actorScope?.self.status === interpreter.ActorStatus.Running) {
         resolvedAction(actionArgs, actionParams);
       } else {
-        actorCtx?.defer(() => {
+        actorScope?.defer(() => {
           resolvedAction(actionArgs, actionParams);
         });
       }
       continue;
     }
     const builtinAction = resolvedAction;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, actionParams, resolvedAction,
+    const [nextState, params, actions] = builtinAction.resolve(actorScope, intermediateState, actionArgs, actionParams, resolvedAction,
     // this holds all params
     extra);
     intermediateState = nextState;
@@ -1144,30 +1147,30 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
       retries?.push([builtinAction, params]);
     }
     if ('execute' in builtinAction) {
-      if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
-        builtinAction.execute(actorCtx, params);
+      if (actorScope?.self.status === interpreter.ActorStatus.Running) {
+        builtinAction.execute(actorScope, params);
       } else {
-        actorCtx?.defer(builtinAction.execute.bind(null, actorCtx, params));
+        actorScope?.defer(builtinAction.execute.bind(null, actorScope, params));
       }
     }
     if (actions) {
-      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorCtx, actions, extra, retries);
+      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorScope, actions, extra, retries);
     }
   }
   return intermediateState;
 }
-function resolveActionsAndContext(currentState, event, actorCtx, actions, internalQueue, deferredActorIds) {
+function resolveActionsAndContext(currentState, event, actorScope, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, {
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorScope, actions, {
     internalQueue,
     deferredActorIds
   }, retries);
   retries?.forEach(([builtinAction, params]) => {
-    builtinAction.retryResolve(actorCtx, nextState, params);
+    builtinAction.retryResolve(actorScope, nextState, params);
   });
   return nextState;
 }
-function macrostep(state, event, actorCtx, internalQueue = []) {
+function macrostep(state, event, actorScope, internalQueue = []) {
   if (event.type === interpreter.WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${interpreter.WILDCARD}')`);
   }
@@ -1176,7 +1179,7 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
 
   // Handle stop event
   if (event.type === interpreter.XSTATE_STOP) {
-    nextState = cloneState(stopChildren(nextState, event, actorCtx), {
+    nextState = cloneState(stopChildren(nextState, event, actorScope), {
       status: 'stopped'
     });
     states.push(nextState);
@@ -1191,7 +1194,7 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== interpreter.XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false, internalQueue);
+    nextState = microstep(transitions, state, actorScope, nextEvent, false, internalQueue);
     states.push(nextState);
   }
   let shouldSelectEventlessTransitions = true;
@@ -1208,20 +1211,20 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
       nextEvent = internalQueue.shift();
       enabledTransitions = selectTransitions(nextEvent, nextState);
     }
-    nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false, internalQueue);
+    nextState = microstep(enabledTransitions, nextState, actorScope, nextEvent, false, internalQueue);
     shouldSelectEventlessTransitions = nextState !== previousState;
     states.push(nextState);
   }
   if (nextState.status !== 'active') {
-    stopChildren(nextState, nextEvent, actorCtx);
+    stopChildren(nextState, nextEvent, actorScope);
   }
   return {
     state: nextState,
     microstates: states
   };
 }
-function stopChildren(nextState, event, actorCtx) {
-  return resolveActionsAndContext(nextState, event, actorCtx, Object.values(nextState.children).map(child => stop(child)), []);
+function stopChildren(nextState, event, actorScope) {
+  return resolveActionsAndContext(nextState, event, actorScope, Object.values(nextState.children).map(child => stop(child)), []);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -1508,9 +1511,9 @@ function resolveRaise(_, state, args, actionParams, {
     delay: resolvedDelay
   }];
 }
-function executeRaise(actorContext, params) {
+function executeRaise(actorScope, params) {
   if (typeof params.delay === 'number') {
-    actorContext.self.delaySend(params);
+    actorScope.self.delaySend(params);
     return;
   }
 }

package/dist/{send-34160163.cjs.js → send-4fdf275e.cjs.js}

@@ -1,9 +1,9 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-7faa9b3b.cjs.js');
-var interpreter = require('./interpreter-b6f22ee2.cjs.js');
+var guards_dist_xstateGuards = require('./raise-27909189.cjs.js');
+var interpreter = require('./interpreter-586abde4.cjs.js');
 
-function createSpawner(actorContext, {
+function createSpawner(actorScope, {
   machine,
   context
 }, event, spawnedChildren) {
@@ -21,11 +21,11 @@ function createSpawner(actorContext, {
       // TODO: this should also receive `src`
       const actorRef = interpreter.createActor(referenced.src, {
         id: options.id,
-        parent: actorContext.self,
+        parent: actorScope.self,
         input: typeof input === 'function' ? input({
           context,
           event,
-          self: actorContext.self
+          self: actorScope.self
         }) : input,
         src,
         systemId
@@ -35,7 +35,7 @@ function createSpawner(actorContext, {
         actorRef.subscribe({
           next: snapshot => {
             if (snapshot.status === 'active') {
-              actorContext.self.send({
+              actorScope.self.send({
                 type: `xstate.snapshot.${actorRef.id}`,
                 snapshot
               });
@@ -49,7 +49,7 @@ function createSpawner(actorContext, {
       // TODO: this should also receive `src`
       const actorRef = interpreter.createActor(src, {
         id: options.id,
-        parent: actorContext.self,
+        parent: actorScope.self,
         input: options.input,
         src: undefined,
         systemId
@@ -58,7 +58,7 @@ function createSpawner(actorContext, {
         actorRef.subscribe({
           next: snapshot => {
             if (snapshot.status === 'active') {
-              actorContext.self.send({
+              actorScope.self.send({
                 type: `xstate.snapshot.${actorRef.id}`,
                 snapshot,
                 id: actorRef.id
@@ -74,14 +74,14 @@ function createSpawner(actorContext, {
   return (src, options) => {
     const actorRef = spawn(src, options); // TODO: fix types
     spawnedChildren[actorRef.id] = actorRef;
-    actorContext.defer(() => {
+    actorScope.defer(() => {
       if (actorRef.status === interpreter.ActorStatus.Stopped) {
         return;
       }
       try {
         actorRef.start?.();
       } catch (err) {
-        actorContext.self.send(interpreter.createErrorActorEvent(actorRef.id, err));
+        actorScope.self.send(interpreter.createErrorActorEvent(actorRef.id, err));
         return;
       }
     });
@@ -89,7 +89,7 @@ function createSpawner(actorContext, {
   };
 }
 
-function resolveAssign(actorContext, state, actionArgs, actionParams, {
+function resolveAssign(actorScope, state, actionArgs, actionParams, {
   assignment
 }) {
   if (!state.context) {
@@ -99,9 +99,9 @@ function resolveAssign(actorContext, state, actionArgs, actionParams, {
   const assignArgs = {
     context: state.context,
     event: actionArgs.event,
-    spawn: createSpawner(actorContext, state, actionArgs.event, spawnedChildren),
-    self: actorContext?.self,
-    system: actorContext?.system
+    spawn: createSpawner(actorScope, state, actionArgs.event, spawnedChildren),
+    self: actorScope?.self,
+    system: actorScope?.system
   };
   let partialUpdate = {};
   if (typeof assignment === 'function') {
@@ -256,7 +256,7 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
   return SpecialTargets;
 }({});
 
-function resolveSendTo(actorContext, state, args, actionParams, {
+function resolveSendTo(actorScope, state, args, actionParams, {
   to,
   event: eventOrExpr,
   id,
@@ -278,9 +278,9 @@ function resolveSendTo(actorContext, state, args, actionParams, {
   let targetActorRef;
   if (typeof resolvedTarget === 'string') {
     if (resolvedTarget === SpecialTargets.Parent) {
-      targetActorRef = actorContext?.self._parent;
+      targetActorRef = actorScope?.self._parent;
     } else if (resolvedTarget === SpecialTargets.Internal) {
-      targetActorRef = actorContext?.self;
+      targetActorRef = actorScope?.self;
     } else if (resolvedTarget.startsWith('#_')) {
       // SCXML compatibility: https://www.w3.org/TR/scxml/#SCXMLEventProcessor
       // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
@@ -292,7 +292,7 @@ function resolveSendTo(actorContext, state, args, actionParams, {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
     }
   } else {
-    targetActorRef = resolvedTarget || actorContext?.self;
+    targetActorRef = resolvedTarget || actorScope?.self;
   }
   return [state, {
     to: targetActorRef,
@@ -306,20 +306,20 @@ function retryResolveSendTo(_, state, params) {
     params.to = state.children[params.to];
   }
 }
-function executeSendTo(actorContext, params) {
+function executeSendTo(actorScope, params) {
   if (typeof params.delay === 'number') {
-    actorContext.self.delaySend(params);
+    actorScope.self.delaySend(params);
     return;
   }
 
   // this forms an outgoing events queue
   // thanks to that the recipient actors are able to read the *updated* snapshot value of the sender
-  actorContext.defer(() => {
+  actorScope.defer(() => {
     const {
       to,
       event
     } = params;
-    actorContext?.system._relay(actorContext.self, to, event.type === interpreter.XSTATE_ERROR ? interpreter.createErrorActorEvent(actorContext.self.id, event.data) : event);
+    actorScope?.system._relay(actorScope.self, to, event.type === interpreter.XSTATE_ERROR ? interpreter.createErrorActorEvent(actorScope.self.id, event.data) : event);
   });
 }
 /**