xstate 5.0.0-beta.16 → 5.0.0-beta.17

package/dist/{actions-6b9073db.cjs.js → actions-5fb9f10d.cjs.js}

@@ -17,12 +17,6 @@ var dev_dist_xstateDev = require('../dev/dist/xstate-dev.cjs.js');
 
 // TODO: narrow this to logic from machine
 
-// TODO: fix last param
-
-/**
- * Extracts action objects that have no extra properties.
- */
-
 /**
  * The string or object representing the state value relative to the parent state node.
  *
@@ -34,25 +28,15 @@ var dev_dist_xstateDev = require('../dev/dist/xstate-dev.cjs.js');
 
 // TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
 
-let ActionTypes = /*#__PURE__*/function (ActionTypes) {
-  ActionTypes["Stop"] = "xstate.stop";
-  ActionTypes["Raise"] = "xstate.raise";
-  ActionTypes["SendTo"] = "xstate.sendTo";
-  ActionTypes["Cancel"] = "xstate.cancel";
-  ActionTypes["Assign"] = "xstate.assign";
-  ActionTypes["After"] = "xstate.after";
-  ActionTypes["DoneState"] = "done.state";
-  ActionTypes["DoneInvoke"] = "done.invoke";
-  ActionTypes["Log"] = "xstate.log";
-  ActionTypes["Init"] = "xstate.init";
-  ActionTypes["Invoke"] = "xstate.invoke";
-  ActionTypes["ErrorExecution"] = "error.execution";
-  ActionTypes["ErrorCommunication"] = "error.communication";
-  ActionTypes["ErrorPlatform"] = "error.platform";
-  ActionTypes["ErrorCustom"] = "xstate.error";
-  ActionTypes["Pure"] = "xstate.pure";
-  ActionTypes["Choose"] = "xstate.choose";
-  return ActionTypes;
+let ConstantPrefix = /*#__PURE__*/function (ConstantPrefix) {
+  ConstantPrefix["After"] = "xstate.after";
+  ConstantPrefix["DoneState"] = "done.state";
+  ConstantPrefix["DoneInvoke"] = "done.invoke";
+  ConstantPrefix["ErrorExecution"] = "error.execution";
+  ConstantPrefix["ErrorCommunication"] = "error.communication";
+  ConstantPrefix["ErrorPlatform"] = "error.platform";
+  ConstantPrefix["ErrorCustom"] = "xstate.error";
+  return ConstantPrefix;
 }({});
 let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
   SpecialTargets["Parent"] = "#_parent";
@@ -60,40 +44,19 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
   return SpecialTargets;
 }({});
 
-// xstate-specific action types
-const stop$1 = ActionTypes.Stop;
-const raise$1 = ActionTypes.Raise;
-const sendTo$1 = ActionTypes.SendTo;
-const cancel$1 = ActionTypes.Cancel;
-const assign$1 = ActionTypes.Assign;
-const after$1 = ActionTypes.After;
-const doneState = ActionTypes.DoneState;
-const log$1 = ActionTypes.Log;
-const init = ActionTypes.Init;
-const invoke$1 = ActionTypes.Invoke;
-const errorExecution = ActionTypes.ErrorExecution;
-const errorPlatform = ActionTypes.ErrorPlatform;
-const error$1 = ActionTypes.ErrorCustom;
-const choose$1 = ActionTypes.Choose;
-const pure$1 = ActionTypes.Pure;
-
-var actionTypes = /*#__PURE__*/Object.freeze({
+const after$1 = ConstantPrefix.After;
+const doneState = ConstantPrefix.DoneState;
+const errorExecution = ConstantPrefix.ErrorExecution;
+const errorPlatform = ConstantPrefix.ErrorPlatform;
+const error$1 = ConstantPrefix.ErrorCustom;
+
+var constantPrefixes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  stop: stop$1,
-  raise: raise$1,
-  sendTo: sendTo$1,
-  cancel: cancel$1,
-  assign: assign$1,
   after: after$1,
   doneState: doneState,
-  log: log$1,
-  init: init,
-  invoke: invoke$1,
   errorExecution: errorExecution,
   errorPlatform: errorPlatform,
-  error: error$1,
-  choose: choose$1,
-  pure: pure$1
+  error: error$1
 });
 
 const STATE_DELIMITER = '.';
@@ -101,208 +64,68 @@ const TARGETLESS_KEY = '';
 const NULL_EVENT = '';
 const STATE_IDENTIFIER = '#';
 const WILDCARD = '*';
