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

package/dist/{raise-e342a840.development.esm.js → raise-e044f460.development.esm.js}

@@ -1,4 +1,4 @@
-import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, W as WILDCARD, X as XSTATE_STOP, u as XSTATE_INIT, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-1c52b23c.development.esm.js';
+import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, W as WILDCARD, X as XSTATE_STOP, u as XSTATE_INIT, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-70cd9217.development.esm.js';
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -14,14 +14,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
@@ -31,7 +31,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`);
     }
@@ -43,7 +43,7 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveInvoke(actorContext, state, actionArgs, {
+function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   id,
   systemId,
   src,
@@ -54,99 +54,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 = 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 === ActorStatus.Stopped) {
       return;
     }
     try {
       actorRef.start?.();
     } catch (err) {
-      actorContext.self.send(createErrorActorEvent(id, err));
+      actorScope.self.send(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) {
@@ -159,22 +154,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 !== 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);
   });
 }
 /**
@@ -183,7 +184,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`);
     }
@@ -205,7 +206,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`);
     }
@@ -223,7 +224,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`);
     }
@@ -241,7 +242,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`);
     }
@@ -259,7 +260,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`);
     }
@@ -284,22 +285,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
@@ -764,15 +760,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);
@@ -812,17 +799,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) {
@@ -854,8 +837,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();
@@ -888,13 +879,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;
   }
@@ -905,17 +891,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)) {
@@ -931,14 +917,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 = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, state.context, event, actorCtx.self) : undefined);
-  return resolveOutput(rootNode.output, state.context, doneStateEvent, actorCtx.self);
+  const doneStateEvent = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, state.context, event, actorScope.self) : undefined);
+  return 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
@@ -959,19 +945,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(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
+        internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self) : undefined));
       }
       while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
         completedNodes.add(ancestorMarker);
@@ -984,7 +973,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)
       });
     }
   }
@@ -1009,7 +998,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);
     }
   }
 }
@@ -1022,7 +1015,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);
@@ -1034,7 +1027,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 {
@@ -1045,7 +1038,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))) {
@@ -1061,10 +1054,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))) {
@@ -1075,7 +1069,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);
@@ -1099,12 +1096,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;
@@ -1122,32 +1119,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 === ActorStatus.Running) {
-        resolvedAction(actionArgs);
+      if (actorScope?.self.status === 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;
@@ -1155,30 +1145,30 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
       retries?.push([builtinAction, params]);
     }
     if ('execute' in builtinAction) {
-      if (actorCtx?.self.status === ActorStatus.Running) {
-        builtinAction.execute(actorCtx, params);
+      if (actorScope?.self.status === 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 === WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
   }
@@ -1187,7 +1177,9 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
-    nextState = stopChildren(nextState, event, actorCtx);
+    nextState = cloneState(stopChildren(nextState, event, actorScope), {
+      status: 'stopped'
+    });
     states.push(nextState);
     return {
       state: nextState,
@@ -1200,7 +1192,7 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== 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;
@@ -1217,20 +1209,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);
@@ -1450,17 +1442,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;
@@ -1489,7 +1481,7 @@ function persistContext(contextPart) {
   return copy ?? contextPart;
 }
 
-function resolveRaise(_, state, args, {
+function resolveRaise(_, state, args, actionParams, {
   event: eventOrExpr,
   id,
   delay
@@ -1500,13 +1492,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);
@@ -1517,9 +1509,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;
   }
 }
@@ -1530,7 +1522,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`);
     }
@@ -1544,4 +1536,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { raise as A, stop as B, State as S, formatTransition as a, formatInitialTransition as b, getCandidates as c, getConfiguration as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getStateNodes as h, isInFinalState as i, cloneState as j, macrostep as k, getInitialConfiguration as l, memo as m, resolveActionsAndContext as n, microstep as o, getInitialStateNodes as p, isStateId as q, resolveStateValue as r, getStateNodeByPath as s, transitionNode as t, getPersistedState as u, and as v, not as w, or as x, stateIn as y, cancel as z };
+export { raise as A, stop as B, spawn as C, State as S, formatTransition as a, formatInitialTransition as b, getCandidates as c, getConfiguration as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getStateNodes as h, isInFinalState as i, cloneState as j, macrostep as k, getInitialConfiguration as l, memo as m, resolveActionsAndContext as n, microstep as o, getInitialStateNodes as p, isStateId as q, resolveStateValue as r, getStateNodeByPath as s, transitionNode as t, getPersistedState as u, and as v, not as w, or as x, stateIn as y, cancel as z };