xstate 5.0.0-beta.35 → 5.0.0-beta.37

package/dist/{interpreter-de5217bc.esm.js → interpreter-8def682e.esm.js}

@@ -28,22 +28,6 @@ class Mailbox {
       this._last = this._current;
     }
   }
-
-  // TODO: rethink this design
-  prepend(event) {
-    if (!this._current) {
-      this.enqueue(event);
-      return;
-    }
-
-    // we know that something is already queued up
-    // so the mailbox is already flushing or it's inactive
-    // therefore the only thing that we need to do is to reassign `this._current`
-    this._current = {
-      value: event,
-      next: this._current
-    };
-  }
   enqueue(event) {
     const enqueued = {
       value: event,
@@ -66,11 +50,7 @@ class Mailbox {
       // we assume here that this won't throw in a way that can affect this mailbox
       const consumed = this._current;
       this._process(consumed.value);
-      // something could have been prepended in the meantime
-      // so we need to be defensive here to avoid skipping over a prepended item
-      if (consumed === this._current) {
-        this._current = this._current.next;
-      }
+      this._current = consumed.next;
     }
     this._last = null;
   }
@@ -331,9 +311,19 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   };
 }
 function createInvokeId(stateNodeId, index) {
-  return `${stateNodeId}:invocation[${index}]`;
+  return `${stateNodeId}[${index}]`;
 }