-
-function matchesState(parentStateId, childStateId) {
-  const parentStateValue = toStateValue(parentStateId);
-  const childStateValue = toStateValue(childStateId);
-  if (isString(childStateValue)) {
-    if (isString(parentStateValue)) {
-      return childStateValue === parentStateValue;
-    }
-
-    // Parent more specific than child
-    return false;
-  }
-  if (isString(parentStateValue)) {
-    return parentStateValue in childStateValue;
-  }
-  return Object.keys(parentStateValue).every(key => {
-    if (!(key in childStateValue)) {
-      return false;
-    }
-    return matchesState(parentStateValue[key], childStateValue[key]);
-  });
-}
-function toStatePath(stateId) {
-  try {
-    if (isArray(stateId)) {
-      return stateId;
-    }
-    return stateId.toString().split(STATE_DELIMITER);
-  } catch (e) {
-    throw new Error(`'${stateId}' is not a valid state path.`);
-  }
-}
-function isStateLike(state) {
-  return typeof state === 'object' && 'value' in state && 'context' in state && 'event' in state;
-}
-function toStateValue(stateValue) {
-  if (isStateLike(stateValue)) {
-    return stateValue.value;
-  }
-  if (isArray(stateValue)) {
-    return pathToStateValue(stateValue);
-  }
-  if (typeof stateValue !== 'string') {
-    return stateValue;
-  }
-  const statePath = toStatePath(stateValue);
-  return pathToStateValue(statePath);
-}
-function pathToStateValue(statePath) {
-  if (statePath.length === 1) {
-    return statePath[0];
-  }
-  const value = {};
-  let marker = value;
-  for (let i = 0; i < statePath.length - 1; i++) {
-    if (i === statePath.length - 2) {
-      marker[statePath[i]] = statePath[i + 1];
+const INIT_TYPE = 'xstate.init';
+
+function resolve$8(actorContext, state, args, {
+  to,
+  event: eventOrExpr,
+  id,
+  delay
+}) {
+  const delaysMap = state.machine.implementations.delays;
+  if (typeof eventOrExpr === 'string') {
+    throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
+  }
+  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr;
+  let resolvedDelay;
+  if (typeof delay === 'string') {
+    const configDelay = delaysMap && delaysMap[delay];
+    resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
+  } else {
+    resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
+  }
+  const resolvedTarget = typeof to === 'function' ? to(args) : to;
+  let targetActorRef;
+  if (typeof resolvedTarget === 'string') {
+    if (resolvedTarget === SpecialTargets.Parent) {
+      targetActorRef = actorContext?.self._parent;
+    } else if (resolvedTarget === SpecialTargets.Internal) {
+      targetActorRef = actorContext?.self;
+    } else if (resolvedTarget.startsWith('#_')) {
+      // SCXML compatibility: https://www.w3.org/TR/scxml/#SCXMLEventProcessor
+      // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
+      targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      const previous = marker;
-      marker = {};
-      previous[statePath[i]] = marker;
+      targetActorRef = state.children[resolvedTarget];
     }
-  }
-  return value;
-}
-function mapValues(collection, iteratee) {
-  const result = {};
-  const collectionKeys = Object.keys(collection);
-  for (let i = 0; i < collectionKeys.length; i++) {
-    const key = collectionKeys[i];
-    result[key] = iteratee(collection[key], key, collection, i);
-  }
-  return result;
-}
-function flatten(array) {
-  return [].concat(...array);
-}
-function toArrayStrict(value) {
-  if (isArray(value)) {
-    return value;
-  }
-  return [value];
-}
-function toArray(value) {
-  if (value === undefined) {
-    return [];
-  }
-  return toArrayStrict(value);
-}
-function mapContext(mapper, context, event) {
-  if (isFunction(mapper)) {
-    return mapper({
-      context,
-      event
-    });
-  }
-  const result = {};
-  const args = {
-    context,
-    event
-  };
-  for (const key of Object.keys(mapper)) {
-    const subMapper = mapper[key];
-    if (isFunction(subMapper)) {
-      result[key] = subMapper(args);
-    } else {
-      result[key] = subMapper;
+    if (!targetActorRef) {
+      throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
     }
+  } else {
+    targetActorRef = resolvedTarget || actorContext?.self;
   }
-  return result;
+  return [state, {
+    to: targetActorRef,
+    event: resolvedEvent,
+    id,
+    delay: resolvedDelay
+  }];
 }
-function isPromiseLike(value) {
-  if (value instanceof Promise) {
-    return true;
-  }
-  // Check if shape matches the Promise/A+ specification for a "thenable".
-  if (value !== null && (isFunction(value) || typeof value === 'object') && isFunction(value.then)) {
-    return true;
+function execute$5(actorContext, params) {
+  if (typeof params.delay === 'number') {
+    actorContext.self.delaySend(params);
+    return;
   }
-  return false;
-}
-function isArray(value) {
-  return Array.isArray(value);
-}
-
-// tslint:disable-next-line:ban-types
-function isFunction(value) {
-  return typeof value === 'function';
-}
-function isString(value) {
-  return typeof value === 'string';
-}
-function isErrorEvent(event) {
-  return typeof event.type === 'string' && (event.type === errorExecution || event.type.startsWith(errorPlatform));
-}
-function toTransitionConfigArray(event, configLike) {
-  const transitions = toArrayStrict(configLike).map(transitionLike => {
-    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string') {
-      return {
-        target: transitionLike,
-        event
-      };
-    }
-    return {
-      ...transitionLike,
-      event
-    };
+  const {
+    to,
+    event
+  } = params;
+  actorContext.defer(() => {
+    to.send(event.type === error$1 ? {
+      type: `${error(actorContext.self.id)}`,
+      data: event.data
+    } : event);
   });
-  return transitions;
-}
-function normalizeTarget(target) {
-  if (target === undefined || target === TARGETLESS_KEY) {
-    return undefined;
-  }
-  return toArray(target);
-}
-function toInvokeConfig(invocable, id) {
-  if (typeof invocable === 'object') {
-    if ('src' in invocable) {
-      return invocable;
-    }
-    if ('transition' in invocable) {
-      return {
-        id,
-        src: invocable
-      };
-    }
-  }
-  return {
-    id,
-    src: invocable
-  };
-}
-function toObserver(nextHandler, errorHandler, completionHandler) {
-  const noop = () => {};
-  const isObserver = typeof nextHandler === 'object';
-  const self = isObserver ? nextHandler : null;
-  return {
-    next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self),
-    error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self),
-    complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self)
-  };
-}
-function createInvokeId(stateNodeId, index) {
-  return `${stateNodeId}:invocation[${index}]`;
-}
-function resolveReferencedActor(referenced) {
-  return referenced ? 'transition' in referenced ? {
-    src: referenced,
-    input: undefined
-  } : referenced : undefined;
-}
-
-function createDynamicAction(action, resolve) {
-  return {
-    type: action.type,
-    params: action.params,
-    resolve
-  };
-}
-function isDynamicAction(action) {
-  return typeof action === 'object' && action !== null && 'resolve' in action;
 }
 
 /**
@@ -314,94 +137,17 @@ function isDynamicAction(action) {
  *  - `id` - The unique send event identifier (used with `cancel()`).
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  */
-function sendTo(actor, eventOrExpr, options) {
-  return createDynamicAction({
-    type: sendTo$1,
-    params: {
-      to: actor,
-      delay: options ? options.delay : undefined,
-      event: eventOrExpr,
-      id: options && options.id !== undefined ? options.id : isFunction(eventOrExpr) ? eventOrExpr.name : eventOrExpr.type
-    }
-  }, (event, {
-    actorContext,
-    state
-  }) => {
-    const params = {
-      to: actor,
-      delay: options ? options.delay : undefined,
-      event: eventOrExpr,
-      // TODO: don't auto-generate IDs here like that
-      // there is too big chance of the ID collision
-      id: options && options.id !== undefined ? options.id : isFunction(eventOrExpr) ? eventOrExpr.name : eventOrExpr.type
-    };
-    const args = {
-      context: state.context,
-      event,
-      self: actorContext?.self ?? null,
-      system: actorContext?.system
-    };
-    const delaysMap = state.machine.implementations.delays;
-
-    // TODO: helper function for resolving Expr
-    if (typeof eventOrExpr === 'string') {
-      throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
-    }
-    const resolvedEvent = isFunction(eventOrExpr) ? eventOrExpr(args) : eventOrExpr;
-    let resolvedDelay;
-    if (isString(params.delay)) {
-      const configDelay = delaysMap && delaysMap[params.delay];
-      resolvedDelay = isFunction(configDelay) ? configDelay(args) : configDelay;
-    } else {
-      resolvedDelay = isFunction(params.delay) ? params.delay(args) : params.delay;
-    }
-    const resolvedTarget = isFunction(params.to) ? params.to(args) : params.to;
-    let targetActorRef;
-    if (typeof resolvedTarget === 'string') {
-      if (resolvedTarget === SpecialTargets.Parent) {
-        targetActorRef = actorContext?.self._parent;
-      } else if (resolvedTarget === SpecialTargets.Internal) {
-        targetActorRef = actorContext?.self;
-      } else if (resolvedTarget.startsWith('#_')) {
-        // SCXML compatibility: https://www.w3.org/TR/scxml/#SCXMLEventProcessor
-        // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
-        targetActorRef = state.children[resolvedTarget.slice(2)];
-      } else {
-        targetActorRef = state.children[resolvedTarget];
-      }
-      if (!targetActorRef) {
-        throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
-      }
-    } else {
-      targetActorRef = resolvedTarget || actorContext?.self;
-    }
-    const resolvedAction = {
-      type: sendTo$1,
-      params: {
-        ...params,
-        to: targetActorRef,
-        event: resolvedEvent,
-        delay: resolvedDelay
-      },
-      execute: actorCtx => {
-        const sendAction = resolvedAction;
-        if (typeof sendAction.params.delay === 'number') {
-          actorCtx.self.delaySend(sendAction);
-          return;
-        } else {
-          const target = sendAction.params.to;
-          const sentEvent = sendAction.params.event;
-          actorCtx.defer(() => {
-            target.send(sentEvent.type === error$1 ? {
-              type: `${error(actorCtx.self.id)}`,
-              data: sentEvent.data
-            } : sendAction.params.event);
-          });
-        }
-      }
-    };
-    return [state, resolvedAction];
-  });
+function sendTo(to, eventOrExpr, options) {
+  function sendTo(_) {
+  }
+  sendTo.type = 'xstate.sendTo';
+  sendTo.to = to;
+  sendTo.event = eventOrExpr;
+  sendTo.id = options?.id;
+  sendTo.delay = options?.delay;
+  sendTo.resolve = resolve$8;
+  sendTo.execute = execute$5;
+  return sendTo;
 }
 
 /**
@@ -436,7 +182,7 @@ function escalate(errorData, options) {
   return sendParent(arg => {
     return {
       type: error$1,
-      data: isFunction(errorData) ? errorData(arg) : errorData
+      data: typeof errorData === 'function' ? errorData(arg) : errorData
     };
   }, options);
 }
@@ -455,6 +201,16 @@ function memo(object, key, fn) {
   return memoizedData[key];
 }
 
+function resolve$7(_, state, actionArgs, {
+  sendId
+}) {
+  const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs) : sendId;
+  return [state, resolvedSendId];
+}
+function execute$4(actorContext, resolvedSendId) {
+  actorContext.self.cancel(resolvedSendId);
+}
+
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent
@@ -462,34 +218,14 @@ function memo(object, key, fn) {
  *
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
-
 function cancel(sendId) {
-  return createDynamicAction({
-    type: cancel$1,
-    params: {
-      sendId
-    }
-  }, (event, {
-    state,
-    actorContext
-  }) => {
-    const resolvedSendId = isFunction(sendId) ? sendId({
-      context: state.context,
-      event,
-      self: actorContext?.self ?? {},
-      system: actorContext?.system
-    }) : sendId;
-    return [state, {
-      type: 'xstate.cancel',
-      params: {
-        sendId: resolvedSendId
-      },
-      execute: actorCtx => {
-        const interpreter = actorCtx.self;
-        interpreter.cancel(resolvedSendId);
-      }
-    }];
-  });
+  function cancel(_) {
+  }
+  cancel.type = 'xstate.cancel';
+  cancel.sendId = sendId;
+  cancel.resolve = resolve$7;
+  cancel.execute = execute$4;
+  return cancel;
 }
 
 class Mailbox {
@@ -889,7 +625,186 @@ function fromEventObservable(lazyObservable) {
       subscription: undefined
     })
   };
-  return logic;
+  return logic;
+}
+
+function matchesState(parentStateId, childStateId) {
+  const parentStateValue = toStateValue(parentStateId);
+  const childStateValue = toStateValue(childStateId);
+  if (typeof childStateValue === 'string') {
+    if (typeof parentStateValue === 'string') {
+      return childStateValue === parentStateValue;
+    }
+
+    // Parent more specific than child
+    return false;
+  }
+  if (typeof parentStateValue === 'string') {
+    return parentStateValue in childStateValue;
+  }
+  return Object.keys(parentStateValue).every(key => {
+    if (!(key in childStateValue)) {
+      return false;
+    }
+    return matchesState(parentStateValue[key], childStateValue[key]);
+  });
+}
+function toStatePath(stateId) {
+  try {
+    if (isArray(stateId)) {
+      return stateId;
+    }
+    return stateId.toString().split(STATE_DELIMITER);
+  } catch (e) {
+    throw new Error(`'${stateId}' is not a valid state path.`);
+  }
+}
+function isStateLike(state) {
+  return typeof state === 'object' && 'value' in state && 'context' in state && 'event' in state;
+}
+function toStateValue(stateValue) {
+  if (isStateLike(stateValue)) {
+    return stateValue.value;
+  }
+  if (isArray(stateValue)) {
+    return pathToStateValue(stateValue);
+  }
+  if (typeof stateValue !== 'string') {
+    return stateValue;
+  }
+  const statePath = toStatePath(stateValue);
+  return pathToStateValue(statePath);
+}
+function pathToStateValue(statePath) {
+  if (statePath.length === 1) {
+    return statePath[0];
+  }
+  const value = {};
+  let marker = value;
+  for (let i = 0; i < statePath.length - 1; i++) {
+    if (i === statePath.length - 2) {
+      marker[statePath[i]] = statePath[i + 1];
+    } else {
+      const previous = marker;
+      marker = {};
+      previous[statePath[i]] = marker;
+    }
+  }
+  return value;
+}
+function mapValues(collection, iteratee) {
+  const result = {};
+  const collectionKeys = Object.keys(collection);
+  for (let i = 0; i < collectionKeys.length; i++) {
+    const key = collectionKeys[i];
+    result[key] = iteratee(collection[key], key, collection, i);
+  }
+  return result;
+}
+function flatten(array) {
+  return [].concat(...array);
+}
+function toArrayStrict(value) {
+  if (isArray(value)) {
+    return value;
+  }
+  return [value];
+}
+function toArray(value) {
+  if (value === undefined) {
+    return [];
+  }
+  return toArrayStrict(value);
+}
+function mapContext(mapper, context, event) {
+  if (typeof mapper === 'function') {
+    return mapper({
+      context,
+      event
+    });
+  }
+  const result = {};
+  const args = {
+    context,
+    event
+  };
+  for (const key of Object.keys(mapper)) {
+    const subMapper = mapper[key];
+    if (typeof subMapper === 'function') {
+      result[key] = subMapper(args);
+    } else {
+      result[key] = subMapper;
+    }
+  }
+  return result;
+}
+function isPromiseLike(value) {
+  if (value instanceof Promise) {
+    return true;
+  }
+  // Check if shape matches the Promise/A+ specification for a "thenable".
+  if (value !== null && (typeof value === 'function' || typeof value === 'object') && typeof value.then === 'function') {
+    return true;
+  }
+  return false;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isErrorEvent(event) {
+  return typeof event.type === 'string' && (event.type === errorExecution || event.type.startsWith(errorPlatform));
+}
+function toTransitionConfigArray(configLike) {
+  return toArrayStrict(configLike).map(transitionLike => {
+    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string') {
+      return {
+        target: transitionLike
+      };
+    }
+    return transitionLike;
+  });
+}
+function normalizeTarget(target) {
+  if (target === undefined || target === TARGETLESS_KEY) {
+    return undefined;
+  }
+  return toArray(target);
+}
+function toInvokeConfig(invocable, id) {
+  if (typeof invocable === 'object') {
+    if ('src' in invocable) {
+      return invocable;
+    }
+    if ('transition' in invocable) {
+      return {
+        id,
+        src: invocable
+      };
+    }
+  }
+  return {
+    id,
+    src: invocable
+  };
+}
+function toObserver(nextHandler, errorHandler, completionHandler) {
+  const noop = () => {};
+  const isObserver = typeof nextHandler === 'object';
+  const self = isObserver ? nextHandler : null;
+  return {
+    next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self),
+    error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self),
+    complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self)
+  };
+}
+function createInvokeId(stateNodeId, index) {
+  return `${stateNodeId}:invocation[${index}]`;
+}
+function resolveReferencedActor(referenced) {
+  return referenced ? 'transition' in referenced ? {
+    src: referenced,
+    input: undefined
+  } : referenced : undefined;
 }
 
 function fromCallback(invokeCallback) {
@@ -934,7 +849,7 @@ function fromCallback(invokeCallback) {
       }
       if (event.type === stopSignalType) {
         state.canceled = true;
-        if (isFunction(state.dispose)) {
+        if (typeof state.dispose === 'function') {
           state.dispose();
         }
         return state;
@@ -1335,14 +1250,24 @@ class Interpreter {
   }
 
   // TODO: make private (and figure out a way to do this within the machine)
-  delaySend(sendAction) {
-    this.delayedEventsMap[sendAction.params.id] = this.clock.setTimeout(() => {
-      if ('to' in sendAction.params && sendAction.params.to) {
-        sendAction.params.to.send(sendAction.params.event);
+  delaySend({
+    event,
+    id,
+    delay,
+    to
+  }) {
+    const timerId = this.clock.setTimeout(() => {
+      if (to) {
+        to.send(event);
       } else {
-        this.send(sendAction.params.event);
+        this.send(event);
       }
-    }, sendAction.params.delay);
+    }, delay);
+
+    // TODO: consider the rehydration story here
+    if (id) {
+      this.delayedEventsMap[id] = timerId;
+    }
   }
 
   // TODO: make private (and figure out a way to do this within the machine)
@@ -1387,78 +1312,75 @@ function interpret(logic, options) {
   return interpreter;
 }
 
-function invoke(invokeDef) {
-  return createDynamicAction({
-    type: invoke$1,
-    params: invokeDef
-  }, (event, {
-    state,
-    actorContext
-  }) => {
-    const type = invoke$1;
-    const {
+function resolve$6(actorContext, state, actionArgs, {
+  id,
+  systemId,
+  src,
+  input
+}) {
+  const referenced = resolveReferencedActor(state.machine.implementations.actors[src]);
+  let actorRef;
+  if (referenced) {
+    // TODO: inline `input: undefined` should win over the referenced one
+    const configuredInput = input || referenced.input;
+    actorRef = interpret(referenced.src, {
       id,
-      src
-    } = invokeDef;
-    let resolvedInvokeAction;
-    const referenced = resolveReferencedActor(state.machine.implementations.actors[src]);
-    if (!referenced) {
-      resolvedInvokeAction = {
-        type,
-        params: invokeDef
-      };
-    } else {
-      const input = 'input' in invokeDef ? invokeDef.input : referenced.input;
-      const ref = interpret(referenced.src, {
-        id,
-        src,
-        parent: actorContext?.self,
-        systemId: invokeDef.systemId,
-        input: typeof input === 'function' ? input({
-          context: state.context,
-          event,
-          self: actorContext?.self
-        }) : input
-      });
-      resolvedInvokeAction = {
-        type,
-        params: {
-          ...invokeDef,
-          ref
-        }
-      };
-    }
-    const actorRef = resolvedInvokeAction.params.ref;
-    const invokedState = cloneState(state, {
-      children: {
-        ...state.children,
-        [id]: actorRef
-      }
+      src,
+      parent: actorContext?.self,
+      systemId,
+      input: typeof configuredInput === 'function' ? configuredInput({
+        context: state.context,
+        event: actionArgs.event,
+        self: actorContext?.self
+      }) : configuredInput
     });
-    resolvedInvokeAction.execute = actorCtx => {
-      const parent = actorCtx.self;
-      const {
-        id,
-        ref
-      } = resolvedInvokeAction.params;
-      if (!ref) {
-        return;
-      }
-      actorCtx.defer(() => {
-        if (actorRef.status === ActorStatus.Stopped) {
-          return;
-        }
-        try {
-          actorRef.start?.();
-        } catch (err) {
-          parent.send(error(id, err));
-          return;
-        }
-      });
-    };
-    return [invokedState, resolvedInvokeAction];
+  }
+  return [cloneState(state, {
+    children: {
+      ...state.children,
+      [id]: actorRef
+    }
+  }), {
+    id,
+    actorRef
+  }];
+}
+function execute$3(actorContext, {
+  id,
+  actorRef
+}) {
+  if (!actorRef) {
+    return;
+  }
+  actorContext.defer(() => {
+    if (actorRef.status === ActorStatus.Stopped) {
+      return;
+    }
+    try {
+      actorRef.start?.();
+    } catch (err) {
+      actorContext.self.send(error(id, err));
+      return;
+    }
   });
 }
+function invoke({
+  id,
+  systemId,
+  src,
+  input
+}) {
+  function invoke(_) {
+  }
+  invoke.type = 'xstate.invoke';
+  invoke.id = id;
+  invoke.systemId = systemId;
+  invoke.src = src;
+  invoke.input = input;
+  invoke.resolve = resolve$6;
+  invoke.execute = execute$3;
+  return invoke;
+}
 
 function stateIn(stateValue) {
   return {
@@ -1469,7 +1391,7 @@ function stateIn(stateValue) {
     predicate: ({
       state
     }) => {
-      if (isString(stateValue) && isStateId(stateValue)) {
+      if (typeof stateValue === 'string' && isStateId(stateValue)) {
         return state.configuration.some(sn => sn.id === stateValue.slice(1));
       }
       return state.matches(stateValue);
@@ -1553,9 +1475,9 @@ function evaluateGuard(guard, context, event, state) {
 function toGuardDefinition(guardConfig, getPredicate) {
   // TODO: check for cycles and consider a refactor to more lazily evaluated guards
   // TODO: resolve this more recursively: https://github.com/statelyai/xstate/pull/4064#discussion_r1229915724
-  if (isString(guardConfig)) {
+  if (typeof guardConfig === 'string') {
     const predicateOrDef = getPredicate?.(guardConfig);
-    if (isFunction(predicateOrDef)) {
+    if (typeof predicateOrDef === 'function') {
       return {
         type: guardConfig,
         predicate: predicateOrDef,
@@ -1574,7 +1496,7 @@ function toGuardDefinition(guardConfig, getPredicate) {
       };
     }
   }
-  if (isFunction(guardConfig)) {
+  if (typeof guardConfig === 'function') {
     return {
       type: guardConfig.name,
       predicate: guardConfig,
@@ -1585,7 +1507,7 @@ function toGuardDefinition(guardConfig, getPredicate) {
     };
   }
   const predicateOrDef = getPredicate?.(guardConfig.type);
-  if (isFunction(predicateOrDef)) {
+  if (typeof predicateOrDef === 'function') {
     return {
       type: guardConfig.type,
       params: guardConfig.params || guardConfig,
@@ -1712,24 +1634,16 @@ function isInFinalState(configuration, stateNode = configuration[0].machine.root
 }
 const isStateId = str => str[0] === STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
-  const candidates = stateNode.transitions.filter(transition => {
-    const {
-      eventType
-    } = transition;
-    // First, check the trivial case: event names are exactly equal
-    if (eventType === receivedEventType) {
-      return true;
-    }
-
-    // Then, check if transition is a wildcard transition,
+  const candidates = stateNode.transitions.get(receivedEventType) || [...stateNode.transitions.keys()].filter(descriptor => {
+    // check if transition is a wildcard transition,
     // which matches any non-transient events
-    if (eventType === WILDCARD) {
+    if (descriptor === WILDCARD) {
       return true;
     }
-    if (!eventType.endsWith('.*')) {
+    if (!descriptor.endsWith('.*')) {
       return false;
     }
-    const partialEventTokens = eventType.split('.');
+    const partialEventTokens = descriptor.split('.');
     const eventTokens = receivedEventType.split('.');
     for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
       const partialEventToken = partialEventTokens[tokenIndex];
@@ -1743,7 +1657,7 @@ function getCandidates(stateNode, receivedEventType) {
       }
     }
     return true;
-  });
+  }).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
   return candidates;
 }
 
@@ -1756,11 +1670,12 @@ function getDelayedTransitions(stateNode) {
     return [];
   }
   const mutateEntryExit = (delay, i) => {
-    const delayRef = isFunction(delay) ? `${stateNode.id}:delay[${i}]` : delay;
+    const delayRef = typeof delay === 'function' ? `${stateNode.id}:delay[${i}]` : delay;
     const eventType = after(delayRef, stateNode.id);
     stateNode.entry.push(raise({
       type: eventType
     }, {
+      id: eventType,
       delay
     }));
     stateNode.exit.push(cancel(eventType));
@@ -1774,7 +1689,7 @@ function getDelayedTransitions(stateNode) {
     };
   }) : Object.keys(afterConfig).flatMap((delay, i) => {
     const configTransition = afterConfig[delay];
-    const resolvedTransition = isString(configTransition) ? {
+    const resolvedTransition = typeof configTransition === 'string' ? {
       target: configTransition
     } : configTransition;
     const resolvedDelay = !isNaN(+delay) ? +delay : delay;
@@ -1790,12 +1705,12 @@ function getDelayedTransitions(stateNode) {
       delay
     } = delayedTransition;
     return {
-      ...formatTransition(stateNode, delayedTransition),
+      ...formatTransition(stateNode, delayedTransition.event, delayedTransition),
       delay
     };
   });
 }
-function formatTransition(stateNode, transitionConfig) {
+function formatTransition(stateNode, descriptor, transitionConfig) {
   const normalizedTarget = normalizeTarget(transitionConfig.target);
   const reenter = transitionConfig.reenter ?? false;
   const {
@@ -1804,12 +1719,12 @@ function formatTransition(stateNode, transitionConfig) {
   const target = resolveTarget(stateNode, normalizedTarget);
   const transition = {
     ...transitionConfig,
-    actions: toActionObjects(toArray(transitionConfig.actions)),
+    actions: toArray(transitionConfig.actions),
     guard: transitionConfig.guard ? toGuardDefinition(transitionConfig.guard, guardType => guards[guardType]) : undefined,
     target,
     source: stateNode,
     reenter,
-    eventType: transitionConfig.event,
+    eventType: descriptor,
     toJSON: () => ({
       ...transition,
       source: `#${stateNode.id}`,
@@ -1819,52 +1734,50 @@ function formatTransition(stateNode, transitionConfig) {
   return transition;
 }
 function formatTransitions(stateNode) {
-  const transitionConfigs = [];
-  if (Array.isArray(stateNode.config.on)) {
-    transitionConfigs.push(...stateNode.config.on);
-  } else if (stateNode.config.on) {
-    const {
-      [WILDCARD]: wildcardConfigs = [],
-      ...namedTransitionConfigs
-    } = stateNode.config.on;
-    for (const eventType of Object.keys(namedTransitionConfigs)) {
-      if (eventType === NULL_EVENT) {
+  const transitions = new Map();
+  if (stateNode.config.on) {
+    for (const descriptor of Object.keys(stateNode.config.on)) {
+      if (descriptor === NULL_EVENT) {
         throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
       }
-      const eventTransitionConfigs = toTransitionConfigArray(eventType, namedTransitionConfigs[eventType]);
-      transitionConfigs.push(...eventTransitionConfigs);
-      // TODO: add dev-mode validation for unreachable transitions
+      const transitionsConfig = stateNode.config.on[descriptor];
+      transitions.set(descriptor, toTransitionConfigArray(transitionsConfig).map(t => formatTransition(stateNode, descriptor, t)));
     }
-
-    transitionConfigs.push(...toTransitionConfigArray(WILDCARD, wildcardConfigs));
   }
-  const doneConfig = stateNode.config.onDone ? toTransitionConfigArray(String(done(stateNode.id)), stateNode.config.onDone) : [];
-  const invokeConfig = stateNode.invoke.flatMap(invokeDef => {
-    const settleTransitions = [];
+  if (stateNode.config.onDone) {
+    const descriptor = String(done(stateNode.id));
+    transitions.set(descriptor, toTransitionConfigArray(stateNode.config.onDone).map(t => formatTransition(stateNode, descriptor, t)));
+  }
+  for (const invokeDef of stateNode.invoke) {
     if (invokeDef.onDone) {
-      settleTransitions.push(...toTransitionConfigArray(`done.invoke.${invokeDef.id}`, invokeDef.onDone));
+      const descriptor = `done.invoke.${invokeDef.id}`;
+      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onDone).map(t => formatTransition(stateNode, descriptor, t)));
     }
     if (invokeDef.onError) {
-      settleTransitions.push(...toTransitionConfigArray(`error.platform.${invokeDef.id}`, invokeDef.onError));
+      const descriptor = `error.platform.${invokeDef.id}`;
+      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onError).map(t => formatTransition(stateNode, descriptor, t)));
     }
     if (invokeDef.onSnapshot) {
-      settleTransitions.push(...toTransitionConfigArray(`xstate.snapshot.${invokeDef.id}`, invokeDef.onSnapshot));
+      const descriptor = `xstate.snapshot.${invokeDef.id}`;
+      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onSnapshot).map(t => formatTransition(stateNode, descriptor, t)));
     }
-    return settleTransitions;
-  });
-  const delayedTransitions = stateNode.after;
-  const formattedTransitions = [...doneConfig, ...invokeConfig, ...transitionConfigs].flatMap(transitionConfig => toArray(transitionConfig).map(transition => formatTransition(stateNode, transition)));
-  for (const delayedTransition of delayedTransitions) {
-    formattedTransitions.push(delayedTransition);
   }
-  return formattedTransitions;
+  for (const delayedTransition of stateNode.after) {
+    let existing = transitions.get(delayedTransition.eventType);
+    if (!existing) {
+      existing = [];
+      transitions.set(delayedTransition.eventType, existing);
+    }
+    existing.push(delayedTransition);
+  }
+  return transitions;
 }
 function formatInitialTransition(stateNode, _target) {
-  if (isString(_target) || isArray(_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 = isString(t) ? isStateId(t) ? stateNode.machine.getStateNodeById(t) : stateNode.states[t] : t;
+      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}`);
       }
@@ -1888,15 +1801,14 @@ function formatInitialTransition(stateNode, _target) {
     };
     return transition;
   }
-  return formatTransition(stateNode, {
+  return formatTransition(stateNode, '__INITIAL__', {
     target: toArray(_target.target).map(t => {
-      if (isString(t)) {
+      if (typeof t === 'string') {
         return isStateId(t) ? t : `${STATE_DELIMITER}${t}`;
       }
       return t;
     }),
-    actions: _target.actions,
-    event: null
+    actions: _target.actions
   });
 }
 function resolveTarget(stateNode, targets) {
@@ -1905,7 +1817,7 @@ function resolveTarget(stateNode, targets) {
     return undefined;
   }
   return targets.map(target => {
-    if (!isString(target)) {
+    if (typeof target !== 'string') {
       return target;
     }
     if (isStateId(target)) {
@@ -2013,7 +1925,7 @@ function getStateNodeByPath(stateNode, statePath) {
  */
 function getStateNodes(stateNode, state) {
   const stateValue = state instanceof State ? state.value : toStateValue(state);
-  if (isString(stateValue)) {
+  if (typeof stateValue === 'string') {
     return [stateNode, stateNode.states[stateValue]];
   }
   const childStateKeys = Object.keys(stateValue);
@@ -2064,7 +1976,7 @@ function transitionParallelNode(stateNode, stateValue, state, event) {
 }
 function transitionNode(stateNode, stateValue, state, event) {
   // leaf node
-  if (isString(stateValue)) {
+  if (typeof stateValue === 'string') {
     return transitionAtomicNode(stateNode, stateValue, state, event);
   }
 
@@ -2398,44 +2310,55 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
   const {
     machine
   } = currentState;
-  const raiseActions = [];
-  let intermediateState = currentState;
-  function handleAction(action) {
-    if (actorCtx?.self.status === ActorStatus.Running) {
-      action.execute?.(actorCtx);
-    } else {
-      actorCtx?.defer(() => action.execute?.(actorCtx));
+  // 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: []
+  });
+  for (const action of actions) {
+    const resolved = typeof action === 'function' ? action : machine.implementations.actions[typeof action === 'string' ? action : action.type];
+    if (!resolved) {
+      continue;
     }
-  }
-  function resolveAction(actionObject) {
-    const executableActionObject = resolveActionObject(actionObject, machine.implementations.actions);
-    if (isDynamicAction(executableActionObject)) {
-      const [nextState, resolvedAction] = executableActionObject.resolve(event, {
-        state: intermediateState,
-        action: actionObject,
-        actorContext: actorCtx
-      });
-      const matchedActions = resolvedAction.params?.actions;
-      intermediateState = nextState;
-      if (resolvedAction.type === raise$1 && typeof resolvedAction.params.delay !== 'number') {
-        raiseActions.push(resolvedAction);
+    const args = {
+      context: intermediateState.context,
+      event,
+      self: actorCtx?.self,
+      system: actorCtx?.system,
+      // TODO: figure out story for `action` and inline actions
+      // what those ones should receive?
+      //
+      // entry: ({ action }) => {}
+      // exit: assign(({ action }) => {})
+      action: typeof action === 'string' ? {
+        type: action
+      } : action
+    };
+    if (!('resolve' in resolved)) {
+      if (actorCtx?.self.status === ActorStatus.Running) {
+        resolved(args);
+      } else {
+        actorCtx?.defer(() => resolved(args));
       }
+      continue;
+    }
+    const builtinAction = resolved;
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, args, resolved // this holds all params
+    );
 
-      // TODO: remove the check; just handleAction
-      if (resolvedAction.type !== pure$1) {
-        handleAction(resolvedAction);
+    intermediateState = nextState;
+    if ('execute' in resolved) {
+      if (actorCtx?.self.status === ActorStatus.Running) {
+        builtinAction.execute(actorCtx, params);
+      } else {
+        actorCtx?.defer(builtinAction.execute.bind(null, actorCtx, params));
       }
-      toActionObjects(matchedActions).forEach(resolveAction);
-      return;
     }
-    handleAction(executableActionObject);
-  }
-  for (const actionObject of actions) {
-    resolveAction(actionObject);
+    if (actions) {
+      intermediateState = resolveActionsAndContext(actions, event, intermediateState, actorCtx);
+    }
   }
-  return cloneState(intermediateState, {
-    _internalQueue: raiseActions.map(a => a.params.event)
-  });
+  return intermediateState;
 }
 function macrostep(state, event, actorCtx) {
   let nextState = state;
@@ -2454,7 +2377,7 @@ function macrostep(state, event, actorCtx) {
 
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
-  if (nextEvent.type !== init) {
+  if (nextEvent.type !== INIT_TYPE) {
     const transitions = selectTransitions(nextEvent, nextState);
     nextState = microstep(transitions, state, actorCtx, nextEvent, false);
     states.push(nextState);
@@ -2620,7 +2543,7 @@ class State {
    * @param delimiter The character(s) that separate each subpath in the string state node path.
    */
   toStrings(stateValue = this.value) {
-    if (isString(stateValue)) {
+    if (typeof stateValue === 'string') {
       return [stateValue];
     }
     const valueKeys = Object.keys(stateValue);
@@ -2715,6 +2638,36 @@ function getPersistedState(state) {
   };
 }
 
+function resolve$5(_, state, args, {
+  actorRef
+}) {
+  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args) : actorRef;
+  const resolvedActorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
+  let children = state.children;
+  if (resolvedActorRef) {
+    children = {
+      ...children
+    };
+    delete children[resolvedActorRef.id];
+  }
+  return [cloneState(state, {
+    children
+  }), resolvedActorRef];
+}
+function execute$2(actorContext, actorRef) {
+  if (!actorRef) {
+    return;
+  }
+  if (actorRef.status !== ActorStatus.Running) {
+    actorContext.stopChild(actorRef);
+    return;
+  }
+  // TODO: recheck why this one has to be deferred
+  actorContext.defer(() => {
+    actorContext.stopChild(actorRef);
+  });
+}
+
 /**
  * Stops an actor.
  *
@@ -2722,61 +2675,37 @@ function getPersistedState(state) {
  */
 
 function stop(actorRef) {
-  const actor = actorRef;
-  return createDynamicAction({
-    type: stop$1,
-    params: {
-      actor
-    }
-  }, (event, {
-    state,
-    actorContext
-  }) => {
-    const actorRefOrString = isFunction(actor) ? actor({
-      context: state.context,
-      event,
-      self: actorContext?.self ?? {},
-      system: actorContext?.system
-    }) : actor;
-    const actorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
-    let children = state.children;
-    if (actorRef) {
-      children = {
-        ...children
-      };
-      delete children[actorRef.id];
-    }
-    return [cloneState(state, {
-      children
-    }), {
-      type: 'xstate.stop',
-      params: {
-        actor: actorRef
-      },
-      execute: actorCtx => {
-        if (!actorRef) {
-          return;
-        }
-        if (actorRef.status !== ActorStatus.Running) {
-          actorCtx.stopChild(actorRef);
-          return;
-        }
-        actorCtx.defer(() => {
-          actorCtx.stopChild(actorRef);
-        });
-      }
-    }];
-  });
+  function stop(_) {
+  }
+  stop.type = 'xstate.stop';
+  stop.actorRef = actorRef;
+  stop.resolve = resolve$5;
+  stop.execute = execute$2;
+  return stop;
+}
+
+function resolve$4(_, state, actionArgs, {
+  value,
+  label
+}) {
+  return [state, {
+    value: typeof value === 'function' ? value(actionArgs) : value,
+    label
+  }];
+}
+function execute$1({
+  logger
+}, {
+  value,
+  label
+}) {
+  if (label) {
+    logger(label, value);
+  } else {
+    logger(value);
+  }
 }
 
-const defaultLogExpr = ({
-  context,
-  event
-}) => ({
-  context,
-  event
-});
-
 /**
  *
  * @param expr The expression function to evaluate which will be logged.
@@ -2785,39 +2714,21 @@ const defaultLogExpr = ({
  *  - `event` - the event that caused this action to be executed.
  * @param label The label to give to the logged expression.
  */
-
-function log(expr = defaultLogExpr, label) {
-  return createDynamicAction({
-    type: log$1,
-    params: {
-      label,
-      expr
-    }
-  }, (event, {
-    state,
-    actorContext
-  }) => {
-    const resolvedValue = typeof expr === 'function' ? expr({
-      context: state.context,
-      event,
-      self: actorContext?.self ?? {},
-      system: actorContext?.system
-    }) : expr;
-    return [state, {
-      type: 'xstate.log',
-      params: {
-        label,
-        value: resolvedValue
-      },
-      execute: actorCtx => {
-        if (label) {
-          actorCtx.logger?.(label, resolvedValue);
-        } else {
-          actorCtx.logger?.(resolvedValue);
-        }
-      }
-    }];
-  });
+function log(value = ({
+  context,
+  event
+}) => ({
+  context,
+  event
+}), label) {
+  function log(_) {
+  }
+  log.type = 'xstate.log';
+  log.value = value;
+  log.label = label;
+  log.resolve = resolve$4;
+  log.execute = execute$1;
+  return log;
 }
 
 function createSpawner(actorContext, {
@@ -2876,57 +2787,84 @@ function createSpawner(actorContext, {
   };
 }
 
+function resolve$3(actorContext, state, actionArgs, {
+  assignment
+}) {
+  if (!state.context) {
+    throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
+  }
+  const spawnedChildren = {};
+  const assignArgs = {
+    context: state.context,
+    event: actionArgs.event,
+    action: actionArgs.action,
+    spawn: createSpawner(actorContext, state, actionArgs.event, spawnedChildren),
+    self: actorContext?.self,
+    system: actorContext?.system
+  };
+  let partialUpdate = {};
+  if (typeof assignment === 'function') {
+    partialUpdate = assignment(assignArgs);
+  } else {
+    for (const key of Object.keys(assignment)) {
+      const propAssignment = assignment[key];
+      partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(assignArgs) : propAssignment;
+    }
+  }
+  const updatedContext = Object.assign({}, state.context, partialUpdate);
+  return [cloneState(state, {
+    context: updatedContext,
+    children: Object.keys(spawnedChildren).length ? {
+      ...state.children,
+      ...spawnedChildren
+    } : state.children
+  })];
+}
+
 /**
  * Updates the current context of the machine.
  *
  * @param assignment An object that represents the partial context to update.
  */
 function assign(assignment) {
-  return createDynamicAction({
-    type: assign$1,
-    params: {
-      assignment
-    }
-  }, (event, {
-    state,
-    action,
-    actorContext
-  }) => {
-    if (!state.context) {
-      throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
-    }
-    const spawnedChildren = {};
-    const args = {
-      context: state.context,
-      event,
-      action,
-      spawn: createSpawner(actorContext, state, event, spawnedChildren),
-      self: actorContext?.self ?? {},
-      system: actorContext?.system
-    };
-    let partialUpdate = {};
-    if (isFunction(assignment)) {
-      partialUpdate = assignment(args);
-    } else {
-      for (const key of Object.keys(assignment)) {
-        const propAssignment = assignment[key];
-        partialUpdate[key] = isFunction(propAssignment) ? propAssignment(args) : propAssignment;
-      }
-    }
-    const updatedContext = Object.assign({}, state.context, partialUpdate);
-    return [cloneState(state, {
-      context: updatedContext,
-      children: Object.keys(spawnedChildren).length ? {
-        ...state.children,
-        ...spawnedChildren
-      } : state.children
-    }), {
-      type: assign$1,
-      params: {
-        context: updatedContext
-      }
-    }];
-  });
+  function assign(_) {
+  }
+  assign.type = 'xstate.assign';
+  assign.assignment = assignment;
+  assign.resolve = resolve$3;
+  return assign;
+}
+
+function resolve$2(_, state, args, {
+  event: eventOrExpr,
+  id,
+  delay
+}) {
+  const delaysMap = state.machine.implementations.delays;
+  if (typeof eventOrExpr === 'string') {
+    throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
+  }
+  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr;
+  let resolvedDelay;
+  if (typeof delay === 'string') {
+    const configDelay = delaysMap && delaysMap[delay];
+    resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
+  } else {
+    resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
+  }
+  return [typeof resolvedDelay !== 'number' ? cloneState(state, {
+    _internalQueue: state._internalQueue.concat(resolvedEvent)
+  }) : state, {
+    event: resolvedEvent,
+    id,
+    delay: resolvedDelay
+  }];
+}
+function execute(actorContext, params) {
+  if (typeof params.delay === 'number') {
+    actorContext.self.delaySend(params);
+    return;
+  }
 }
 
 /**
@@ -2937,183 +2875,51 @@ function assign(assignment) {
  */
 
 function raise(eventOrExpr, options) {
-  return createDynamicAction({
-    type: raise$1,
-    params: {
-      delay: options ? options.delay : undefined,
-      event: eventOrExpr,
-      id: options && options.id !== undefined ? options.id : typeof eventOrExpr === 'function' ? eventOrExpr.name : eventOrExpr.type
-    }
-  }, (event, {
-    state,
-    actorContext
-  }) => {
-    const params = {
-      delay: options ? options.delay : undefined,
-      event: eventOrExpr,
-      id: options && options.id !== undefined ? options.id : typeof eventOrExpr === 'function' ? eventOrExpr.name : eventOrExpr.type
-    };
-    const args = {
-      context: state.context,
-      event,
-      self: actorContext?.self ?? {},
-      system: actorContext?.system
-    };
-    const delaysMap = state.machine.implementations.delays;
-
-    // TODO: helper function for resolving Expr
-    if (typeof eventOrExpr === 'string') {
-      throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
-    }
-    const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr;
-    let resolvedDelay;
-    if (typeof params.delay === 'string') {
-      const configDelay = delaysMap && delaysMap[params.delay];
-      resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
-    } else {
-      resolvedDelay = typeof params.delay === 'function' ? params.delay(args) : params.delay;
-    }
-    const resolvedAction = {
-      type: raise$1,
-      params: {
-        ...params,
-        event: resolvedEvent,
-        delay: resolvedDelay
-      },
-      execute: actorCtx => {
-        if (typeof resolvedAction.params.delay === 'number') {
-          actorCtx.self.delaySend(resolvedAction);
-          return;
-        }
-      }
-    };
-    return [state, resolvedAction];
-  });
+  function raise(_) {
+  }
+  raise.type = 'xstate.raise';
+  raise.event = eventOrExpr;
+  raise.id = options?.id;
+  raise.delay = options?.delay;
+  raise.resolve = resolve$2;
+  raise.execute = execute;
+  return raise;
+}
+
+function resolve$1(_, state, actionArgs, {
+  branches
+}) {
+  const matchedActions = branches.find(condition => {
+    const guard = condition.guard && toGuardDefinition(condition.guard, guardType => state.machine.implementations.guards[guardType]);
+    return !guard || evaluateGuard(guard, state.context, actionArgs.event, state);
+  })?.actions;
+  return [state, undefined, toArray(matchedActions)];
+}
+function choose(branches) {
+  function choose(_) {
+  }
+  choose.type = 'xstate.choose';
+  choose.branches = branches;
+  choose.resolve = resolve$1;
+  return choose;
+}
+
+function resolve(_, state, args, {
+  get
+}) {
+  return [state, undefined, toArray(get({
+    context: state.context,
+    event: args.event
+  }))];
 }
-
-function choose(guards) {
-  return createDynamicAction({
-    type: choose$1,
-    params: {
-      guards
-    }
-  }, (event, {
-    state
-  }) => {
-    const matchedActions = guards.find(condition => {
-      const guard = condition.guard && toGuardDefinition(condition.guard, guardType => state.machine.implementations.guards[guardType]);
-      return !guard || evaluateGuard(guard, state.context, event, state);
-    })?.actions;
-    return [state, {
-      type: choose$1,
-      params: {
-        actions: toActionObjects(matchedActions)
-      }
-    }];
-  });
-}
-
 function pure(getActions) {
-  return createDynamicAction({
-    type: pure$1,
-    params: {
-      get: getActions
-    }
-  }, (event, {
-    state
-  }) => {
-    return [state, {
-      type: pure$1,
-      params: {
-        actions: toArray(toActionObjects(getActions({
-          context: state.context,
-          event
-        }))) ?? []
-      }
-    }];
-  });
-}
-
-function resolveActionObject(actionObject, actionFunctionMap) {
-  if (isDynamicAction(actionObject)) {
-    return actionObject;
-  }
-  const dereferencedAction = actionFunctionMap[actionObject.type];
-  if (typeof dereferencedAction === 'function') {
-    return createDynamicAction({
-      type: 'xstate.function',
-      params: actionObject.params ?? {}
-    }, (event, {
-      state
-    }) => {
-      const a = {
-        type: actionObject.type,
-        params: actionObject.params,
-        execute: actorCtx => {
-          return dereferencedAction({
-            context: state.context,
-            event,
-            action: a,
-            system: actorCtx.system,
-            self: actorCtx.self
-          });
-        }
-      };
-      return [state, a];
-    });
-  } else if (dereferencedAction) {
-    return dereferencedAction;
-  } else {
-    return actionObject;
-  }
-}
-function toActionObject(action) {
-  if (isDynamicAction(action)) {
-    return action;
+  function pure(_) {
   }
-  if (typeof action === 'string') {
-    return {
-      type: action,
-      params: {}
-    };
-  }
-  if (typeof action === 'function') {
-    const type = 'xstate.function';
-    return createDynamicAction({
-      type,
-      params: {}
-    }, (event, {
-      state
-    }) => {
-      const actionObject = {
-        type,
-        params: {
-          function: action
-        },
-        execute: actorCtx => {
-          return action({
-            context: state.context,
-            event: event,
-            action: actionObject,
-            self: actorCtx.self,
-            system: actorCtx.system
-          });
-        }
-      };
-      return [state, actionObject];
-    });
-  }
-
-  // action is already a BaseActionObject
-  return action;
+  pure.type = 'xstate.pure';
+  pure.get = getActions;
+  pure.resolve = resolve;
+  return pure;
 }
-const toActionObjects = action => {
-  if (!action) {
-    return [];
-  }
-  const actions = isArray(action) ? action : [action];
-  return actions.map(toActionObject);
-};
 
 /**
  * Returns an event type that represents an implicit event that
@@ -3124,7 +2930,7 @@ const toActionObjects = action => {
  */
 function after(delayRef, id) {
   const idSuffix = id ? `#${id}` : '';
-  return `${ActionTypes.After}(${delayRef})${idSuffix}`;
+  return `${ConstantPrefix.After}(${delayRef})${idSuffix}`;
 }
 
 /**
@@ -3135,7 +2941,7 @@ function after(delayRef, id) {
  * @param output The data to pass into the event
  */
 function done(id, output) {
-  const type = `${ActionTypes.DoneState}.${id}`;
+  const type = `${ConstantPrefix.DoneState}.${id}`;
   const eventObject = {
     type,
     output
@@ -3154,7 +2960,7 @@ function done(id, output) {
  * @param output The data to pass into the event
  */
 function doneInvoke(invokeId, output) {
-  const type = `${ActionTypes.DoneInvoke}.${invokeId}`;
+  const type = `${ConstantPrefix.DoneInvoke}.${invokeId}`;
   const eventObject = {
     type,
     output
@@ -3163,7 +2969,7 @@ function doneInvoke(invokeId, output) {
   return eventObject;
 }
 function error(id, data) {
-  const type = `${ActionTypes.ErrorPlatform}.${id}`;
+  const type = `${ConstantPrefix.ErrorPlatform}.${id}`;
   const eventObject = {
     type,
     data
@@ -3173,24 +2979,24 @@ function error(id, data) {
 }
 function createInitEvent(input) {
   return {
-    type: init,
+    type: INIT_TYPE,
     input
   };
 }
 
-exports.ActionTypes = ActionTypes;
 exports.ActorStatus = ActorStatus;
+exports.ConstantPrefix = ConstantPrefix;
 exports.Interpreter = Interpreter;
 exports.NULL_EVENT = NULL_EVENT;
 exports.STATE_DELIMITER = STATE_DELIMITER;
 exports.SpecialTargets = SpecialTargets;
 exports.State = State;
-exports.actionTypes = actionTypes;
 exports.after = after;
 exports.and = and;
 exports.assign = assign;
 exports.cancel = cancel;
 exports.choose = choose;
+exports.constantPrefixes = constantPrefixes;
 exports.createEmptyActor = createEmptyActor;
 exports.createInitEvent = createInitEvent;
 exports.createInvokeId = createInvokeId;
@@ -3217,14 +3023,12 @@ exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.interpret = interpret;
-exports.invoke = invoke$1;
 exports.isActorRef = isActorRef;
 exports.isAtomicStateNode = isAtomicStateNode;
 exports.isErrorEvent = isErrorEvent;
 exports.isInFinalState = isInFinalState;
 exports.isSignal = isSignal;
 exports.isStateId = isStateId;
-exports.isString = isString;
 exports.log = log;
 exports.macrostep = macrostep;
 exports.mapValues = mapValues;
@@ -3236,7 +3040,6 @@ exports.or = or;
 exports.pathToStateValue = pathToStateValue;
 exports.pure = pure;
 exports.raise = raise;
-exports.resolveActionObject = resolveActionObject;
 exports.resolveActionsAndContext = resolveActionsAndContext;
 exports.resolveReferencedActor = resolveReferencedActor;
 exports.resolveStateValue = resolveStateValue;
@@ -3248,8 +3051,6 @@ exports.stateIn = stateIn;
 exports.stop = stop;
 exports.stopSignal = stopSignal;
 exports.stopSignalType = stopSignalType;
-exports.toActionObject = toActionObject;
-exports.toActionObjects = toActionObjects;
 exports.toActorRef = toActorRef;
 exports.toArray = toArray;
 exports.toGuardDefinition = toGuardDefinition;