xstate 5.0.0-beta.15 → 5.0.0-beta.17

package/dist/{actions-d71ac253.development.cjs.js → actions-40bd643f.development.cjs.js}

@@ -17,12 +17,6 @@ var dev_dist_xstateDev = require('../dev/dist/xstate-dev.development.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.development.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["Send"] = "xstate.send";
-  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 send$1 = ActionTypes.Send;
-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,
-  send: send$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,311 +64,93 @@ 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;
+function execute$5(actorContext, params) {
+  if (typeof params.delay === 'number') {
+    actorContext.self.delaySend(params);
+    return;
   }
-  // Check if shape matches the Promise/A+ specification for a "thenable".
-  if (value !== null && (isFunction(value) || typeof value === 'object') && isFunction(value.then)) {
-    return true;
-  }
-  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;
 }
 
 /**
- * Sends an event. This returns an action that will be read by an interpreter to
- * send the event in the next step, after the current step is finished executing.
- *
- * @deprecated Use the `sendTo(...)` action creator instead.
+ * Sends an event to an actor.
  *
- * @param eventOrExpr The event to send.
- * @param options Options to pass into the send event:
+ * @param actor The `ActorRef` to send the event to.
+ * @param event The event to send, or an expression that evaluates to the event to send
+ * @param options Send action options
  *  - `id` - The unique send event identifier (used with `cancel()`).
  *  - `delay` - The number of milliseconds to delay the sending of the event.
- *  - `to` - The target of this event (by default, the machine the event was sent from).
  */
-function send(eventOrExpr, options) {
-  return createDynamicAction({
-    type: send$1,
-    params: {
-      to: options ? options.to : undefined,
-      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: options ? options.to : undefined,
-      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: send$1,
-      params: {
-        ...params,
-        to: targetActorRef,
-        event: resolvedEvent,
-        delay: resolvedDelay,
-        internal: resolvedTarget === SpecialTargets.Internal
-      },
-      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;
 }
 
 /**
@@ -415,12 +160,8 @@ function send(eventOrExpr, options) {
  * @param options Options to pass into the send event.
  */
 function sendParent(event, options) {
-  return send(event, {
-    ...options,
-    to: SpecialTargets.Parent
-  });
+  return sendTo(SpecialTargets.Parent, event, options);
 }
-
 /**
  * Forwards (sends) an event to a specified service.
  *
@@ -438,12 +179,9 @@ function forwardTo(target, options) {
       return resolvedTarget;
     };
   }
-  return send(({
+  return sendTo(target, ({
     event
-  }) => event, {
-    ...options,
-    to: target
-  });
+  }) => event, options);
 }
 
 /**
@@ -457,27 +195,9 @@ 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,
-    to: SpecialTargets.Parent
-  });
-}
-
-/**
- * Sends an event to an actor.
- *
- * @param actor The `ActorRef` to send the event to.
- * @param event The event to send, or an expression that evaluates to the event to send
- * @param options Send action options
- * @returns An XState send action object
- */
-function sendTo(actor, event, options) {
-  return send(event, {
-    ...options,
-    to: actor
-  });
+  }, options);
 }
 
 const cache = new WeakMap();
@@ -494,6 +214,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
@@ -501,38 +231,19 @@ 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;
 }
 
-const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -600,528 +311,147 @@ class Mailbox {
   }
 }
 
