xstate 5.0.0-beta.33 → 5.0.0-beta.34

package/dist/{raise-2d92eae8.esm.js → raise-b5cfe1bb.esm.js}

@@ -1,4 +1,4 @@
-import { r as resolveReferencedActor, d as createActor, f as ActorStatus, k as createErrorActorEvent, l as toStateValue, n as STATE_IDENTIFIER, o as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, q as toStatePath, s as createDoneStateEvent, u as resolveOutput, j as XSTATE_STOP, X as XSTATE_INIT, W as WILDCARD, v as isArray, w as createAfterEvent, x as flatten, e as matchesState } from './interpreter-03737810.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, X as XSTATE_STOP, u as XSTATE_INIT, W as WILDCARD, v as isArray, w as createAfterEvent, x as flatten, e as matchesState } from './interpreter-83f7f2d4.esm.js';
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -885,31 +885,33 @@ function microstep(transitions, currentState, actorCtx, event, isInitial) {
 }
 
 function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const actions = [];
   const historyValue = {
     ...currentState.historyValue
   };
   const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
   const internalQueue = [...currentState._internalQueue];
+  // TODO: this `cloneState` is really just a hack to prevent infinite loops
+  // we need to take another look at how internal queue is managed
+  let nextState = cloneState(currentState, {
+    _internalQueue: []
+  });
 
   // Exit states
   if (!isInitial) {
-    exitStates(filteredTransitions, mutConfiguration, historyValue, actions);
+    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
   }
 
   // Execute transition content
-  actions.push(...filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
 
   // Enter states
-  enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorCtx);
+  nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
   const done = isInFinalState(nextConfiguration);
   if (done) {
-    const finalActions = nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit);
-    actions.push(...finalActions);
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit));
   }
   try {
-    const nextState = resolveActionsAndContext(actions, event, currentState, actorCtx);
     const output = done ? getOutput(nextConfiguration, nextState.context, event, actorCtx.self) : undefined;
     internalQueue.push(...nextState._internalQueue);
     return cloneState(currentState, {
@@ -927,7 +929,8 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
     throw e;
   }
 }
-function enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorContext) {
+function enterStates(currentState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
+  let nextState = currentState;
   const statesToEnter = new Set();
   const statesForDefaultEntry = new Set();
   computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
@@ -938,24 +941,26 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
   }
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
     mutConfiguration.add(stateNodeToEnter);
-    for (const invokeDef of stateNodeToEnter.invoke) {
-      actions.push(invoke(invokeDef));
-    }
+    const actions = [];
 
     // Add entry actions
     actions.push(...stateNodeToEnter.entry);
+    for (const invokeDef of stateNodeToEnter.invoke) {
+      actions.push(invoke(invokeDef));
+    }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
       for (const stateNode of statesForDefaultEntry) {
         const initialActions = stateNode.initial.actions;
         actions.push(...initialActions);
       }
     }
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
       if (!parent.parent) {
         continue;
       }
-      internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
+      internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
       if (parent.parent) {
         const grandparent = parent.parent;
         if (grandparent.type === 'parallel') {
@@ -966,6 +971,7 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
       }
     }
   }
+  return nextState;
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
@@ -1039,7 +1045,8 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(transitions, mutConfiguration, historyValue, actions) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+  let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
 
@@ -1058,19 +1065,16 @@ function exitStates(transitions, mutConfiguration, historyValue, actions) {
     }
   }
   for (const s of statesToExit) {
-    actions.push(...s.exit, ...s.invoke.map(def => stop(def.id)));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
     mutConfiguration.delete(s);
   }
+  return nextState;
 }
-function resolveActionsAndContext(actions, event, currentState, actorCtx) {
+function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
     machine
   } = currentState;
