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

package/dist/{interpreter-03737810.esm.js → interpreter-83f7f2d4.esm.js}

@@ -557,7 +557,7 @@ class Actor {
     const status = this._state.status;
     switch (status) {
       case 'done':
-        // a state machine can be "done" upon intialization (it could reach a final state using initial microsteps)
+        // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
         // we still need to complete observers, flush deferreds etc
         this.update(this._state, initEvent);
       // fallthrough
@@ -712,14 +712,14 @@ class Actor {
   }
 
   // TODO: make private (and figure out a way to do this within the machine)
-  delaySend({
-    event,
-    id,
-    delay,
-    to
-  }) {
+  delaySend(params) {
+    const {
+      event,
+      id,
+      delay
+    } = params;
     const timerId = this.clock.setTimeout(() => {
-      this.system._relay(this, to ?? this, event);
+      this.system._relay(this, params.to ?? this, event);
     }, delay);
 
     // TODO: consider the rehydration story here
@@ -781,4 +781,4 @@ const interpret = createActor;
  * @deprecated Use `Actor` instead.
  */
 
-export { Actor as A, InterpreterStatus as I, NULL_EVENT as N, STATE_DELIMITER as S, WILDCARD as W, XSTATE_INIT as X, toTransitionConfigArray as a, createInitEvent as b, createInvokeId as c, createActor as d, matchesState as e, ActorStatus as f, interpret as g, toObserver as h, isErrorActorEvent as i, XSTATE_STOP as j, createErrorActorEvent as k, toStateValue as l, mapValues as m, STATE_IDENTIFIER as n, normalizeTarget as o, pathToStateValue as p, toStatePath as q, resolveReferencedActor as r, createDoneStateEvent as s, toArray as t, resolveOutput as u, isArray as v, createAfterEvent as w, flatten as x, XSTATE_ERROR as y };
+export { Actor as A, InterpreterStatus as I, NULL_EVENT as N, STATE_DELIMITER as S, WILDCARD as W, XSTATE_STOP as X, toTransitionConfigArray as a, createInitEvent as b, createInvokeId as c, createActor as d, matchesState as e, ActorStatus as f, interpret as g, toObserver as h, isErrorActorEvent as i, createErrorActorEvent as j, toStateValue as k, STATE_IDENTIFIER as l, mapValues as m, normalizeTarget as n, toStatePath as o, pathToStateValue as p, createDoneStateEvent as q, resolveReferencedActor as r, resolveOutput as s, toArray as t, XSTATE_INIT as u, isArray as v, createAfterEvent as w, flatten as x, XSTATE_ERROR as y };

package/dist/{interpreter-825f3d6e.development.esm.js → interpreter-dee56dc8.development.esm.js}

@@ -560,7 +560,7 @@ class Actor {
     const status = this._state.status;
     switch (status) {
       case 'done':
-        // a state machine can be "done" upon intialization (it could reach a final state using initial microsteps)
+        // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
         // we still need to complete observers, flush deferreds etc
         this.update(this._state, initEvent);
       // fallthrough
@@ -723,14 +723,14 @@ class Actor {
   }
 
   // TODO: make private (and figure out a way to do this within the machine)
-  delaySend({
-    event,
-    id,
-    delay,
-    to
-  }) {
+  delaySend(params) {
+    const {
+      event,
+      id,
+      delay
+    } = params;
     const timerId = this.clock.setTimeout(() => {
-      this.system._relay(this, to ?? this, event);
+      this.system._relay(this, params.to ?? this, event);
     }, delay);
 
     // TODO: consider the rehydration story here
@@ -792,4 +792,4 @@ const interpret = createActor;
  * @deprecated Use `Actor` instead.
  */
 
-export { Actor as A, InterpreterStatus as I, NULL_EVENT as N, STATE_DELIMITER as S, WILDCARD as W, XSTATE_INIT as X, toTransitionConfigArray as a, createInitEvent as b, createInvokeId as c, createActor as d, matchesState as e, ActorStatus as f, interpret as g, toObserver as h, isErrorActorEvent as i, XSTATE_STOP as j, createErrorActorEvent as k, toStateValue as l, mapValues as m, STATE_IDENTIFIER as n, normalizeTarget as o, pathToStateValue as p, toStatePath as q, resolveReferencedActor as r, createDoneStateEvent as s, toArray as t, resolveOutput as u, isArray as v, createAfterEvent as w, flatten as x, XSTATE_ERROR as y };
+export { Actor as A, InterpreterStatus as I, NULL_EVENT as N, STATE_DELIMITER as S, WILDCARD as W, XSTATE_STOP as X, toTransitionConfigArray as a, createInitEvent as b, createInvokeId as c, createActor as d, matchesState as e, ActorStatus as f, interpret as g, toObserver as h, isErrorActorEvent as i, createErrorActorEvent as j, toStateValue as k, STATE_IDENTIFIER as l, mapValues as m, normalizeTarget as n, toStatePath as o, pathToStateValue as p, createDoneStateEvent as q, resolveReferencedActor as r, resolveOutput as s, toArray as t, XSTATE_INIT as u, isArray as v, createAfterEvent as w, flatten as x, XSTATE_ERROR as y };

package/dist/{raise-46f122aa.development.esm.js → raise-05f8b2a6.development.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, W as WILDCARD, j as XSTATE_STOP, X as XSTATE_INIT, v as isArray, w as createAfterEvent, x as flatten, e as matchesState } from './interpreter-825f3d6e.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 isArray, w as createAfterEvent, x as flatten, e as matchesState } from './interpreter-dee56dc8.development.esm.js';
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -916,31 +916,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, {
@@ -958,7 +960,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);
@@ -969,24 +972,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') {
@@ -997,6 +1002,7 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
       }
     }
   }
+  return nextState;
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
@@ -1070,7 +1076,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);
 
@@ -1089,19 +1096,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 :
@@ -1140,11 +1144,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 {
@@ -1152,11 +1159,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) {
   if (event.type === WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
@@ -1216,7 +1233,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/{raise-987c242e.cjs.js → raise-1dd65455.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-054e9fb7.cjs.js');
+var interpreter = require('./interpreter-1301970f.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -887,31 +887,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, {
@@ -929,7 +931,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);
@@ -940,24 +943,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(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
+      internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
       if (parent.parent) {
         const grandparent = parent.parent;
         if (grandparent.type === 'parallel') {
@@ -968,6 +973,7 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
       }
     }
   }
+  return nextState;
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
@@ -1041,7 +1047,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);
 
@@ -1060,19 +1067,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 :
@@ -1111,11 +1115,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 === interpreter.ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
@@ -1123,11 +1130,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 = [];
@@ -1184,7 +1201,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/{raise-4c6a5a96.development.cjs.js → raise-38b707c0.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-0c630f66.development.cjs.js');
+var interpreter = require('./interpreter-70ed62f2.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -918,31 +918,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, {
@@ -960,7 +962,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);
@@ -971,24 +974,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(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
+      internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
       if (parent.parent) {
         const grandparent = parent.parent;
         if (grandparent.type === 'parallel') {
@@ -999,6 +1004,7 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
       }
     }
   }
+  return nextState;
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
@@ -1072,7 +1078,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);
 
@@ -1091,19 +1098,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 :
@@ -1142,11 +1146,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 === interpreter.ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
@@ -1154,11 +1161,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) {
   if (event.type === interpreter.WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${interpreter.WILDCARD}')`);
@@ -1218,7 +1235,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);