-function createSystem() {
-  let sessionIdCounter = 0;
-  const children = new Map();
-  const keyedActors = new Map();
-  const reverseKeyedActors = new WeakMap();
-  const system = {
-    _bookId: () => `x:${sessionIdCounter++}`,
-    _register: (sessionId, actorRef) => {
-      children.set(sessionId, actorRef);
-      return sessionId;
-    },
-    _unregister: actorRef => {
-      children.delete(actorRef.sessionId);
-      const systemId = reverseKeyedActors.get(actorRef);
-      if (systemId !== undefined) {
-        keyedActors.delete(systemId);
-        reverseKeyedActors.delete(actorRef);
-      }
+const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
+
+/**
+ * Returns actor logic from a transition function and its initial state.
+ *
+ * A transition function is a function that takes the current state and an event and returns the next state.
+ *
+ * @param transition The transition function that returns the next state given the current state and event.
+ * @param initialState The initial state of the transition function.
+ * @returns Actor logic
+ */
+function fromTransition(transition, initialState) {
+  const logic = {
+    config: transition,
+    transition: (state, event, actorContext) => {
+      return transition(state, event, actorContext);
     },
-    get: systemId => {
-      return keyedActors.get(systemId);
+    getInitialState: (_, input) => {
+      return typeof initialState === 'function' ? initialState({
+        input
+      }) : initialState;
     },
-    _set: (systemId, actorRef) => {
-      const existing = keyedActors.get(systemId);
-      if (existing && existing !== actorRef) {
-        throw new Error(`Actor with system ID '${systemId}' already exists.`);
-      }
-      keyedActors.set(systemId, actorRef);
-      reverseKeyedActors.set(actorRef, systemId);
-    }
+    getSnapshot: state => state,
+    getPersistedState: state => state,
+    restoreState: state => state
   };
-  return system;
+  return logic;
 }
 
-let ActorStatus = /*#__PURE__*/function (ActorStatus) {
-  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
-  ActorStatus[ActorStatus["Running"] = 1] = "Running";
-  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
-  return ActorStatus;
-}({});
-const defaultOptions = {
-  deferEvents: true,
-  clock: {
-    setTimeout: (fn, ms) => {
-      return setTimeout(fn, ms);
+const resolveEventType = '$$xstate.resolve';
+const rejectEventType = '$$xstate.reject';
+function fromPromise(
+// TODO: add types
+promiseCreator) {
+  // TODO: add event types, consider making the `PromiseEvent` a private type or smth alike
+  const logic = {
+    config: promiseCreator,
+    transition: (state, event) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      switch (event.type) {
+        case resolveEventType:
+          return {
+            ...state,
+            status: 'done',
+            data: event.data,
+            input: undefined
+          };
+        case rejectEventType:
+          return {
+            ...state,
+            status: 'error',
+            data: event.data,
+            input: undefined
+          };
+        case stopSignalType:
+          return {
+            ...state,
+            status: 'canceled',
+            input: undefined
+          };
+        default:
+          return state;
+      }
     },
-    clearTimeout: id => {
-      return clearTimeout(id);
-    }
-  },
-  logger: console.log.bind(console),
-  devTools: false
-};
-class Interpreter {
-  /**
-   * The current state of the interpreted logic.
-   */
-
-  /**
-   * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
-   */
-
-  /**
-   * The unique identifier for this actor relative to its parent.
-   */
-
-  /**
-   * Whether the service is started.
-   */
-
-  // Actor Ref
-
-  // TODO: add typings for system
-
-  /**
-   * The globally unique process ID for this invocation.
-   */
-
-  /**
-   * Creates a new Interpreter instance (i.e., service) for the given logic with the provided options, if any.
-   *
-   * @param logic The logic to be interpreted
-   * @param options Interpreter options
-   */
-  constructor(logic, options) {
-    this.logic = logic;
-    this._state = void 0;
-    this.clock = void 0;
-    this.options = void 0;
-    this.id = void 0;
-    this.mailbox = new Mailbox(this._process.bind(this));
-    this.delayedEventsMap = {};
-    this.observers = new Set();
-    this.logger = void 0;
-    this.status = ActorStatus.NotStarted;
-    this._parent = void 0;
-    this.ref = void 0;
-    this._actorContext = void 0;
-    this._systemId = void 0;
-    this.sessionId = void 0;
-    this.system = void 0;
-    this._doneEvent = void 0;
-    this.src = void 0;
-    this._deferred = [];
-    const resolvedOptions = {
-      ...defaultOptions,
-      ...options
-    };
-    const {
-      clock,
-      logger,
-      parent,
-      id,
-      systemId
-    } = resolvedOptions;
-    const self = this;
-    this.system = parent?.system ?? createSystem();
-    if (systemId) {
-      this._systemId = systemId;
-      this.system._set(systemId, this);
-    }
-    this.sessionId = this.system._bookId();
-    this.id = id ?? this.sessionId;
-    this.logger = logger;
-    this.clock = clock;
-    this._parent = parent;
-    this.options = resolvedOptions;
-    this.src = resolvedOptions.src;
-    this.ref = this;
-    this._actorContext = {
+    start: (state, {
       self,
-      id: this.id,
-      sessionId: this.sessionId,
-      logger: this.logger,
-      defer: fn => {
-        this._deferred.push(fn);
-      },
-      system: this.system,
-      stopChild: child => {
-        if (child._parent !== this) {
-          throw new Error(`Cannot stop child actor ${child.id} of ${this.id} because it is not a child`);
-        }
-        child._stop();
+      system
+    }) => {
+      // TODO: determine how to allow customizing this so that promises
+      // can be restarted if necessary
+      if (state.status !== 'active') {
+        return;
       }
-    };
-
-    // Ensure that the send method is bound to this interpreter instance
-    // if destructured
-    this.send = this.send.bind(this);
-    this._initState();
-  }
-  _initState() {
-    this._state = this.options.state ? this.logic.restoreState ? this.logic.restoreState(this.options.state, this._actorContext) : this.options.state : this.logic.getInitialState(this._actorContext, this.options?.input);
-  }
-
-  // array of functions to defer
+      const resolvedPromise = Promise.resolve(promiseCreator({
+        input: state.input,
+        system
+      }));
+      resolvedPromise.then(response => {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
+        self.send({
+          type: resolveEventType,
+          data: response
+        });
+      }, errorData => {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
+        self.send({
+          type: rejectEventType,
+          data: errorData
+        });
+      });
+    },
+    getInitialState: (_, input) => {
+      return {
+        status: 'active',
+        data: undefined,
+        input
+      };
+    },
+    getSnapshot: state => state.data,
+    getStatus: state => state,
+    getPersistedState: state => state,
+    restoreState: state => state
+  };
+  return logic;
+}
 
-  update(state) {
-    // Update state
-    this._state = state;
-    const snapshot = this.getSnapshot();
+// TODO: this likely shouldn't accept TEvent, observable actor doesn't accept external events
+function fromObservable(observableCreator) {
+  const nextEventType = '$$xstate.next';
+  const errorEventType = '$$xstate.error';
+  const completeEventType = '$$xstate.complete';
 
-    // Execute deferred effects
-    let deferredFn;
-    while (deferredFn = this._deferred.shift()) {
-      deferredFn();
-    }
-    for (const observer of this.observers) {
-      observer.next?.(snapshot);
-    }
-    const status = this.logic.getStatus?.(state);
-    switch (status?.status) {
-      case 'done':
-        this._stopProcedure();
-        this._doneEvent = doneInvoke(this.id, status.data);
-        this._parent?.send(this._doneEvent);
-        this._complete();
-        break;
-      case 'error':
-        this._stopProcedure();
-        this._parent?.send(error(this.id, status.data));
-        this._error(status.data);
-        break;
-    }
-  }
-  subscribe(nextListenerOrObserver, errorListener, completeListener) {
-    const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
-    this.observers.add(observer);
-    if (this.status === ActorStatus.Stopped) {
-      observer.complete?.();
-      this.observers.delete(observer);
-    }
-    return {
-      unsubscribe: () => {
-        this.observers.delete(observer);
-      }
-    };
-  }
-
-  /**
-   * Starts the interpreter from the initial state
-   */
-  start() {
-    if (this.status === ActorStatus.Running) {
-      // Do not restart the service if it is already started
-      return this;
-    }
-    this.system._register(this.sessionId, this);
-    if (this._systemId) {
-      this.system._set(this._systemId, this);
-    }
-    this.status = ActorStatus.Running;
-    if (this.logic.start) {
-      this.logic.start(this._state, this._actorContext);
-    }
-
-    // TODO: this notifies all subscribers but usually this is redundant
-    // there is no real change happening here
-    // we need to rethink if this needs to be refactored
-    this.update(this._state);
-    if (this.options.devTools) {
-      this.attachDevTools();
-    }
-    this.mailbox.start();
-    return this;
-  }
-  _process(event) {
-    try {
-      const nextState = this.logic.transition(this._state, event, this._actorContext);
-      this.update(nextState);
-      if (event.type === stopSignalType) {
-        this._stopProcedure();
-        this._complete();
-      }
-    } catch (err) {
-      // TODO: properly handle errors
-      if (this.observers.size > 0) {
-        this.observers.forEach(observer => {
-          observer.error?.(err);
-        });
-        this.stop();
-      } else {
-        throw err;
-      }
-    }
-  }
-  _stop() {
-    if (this.status === ActorStatus.Stopped) {
-      return this;
-    }
-    this.mailbox.clear();
-    if (this.status === ActorStatus.NotStarted) {
-      this.status = ActorStatus.Stopped;
-      return this;
-    }
-    this.mailbox.enqueue({
-      type: stopSignalType
-    });
-    return this;
-  }
-
-  /**
-   * Stops the interpreter and unsubscribe all listeners.
-   */
-  stop() {
-    if (this._parent) {
-      throw new Error('A non-root actor cannot be stopped directly.');
-    }
-    return this._stop();
-  }
-  _complete() {
-    for (const observer of this.observers) {
-      observer.complete?.();
-    }
-    this.observers.clear();
-  }
-  _error(data) {
-    for (const observer of this.observers) {
-      observer.error?.(data);
-    }
-    this.observers.clear();
-  }
-  _stopProcedure() {
-    if (this.status !== ActorStatus.Running) {
-      // Interpreter already stopped; do nothing
-      return this;
-    }
-
-    // Cancel all delayed events
-    for (const key of Object.keys(this.delayedEventsMap)) {
-      this.clock.clearTimeout(this.delayedEventsMap[key]);
-    }
-
-    // TODO: mailbox.reset
-    this.mailbox.clear();
-    // TODO: after `stop` we must prepare ourselves for receiving events again
-    // events sent *after* stop signal must be queued
-    // it seems like this should be the common behavior for all of our consumers
-    // so perhaps this should be unified somehow for all of them
-    this.mailbox = new Mailbox(this._process.bind(this));
-    this.status = ActorStatus.Stopped;
-    this.system._unregister(this);
-    return this;
-  }
-
-  /**
-   * Sends an event to the running interpreter to trigger a transition.
-   *
-   * @param event The event to send
-   */
-  send(event) {
-    if (typeof event === 'string') {
-      throw new Error(`Only event objects may be sent to actors; use .send({ type: "${event}" }) instead`);
-    }
-    if (this.status === ActorStatus.Stopped) {
-      // do nothing
-      {
-        const eventString = JSON.stringify(event);
-        console.warn(`Event "${event.type.toString()}" was sent to stopped actor "${this.id} (${this.sessionId})". This actor has already reached its final state, and will not transition.\nEvent: ${eventString}`);
-      }
-      return;
-    }
-    if (this.status !== ActorStatus.Running && !this.options.deferEvents) {
-      throw new Error(`Event "${event.type}" was sent to uninitialized actor "${this.id
-      // tslint:disable-next-line:max-line-length
-      }". Make sure .start() is called for this actor, or set { deferEvents: true } in the actor options.\nEvent: ${JSON.stringify(event)}`);
-    }
-    this.mailbox.enqueue(event);
-  }
-
-  // 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);
-      } else {
-        this.send(sendAction.params.event);
-      }
-    }, sendAction.params.delay);
-  }
-
-  // TODO: make private (and figure out a way to do this within the machine)
-  cancel(sendId) {
-    this.clock.clearTimeout(this.delayedEventsMap[sendId]);
-    delete this.delayedEventsMap[sendId];
-  }
-  attachDevTools() {
-    const {
-      devTools
-    } = this.options;
-    if (devTools) {
-      const resolvedDevToolsAdapter = typeof devTools === 'function' ? devTools : dev_dist_xstateDev.devToolsAdapter;
-      resolvedDevToolsAdapter(this);
-    }
-  }
-  toJSON() {
-    return {
-      id: this.id
-    };
-  }
-  getPersistedState() {
-    return this.logic.getPersistedState?.(this._state);
-  }
-  [symbolObservable]() {
-    return this;
-  }
-  getSnapshot() {
-    return this.logic.getSnapshot ? this.logic.getSnapshot(this._state) : this._state;
-  }
-}
-
-/**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
- *
- * @param machine The machine to interpret
- * @param options Interpreter options
- */
-
-function interpret(logic, options) {
-  const interpreter = new Interpreter(logic, options);
-  return interpreter;
-}
-
-/**
- * Returns actor logic from a transition function and its initial state.
- *
- * A transition function is a function that takes the current state and an event and returns the next state.
- *
- * @param transition The transition function that returns the next state given the current state and event.
- * @param initialState The initial state of the transition function.
- * @returns Actor logic
- */
-function fromTransition(transition, initialState) {
-  const logic = {
-    config: transition,
-    transition: (state, event, actorContext) => {
-      return transition(state, event, actorContext);
-    },
-    getInitialState: (_, input) => {
-      return typeof initialState === 'function' ? initialState({
-        input
-      }) : initialState;
-    },
-    getSnapshot: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
-  };
-  return logic;
-}
-
-const resolveEventType = '$$xstate.resolve';
-const rejectEventType = '$$xstate.reject';
-function fromPromise(
-// TODO: add types
-promiseCreator) {
-  // TODO: add event types, consider making the `PromiseEvent` a private type or smth alike
+  // TODO: add event types
   const logic = {
-    config: promiseCreator,
-    transition: (state, event) => {
+    config: observableCreator,
+    transition: (state, event, {
+      self,
+      id,
+      defer
+    }) => {
       if (state.status !== 'active') {
         return state;
       }
       switch (event.type) {
-        case resolveEventType:
-          return {
-            ...state,
-            status: 'done',
-            data: event.data,
-            input: undefined
-          };
-        case rejectEventType:
-          return {
-            ...state,
-            status: 'error',
-            data: event.data,
-            input: undefined
-          };
-        case stopSignalType:
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    start: (state, {
-      self,
-      system
-    }) => {
-      // TODO: determine how to allow customizing this so that promises
-      // can be restarted if necessary
-      if (state.status !== 'active') {
-        return;
-      }
-      const resolvedPromise = Promise.resolve(promiseCreator({
-        input: state.input,
-        system
-      }));
-      resolvedPromise.then(response => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: resolveEventType,
-          data: response
-        });
-      }, errorData => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: rejectEventType,
-          data: errorData
-        });
-      });
-    },
-    getInitialState: (_, input) => {
-      return {
-        status: 'active',
-        data: undefined,
-        input
-      };
-    },
-    getSnapshot: state => state.data,
-    getStatus: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
-  };
-  return logic;
-}
-
-// TODO: this likely shouldn't accept TEvent, observable actor doesn't accept external events
-function fromObservable(observableCreator) {
-  const nextEventType = '$$xstate.next';
-  const errorEventType = '$$xstate.error';
-  const completeEventType = '$$xstate.complete';
-
-  // TODO: add event types
-  const logic = {
-    config: observableCreator,
-    transition: (state, event, {
-      self,
-      id,
-      defer
-    }) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case nextEventType:
-          // match the exact timing of events sent by machines
-          // send actions are not executed immediately
-          defer(() => {
-            self._parent?.send({
-              type: `xstate.snapshot.${id}`,
-              data: event.data
-            });
-          });
+        case nextEventType:
+          // match the exact timing of events sent by machines
+          // send actions are not executed immediately
+          defer(() => {
+            self._parent?.send({
+              type: `xstate.snapshot.${id}`,
+              data: event.data
+            });
+          });
           return {
             ...state,
             data: event.data
@@ -1314,208 +644,770 @@ function fromEventObservable(lazyObservable) {
   return logic;
 }
 
-function fromCallback(invokeCallback) {
-  const logic = {
-    config: invokeCallback,
-    start: (_state, {
-      self
-    }) => {
-      self.send({
-        type: startSignalType
-      });
-    },
-    transition: (state, event, {
-      self,
-      id,
-      system
-    }) => {
-      if (event.type === startSignalType) {
-        const sender = eventForParent => {
-          if (state.canceled) {
-            return;
-          }
-          self._parent?.send(eventForParent);
-        };
-        const receiver = newListener => {
-          state.receivers.add(newListener);
-        };
-        state.dispose = invokeCallback(sender, receiver, {
-          input: state.input,
-          system
-        });
-        if (isPromiseLike(state.dispose)) {
-          state.dispose.then(resolved => {
-            self._parent?.send(doneInvoke(id, resolved));
-            state.canceled = true;
-          }, errorData => {
-            state.canceled = true;
-            self._parent?.send(error(id, errorData));
-          });
-        }
-        return state;
-      }
-      if (event.type === stopSignalType) {
-        state.canceled = true;
-        if (isFunction(state.dispose)) {
-          state.dispose();
-        }
-        return state;
-      }
-      if (isSignal(event)) {
-        // TODO: unrecognized signal
-        return state;
-      }
-      state.receivers.forEach(receiver => receiver(event));
-      return state;
-    },
-    getInitialState: (_, input) => {
-      return {
-        canceled: false,
-        receivers: new Set(),
-        dispose: undefined,
-        input
-      };
-    },
-    getSnapshot: () => undefined,
-    getPersistedState: ({
-      input
-    }) => input
-  };
-  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) {
+  const logic = {
+    config: invokeCallback,
+    start: (_state, {
+      self
+    }) => {
+      self.send({
+        type: startSignalType
+      });
+    },
+    transition: (state, event, {
+      self,
+      id,
+      system
+    }) => {
+      if (event.type === startSignalType) {
+        const sender = eventForParent => {
+          if (state.canceled) {
+            return;
+          }
+          self._parent?.send(eventForParent);
+        };
+        const receiver = newListener => {
+          state.receivers.add(newListener);
+        };
+        state.dispose = invokeCallback(sender, receiver, {
+          input: state.input,
+          system
+        });
+        if (isPromiseLike(state.dispose)) {
+          state.dispose.then(resolved => {
+            self._parent?.send(doneInvoke(id, resolved));
+            state.canceled = true;
+          }, errorData => {
+            state.canceled = true;
+            self._parent?.send(error(id, errorData));
+          });
+        }
+        return state;
+      }
+      if (event.type === stopSignalType) {
+        state.canceled = true;
+        if (typeof state.dispose === 'function') {
+          state.dispose();
+        }
+        return state;
+      }
+      if (isSignal(event)) {
+        // TODO: unrecognized signal
+        return state;
+      }
+      state.receivers.forEach(receiver => receiver(event));
+      return state;
+    },
+    getInitialState: (_, input) => {
+      return {
+        canceled: false,
+        receivers: new Set(),
+        dispose: undefined,
+        input
+      };
+    },
+    getSnapshot: () => undefined,
+    getPersistedState: ({
+      input
+    }) => input
+  };
+  return logic;
+}
+
+const startSignalType = 'xstate.init';
+const stopSignalType = 'xstate.stop';
+const startSignal = {
+  type: 'xstate.init'
+};
+const stopSignal = {
+  type: 'xstate.stop'
+};
+/**
+ * An object that expresses the actor logic in reaction to received events,
+ * as well as an optionally emitted stream of values.
+ *
+ * @template TReceived The received event
+ * @template TSnapshot The emitted value
+ */
+
+function isSignal(event) {
+  return event.type === startSignalType || event.type === stopSignalType;
+}
+function isActorRef(item) {
+  return !!item && typeof item === 'object' && typeof item.send === 'function';
+}
+
+// TODO: refactor the return type, this could be written in a better way
+// but it's best to avoid unneccessary breaking changes now
+// @deprecated use `interpret(actorLogic)` instead
+function toActorRef(actorRefLike) {
+  return {
+    subscribe: () => ({
+      unsubscribe: () => void 0
+    }),
+    id: 'anonymous',
+    sessionId: '',
+    getSnapshot: () => undefined,
+    [symbolObservable]: function () {
+      return this;
+    },
+    status: ActorStatus.Running,
+    stop: () => void 0,
+    ...actorRefLike
+  };
+}
+const emptyLogic = fromTransition(_ => undefined, undefined);
+function createEmptyActor() {
+  return interpret(emptyLogic);
+}
+
+function createSystem() {
+  let sessionIdCounter = 0;
+  const children = new Map();
+  const keyedActors = new Map();
+  const reverseKeyedActors = new WeakMap();
+  const system = {
+    _bookId: () => `x:${sessionIdCounter++}`,
+    _register: (sessionId, actorRef) => {
+      children.set(sessionId, actorRef);
+      return sessionId;
+    },
+    _unregister: actorRef => {
+      children.delete(actorRef.sessionId);
+      const systemId = reverseKeyedActors.get(actorRef);
+      if (systemId !== undefined) {
+        keyedActors.delete(systemId);
+        reverseKeyedActors.delete(actorRef);
+      }
+    },
+    get: systemId => {
+      return keyedActors.get(systemId);
+    },
+    _set: (systemId, actorRef) => {
+      const existing = keyedActors.get(systemId);
+      if (existing && existing !== actorRef) {
+        throw new Error(`Actor with system ID '${systemId}' already exists.`);
+      }
+      keyedActors.set(systemId, actorRef);
+      reverseKeyedActors.set(actorRef, systemId);
+    }
+  };
+  return system;
+}
+
+let ActorStatus = /*#__PURE__*/function (ActorStatus) {
+  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
+  ActorStatus[ActorStatus["Running"] = 1] = "Running";
+  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
+  return ActorStatus;
+}({});
+const defaultOptions = {
+  deferEvents: true,
+  clock: {
+    setTimeout: (fn, ms) => {
+      return setTimeout(fn, ms);
+    },
+    clearTimeout: id => {
+      return clearTimeout(id);
+    }
+  },
+  logger: console.log.bind(console),
+  devTools: false
+};
+class Interpreter {
+  /**
+   * The current state of the interpreted logic.
+   */
+
+  /**
+   * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+   */
+
+  /**
+   * The unique identifier for this actor relative to its parent.
+   */
+
+  /**
+   * Whether the service is started.
+   */
+
+  // Actor Ref
+
+  // TODO: add typings for system
+
+  /**
+   * The globally unique process ID for this invocation.
+   */
+
+  /**
+   * Creates a new Interpreter instance (i.e., service) for the given logic with the provided options, if any.
+   *
+   * @param logic The logic to be interpreted
+   * @param options Interpreter options
+   */
+  constructor(logic, options) {
+    this.logic = logic;
+    this._state = void 0;
+    this.clock = void 0;
+    this.options = void 0;
+    this.id = void 0;
+    this.mailbox = new Mailbox(this._process.bind(this));
+    this.delayedEventsMap = {};
+    this.observers = new Set();
+    this.logger = void 0;
+    this.status = ActorStatus.NotStarted;
+    this._parent = void 0;
+    this.ref = void 0;
+    this._actorContext = void 0;
+    this._systemId = void 0;
+    this.sessionId = void 0;
+    this.system = void 0;
+    this._doneEvent = void 0;
+    this.src = void 0;
+    this._deferred = [];
+    const resolvedOptions = {
+      ...defaultOptions,
+      ...options
+    };
+    const {
+      clock,
+      logger,
+      parent,
+      id,
+      systemId
+    } = resolvedOptions;
+    const self = this;
+    this.system = parent?.system ?? createSystem();
+    if (systemId) {
+      this._systemId = systemId;
+      this.system._set(systemId, this);
+    }
+    this.sessionId = this.system._bookId();
+    this.id = id ?? this.sessionId;
+    this.logger = logger;
+    this.clock = clock;
+    this._parent = parent;
+    this.options = resolvedOptions;
+    this.src = resolvedOptions.src;
+    this.ref = this;
+    this._actorContext = {
+      self,
+      id: this.id,
+      sessionId: this.sessionId,
+      logger: this.logger,
+      defer: fn => {
+        this._deferred.push(fn);
+      },
+      system: this.system,
+      stopChild: child => {
+        if (child._parent !== this) {
+          throw new Error(`Cannot stop child actor ${child.id} of ${this.id} because it is not a child`);
+        }
+        child._stop();
+      }
+    };
+
+    // Ensure that the send method is bound to this interpreter instance
+    // if destructured
+    this.send = this.send.bind(this);
+    this._initState();
+  }
+  _initState() {
+    this._state = this.options.state ? this.logic.restoreState ? this.logic.restoreState(this.options.state, this._actorContext) : this.options.state : this.logic.getInitialState(this._actorContext, this.options?.input);
+  }
+
+  // array of functions to defer
+
+  update(state) {
+    // Update state
+    this._state = state;
+    const snapshot = this.getSnapshot();
+
+    // Execute deferred effects
+    let deferredFn;
+    while (deferredFn = this._deferred.shift()) {
+      deferredFn();
+    }
+    for (const observer of this.observers) {
+      observer.next?.(snapshot);
+    }
+    const status = this.logic.getStatus?.(state);
+    switch (status?.status) {
+      case 'done':
+        this._stopProcedure();
+        this._doneEvent = doneInvoke(this.id, status.data);
+        this._parent?.send(this._doneEvent);
+        this._complete();
+        break;
+      case 'error':
+        this._stopProcedure();
+        this._parent?.send(error(this.id, status.data));
+        this._error(status.data);
+        break;
+    }
+  }
+  subscribe(nextListenerOrObserver, errorListener, completeListener) {
+    const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
+    this.observers.add(observer);
+    if (this.status === ActorStatus.Stopped) {
+      observer.complete?.();
+      this.observers.delete(observer);
+    }
+    return {
+      unsubscribe: () => {
+        this.observers.delete(observer);
+      }
+    };
+  }
+
+  /**
+   * Starts the interpreter from the initial state
+   */
+  start() {
+    if (this.status === ActorStatus.Running) {
+      // Do not restart the service if it is already started
+      return this;
+    }
+    this.system._register(this.sessionId, this);
+    if (this._systemId) {
+      this.system._set(this._systemId, this);
+    }
+    this.status = ActorStatus.Running;
+    if (this.logic.start) {
+      this.logic.start(this._state, this._actorContext);
+    }
+
+    // TODO: this notifies all subscribers but usually this is redundant
+    // there is no real change happening here
+    // we need to rethink if this needs to be refactored
+    this.update(this._state);
+    if (this.options.devTools) {
+      this.attachDevTools();
+    }
+    this.mailbox.start();
+    return this;
+  }
+  _process(event) {
+    try {
+      const nextState = this.logic.transition(this._state, event, this._actorContext);
+      this.update(nextState);
+      if (event.type === stopSignalType) {
+        this._stopProcedure();
+        this._complete();
+      }
+    } catch (err) {
+      // TODO: properly handle errors
+      if (this.observers.size > 0) {
+        this.observers.forEach(observer => {
+          observer.error?.(err);
+        });
+        this.stop();
+      } else {
+        throw err;
+      }
+    }
+  }
+  _stop() {
+    if (this.status === ActorStatus.Stopped) {
+      return this;
+    }
+    this.mailbox.clear();
+    if (this.status === ActorStatus.NotStarted) {
+      this.status = ActorStatus.Stopped;
+      return this;
+    }
+    this.mailbox.enqueue({
+      type: stopSignalType
+    });
+    return this;
+  }
+
+  /**
+   * Stops the interpreter and unsubscribe all listeners.
+   */
+  stop() {
+    if (this._parent) {
+      throw new Error('A non-root actor cannot be stopped directly.');
+    }
+    return this._stop();
+  }
+  _complete() {
+    for (const observer of this.observers) {
+      observer.complete?.();
+    }
+    this.observers.clear();
+  }
+  _error(data) {
+    for (const observer of this.observers) {
+      observer.error?.(data);
+    }
+    this.observers.clear();
+  }
+  _stopProcedure() {
+    if (this.status !== ActorStatus.Running) {
+      // Interpreter already stopped; do nothing
+      return this;
+    }
+
+    // Cancel all delayed events
+    for (const key of Object.keys(this.delayedEventsMap)) {
+      this.clock.clearTimeout(this.delayedEventsMap[key]);
+    }
+
+    // TODO: mailbox.reset
+    this.mailbox.clear();
+    // TODO: after `stop` we must prepare ourselves for receiving events again
+    // events sent *after* stop signal must be queued
+    // it seems like this should be the common behavior for all of our consumers
+    // so perhaps this should be unified somehow for all of them
+    this.mailbox = new Mailbox(this._process.bind(this));
+    this.status = ActorStatus.Stopped;
+    this.system._unregister(this);
+    return this;
+  }
+
+  /**
+   * Sends an event to the running interpreter to trigger a transition.
+   *
+   * @param event The event to send
+   */
+  send(event) {
+    if (typeof event === 'string') {
+      throw new Error(`Only event objects may be sent to actors; use .send({ type: "${event}" }) instead`);
+    }
+    if (this.status === ActorStatus.Stopped) {
+      // do nothing
+      {
+        const eventString = JSON.stringify(event);
+        console.warn(`Event "${event.type.toString()}" was sent to stopped actor "${this.id} (${this.sessionId})". This actor has already reached its final state, and will not transition.\nEvent: ${eventString}`);
+      }
+      return;
+    }
+    if (this.status !== ActorStatus.Running && !this.options.deferEvents) {
+      throw new Error(`Event "${event.type}" was sent to uninitialized actor "${this.id
+      // tslint:disable-next-line:max-line-length
+      }". Make sure .start() is called for this actor, or set { deferEvents: true } in the actor options.\nEvent: ${JSON.stringify(event)}`);
+    }
+    this.mailbox.enqueue(event);
+  }
+
+  // TODO: make private (and figure out a way to do this within the machine)
+  delaySend({
+    event,
+    id,
+    delay,
+    to
+  }) {
+    const timerId = this.clock.setTimeout(() => {
+      if (to) {
+        to.send(event);
+      } else {
+        this.send(event);
+      }
+    }, 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)
+  cancel(sendId) {
+    this.clock.clearTimeout(this.delayedEventsMap[sendId]);
+    delete this.delayedEventsMap[sendId];
+  }
+  attachDevTools() {
+    const {
+      devTools
+    } = this.options;
+    if (devTools) {
+      const resolvedDevToolsAdapter = typeof devTools === 'function' ? devTools : dev_dist_xstateDev.devToolsAdapter;
+      resolvedDevToolsAdapter(this);
+    }
+  }
+  toJSON() {
+    return {
+      id: this.id
+    };
+  }
+  getPersistedState() {
+    return this.logic.getPersistedState?.(this._state);
+  }
+  [symbolObservable]() {
+    return this;
+  }
+  getSnapshot() {
+    return this.logic.getSnapshot ? this.logic.getSnapshot(this._state) : this._state;
+  }
 }
 
-const startSignalType = 'xstate.init';
-const stopSignalType = 'xstate.stop';
-const startSignal = {
-  type: 'xstate.init'
-};
-const stopSignal = {
-  type: 'xstate.stop'
-};
 /**
- * An object that expresses the actor logic in reaction to received events,
- * as well as an optionally emitted stream of values.
+ * Creates a new Interpreter instance for the given machine with the provided options, if any.
  *
- * @template TReceived The received event
- * @template TSnapshot The emitted value
+ * @param machine The machine to interpret
+ * @param options Interpreter options
  */
 
-function isSignal(event) {
-  return event.type === startSignalType || event.type === stopSignalType;
-}
-function isActorRef(item) {
-  return !!item && typeof item === 'object' && typeof item.send === 'function';
-}
-
-// TODO: refactor the return type, this could be written in a better way
-// but it's best to avoid unneccessary breaking changes now
-// @deprecated use `interpret(actorLogic)` instead
-function toActorRef(actorRefLike) {
-  return {
-    subscribe: () => ({
-      unsubscribe: () => void 0
-    }),
-    id: 'anonymous',
-    sessionId: '',
-    getSnapshot: () => undefined,
-    [symbolObservable]: function () {
-      return this;
-    },
-    status: ActorStatus.Running,
-    stop: () => void 0,
-    ...actorRefLike
-  };
-}
-const emptyLogic = fromTransition(_ => undefined, undefined);
-function createEmptyActor() {
-  return interpret(emptyLogic);
+function interpret(logic, options) {
+  const interpreter = new Interpreter(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;
-    if (isActorRef(src)) {
-      resolvedInvokeAction = {
-        type,
-        params: {
-          ...invokeDef,
-          ref: src
-        }
-      };
-    } else {
-      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 {
@@ -1526,7 +1418,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);
@@ -1610,9 +1502,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,
@@ -1631,7 +1523,7 @@ function toGuardDefinition(guardConfig, getPredicate) {
       };
     }
   }
-  if (isFunction(guardConfig)) {
+  if (typeof guardConfig === 'function') {
     return {
       type: guardConfig.name,
       predicate: guardConfig,
@@ -1642,7 +1534,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,
@@ -1769,27 +1661,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];
@@ -1797,7 +1681,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;
       }
@@ -1806,7 +1690,7 @@ function getCandidates(stateNode, receivedEventType) {
       }
     }
     return true;
-  });
+  }).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
   return candidates;
 }
 
@@ -1819,11 +1703,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));
@@ -1837,7 +1722,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;
@@ -1853,12 +1738,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 {
@@ -1872,12 +1757,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}`,
@@ -1887,52 +1772,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}`);
       }