-function resolveReferencedActor(referenced) {
+function resolveReferencedActor(machine, src) {
+  if (src.startsWith('xstate#')) {
+    const [, indexStr] = src.match(/\[(\d+)\]$/);
+    const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
+    const invokeConfig = node.config.invoke;
+    return {
+      src: (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src,
+      input: undefined
+    };
+  }
+  const referenced = machine.implementations.actors[src];
   return referenced ? 'transition' in referenced ? {
     src: referenced,
     input: undefined

package/dist/{interpreter-69605bf0.cjs.js → interpreter-97aff8d2.cjs.js}

@@ -30,22 +30,6 @@ class Mailbox {
       this._last = this._current;
     }
   }
-
-  // TODO: rethink this design
-  prepend(event) {
-    if (!this._current) {
-      this.enqueue(event);
-      return;
-    }
-
-    // we know that something is already queued up
-    // so the mailbox is already flushing or it's inactive
-    // therefore the only thing that we need to do is to reassign `this._current`
-    this._current = {
-      value: event,
-      next: this._current
-    };
-  }
   enqueue(event) {
     const enqueued = {
       value: event,
@@ -68,11 +52,7 @@ class Mailbox {
       // we assume here that this won't throw in a way that can affect this mailbox
       const consumed = this._current;
       this._process(consumed.value);
-      // something could have been prepended in the meantime
-      // so we need to be defensive here to avoid skipping over a prepended item
-      if (consumed === this._current) {
-        this._current = this._current.next;
-      }
+      this._current = consumed.next;
     }
     this._last = null;
   }
@@ -333,9 +313,19 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   };
 }
 function createInvokeId(stateNodeId, index) {
-  return `${stateNodeId}:invocation[${index}]`;
+  return `${stateNodeId}[${index}]`;
 }
-function resolveReferencedActor(referenced) {
+function resolveReferencedActor(machine, src) {
+  if (src.startsWith('xstate#')) {
+    const [, indexStr] = src.match(/\[(\d+)\]$/);
+    const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
+    const invokeConfig = node.config.invoke;
+    return {
+      src: (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src,
+      input: undefined
+    };
+  }
+  const referenced = machine.implementations.actors[src];
   return referenced ? 'transition' in referenced ? {
     src: referenced,
     input: undefined

package/dist/{interpreter-d3567419.development.cjs.js → interpreter-e58ca48d.development.cjs.js}

@@ -30,22 +30,6 @@ class Mailbox {
       this._last = this._current;
     }
   }
-
-  // TODO: rethink this design
-  prepend(event) {
-    if (!this._current) {
-      this.enqueue(event);
-      return;
-    }
-
-    // we know that something is already queued up
-    // so the mailbox is already flushing or it's inactive
-    // therefore the only thing that we need to do is to reassign `this._current`
-    this._current = {
-      value: event,
-      next: this._current
-    };
-  }
   enqueue(event) {
     const enqueued = {
       value: event,
@@ -68,11 +52,7 @@ class Mailbox {
       // we assume here that this won't throw in a way that can affect this mailbox
       const consumed = this._current;
       this._process(consumed.value);
-      // something could have been prepended in the meantime
-      // so we need to be defensive here to avoid skipping over a prepended item
-      if (consumed === this._current) {
-        this._current = this._current.next;
-      }
+      this._current = consumed.next;
     }
     this._last = null;
   }
@@ -336,9 +316,19 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   };
 }
 function createInvokeId(stateNodeId, index) {
-  return `${stateNodeId}:invocation[${index}]`;
+  return `${stateNodeId}[${index}]`;
 }
-function resolveReferencedActor(referenced) {
+function resolveReferencedActor(machine, src) {
+  if (src.startsWith('xstate#')) {
+    const [, indexStr] = src.match(/\[(\d+)\]$/);
+    const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
+    const invokeConfig = node.config.invoke;
+    return {
+      src: (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src,
+      input: undefined
+    };
+  }
+  const referenced = machine.implementations.actors[src];
   return referenced ? 'transition' in referenced ? {
     src: referenced,
     input: undefined

package/dist/{raise-26e4d83c.development.cjs.js → raise-1fd59c65.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-d3567419.development.cjs.js');
+var interpreter = require('./interpreter-e58ca48d.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -52,14 +52,17 @@ function resolveInvoke(actorContext, state, actionArgs, {
   input,
   syncSnapshot
 }) {
-  const referenced = interpreter.resolveReferencedActor(state.machine.implementations.actors[src]);
+  const referenced = typeof src === 'string' ? interpreter.resolveReferencedActor(state.machine, src) : {
+    src,
+    input: undefined
+  };
   let actorRef;
   if (referenced) {
     // TODO: inline `input: undefined` should win over the referenced one
     const configuredInput = input || referenced.input;
     actorRef = interpreter.createActor(referenced.src, {
       id,
-      src,
+      src: typeof src === 'string' ? src : undefined,
       parent: actorContext?.self,
       systemId,
       input: typeof configuredInput === 'function' ? configuredInput({
@@ -162,11 +165,16 @@ function executeStop(actorContext, actorRef) {
   if (!actorRef) {
     return;
   }
+  // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
+  // this can happen, for example, when the invoking state is being exited immediately by an always transition
   if (actorRef.status !== interpreter.ActorStatus.Running) {
     actorContext.stopChild(actorRef);
     return;
   }
-  // TODO: recheck why this one has to be deferred
+  // 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);
   });
@@ -193,7 +201,8 @@ function checkStateIn(state, _, {
   stateValue
 }) {
   if (typeof stateValue === 'string' && isStateId(stateValue)) {
-    return state.configuration.some(sn => sn.id === stateValue.slice(1));
+    const target = state.machine.getStateNodeById(stateValue);
+    return state.configuration.some(sn => sn === target);
   }
   return state.matches(stateValue);
 }
@@ -305,6 +314,9 @@ function getChildren(stateNode) {
 }
 function getProperAncestors(stateNode, toStateNode) {
   const ancestors = [];
+  if (toStateNode === stateNode) {
+    return ancestors;
+  }
 
   // add all ancestors
   let m = stateNode.parent;
@@ -592,12 +604,14 @@ function resolveTarget(stateNode, targets) {
     }
   });
 }
-function resolveHistoryTarget(stateNode) {
+function resolveHistoryDefaultTransition(stateNode) {
   const normalizedTarget = interpreter.normalizeTarget(stateNode.config.target);
   if (!normalizedTarget) {
-    return stateNode.parent.initial.target;
+    return stateNode.parent.initial;
   }
-  return normalizedTarget.map(t => typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t);
+  return {
+    target: normalizedTarget.map(t => typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t)
+  };
 }
 function isHistoryNode(stateNode) {
   return stateNode.type === 'history';
@@ -824,9 +838,7 @@ function getEffectiveTargetStates(transition, historyValue) {
           targets.add(node);
         }
       } else {
-        for (const node of getEffectiveTargetStates({
-          target: resolveHistoryTarget(targetNode)
-        }, historyValue)) {
+        for (const node of getEffectiveTargetStates(resolveHistoryDefaultTransition(targetNode), historyValue)) {
           targets.add(node);
         }
       }
@@ -839,9 +851,9 @@ function getEffectiveTargetStates(transition, historyValue) {
 function getTransitionDomain(transition, historyValue) {
   const targetStates = getEffectiveTargetStates(transition, historyValue);
   if (!targetStates) {
-    return null;
+    return;
   }
-  if (!transition.reenter && transition.source.type !== 'parallel' && targetStates.every(targetStateNode => isDescendant(targetStateNode, transition.source))) {
+  if (!transition.reenter && targetStates.every(target => target === transition.source || isDescendant(target, transition.source))) {
     return transition.source;
   }
   const lcca = findLCCA(targetStates.concat(transition.source));
@@ -852,6 +864,9 @@ function computeExitSet(transitions, configuration, historyValue) {
   for (const t of transitions) {
     if (t.target?.length) {
       const domain = getTransitionDomain(t, historyValue);
+      if (t.reenter && t.source === domain) {
+        statesToExit.add(domain);
+      }
       for (const stateNode of configuration) {
         if (isDescendant(stateNode, domain)) {
           statesToExit.add(stateNode);
@@ -861,6 +876,17 @@ function computeExitSet(transitions, configuration, historyValue) {
   }
   return [...statesToExit];
 }
+function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
+  if (previousConfiguration.length !== nextConfigurationSet.size) {
+    return false;
+  }
+  for (const node of previousConfiguration) {
+    if (!nextConfigurationSet.has(node)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -870,50 +896,36 @@ function computeExitSet(transitions, configuration, historyValue) {
  * @param currentState
  * @param mutConfiguration
  */
-
-function microstep(transitions, currentState, actorCtx, event, isInitial) {
-  const mutConfiguration = new Set(currentState.configuration);
+function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentState;
   }
-  const microstate = microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial);
-  return cloneState(microstate, {
-    value: {} // TODO: make optional
-  });
-}
-
-function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const historyValue = {
-    ...currentState.historyValue
-  };
+  const mutConfiguration = new Set(currentState.configuration);
+  let 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: []
-  });
+  let nextState = currentState;
 
   // Exit states
   if (!isInitial) {
-    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
+    [nextState, historyValue] = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue, internalQueue);
   }
 
   // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
   nextState = enterStates(nextState, event, actorCtx, 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));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    internalQueue.push(...nextState._internalQueue);
+    if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
+      return nextState;
+    }
     return cloneState(nextState, {
       configuration: nextConfiguration,
-      historyValue,
-      _internalQueue: internalQueue
+      historyValue
     });
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
@@ -931,6 +943,9 @@ function getMachineOutput(state, event, actorCtx, rootNode, rootCompletionNode)
 function enterStates(currentState, event, actorCtx, 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
+  // in other words, those are states for which initial actions should be executed
+  // when we target `#deep_child` initial actions of its ancestors shouldn't be executed
   const statesForDefaultEntry = new Set();
   computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
 
@@ -952,23 +967,19 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       const initialActions = stateNodeToEnter.initial.actions;
       actions.push(...initialActions);
     }
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
-      if (completedNodes.has(parent)) {
-        continue;
-      }
-      completedNodes.add(parent);
-      let rootCompletionNode = parent?.type === 'parallel' ? parent : stateNodeToEnter;
-      let ancestorMarker = parent?.parent;
-      if (ancestorMarker) {
+      let ancestorMarker = parent?.type === 'parallel' ? parent : parent?.parent;
+      let rootCompletionNode = ancestorMarker || stateNodeToEnter;
+      if (parent?.type === 'compound') {
         internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
-        while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
-          completedNodes.add(ancestorMarker);
-          internalQueue.push(interpreter.createDoneStateEvent(ancestorMarker.id));
-          rootCompletionNode = ancestorMarker;
-          ancestorMarker = ancestorMarker.parent;
-        }
+      }
+      while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
+        completedNodes.add(ancestorMarker);
+        internalQueue.push(interpreter.createDoneStateEvent(ancestorMarker.id));
+        rootCompletionNode = ancestorMarker;
+        ancestorMarker = ancestorMarker.parent;
       }
       if (ancestorMarker) {
         continue;
@@ -983,13 +994,24 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
+    const domain = getTransitionDomain(t, historyValue);
     for (const s of t.target || []) {
+      if (!isHistoryNode(s) && (
+      // if the target is different than the source then it will *definitely* be entered
+      t.source !== s ||
+      // we know that the domain can't lie within the source
+      // if it's different than the source then it's outside of it and it means that the target has to be entered as well
+      t.source !== domain ||
+      // reentering transitions always enter the target, even if it's the source itself
+      t.reenter)) {
+        statesToEnter.add(s);
+        statesForDefaultEntry.add(s);
+      }
       addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
     }
-    const ancestor = getTransitionDomain(t, historyValue);
     const targetStates = getEffectiveTargetStates(t, historyValue);
     for (const s of targetStates) {
-      addAncestorStatesToEnter(s, ancestor, statesToEnter, historyValue, statesForDefaultEntry);
+      addAncestorStatesToEnter(s, domain, statesToEnter, historyValue, statesForDefaultEntry);
     }
   }
 }
@@ -998,37 +1020,42 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
     if (historyValue[stateNode.id]) {
       const historyStateNodes = historyValue[stateNode.id];
       for (const s of historyStateNodes) {
+        statesToEnter.add(s);
         addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
       }
       for (const s of historyStateNodes) {
         addAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
-        for (const stateForDefaultEntry of statesForDefaultEntry) {
-          statesForDefaultEntry.add(stateForDefaultEntry);
-        }
       }
     } else {
-      const targets = resolveHistoryTarget(stateNode);
-      for (const s of targets) {
+      const historyDefaultTransition = resolveHistoryDefaultTransition(stateNode);
+      for (const s of historyDefaultTransition.target) {
+        statesToEnter.add(s);
+        if (historyDefaultTransition === stateNode.parent?.initial) {
+          statesForDefaultEntry.add(stateNode.parent);
+        }
         addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
       }
-      for (const s of targets) {
+      for (const s of historyDefaultTransition.target) {
         addAncestorStatesToEnter(s, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
-        for (const stateForDefaultEntry of statesForDefaultEntry) {
-          statesForDefaultEntry.add(stateForDefaultEntry);
-        }
       }
     }
   } else {
-    statesToEnter.add(stateNode);
     if (stateNode.type === 'compound') {
-      statesForDefaultEntry.add(stateNode);
       const [initialState] = stateNode.initial.target;
+      if (!isHistoryNode(initialState)) {
+        statesToEnter.add(initialState);
+        statesForDefaultEntry.add(initialState);
+      }
       addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
       addAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
     } else {
       if (stateNode.type === 'parallel') {
         for (const child of getChildren(stateNode).filter(sn => !isHistoryNode(sn))) {
           if (![...statesToEnter].some(s => isDescendant(s, child))) {
+            if (!isHistoryNode(child)) {
+              statesToEnter.add(child);
+              statesForDefaultEntry.add(child);
+            }
             addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
           }
         }
@@ -1043,16 +1070,18 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     if (anc.type === 'parallel') {
       for (const child of getChildren(anc).filter(sn => !isHistoryNode(sn))) {
         if (![...statesToEnter].some(s => isDescendant(s, child))) {
+          statesToEnter.add(child);
           addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
         }
       }
     }
   }
 }
-function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue, internalQueue) {
   let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
+  let changedHistory;
 
   // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
   for (const exitStateNode of statesToExit) {
@@ -1065,14 +1094,17 @@ function exitStates(currentState, event, actorCtx, transitions, mutConfiguration
           return sn.parent === exitStateNode;
         };
       }
-      historyValue[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
+      changedHistory ??= {
+        ...historyValue
+      };
+      changedHistory[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
     }
   }
   for (const s of statesToExit) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
     mutConfiguration.delete(s);
   }
-  return nextState;
+  return [nextState, changedHistory || historyValue];
 }
 function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
@@ -1137,9 +1169,10 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
   }
   return intermediateState;
 }
-function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+function resolveActionsAndContext(currentState, event, actorCtx, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, {
+    internalQueue,
     deferredActorIds
   }, retries);
   retries?.forEach(([builtinAction, params]) => {
@@ -1147,7 +1180,7 @@ function resolveActionsAndContext(currentState, event, actorCtx, actions, deferr
   });
   return nextState;
 }
-function macrostep(state, event, actorCtx) {
+function macrostep(state, event, actorCtx, internalQueue = []) {
   if (event.type === interpreter.WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${interpreter.WILDCARD}')`);
   }
@@ -1156,7 +1189,7 @@ function macrostep(state, event, actorCtx) {
 
   // Handle stop event
   if (event.type === interpreter.XSTATE_STOP) {
-    nextState = stopStep(event, nextState, actorCtx);
+    nextState = stopChildren(nextState, event, actorCtx);
     states.push(nextState);
     return {
       state: nextState,
@@ -1169,44 +1202,37 @@ function macrostep(state, event, actorCtx) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== interpreter.XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false);
+    nextState = microstep(transitions, state, actorCtx, nextEvent, false, internalQueue);
     states.push(nextState);
   }
+  let shouldSelectEventlessTransitions = true;
   while (nextState.status === 'active') {
-    let enabledTransitions = selectEventlessTransitions(nextState, nextEvent);
+    let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextState, nextEvent) : [];
+
+    // eventless transitions should always be selected after selecting *regular* transitions
+    // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
+    const previousState = enabledTransitions.length ? nextState : undefined;
     if (!enabledTransitions.length) {
-      if (!nextState._internalQueue.length) {
+      if (!internalQueue.length) {
         break;
-      } else {
-        nextEvent = nextState._internalQueue[0];
-        const transitions = selectTransitions(nextEvent, nextState);
-        nextState = microstep(transitions, nextState, actorCtx, nextEvent, false);
-        nextState._internalQueue.shift();
-        states.push(nextState);
       }
-    } else {
-      nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false);
-      states.push(nextState);
+      nextEvent = internalQueue.shift();
+      enabledTransitions = selectTransitions(nextEvent, nextState);
     }
+    nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false, internalQueue);
+    shouldSelectEventlessTransitions = nextState !== previousState;
+    states.push(nextState);
   }
   if (nextState.status !== 'active') {
-    // Perform the stop step to ensure that child actors are stopped
-    stopStep(nextEvent, nextState, actorCtx);
+    stopChildren(nextState, nextEvent, actorCtx);
   }
   return {
     state: nextState,
     microstates: states
   };
 }
-function stopStep(event, nextState, actorCtx) {
-  const actions = [];
-  for (const stateNode of nextState.configuration.sort((a, b) => b.order - a.order)) {
-    actions.push(...stateNode.exit);
-  }
-  for (const child of Object.values(nextState.children)) {
-    actions.push(stop(child));
-  }
-  return resolveActionsAndContext(nextState, event, actorCtx, actions);
+function stopChildren(nextState, event, actorCtx) {
+  return resolveActionsAndContext(nextState, event, actorCtx, Object.values(nextState.children).map(child => stop(child)), []);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -1215,7 +1241,7 @@ function selectEventlessTransitions(nextState, event) {
   const enabledTransitionSet = new Set();
   const atomicStates = nextState.configuration.filter(isAtomicStateNode);
   for (const stateNode of atomicStates) {
-    loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, null))) {
+    loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, undefined))) {
       if (!s.always) {
         continue;
       }
@@ -1312,11 +1338,9 @@ class State {
     this.error = void 0;
     this.context = void 0;
     this.historyValue = {};
-    this._internalQueue = void 0;
     this.configuration = void 0;
     this.children = void 0;
     this.context = config.context;
-    this._internalQueue = config._internalQueue ?? [];
     this.historyValue = config.historyValue || {};
     this.matches = this.matches.bind(this);
     this.toStrings = this.toStrings.bind(this);
@@ -1471,6 +1495,8 @@ function resolveRaise(_, state, args, {
   event: eventOrExpr,
   id,
   delay
+}, {
+  internalQueue
 }) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
@@ -1484,9 +1510,10 @@ function resolveRaise(_, state, args, {
   } else {
     resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
   }
-  return [typeof resolvedDelay !== 'number' ? cloneState(state, {
-    _internalQueue: state._internalQueue.concat(resolvedEvent)
-  }) : state, {
+  if (typeof resolvedDelay !== 'number') {
+    internalQueue.push(resolvedEvent);
+  }
+  return [state, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay