xstate 5.0.0-beta.37 → 5.0.0-beta.39

package/dist/{raise-1fd59c65.development.cjs.js → raise-17cb3d9d.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-e58ca48d.development.cjs.js');
+var interpreter = require('./interpreter-03a5c3f5.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -16,14 +16,14 @@ function memo(object, key, fn) {
   return memoizedData[key];
 }
 
-function resolveCancel(_, state, actionArgs, {
+function resolveCancel(_, state, actionArgs, actionParams, {
   sendId
 }) {
-  const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs) : sendId;
+  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
@@ -33,7 +33,7 @@ function executeCancel(actorContext, resolvedSendId) {
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
 function cancel(sendId) {
-  function cancel(_) {
+  function cancel(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -45,7 +45,7 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveInvoke(actorContext, state, actionArgs, {
+function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   id,
   systemId,
   src,
@@ -56,99 +56,94 @@ function resolveInvoke(actorContext, state, actionArgs, {
     src,
     input: undefined
   };
+  const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
   if (referenced) {
     // TODO: inline `input: undefined` should win over the referenced one
     const configuredInput = input || referenced.input;
     actorRef = interpreter.createActor(referenced.src, {
-      id,
+      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
             });
           }
         },
-        error: () => {
-          /* TODO */
-        }
+        error: () => {}
       });
     }
   }
   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: {
       ...state.children,
-      [id]: actorRef
+      [resolvedId]: actorRef
     }
   }), {
     id,
     actorRef
   }];
 }
-function executeInvoke(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;
     }
   });
 }