-  // TODO: this `cloneState` is really just a hack to prevent infinite loops
-  // we need to take another look at how internal queue is managed
-  let intermediateState = cloneState(currentState, {
-    _internalQueue: []
-  });
+  let intermediateState = currentState;
   for (const action of actions) {
     const isInline = typeof action === 'function';
     const resolvedAction = isInline ? action :
@@ -1109,11 +1113,14 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       continue;
     }
     const builtinAction = resolvedAction;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction // this holds all params
-    );
-
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    // this holds all params
+    extra);
     intermediateState = nextState;
-    if ('execute' in resolvedAction) {
+    if ('retryResolve' in builtinAction) {
+      retries?.push([builtinAction, params]);
+    }
+    if ('execute' in builtinAction) {
       if (actorCtx?.self.status === ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
@@ -1121,11 +1128,21 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       }
     }
     if (actions) {
-      intermediateState = resolveActionsAndContext(actions, event, intermediateState, actorCtx);
+      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorCtx, actions, extra, retries);
     }
   }
   return intermediateState;
 }
+function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+  const retries = deferredActorIds ? [] : undefined;
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+    deferredActorIds
+  }, retries);
+  retries?.forEach(([builtinAction, params]) => {
+    builtinAction.retryResolve(actorCtx, nextState, params);
+  });
+  return nextState;
+}
 function macrostep(state, event, actorCtx) {
   let nextState = state;
   const states = [];
@@ -1182,7 +1199,7 @@ function stopStep(event, nextState, actorCtx) {
   for (const child of Object.values(nextState.children)) {
     actions.push(stop(child));
   }
-  return resolveActionsAndContext(actions, event, nextState, actorCtx);
+  return resolveActionsAndContext(nextState, event, actorCtx, actions);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);

package/dist/{send-0edee2b4.esm.js → send-0b5eda0c.esm.js}

@@ -1,5 +1,5 @@
-import { j as cloneState, e as evaluateGuard } from './raise-2d92eae8.esm.js';
-import { f as ActorStatus, k as createErrorActorEvent, r as resolveReferencedActor, d as createActor, t as toArray, y as XSTATE_ERROR } from './interpreter-03737810.esm.js';
+import { j as cloneState, e as evaluateGuard } from './raise-b5cfe1bb.esm.js';
+import { f as ActorStatus, j as createErrorActorEvent, r as resolveReferencedActor, d as createActor, t as toArray, y as XSTATE_ERROR } from './interpreter-83f7f2d4.esm.js';
 
 function createSpawner(actorContext, {
   machine,
@@ -256,7 +256,7 @@ function resolveSendTo(actorContext, state, args, {
   event: eventOrExpr,
   id,
   delay
-}) {
+}, extra) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
@@ -281,7 +281,7 @@ function resolveSendTo(actorContext, state, args, {
       // #_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.
       targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      targetActorRef = state.children[resolvedTarget];
+      targetActorRef = extra?.deferredActorIds.includes(resolvedTarget) ? resolvedTarget : state.children[resolvedTarget];
     }
     if (!targetActorRef) {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
@@ -296,16 +296,21 @@ function resolveSendTo(actorContext, state, args, {
     delay: resolvedDelay
   }];
 }
+function retryResolveSendTo(_, state, params) {
+  if (typeof params.to === 'string') {
+    params.to = state.children[params.to];
+  }
+}
 function executeSendTo(actorContext, params) {
   if (typeof params.delay === 'number') {
     actorContext.self.delaySend(params);
     return;
   }
-  const {
-    to,
-    event
-  } = params;
   actorContext.defer(() => {
+    const {
+      to,
+      event
+    } = params;
     actorContext?.system._relay(actorContext.self, to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorContext.self.id, event.data) : event);
   });
 }
@@ -327,6 +332,7 @@ function sendTo(to, eventOrExpr, options) {
   sendTo.id = options?.id;
   sendTo.delay = options?.delay;
   sendTo.resolve = resolveSendTo;
+  sendTo.retryResolve = retryResolveSendTo;
   sendTo.execute = executeSendTo;
   return sendTo;
 }

package/dist/{send-0e8675c8.development.cjs.js → send-3764c866.development.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-4c6a5a96.development.cjs.js');
-var interpreter = require('./interpreter-0c630f66.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-38b707c0.development.cjs.js');
+var interpreter = require('./interpreter-70ed62f2.development.cjs.js');
 
 function createSpawner(actorContext, {
   machine,
@@ -270,7 +270,7 @@ function resolveSendTo(actorContext, state, args, {
   event: eventOrExpr,
   id,
   delay
-}) {
+}, extra) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
@@ -295,7 +295,7 @@ function resolveSendTo(actorContext, state, args, {
       // #_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.
       targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      targetActorRef = state.children[resolvedTarget];
+      targetActorRef = extra?.deferredActorIds.includes(resolvedTarget) ? resolvedTarget : state.children[resolvedTarget];
     }
     if (!targetActorRef) {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
@@ -310,16 +310,21 @@ function resolveSendTo(actorContext, state, args, {
     delay: resolvedDelay
   }];
 }
+function retryResolveSendTo(_, state, params) {
+  if (typeof params.to === 'string') {
+    params.to = state.children[params.to];
+  }
+}
 function executeSendTo(actorContext, params) {
   if (typeof params.delay === 'number') {
     actorContext.self.delaySend(params);
     return;
   }
-  const {
-    to,
-    event
-  } = params;
   actorContext.defer(() => {
+    const {
+      to,
+      event
+    } = params;
     actorContext?.system._relay(actorContext.self, to, event.type === interpreter.XSTATE_ERROR ? interpreter.createErrorActorEvent(actorContext.self.id, event.data) : event);
   });
 }
@@ -344,6 +349,7 @@ function sendTo(to, eventOrExpr, options) {
   sendTo.id = options?.id;
   sendTo.delay = options?.delay;
   sendTo.resolve = resolveSendTo;
+  sendTo.retryResolve = retryResolveSendTo;
   sendTo.execute = executeSendTo;
   return sendTo;
 }

package/dist/{send-4d5b92dc.development.esm.js → send-9526366e.development.esm.js}

@@ -1,5 +1,5 @@
-import { j as cloneState, e as evaluateGuard } from './raise-46f122aa.development.esm.js';
-import { f as ActorStatus, k as createErrorActorEvent, r as resolveReferencedActor, d as createActor, t as toArray, y as XSTATE_ERROR } from './interpreter-825f3d6e.development.esm.js';
+import { j as cloneState, e as evaluateGuard } from './raise-05f8b2a6.development.esm.js';
+import { f as ActorStatus, j as createErrorActorEvent, r as resolveReferencedActor, d as createActor, t as toArray, y as XSTATE_ERROR } from './interpreter-dee56dc8.development.esm.js';
 
 function createSpawner(actorContext, {
   machine,
@@ -268,7 +268,7 @@ function resolveSendTo(actorContext, state, args, {
   event: eventOrExpr,
   id,
   delay
-}) {
+}, extra) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
@@ -293,7 +293,7 @@ function resolveSendTo(actorContext, state, args, {
       // #_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.
       targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      targetActorRef = state.children[resolvedTarget];
+      targetActorRef = extra?.deferredActorIds.includes(resolvedTarget) ? resolvedTarget : state.children[resolvedTarget];
     }
     if (!targetActorRef) {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
@@ -308,16 +308,21 @@ function resolveSendTo(actorContext, state, args, {
     delay: resolvedDelay
   }];
 }
+function retryResolveSendTo(_, state, params) {
+  if (typeof params.to === 'string') {
+    params.to = state.children[params.to];
+  }
+}
 function executeSendTo(actorContext, params) {
   if (typeof params.delay === 'number') {
     actorContext.self.delaySend(params);
     return;
   }
-  const {
-    to,
-    event
-  } = params;
   actorContext.defer(() => {
+    const {
+      to,
+      event
+    } = params;
     actorContext?.system._relay(actorContext.self, to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorContext.self.id, event.data) : event);
   });
 }
@@ -342,6 +347,7 @@ function sendTo(to, eventOrExpr, options) {
   sendTo.id = options?.id;
   sendTo.delay = options?.delay;
   sendTo.resolve = resolveSendTo;
+  sendTo.retryResolve = retryResolveSendTo;
   sendTo.execute = executeSendTo;
   return sendTo;
 }

package/dist/{send-bd1bd0e3.cjs.js → send-fe94de2b.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-987c242e.cjs.js');
-var interpreter = require('./interpreter-054e9fb7.cjs.js');
+var guards_dist_xstateGuards = require('./raise-1dd65455.cjs.js');
+var interpreter = require('./interpreter-1301970f.cjs.js');
 
 function createSpawner(actorContext, {
   machine,
@@ -258,7 +258,7 @@ function resolveSendTo(actorContext, state, args, {
   event: eventOrExpr,
   id,
   delay
-}) {
+}, extra) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
@@ -283,7 +283,7 @@ function resolveSendTo(actorContext, state, args, {
       // #_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.
       targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      targetActorRef = state.children[resolvedTarget];
+      targetActorRef = extra?.deferredActorIds.includes(resolvedTarget) ? resolvedTarget : state.children[resolvedTarget];
     }
     if (!targetActorRef) {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
@@ -298,16 +298,21 @@ function resolveSendTo(actorContext, state, args, {
     delay: resolvedDelay
   }];
 }
+function retryResolveSendTo(_, state, params) {
+  if (typeof params.to === 'string') {
+    params.to = state.children[params.to];
+  }
+}
 function executeSendTo(actorContext, params) {
   if (typeof params.delay === 'number') {
     actorContext.self.delaySend(params);
     return;
   }
-  const {
-    to,
-    event
-  } = params;
   actorContext.defer(() => {
+    const {
+      to,
+      event
+    } = params;
     actorContext?.system._relay(actorContext.self, to, event.type === interpreter.XSTATE_ERROR ? interpreter.createErrorActorEvent(actorContext.self.id, event.data) : event);
   });
 }
@@ -329,6 +334,7 @@ function sendTo(to, eventOrExpr, options) {
   sendTo.id = options?.id;
   sendTo.delay = options?.delay;
   sendTo.resolve = resolveSendTo;
+  sendTo.retryResolve = retryResolveSendTo;
   sendTo.execute = executeSendTo;
   return sendTo;
 }

package/dist/xstate.cjs.js

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.cjs.js');
-var interpreter = require('./interpreter-054e9fb7.cjs.js');
-var guards_dist_xstateGuards = require('./raise-987c242e.cjs.js');
-var send = require('./send-bd1bd0e3.cjs.js');
+var interpreter = require('./interpreter-1301970f.cjs.js');
+var guards_dist_xstateGuards = require('./raise-1dd65455.cjs.js');
+var send = require('./send-fe94de2b.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 class SimulatedClock {
@@ -539,7 +539,7 @@ class StateMachine {
         spawn,
         input: event.input
       });
-      return guards_dist_xstateGuards.resolveActionsAndContext([send.assign(assignment)], initEvent, preInitial, actorCtx);
+      return guards_dist_xstateGuards.resolveActionsAndContext(preInitial, initEvent, actorCtx, [send.assign(assignment)]);
     }
     return preInitial;
   }
@@ -567,7 +567,7 @@ class StateMachine {
   start(state) {
     Object.values(state.children).forEach(child => {
       if (child.status === 0) {
-        child.start?.();
+        child.start();
       }
     });
   }

package/dist/xstate.development.cjs.js

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.development.cjs.js');
-var interpreter = require('./interpreter-0c630f66.development.cjs.js');
-var guards_dist_xstateGuards = require('./raise-4c6a5a96.development.cjs.js');
-var send = require('./send-0e8675c8.development.cjs.js');
+var interpreter = require('./interpreter-70ed62f2.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-38b707c0.development.cjs.js');
+var send = require('./send-3764c866.development.cjs.js');
 require('../dev/dist/xstate-dev.development.cjs.js');
 
 class SimulatedClock {
@@ -542,7 +542,7 @@ class StateMachine {
         spawn,
         input: event.input
       });
-      return guards_dist_xstateGuards.resolveActionsAndContext([send.assign(assignment)], initEvent, preInitial, actorCtx);
+      return guards_dist_xstateGuards.resolveActionsAndContext(preInitial, initEvent, actorCtx, [send.assign(assignment)]);
     }
     return preInitial;
   }
@@ -570,7 +570,7 @@ class StateMachine {
   start(state) {
     Object.values(state.children).forEach(child => {
       if (child.status === 0) {
-        child.start?.();
+        child.start();
       }
     });
   }

package/dist/xstate.development.esm.js

@@ -1,10 +1,10 @@
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.development.esm.js';
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, a as toTransitionConfigArray, N as NULL_EVENT, c as createInvokeId, i as isErrorActorEvent, b as createInitEvent, r as resolveReferencedActor, d as createActor, e as matchesState } from './interpreter-825f3d6e.development.esm.js';
-export { A as Actor, f as ActorStatus, I as InterpreterStatus, d as createActor, g as interpret, e as matchesState, p as pathToStateValue, h as toObserver } from './interpreter-825f3d6e.development.esm.js';
-import { f as formatTransitions, a as formatTransition, m as memo, e as evaluateGuard, g as getDelayedTransitions, b as formatInitialTransition, c as getCandidates, d as getConfiguration, h as getStateNodes, r as resolveStateValue, i as isInFinalState, S as State, j as cloneState, k as macrostep, t as transitionNode, l as getInitialConfiguration, n as resolveActionsAndContext, o as microstep, p as isAtomicStateNode, q as isStateId, s as getStateNodeByPath, u as getPersistedState } from './raise-46f122aa.development.esm.js';
-export { S as State, v as and, z as cancel, h as getStateNodes, w as not, x as or, A as raise, y as stateIn, B as stop } from './raise-46f122aa.development.esm.js';
-import { a as assign } from './send-4d5b92dc.development.esm.js';
-export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-4d5b92dc.development.esm.js';
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, a as toTransitionConfigArray, N as NULL_EVENT, c as createInvokeId, i as isErrorActorEvent, b as createInitEvent, r as resolveReferencedActor, d as createActor, e as matchesState } from './interpreter-dee56dc8.development.esm.js';
+export { A as Actor, f as ActorStatus, I as InterpreterStatus, d as createActor, g as interpret, e as matchesState, p as pathToStateValue, h as toObserver } from './interpreter-dee56dc8.development.esm.js';
+import { f as formatTransitions, a as formatTransition, m as memo, e as evaluateGuard, g as getDelayedTransitions, b as formatInitialTransition, c as getCandidates, d as getConfiguration, h as getStateNodes, r as resolveStateValue, i as isInFinalState, S as State, j as cloneState, k as macrostep, t as transitionNode, l as getInitialConfiguration, n as resolveActionsAndContext, o as microstep, p as isAtomicStateNode, q as isStateId, s as getStateNodeByPath, u as getPersistedState } from './raise-05f8b2a6.development.esm.js';
+export { S as State, v as and, z as cancel, h as getStateNodes, w as not, x as or, A as raise, y as stateIn, B as stop } from './raise-05f8b2a6.development.esm.js';
+import { a as assign } from './send-9526366e.development.esm.js';
+export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-9526366e.development.esm.js';
 import '../dev/dist/xstate-dev.development.esm.js';
 
 class SimulatedClock {
@@ -541,7 +541,7 @@ class StateMachine {
         spawn,
         input: event.input
       });
-      return resolveActionsAndContext([assign(assignment)], initEvent, preInitial, actorCtx);
+      return resolveActionsAndContext(preInitial, initEvent, actorCtx, [assign(assignment)]);
     }
     return preInitial;
   }
@@ -569,7 +569,7 @@ class StateMachine {
   start(state) {
     Object.values(state.children).forEach(child => {
       if (child.status === 0) {
-        child.start?.();
+        child.start();
       }
     });
   }

package/dist/xstate.esm.js

@@ -1,10 +1,10 @@
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.esm.js';
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, a as toTransitionConfigArray, N as NULL_EVENT, c as createInvokeId, i as isErrorActorEvent, b as createInitEvent, r as resolveReferencedActor, d as createActor, e as matchesState } from './interpreter-03737810.esm.js';
-export { A as Actor, f as ActorStatus, I as InterpreterStatus, d as createActor, g as interpret, e as matchesState, p as pathToStateValue, h as toObserver } from './interpreter-03737810.esm.js';
-import { f as formatTransitions, a as formatTransition, m as memo, e as evaluateGuard, g as getDelayedTransitions, b as formatInitialTransition, c as getCandidates, d as getConfiguration, h as getStateNodes, r as resolveStateValue, i as isInFinalState, S as State, j as cloneState, k as macrostep, t as transitionNode, l as getInitialConfiguration, n as resolveActionsAndContext, o as microstep, p as isAtomicStateNode, q as isStateId, s as getStateNodeByPath, u as getPersistedState } from './raise-2d92eae8.esm.js';
-export { S as State, v as and, z as cancel, h as getStateNodes, w as not, x as or, A as raise, y as stateIn, B as stop } from './raise-2d92eae8.esm.js';
-import { a as assign } from './send-0edee2b4.esm.js';
-export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-0edee2b4.esm.js';
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, a as toTransitionConfigArray, N as NULL_EVENT, c as createInvokeId, i as isErrorActorEvent, b as createInitEvent, r as resolveReferencedActor, d as createActor, e as matchesState } from './interpreter-83f7f2d4.esm.js';
+export { A as Actor, f as ActorStatus, I as InterpreterStatus, d as createActor, g as interpret, e as matchesState, p as pathToStateValue, h as toObserver } from './interpreter-83f7f2d4.esm.js';
+import { f as formatTransitions, a as formatTransition, m as memo, e as evaluateGuard, g as getDelayedTransitions, b as formatInitialTransition, c as getCandidates, d as getConfiguration, h as getStateNodes, r as resolveStateValue, i as isInFinalState, S as State, j as cloneState, k as macrostep, t as transitionNode, l as getInitialConfiguration, n as resolveActionsAndContext, o as microstep, p as isAtomicStateNode, q as isStateId, s as getStateNodeByPath, u as getPersistedState } from './raise-b5cfe1bb.esm.js';
+export { S as State, v as and, z as cancel, h as getStateNodes, w as not, x as or, A as raise, y as stateIn, B as stop } from './raise-b5cfe1bb.esm.js';
+import { a as assign } from './send-0b5eda0c.esm.js';
+export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-0b5eda0c.esm.js';
 import '../dev/dist/xstate-dev.esm.js';
 
 class SimulatedClock {
@@ -538,7 +538,7 @@ class StateMachine {
         spawn,
         input: event.input
       });
-      return resolveActionsAndContext([assign(assignment)], initEvent, preInitial, actorCtx);
+      return resolveActionsAndContext(preInitial, initEvent, actorCtx, [assign(assignment)]);
     }
     return preInitial;
   }
@@ -566,7 +566,7 @@ class StateMachine {
   start(state) {
     Object.values(state.children).forEach(child => {
       if (child.status === 0) {
-        child.start?.();
+        child.start();
       }
     });
   }