@@ -1956,15 +1839,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) {
@@ -1973,7 +1855,7 @@ function resolveTarget(stateNode, targets) {
     return undefined;
   }
   return targets.map(target => {
-    if (!isString(target)) {
+    if (typeof target !== 'string') {
       return target;
     }
     if (isStateId(target)) {
@@ -2081,7 +1963,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);
@@ -2132,7 +2014,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);
   }
 
@@ -2466,44 +2348,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 || resolvedAction.type === send$1 && resolvedAction.params.internal) && 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) {
@@ -2525,7 +2418,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);
@@ -2691,7 +2584,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);
@@ -2789,6 +2682,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.
  *
@@ -2796,58 +2719,40 @@ function getPersistedState(state) {
  */
 
 function stop(actorRef) {
-  const actor = actorRef;
-  return createDynamicAction({
-    type: stop$1,
-    params: {
-      actor
-    }
-  }, (event, {
-    state
-  }) => {
-    const actorRefOrString = isFunction(actor) ? actor({
-      context: state.context,
-      event
-    }) : 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.
@@ -2856,94 +2761,114 @@ 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(self, machine, context, event, mutCapturedActions) {
-  return (src, options = {}) => {
+function createSpawner(actorContext, {
+  machine,
+  context
+}, event, spawnedChildren) {
+  const spawn = (src, options = {}) => {
     const {
       systemId
     } = options;
-    if (isString(src)) {
+    if (typeof src === 'string') {
       const referenced = resolveReferencedActor(machine.implementations.actors[src]);
-      if (referenced) {
-        const input = 'input' in options ? options.input : referenced.input;
-
-        // TODO: this should also receive `src`
-        const actorRef = interpret(referenced.src, {
-          id: options.id,
-          parent: self,
-          input: typeof input === 'function' ? input({
-            context,
-            event,
-            self
-          }) : input
-        });
-        mutCapturedActions.push(invoke({
-          id: actorRef.id,
-          // @ts-ignore TODO: fix types
-          src: actorRef,
-          // TODO
-          ref: actorRef,
-          meta: undefined,
-          input,
-          systemId
-        }));
-        return actorRef; // TODO: fix types
+      if (!referenced) {
+        throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
       }
+      const input = 'input' in options ? options.input : referenced.input;
 
-      throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
+      // TODO: this should also receive `src`
+      const actor = interpret(referenced.src, {
+        id: options.id,
+        parent: actorContext.self,
+        input: typeof input === 'function' ? input({
+          context,
+          event,
+          self: actorContext.self
+        }) : input,
+        systemId
+      });
+      spawnedChildren[actor.id] = actor;
+      return actor;
     } else {
       // TODO: this should also receive `src`
-      const actorRef = interpret(src, {
+      return interpret(src, {
         id: options.id,
-        parent: self,
+        parent: actorContext.self,
         input: options.input,
         systemId
       });
-      mutCapturedActions.push(invoke({
-        // @ts-ignore TODO: fix types
-        src: actorRef,
-        ref: actorRef,
-        id: actorRef.id,
-        meta: undefined,
-        input: options.input
-      }));
-      return actorRef; // TODO: fix types
     }
   };
+  return (src, options) => {
+    const actorRef = spawn(src, options);
+    spawnedChildren[actorRef.id] = actorRef;
+    actorContext.defer(() => {
+      if (actorRef.status === ActorStatus.Stopped) {
+        return;
+      }
+      try {
+        actorRef.start?.();
+      } catch (err) {
+        actorContext.self.send(error(actorRef.id, err));
+        return;
+      }
+    });
+    return actorRef;
+  };
+}
+
+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
+  })];
 }
 
 /**
@@ -2952,48 +2877,47 @@ function createSpawner(self, machine, context, event, mutCapturedActions) {
  * @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
-  }) => {
-    const capturedActions = [];
-    if (!state.context) {
-      throw new Error('Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.');
-    }
-    const args = {
-      context: state.context,
-      event,
-      action,
-      spawn: createSpawner(actorContext?.self, state.machine, state.context, event, capturedActions),
-      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
-    }), {
-      type: assign$1,
-      params: {
-        context: updatedContext,
-        actions: capturedActions
-      }
-    }];
-  });
+  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;
+  }
 }
 
 /**
@@ -3004,186 +2928,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
-        }))) ?? []
-      }
-    }];
-  });
-}
-
-const initEvent = {
-  type: init
-};
-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
@@ -3194,7 +2992,7 @@ const toActionObjects = action => {
  */
 function after(delayRef, id) {
   const idSuffix = id ? `#${id}` : '';
-  return `${ActionTypes.After}(${delayRef})${idSuffix}`;
+  return `${ConstantPrefix.After}(${delayRef})${idSuffix}`;
 }
 
 /**
@@ -3205,7 +3003,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
@@ -3224,7 +3022,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
@@ -3233,7 +3031,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
@@ -3243,28 +3041,27 @@ 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;
-exports.createSpawner = createSpawner;
 exports.done = done;
 exports.doneInvoke = doneInvoke;
 exports.error = error;
@@ -3287,16 +3084,13 @@ exports.getInitialConfiguration = getInitialConfiguration;
 exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
-exports.initEvent = initEvent;
 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;
@@ -3308,11 +3102,9 @@ exports.or = or;
 exports.pathToStateValue = pathToStateValue;
 exports.pure = pure;
 exports.raise = raise;
-exports.resolveActionObject = resolveActionObject;
 exports.resolveActionsAndContext = resolveActionsAndContext;
 exports.resolveReferencedActor = resolveReferencedActor;
 exports.resolveStateValue = resolveStateValue;
-exports.send = send;
 exports.sendParent = sendParent;
 exports.sendTo = sendTo;
 exports.startSignal = startSignal;
@@ -3321,8 +3113,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;