xstate 5.0.0-beta.34 → 5.0.0-beta.36

package/dist/{raise-05f8b2a6.development.esm.js → raise-5b7ad3b7.development.esm.js}

@@ -1,4 +1,4 @@
-import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, W as WILDCARD, X as XSTATE_STOP, u as XSTATE_INIT, v as isArray, w as createAfterEvent, x as flatten, e as matchesState } from './interpreter-dee56dc8.development.esm.js';
+import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, W as WILDCARD, X as XSTATE_STOP, u as XSTATE_INIT, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-5c4e6634.development.esm.js';
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -297,20 +297,6 @@ function evaluateGuard(guard, context, event, state) {
   );
 }
 
-function getOutput(configuration, context, event, self) {
-  const {
-    machine
-  } = configuration[0];
-  const {
-    root
-  } = machine;
-  if (!root.output) {
-    return undefined;
-  }
-  const finalChildStateNode = configuration.find(stateNode => stateNode.type === 'final' && stateNode.parent === machine.root);
-  const doneStateEvent = createDoneStateEvent(finalChildStateNode.id, finalChildStateNode.output ? resolveOutput(finalChildStateNode.output, context, event, self) : undefined);
-  return resolveOutput(root.output, context, doneStateEvent, self);
-}
 const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
@@ -335,7 +321,7 @@ function getConfiguration(stateNodes) {
   for (const s of configuration) {
     // if previously active, add existing child nodes
     if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
-      getInitialStateNodes(s).forEach(sn => configurationSet.add(sn));
+      getInitialStateNodesWithTheirAncestors(s).forEach(sn => configurationSet.add(sn));
     } else {
       if (s.type === 'parallel') {
         for (const child of getChildren(s)) {
@@ -343,7 +329,8 @@ function getConfiguration(stateNodes) {
             continue;
           }
           if (!configurationSet.has(child)) {
-            for (const initialStateNode of getInitialStateNodes(child)) {
+            const initialStates = getInitialStateNodesWithTheirAncestors(child);
+            for (const initialStateNode of initialStates) {
               configurationSet.add(initialStateNode);
             }
           }
@@ -403,14 +390,14 @@ function getStateValue(rootNode, configuration) {
   const config = getConfiguration(configuration);
   return getValueFromAdj(rootNode, getAdjList(config));
 }
-function isInFinalState(configuration, stateNode = configuration[0].machine.root) {
+function isInFinalState(configuration, stateNode) {
   if (stateNode.type === 'compound') {
-    return getChildren(stateNode).some(s => s.type === 'final' && configuration.includes(s));
+    return getChildren(stateNode).some(s => s.type === 'final' && configuration.has(s));
   }
   if (stateNode.type === 'parallel') {
     return getChildren(stateNode).every(sn => isInFinalState(configuration, sn));
   }
-  return false;
+  return stateNode.type === 'final';
 }
 const isStateId = str => str[0] === STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
@@ -466,13 +453,7 @@ function getDelayedTransitions(stateNode) {
     stateNode.exit.push(cancel(eventType));
     return eventType;
   };
-  const delayedTransitions = isArray(afterConfig) ? afterConfig.map((transition, i) => {
-    const eventType = mutateEntryExit(transition.delay, i);
-    return {
-      ...transition,
-      event: eventType
-    };
-  }) : Object.keys(afterConfig).flatMap((delay, i) => {
+  const delayedTransitions = Object.keys(afterConfig).flatMap((delay, i) => {
     const configTransition = afterConfig[delay];
     const resolvedTransition = typeof configTransition === 'string' ? {
       target: configTransition
@@ -560,43 +541,23 @@ function formatTransitions(stateNode) {
   return transitions;
 }
 function formatInitialTransition(stateNode, _target) {
-  if (typeof _target === 'string' || isArray(_target)) {
-    const targets = toArray(_target).map(t => {
-      // Resolve state string keys (which represent children)
-      // to their state node
-      const descStateNode = typeof t === 'string' ? isStateId(t) ? stateNode.machine.getStateNodeById(t) : stateNode.states[t] : t;
-      if (!descStateNode) {
-        throw new Error(`Initial state node "${t}" not found on parent state node #${stateNode.id}`);
-      }
-      if (!isDescendant(descStateNode, stateNode)) {
-        throw new Error(`Invalid initial target: state node #${descStateNode.id} is not a descendant of #${stateNode.id}`);
-      }
-      return descStateNode;
-    });
-    const resolvedTarget = resolveTarget(stateNode, targets);
-    const transition = {
-      source: stateNode,
-      actions: [],
-      eventType: null,
-      reenter: false,
-      target: resolvedTarget,
-      toJSON: () => ({
-        ...transition,
-        source: `#${stateNode.id}`,
-        target: resolvedTarget ? resolvedTarget.map(t => `#${t.id}`) : undefined
-      })
-    };
-    return transition;
+  const resolvedTarget = typeof _target === 'string' ? stateNode.states[_target] : _target ? stateNode.states[_target.target] : undefined;
+  if (!resolvedTarget && _target) {
+    throw new Error(`Initial state node "${_target}" not found on parent state node #${stateNode.id}`);
   }
-  return formatTransition(stateNode, '__INITIAL__', {
-    target: toArray(_target.target).map(t => {
-      if (typeof t === 'string') {
-        return isStateId(t) ? t : `${STATE_DELIMITER}${t}`;
-      }
-      return t;
-    }),
-    actions: _target.actions
-  });
+  const transition = {
+    source: stateNode,
+    actions: !_target || typeof _target === 'string' ? [] : toArray(_target.actions),
+    eventType: null,
+    reenter: false,
+    target: resolvedTarget ? [resolvedTarget] : [],
+    toJSON: () => ({
+      ...transition,
+      source: `#${stateNode.id}`,
+      target: resolvedTarget ? [`#${resolvedTarget.id}`] : []
+    })
+  };
+  return transition;
 }
 function resolveTarget(stateNode, targets) {
   if (targets === undefined) {
@@ -639,6 +600,15 @@ function resolveHistoryTarget(stateNode) {
 function isHistoryNode(stateNode) {
   return stateNode.type === 'history';
 }
+function getInitialStateNodesWithTheirAncestors(stateNode) {
+  const states = getInitialStateNodes(stateNode);
+  for (const initialState of states) {
+    for (const ancestor of getProperAncestors(initialState, stateNode)) {
+      states.add(ancestor);
+    }
+  }
+  return states;
+}
 function getInitialStateNodes(stateNode) {
   const set = new Set();
   function iter(descStateNode) {
@@ -647,12 +617,7 @@ function getInitialStateNodes(stateNode) {
     }
     set.add(descStateNode);
     if (descStateNode.type === 'compound') {
-      for (const targetStateNode of descStateNode.initial.target) {
-        for (const a of getProperAncestors(targetStateNode, stateNode)) {
-          set.add(a);
-        }
-        iter(targetStateNode);
-      }
+      iter(descStateNode.initial.target[0]);
     } else if (descStateNode.type === 'parallel') {
       for (const child of getChildren(descStateNode)) {
         iter(child);
@@ -660,7 +625,7 @@ function getInitialStateNodes(stateNode) {
     }
   }
   iter(stateNode);
-  return [...set];
+  return set;
 }
 /**
  * Returns the child state node from its relative `stateKey`, or throws.
@@ -894,6 +859,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
@@ -903,56 +879,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];
-  const done = isInFinalState(nextConfiguration);
-  if (done) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit));
+  if (nextState.status === 'done') {
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    const output = done ? getOutput(nextConfiguration, nextState.context, event, actorCtx.self) : undefined;
-    internalQueue.push(...nextState._internalQueue);
-    return cloneState(currentState, {
+    if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
+      return nextState;
+    }
+    return cloneState(nextState, {
       configuration: nextConfiguration,
-      historyValue,
-      _internalQueue: internalQueue,
-      context: nextState.context,
-      status: done ? 'done' : currentState.status,
-      output,
-      children: nextState.children
+      historyValue
     });
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
@@ -960,6 +916,13 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
     throw e;
   }
 }
+function getMachineOutput(state, event, actorCtx, rootNode, rootCompletionNode) {
+  if (!rootNode.output) {
+    return;
+  }
+  const doneStateEvent = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, state.context, event, actorCtx.self) : undefined);
+  return resolveOutput(rootNode.output, state.context, doneStateEvent, actorCtx.self);
+}
 function enterStates(currentState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
   let nextState = currentState;
   const statesToEnter = new Set();
@@ -970,6 +933,7 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
   if (isInitial) {
     statesForDefaultEntry.add(currentState.machine.root);
   }
+  const completedNodes = new Set();
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
     mutConfiguration.add(stateNodeToEnter);
     const actions = [];
@@ -980,26 +944,34 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       actions.push(invoke(invokeDef));
     }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
-      for (const stateNode of statesForDefaultEntry) {
-        const initialActions = stateNode.initial.actions;
-        actions.push(...initialActions);
-      }
+      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 (!parent.parent) {
+      if (completedNodes.has(parent)) {
         continue;
       }
-      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') {
-          if (getChildren(grandparent).every(parentNode => isInFinalState([...mutConfiguration], parentNode))) {
-            internalQueue.push(createDoneStateEvent(grandparent.id));
-          }
+      completedNodes.add(parent);
+      let rootCompletionNode = parent?.type === 'parallel' ? parent : stateNodeToEnter;
+      let ancestorMarker = parent?.parent;
+      if (ancestorMarker) {
+        internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
+        while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
+          completedNodes.add(ancestorMarker);
+          internalQueue.push(createDoneStateEvent(ancestorMarker.id));
+          rootCompletionNode = ancestorMarker;
+          ancestorMarker = ancestorMarker.parent;
         }
       }
+      if (ancestorMarker) {
+        continue;
+      }
+      nextState = cloneState(nextState, {
+        status: 'done',
+        output: getMachineOutput(nextState, event, actorCtx, currentState.configuration[0].machine.root, rootCompletionNode)
+      });
     }
   }
   return nextState;
@@ -1045,13 +1017,9 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
     statesToEnter.add(stateNode);
     if (stateNode.type === 'compound') {
       statesForDefaultEntry.add(stateNode);
-      const initialStates = stateNode.initial.target;
-      for (const initialState of initialStates) {
-        addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
-      }
-      for (const initialState of initialStates) {
-        addAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
-      }
+      const [initialState] = stateNode.initial.target;
+      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))) {
@@ -1076,10 +1044,11 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-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) {
@@ -1092,14 +1061,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 {
@@ -1164,9 +1136,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]) => {
@@ -1174,7 +1147,7 @@ function resolveActionsAndContext(currentState, event, actorCtx, actions, deferr
   });
   return nextState;
 }
-function macrostep(state, event, actorCtx) {
+function macrostep(state, event, actorCtx, internalQueue = []) {
   if (event.type === WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
   }
@@ -1183,7 +1156,7 @@ function macrostep(state, event, actorCtx) {
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
-    nextState = stopStep(event, nextState, actorCtx);
+    nextState = stopChildren(nextState, event, actorCtx);
     states.push(nextState);
     return {
       state: nextState,
@@ -1196,44 +1169,37 @@ function macrostep(state, event, actorCtx) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false);
+    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);
@@ -1339,11 +1305,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);
@@ -1445,11 +1409,15 @@ function getPersistedState(state) {
     tags,
     machine,
     children,
+    context,
     ...jsonValues
   } = state;
   const childrenJson = {};
   for (const id in children) {
     const child = children[id];
+    if (typeof child.src !== 'string') {
+      throw new Error('An inline child actor cannot be persisted.');
+    }
     childrenJson[id] = {
       state: child.getPersistedState?.(),
       src: child.src
@@ -1457,14 +1425,45 @@ function getPersistedState(state) {
   }
   return {
     ...jsonValues,
+    // TODO: this makes `PersistedMachineState`'s type kind of a lie
+    // it doesn't truly use `TContext` but rather some kind of a derived form of it
+    context: persistContext(context),
     children: childrenJson
   };
 }
+function persistContext(contextPart) {
+  let copy;
+  for (const key in contextPart) {
+    const value = contextPart[key];
+    if (value && typeof value === 'object') {
+      if ('sessionId' in value && 'send' in value && 'ref' in value) {
+        copy ??= Array.isArray(contextPart) ? contextPart.slice() : {
+          ...contextPart
+        };
+        copy[key] = {
+          xstate$$type: $$ACTOR_TYPE,
+          id: value.id
+        };
+      } else {
+        const result = persistContext(value);
+        if (result !== value) {
+          copy ??= Array.isArray(contextPart) ? contextPart.slice() : {
+            ...contextPart
+          };
+          copy[key] = result;
+        }
+      }
+    }
+  }
+  return copy ?? contextPart;
+}
 
 function resolveRaise(_, state, args, {
   event: eventOrExpr,
   id,
   delay
+}, {
+  internalQueue
 }) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
@@ -1478,9 +1477,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
@@ -1513,4 +1513,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { raise as A, stop as B, State as S, formatTransition as a, formatInitialTransition as b, getCandidates as c, getConfiguration as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getStateNodes as h, isInFinalState as i, cloneState as j, macrostep as k, getInitialConfiguration as l, memo as m, resolveActionsAndContext as n, microstep as o, isAtomicStateNode as p, isStateId as q, resolveStateValue as r, getStateNodeByPath as s, transitionNode as t, getPersistedState as u, and as v, not as w, or as x, stateIn as y, cancel as z };
+export { raise as A, stop as B, State as S, formatTransition as a, formatInitialTransition as b, getCandidates as c, getConfiguration as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getStateNodes as h, isInFinalState as i, cloneState as j, macrostep as k, getInitialConfiguration as l, memo as m, resolveActionsAndContext as n, microstep as o, getInitialStateNodes as p, isStateId as q, resolveStateValue as r, getStateNodeByPath as s, transitionNode as t, getPersistedState as u, and as v, not as w, or as x, stateIn as y, cancel as z };