xstate 5.0.0-beta.32 → 5.0.0-beta.34

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

@@ -147,13 +147,14 @@ function reportUnhandledError(err) {
 
 const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
 
-function createSystem() {
-  let sessionIdCounter = 0;
+let idCounter = 0;
+function createSystem(rootActor) {
   const children = new Map();
   const keyedActors = new Map();
   const reverseKeyedActors = new WeakMap();
+  const observers = new Set();
   const system = {
-    _bookId: () => `x:${sessionIdCounter++}`,
+    _bookId: () => `x:${idCounter++}`,
     _register: (sessionId, actorRef) => {
       children.set(sessionId, actorRef);
       return sessionId;
@@ -176,6 +177,25 @@ function createSystem() {
       }
       keyedActors.set(systemId, actorRef);
       reverseKeyedActors.set(actorRef, systemId);
+    },
+    inspect: observer => {
+      observers.add(observer);
+    },
+    _sendInspectionEvent: event => {
+      const resolvedInspectionEvent = {
+        ...event,
+        rootId: rootActor.sessionId
+      };
+      observers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+    },
+    _relay: (source, target, event) => {
+      system._sendInspectionEvent({
+        type: '@xstate.event',
+        sourceRef: source,
+        targetRef: target,
+        event
+      });
+      target._send(event);
     }
   };
   return system;
@@ -406,10 +426,14 @@ class Actor {
       logger,
       parent,
       id,
-      systemId
+      systemId,
+      inspect
     } = resolvedOptions;
-    const self = this;
-    this.system = parent?.system ?? createSystem();
+    this.system = parent?.system ?? createSystem(this);
+    if (inspect && !parent) {
+      // Always inspect at the system-level
+      this.system.inspect(toObserver(inspect));
+    }
     if (systemId) {
       this._systemId = systemId;
       this.system._set(systemId, this);
@@ -423,7 +447,7 @@ class Actor {
     this.src = resolvedOptions.src;
     this.ref = this;
     this._actorContext = {
-      self,
+      self: this,
       id: this.id,
       sessionId: this.sessionId,
       logger: this.logger,
@@ -442,6 +466,10 @@ class Actor {
     // Ensure that the send method is bound to this Actor instance
     // if destructured
     this.send = this.send.bind(this);
+    this.system._sendInspectionEvent({
+      type: '@xstate.actor',
+      actorRef: this
+    });
     this._initState();
   }
   _initState() {
@@ -450,7 +478,7 @@ class Actor {
 
   // array of functions to defer
 
-  update(snapshot) {
+  update(snapshot, event) {
     // Update state
     this._state = snapshot;
 
@@ -472,14 +500,24 @@ class Actor {
         this._stopProcedure();
         this._complete();
         this._doneEvent = createDoneActorEvent(this.id, this._state.output);
-        this._parent?.send(this._doneEvent);
+        if (this._parent) {
+          this.system._relay(this, this._parent, this._doneEvent);
+        }
         break;
       case 'error':
         this._stopProcedure();
         this._error(this._state.error);
-        this._parent?.send(createErrorActorEvent(this.id, this._state.error));
+        if (this._parent) {
+          this.system._relay(this, this._parent, createErrorActorEvent(this.id, this._state.error));
+        }
         break;
     }
+    this.system._sendInspectionEvent({
+      type: '@xstate.snapshot',
+      actorRef: this,
+      event,
+      snapshot
+    });
   }
   subscribe(nextListenerOrObserver, errorListener, completeListener) {
     const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
@@ -512,12 +550,19 @@ class Actor {
       this.system._set(this._systemId, this);
     }
     this.status = ActorStatus.Running;
+    const initEvent = createInitEvent(this.options.input);
+    this.system._sendInspectionEvent({
+      type: '@xstate.event',
+      sourceRef: this._parent,
+      targetRef: this,
+      event: initEvent
+    });
     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);
+        this.update(this._state, initEvent);
       // fallthrough
       case 'error':
         // TODO: rethink cleanup of observers, mailbox, etc
@@ -537,7 +582,7 @@ class Actor {
     // TODO: this notifies all subscribers but usually this is redundant
     // there is no real change happening here
     // we need to rethink if this needs to be refactored
-    this.update(this._state);
+    this.update(this._state, initEvent);
     if (this.options.devTools) {
       this.attachDevTools();
     }
@@ -565,7 +610,7 @@ class Actor {
       this._parent?.send(createErrorActorEvent(this.id, err));
       return;
     }
-    this.update(nextState);
+    this.update(nextState, event);
     if (event.type === XSTATE_STOP) {
       this._stopProcedure();
       this._complete();
@@ -651,14 +696,9 @@ class Actor {
   }
 
   /**
-   * Sends an event to the running Actor to trigger a transition.
-   *
-   * @param event The event to send
+   * @internal
    */
-  send(event) {
-    if (typeof event === 'string') {
-      throw new Error(`Only event objects may be sent to actors; use .send({ type: "${event}" }) instead`);
-    }
+  _send(event) {
     if (this.status === ActorStatus.Stopped) {
       // do nothing
       {
@@ -670,19 +710,27 @@ class Actor {
     this.mailbox.enqueue(event);
   }
 
+  /**
+   * Sends an event to the running Actor to trigger a transition.
+   *
+   * @param event The event to send
+   */
+  send(event) {
+    if (typeof event === 'string') {
+      throw new Error(`Only event objects may be sent to actors; use .send({ type: "${event}" }) instead`);
+    }
+    this.system._relay(undefined, this, event);
+  }
+
   // 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(() => {
-      if (to) {
-        to.send(event);
-      } else {
-        this.send(event);
-      }
+      this.system._relay(this, params.to ?? this, event);
     }, delay);
 
     // TODO: consider the rehydration story here
@@ -744,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-6fbd4513.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-e4d2487f.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,27 +1096,24 @@ 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 resolved = isInline ? action :
+    const resolvedAction = isInline ? action :
     // the existing type of `.actions` assumes non-nullable `TExpressionAction`
     // it's fine to cast this here to get a common type and lack of errors in the rest of the code
     // our logic below makes sure that we call those 2 "variants" correctly
     machine.implementations.actions[typeof action === 'string' ? action : action.type];
-    if (!resolved) {
+    if (!resolvedAction) {
       continue;
     }
     const actionArgs = {
@@ -1129,20 +1133,25 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       // TS isn't able to narrow it down here
       action
     };
-    if (!('resolve' in resolved)) {
+    if (!('resolve' in resolvedAction)) {
       if (actorCtx?.self.status === ActorStatus.Running) {
-        resolved(actionArgs);
+        resolvedAction(actionArgs);
       } else {
-        actorCtx?.defer(() => resolved(actionArgs));
+        actorCtx?.defer(() => {
+          resolvedAction(actionArgs);
+        });
       }
       continue;
     }
-    const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
-    );
-
+    const builtinAction = resolvedAction;
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    // this holds all params
+    extra);
     intermediateState = nextState;
-    if ('execute' in resolved) {
+    if ('retryResolve' in builtinAction) {
+      retries?.push([builtinAction, params]);
+    }
+    if ('execute' in builtinAction) {
       if (actorCtx?.self.status === ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
@@ -1150,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}')`);
@@ -1214,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-90808d65.cjs.js → raise-1dd65455.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-05e11c15.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,27 +1067,24 @@ 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 resolved = isInline ? action :
+    const resolvedAction = isInline ? action :
     // the existing type of `.actions` assumes non-nullable `TExpressionAction`
     // it's fine to cast this here to get a common type and lack of errors in the rest of the code
     // our logic below makes sure that we call those 2 "variants" correctly
     machine.implementations.actions[typeof action === 'string' ? action : action.type];
-    if (!resolved) {
+    if (!resolvedAction) {
       continue;
     }
     const actionArgs = {
@@ -1100,20 +1104,25 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       // TS isn't able to narrow it down here
       action
     };
-    if (!('resolve' in resolved)) {
+    if (!('resolve' in resolvedAction)) {
       if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
-        resolved(actionArgs);
+        resolvedAction(actionArgs);
       } else {
-        actorCtx?.defer(() => resolved(actionArgs));
+        actorCtx?.defer(() => {
+          resolvedAction(actionArgs);
+        });
       }
       continue;
     }
-    const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
-    );
-
+    const builtinAction = resolvedAction;
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    // this holds all params
+    extra);
     intermediateState = nextState;
-    if ('execute' in resolved) {
+    if ('retryResolve' in builtinAction) {
+      retries?.push([builtinAction, params]);
+    }
+    if ('execute' in builtinAction) {
       if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
@@ -1121,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 = [];
@@ -1182,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);