xstate 5.0.0-beta.16 → 5.0.0-beta.18

package/dist/{actions-6f7fbc84.development.esm.js → actions-13190b25.development.esm.js}

@@ -15,12 +15,6 @@ import { devToolsAdapter } from '../dev/dist/xstate-dev.development.esm.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.
  *
@@ -32,25 +26,15 @@ import { devToolsAdapter } from '../dev/dist/xstate-dev.development.esm.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";
@@ -58,40 +42,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 = '.';
@@ -99,208 +62,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;
 }
 
 /**
@@ -312,94 +135,20 @@ 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;
+function sendTo(to, eventOrExpr, options) {
+  function sendTo(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-    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];
-  });
+  }
+  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;
 }
 
 /**
@@ -444,7 +193,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);
 }
@@ -463,6 +212,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
@@ -470,34 +229,17 @@ 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
+  function cancel(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  }, (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);
-      }
-    }];
-  });
+  }
+  cancel.type = 'xstate.cancel';
+  cancel.sendId = sendId;
+  cancel.resolve = resolve$7;
+  cancel.execute = execute$4;
+  return cancel;
 }
 
 class Mailbox {
@@ -897,7 +639,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) {
@@ -942,7 +863,7 @@ function fromCallback(invokeCallback) {
       }
       if (event.type === stopSignalType) {
         state.canceled = true;
-        if (isFunction(state.dispose)) {
+        if (typeof state.dispose === 'function') {
           state.dispose();
         }
         return state;
@@ -1348,14 +1269,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)
@@ -1400,81 +1331,81 @@ 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) {
-        {
-          console.warn(`Actor type '${resolvedInvokeAction.params.src}' not found in machine '${actorCtx.id}'.`);
-        }
-        return;
-      }
-      actorCtx.defer(() => {
-        if (actorRef.status === ActorStatus.Stopped) {
-          return;
-        }
-        try {
-          actorRef.start?.();
-        } catch (err) {
-          parent.send(error(id, err));
-          return;
-        }
-      });
-    };
-    return [invokedState, resolvedInvokeAction];
+  }
+  if (!actorRef) {
+    console.warn(`Actor type '${src}' not found in machine '${actorContext.id}'.`);
+  }
+  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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  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 {
@@ -1485,7 +1416,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);
@@ -1569,9 +1500,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,
@@ -1590,7 +1521,7 @@ function toGuardDefinition(guardConfig, getPredicate) {
       };
     }
   }
-  if (isFunction(guardConfig)) {
+  if (typeof guardConfig === 'function') {
     return {
       type: guardConfig.name,
       predicate: guardConfig,
@@ -1601,7 +1532,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,
@@ -1728,27 +1659,19 @@ 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;
     }
-    if (/.*\*.+/.test(eventType)) {
-      console.warn(`Wildcards can only be the last token of an event descriptor (e.g., "event.*") or the entire event descriptor ("*"). Check the "${eventType}" event.`);
+    if (/.*\*.+/.test(descriptor)) {
+      console.warn(`Wildcards can only be the last token of an event descriptor (e.g., "event.*") or the entire event descriptor ("*"). Check the "${descriptor}" event.`);
     }
-    const partialEventTokens = eventType.split('.');
+    const partialEventTokens = descriptor.split('.');
     const eventTokens = receivedEventType.split('.');
     for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
       const partialEventToken = partialEventTokens[tokenIndex];
@@ -1756,7 +1679,7 @@ function getCandidates(stateNode, receivedEventType) {
       if (partialEventToken === '*') {
         const isLastToken = tokenIndex === partialEventTokens.length - 1;
         if (!isLastToken) {
-          console.warn(`Infix wildcards in transition events are not allowed. Check the "${eventType}" event.`);
+          console.warn(`Infix wildcards in transition events are not allowed. Check the "${descriptor}" transition.`);
         }
         return isLastToken;
       }
@@ -1765,7 +1688,7 @@ function getCandidates(stateNode, receivedEventType) {
       }
     }
     return true;
-  });
+  }).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
   return candidates;
 }
 
@@ -1778,11 +1701,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));
@@ -1796,7 +1720,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;
@@ -1812,12 +1736,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 {
@@ -1831,12 +1755,12 @@ function formatTransition(stateNode, transitionConfig) {
   }
   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}`,
@@ -1846,52 +1770,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}`);
       }
@@ -1915,15 +1837,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) {
@@ -1932,7 +1853,7 @@ function resolveTarget(stateNode, targets) {
     return undefined;
   }
   return targets.map(target => {
-    if (!isString(target)) {
+    if (typeof target !== 'string') {
       return target;
     }
     if (isStateId(target)) {
@@ -2040,7 +1961,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);
@@ -2091,7 +2012,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);
   }
 
@@ -2425,44 +2346,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) {
   if (event.type === WILDCARD) {
@@ -2484,7 +2416,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);
@@ -2650,7 +2582,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);
@@ -2748,6 +2680,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.
  *
@@ -2755,61 +2717,40 @@ 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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  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.
@@ -2818,39 +2759,24 @@ 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
+function log(value = ({
+  context,
+  event
+}) => ({
+  context,
+  event
+}), label) {
+  function log(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  }, (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);
-        }
-      }
-    }];
-  });
+  }
+  log.type = 'xstate.log';
+  log.value = value;
+  log.label = label;
+  log.resolve = resolve$4;
+  log.execute = execute$1;
+  return log;
 }
 
 function createSpawner(actorContext, {
@@ -2909,57 +2835,87 @@ 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(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  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;
+  }
 }
 
 /**
@@ -2970,183 +2926,60 @@ 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`);
+  function raise(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-    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];
-  });
+  }
+  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 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 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 pure(getActions) {
-  return createDynamicAction({
-    type: pure$1,
-    params: {
-      get: getActions
+function choose(branches) {
+  function choose(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  }, (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;
   }
+  choose.type = 'xstate.choose';
+  choose.branches = branches;
+  choose.resolve = resolve$1;
+  return choose;
 }
-function toActionObject(action) {
-  if (isDynamicAction(action)) {
-    return action;
-  }
-  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;
+function resolve(_, state, args, {
+  get
+}) {
+  return [state, undefined, toArray(get({
+    context: state.context,
+    event: args.event
+  }))];
 }
-const toActionObjects = action => {
-  if (!action) {
-    return [];
+function pure(getActions) {
+  function pure(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
-  const actions = isArray(action) ? action : [action];
-  return actions.map(toActionObject);
-};
+  pure.type = 'xstate.pure';
+  pure.get = getActions;
+  pure.resolve = resolve;
+  return pure;
+}
 
 /**
  * Returns an event type that represents an implicit event that
@@ -3157,7 +2990,7 @@ const toActionObjects = action => {
  */
 function after(delayRef, id) {
   const idSuffix = id ? `#${id}` : '';
-  return `${ActionTypes.After}(${delayRef})${idSuffix}`;
+  return `${ConstantPrefix.After}(${delayRef})${idSuffix}`;
 }
 
 /**
@@ -3168,7 +3001,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
@@ -3187,7 +3020,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
@@ -3196,7 +3029,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
@@ -3206,9 +3039,9 @@ function error(id, data) {
 }
 function createInitEvent(input) {
   return {
-    type: init,
+    type: INIT_TYPE,
     input
   };
 }
 
-export { fromPromise as $, assign as A, microstep as B, isAtomicStateNode as C, error as D, isStateId as E, getStateNodeByPath as F, getPersistedState as G, resolveReferencedActor as H, interpret as I, createInitEvent as J, matchesState as K, sendTo as L, sendParent as M, NULL_EVENT as N, forwardTo as O, Interpreter as P, ActorStatus as Q, doneInvoke as R, STATE_DELIMITER as S, cancel as T, choose as U, log as V, pure as W, raise as X, stop as Y, pathToStateValue as Z, toObserver as _, toArray as a, fromObservable as a0, fromCallback as a1, fromEventObservable as a2, fromTransition as a3, stateIn as a4, not as a5, and as a6, or as a7, ActionTypes as a8, SpecialTargets as a9, startSignalType as aa, stopSignalType as ab, startSignal as ac, stopSignal as ad, isSignal as ae, isActorRef as af, toActorRef as ag, createEmptyActor as ah, toGuardDefinition as ai, actionTypes as aj, resolveActionObject as ak, toActionObject as al, after as am, done as an, escalate as ao, toTransitionConfigArray as b, formatTransition as c, memo as d, evaluateGuard as e, formatTransitions as f, flatten as g, createInvokeId as h, isString as i, invoke$1 as j, getDelayedTransitions as k, formatInitialTransition as l, mapValues as m, getCandidates as n, toInvokeConfig as o, getConfiguration as p, getStateNodes as q, resolveStateValue as r, isInFinalState as s, toActionObjects as t, State as u, isErrorEvent as v, macrostep as w, transitionNode as x, getInitialConfiguration as y, resolveActionsAndContext as z };
+export { fromEventObservable as $, isAtomicStateNode as A, error as B, isStateId as C, getStateNodeByPath as D, getPersistedState as E, resolveReferencedActor as F, interpret as G, matchesState as H, sendTo as I, sendParent as J, forwardTo as K, Interpreter as L, ActorStatus as M, NULL_EVENT as N, doneInvoke as O, cancel as P, choose as Q, log as R, STATE_DELIMITER as S, pure as T, raise as U, stop as V, pathToStateValue as W, toObserver as X, fromPromise as Y, fromObservable as Z, fromCallback as _, toTransitionConfigArray as a, fromTransition as a0, stateIn as a1, not as a2, and as a3, or as a4, ConstantPrefix as a5, SpecialTargets as a6, startSignalType as a7, stopSignalType as a8, startSignal as a9, stopSignal as aa, isSignal as ab, isActorRef as ac, toActorRef as ad, createEmptyActor as ae, toGuardDefinition as af, constantPrefixes as ag, after as ah, done as ai, escalate as aj, formatTransition as b, memo as c, flatten as d, evaluateGuard as e, formatTransitions as f, createInvokeId as g, getDelayedTransitions as h, formatInitialTransition as i, getCandidates as j, toInvokeConfig as k, getConfiguration as l, mapValues as m, getStateNodes as n, isInFinalState as o, State as p, isErrorEvent as q, resolveStateValue as r, macrostep as s, toArray as t, transitionNode as u, getInitialConfiguration as v, resolveActionsAndContext as w, assign as x, createInitEvent as y, microstep as z };