-
-// we don't export this since it's an internal action that is not meant to be used in the user's code
-
-function invoke({
+function spawn(...[src, {
   id,
   systemId,
-  src,
   input,
-  onSnapshot
-}) {
-  function invoke(_) {
+  syncSnapshot = false
+} = {}]) {
+  function spawn(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
   }
-  invoke.type = 'xstate.invoke';
-  invoke.id = id;
-  invoke.systemId = systemId;
-  invoke.src = src;
-  invoke.input = input;
-  invoke.syncSnapshot = !!onSnapshot;
-  invoke.resolve = resolveInvoke;
-  invoke.execute = executeInvoke;
-  return invoke;
+  spawn.type = 'xstate.spawn';
+  spawn.id = id;
+  spawn.systemId = systemId;
+  spawn.src = src;
+  spawn.input = input;
+  spawn.syncSnapshot = syncSnapshot;
+  spawn.resolve = resolveSpawn;
+  spawn.execute = executeSpawn;
+  return spawn;
 }
 
-function resolveStop(_, state, args, {
+function resolveStop(_, state, args, actionParams, {
   actorRef
 }) {
-  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args) : actorRef;
+  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args, actionParams) : actorRef;
   const resolvedActorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
   let children = state.children;
   if (resolvedActorRef) {
@@ -161,22 +156,28 @@ function resolveStop(_, state, args, {
     children
   }), resolvedActorRef];
 }
-function executeStop(actorContext, actorRef) {
+function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
   }
+
+  // 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
+  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);
   });
 }
 /**
@@ -185,7 +186,7 @@ function executeStop(actorContext, actorRef) {
  * @param actorRef The actor to stop.
  */
 function stop(actorRef) {
-  function stop(_) {
+  function stop(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -207,7 +208,7 @@ function checkStateIn(state, _, {
   return state.matches(stateValue);
 }
 function stateIn(stateValue) {
-  function stateIn(_) {
+  function stateIn(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -225,7 +226,7 @@ function checkNot(state, {
   return !evaluateGuard(guards[0], context, event, state);
 }
 function not(guard) {
-  function not(_) {
+  function not(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -243,7 +244,7 @@ function checkAnd(state, {
   return guards.every(guard => evaluateGuard(guard, context, event, state));
 }
 function and(guards) {
-  function and(_) {
+  function and(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -261,7 +262,7 @@ function checkOr(state, {
   return guards.some(guard => evaluateGuard(guard, context, event, state));
 }
 function or(guards) {
-  function or(_) {
+  function or(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -286,22 +287,17 @@ function evaluateGuard(guard, context, event, state) {
   }
   const guardArgs = {
     context,
-    event,
-    guard: isInline ? undefined : typeof guard === 'string' ? {
-      type: guard
-    } : typeof guard.params === 'function' ? {
-      type: guard.type,
-      params: guard.params({
-        context,
-        event
-      })
-    } : guard
+    event
   };
+  const guardParams = isInline || typeof guard === 'string' ? undefined : 'params' in guard ? typeof guard.params === 'function' ? guard.params({
+    context,
+    event
+  }) : guard.params : undefined;
   if (!('check' in resolved)) {
     // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
     // inline guards expect `TExpressionGuard` to be set to `undefined`
     // it's fine to cast this here, our logic makes sure that we call those 2 "variants" correctly
-    return resolved(guardArgs);
+    return resolved(guardArgs, guardParams);
   }
   const builtinGuard = resolved;
   return builtinGuard.check(state, guardArgs, resolved // this holds all params
@@ -766,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);
@@ -814,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) {
@@ -856,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();
@@ -890,13 +881,8 @@ function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
 
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
- *
- * @private
- * @param transitions
- * @param currentState
- * @param mutConfiguration
  */
-function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
+function microstep(transitions, currentState, actorScope, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentState;
   }
@@ -907,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)) {
@@ -933,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,19 +947,22 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
     // Add entry actions
     actions.push(...stateNodeToEnter.entry);
     for (const invokeDef of stateNodeToEnter.invoke) {
-      actions.push(invoke(invokeDef));
+      actions.push(spawn(invokeDef.src, {
+        ...invokeDef,
+        syncSnapshot: !!invokeDef.onSnapshot
+      }));
     }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
       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);
@@ -986,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)
       });
     }
   }
@@ -1011,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);
     }
   }
 }
@@ -1024,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);
@@ -1036,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 {
@@ -1047,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))) {
@@ -1063,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))) {
@@ -1077,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);
@@ -1101,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;
@@ -1124,32 +1121,25 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
     const actionArgs = {
       context: intermediateState.context,
       event,
-      self: actorCtx?.self,
-      system: actorCtx?.system,
-      action: isInline ? undefined : typeof action === 'string' ? {
-        type: action
-      } : typeof action.params === 'function' ? {
-        type: action.type,
-        params: action.params({
-          context: intermediateState.context,
-          event
-        })
-      } :
-      // TS isn't able to narrow it down here
-      action
+      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) {
-        resolvedAction(actionArgs);
+      if (actorScope?.self.status === interpreter.ActorStatus.Running) {
+        resolvedAction(actionArgs, actionParams);
       } else {
-        actorCtx?.defer(() => {
-          resolvedAction(actionArgs);
+        actorScope?.defer(() => {
+          resolvedAction(actionArgs, actionParams);
         });
       }
       continue;
     }
     const builtinAction = resolvedAction;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    const [nextState, params, actions] = builtinAction.resolve(actorScope, intermediateState, actionArgs, actionParams, resolvedAction,
     // this holds all params
     extra);
     intermediateState = nextState;
@@ -1157,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}')`);
   }
@@ -1189,7 +1179,9 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
 
   // Handle stop event
   if (event.type === interpreter.XSTATE_STOP) {
-    nextState = stopChildren(nextState, event, actorCtx);
+    nextState = cloneState(stopChildren(nextState, event, actorScope), {
+      status: 'stopped'
+    });
     states.push(nextState);
     return {
       state: nextState,
@@ -1202,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;
@@ -1219,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);
@@ -1452,17 +1444,17 @@ function getPersistedState(state) {
       throw new Error('An inline child actor cannot be persisted.');
     }
     childrenJson[id] = {
-      state: child.getPersistedState?.(),
-      src: child.src
+      state: child.getPersistedState(),
+      src: child.src,
+      systemId: child._systemId
     };
   }
-  return {
+  const persisted = {
     ...jsonValues,
-    // TODO: this makes `PersistedMachineState`'s type kind of a lie
-    // it doesn't truly use `TContext` but rather some kind of a derived form of it
     context: persistContext(context),
     children: childrenJson
   };
+  return persisted;
 }
 function persistContext(contextPart) {
   let copy;
@@ -1491,7 +1483,7 @@ function persistContext(contextPart) {
   return copy ?? contextPart;
 }
 
-function resolveRaise(_, state, args, {
+function resolveRaise(_, state, args, actionParams, {
   event: eventOrExpr,
   id,
   delay
@@ -1502,13 +1494,13 @@ function resolveRaise(_, state, args, {
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
   }
-  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr;
+  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args, actionParams) : eventOrExpr;
   let resolvedDelay;
   if (typeof delay === 'string') {
     const configDelay = delaysMap && delaysMap[delay];
-    resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
+    resolvedDelay = typeof configDelay === 'function' ? configDelay(args, actionParams) : configDelay;
   } else {
-    resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
+    resolvedDelay = typeof delay === 'function' ? delay(args, actionParams) : delay;
   }
   if (typeof resolvedDelay !== 'number') {
     internalQueue.push(resolvedEvent);
@@ -1519,9 +1511,9 @@ function resolveRaise(_, state, args, {
     delay: resolvedDelay
   }];
 }
-function executeRaise(actorContext, params) {
+function executeRaise(actorScope, params) {
   if (typeof params.delay === 'number') {
-    actorContext.self.delaySend(params);
+    actorScope.self.delaySend(params);
     return;
   }
 }
@@ -1532,7 +1524,7 @@ function executeRaise(actorContext, params) {
  * @param eventType The event to raise.
  */
 function raise(eventOrExpr, options) {
-  function raise(_) {
+  function raise(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -1572,6 +1564,7 @@ exports.or = or;
 exports.raise = raise;
 exports.resolveActionsAndContext = resolveActionsAndContext;
 exports.resolveStateValue = resolveStateValue;
+exports.spawn = spawn;
 exports.stateIn = stateIn;
 exports.stop = stop;
 exports.transitionNode = transitionNode;