xstate 5.0.0-beta.27 → 5.0.0-beta.29

package/dist/{actions-9754d2ca.development.esm.js → raise-03e57569.cjs.js}

@@ -1,209 +1,6 @@
-import { devToolsAdapter } from '../dev/dist/xstate-dev.development.esm.js';
+'use strict';
 
-/**
- * `T | unknown` reduces to `unknown` and that can be problematic when it comes to contextual typing.
- * It especially is a problem when the union has a function member, like here:
- *
- * ```ts
- * declare function test(cbOrVal: ((arg: number) => unknown) | unknown): void;
- * test((arg) => {}) // oops, implicit any
- * ```
- *
- * This type can be used to avoid this problem. This union represents the same value space as `unknown`.
- */
-
-// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
-
-/**
- * The full definition of an event, with a string `type`.
- */
-
-// TODO: do not accept machines without all implementations
-// we should also accept a raw machine as actor logic here
-// or just make machine actor logic
-
-/**
- * The string or object representing the state value relative to the parent state node.
- *
- * - For a child atomic state node, this is a string, e.g., `"pending"`.
- * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
- */
-
-// TODO: remove once TS fixes this type-widening issue
-
-// TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
-
-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";
-  SpecialTargets["Internal"] = "#_internal";
-  return SpecialTargets;
-}({});
-
-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,
-  after: after$1,
-  doneState: doneState,
-  errorExecution: errorExecution,
-  errorPlatform: errorPlatform,
-  error: error$1
-});
-
-const STATE_DELIMITER = '.';
-const TARGETLESS_KEY = '';
-const NULL_EVENT = '';
-const STATE_IDENTIFIER = '#';
-const WILDCARD = '*';
-const XSTATE_INIT = 'xstate.init';
-const XSTATE_STOP = 'xstate.stop';
-
-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 {
-      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;
-  }
-  return [state, {
-    to: targetActorRef,
-    event: resolvedEvent,
-    id,
-    delay: resolvedDelay
-  }];
-}
-function execute$5(actorContext, params) {
-  if (typeof params.delay === 'number') {
-    actorContext.self.delaySend(params);
-    return;
-  }
-  const {
-    to,
-    event
-  } = params;
-  actorContext.defer(() => {
-    to.send(event.type === error$1 ? {
-      type: `${error(actorContext.self.id)}`,
-      data: event.data
-    } : event);
-  });
-}
-/**
- * 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
- *  - `id` - The unique send event identifier (used with `cancel()`).
- *  - `delay` - The number of milliseconds to delay the sending of the event.
- */
-function sendTo(to, eventOrExpr, options) {
-  function sendTo(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  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;
-}
-
-/**
- * Sends an event to this machine's parent.
- *
- * @param event The event to send to the parent machine.
- * @param options Options to pass into the send event.
- */
-function sendParent(event, options) {
-  return sendTo(SpecialTargets.Parent, event, options);
-}
-/**
- * Forwards (sends) an event to a specified service.
- *
- * @param target The target service to forward the event to.
- * @param options Options to pass into the send action creator.
- */
-function forwardTo(target, options) {
-  if ((!target || typeof target === 'function')) {
-    const originalTarget = target;
-    target = (...args) => {
-      const resolvedTarget = typeof originalTarget === 'function' ? originalTarget(...args) : originalTarget;
-      if (!resolvedTarget) {
-        throw new Error(`Attempted to forward event to undefined actor. This risks an infinite loop in the sender.`);
-      }
-      return resolvedTarget;
-    };
-  }
-  return sendTo(target, ({
-    event
-  }) => event, options);
-}
-
-/**
- * Escalates an error by sending it as an event to this machine's parent.
- *
- * @param errorData The error data to send, or the expression function that
- * takes in the `context`, `event`, and `meta`, and returns the error data to send.
- * @param options Options to pass into the send action creator.
- */
-function escalate(errorData, options) {
-  return sendParent(arg => {
-    return {
-      type: error$1,
-      data: typeof errorData === 'function' ? errorData(arg) : errorData
-    };
-  }, options);
-}
+var interpreter = require('./interpreter-c357bc50.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -219,13 +16,13 @@ function memo(object, key, fn) {
   return memoizedData[key];
 }
 
-function resolve$7(_, state, actionArgs, {
+function resolve$3(_, state, actionArgs, {
   sendId
 }) {
   const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs) : sendId;
   return [state, resolvedSendId];
 }
-function execute$4(actorContext, resolvedSendId) {
+function execute$3(actorContext, resolvedSendId) {
   actorContext.self.cancel(resolvedSendId);
 }
 /**
@@ -237,726 +34,26 @@ function execute$4(actorContext, resolvedSendId) {
  */
 function cancel(sendId) {
   function cancel(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
   }
   cancel.type = 'xstate.cancel';
   cancel.sendId = sendId;
-  cancel.resolve = resolve$7;
-  cancel.execute = execute$4;
+  cancel.resolve = resolve$3;
+  cancel.execute = execute$3;
   return cancel;
 }
 
-class Mailbox {
-  constructor(_process) {
-    this._process = _process;
-    this._active = false;
-    this._current = null;
-    this._last = null;
-  }
-  start() {
-    this._active = true;
-    this.flush();
-  }
-  clear() {
-    // we can't set _current to null because we might be currently processing
-    // and enqueue following clear shouldnt start processing the enqueued item immediately
-    if (this._current) {
-      this._current.next = null;
-      this._last = this._current;
-    }
-  }
-
-  // TODO: rethink this design
-  prepend(event) {
-    if (!this._current) {
-      this.enqueue(event);
-      return;
-    }
-
-    // we know that something is already queued up
-    // so the mailbox is already flushing or it's inactive
-    // therefore the only thing that we need to do is to reassign `this._current`
-    this._current = {
-      value: event,
-      next: this._current
-    };
-  }
-  enqueue(event) {
-    const enqueued = {
-      value: event,
-      next: null
-    };
-    if (this._current) {
-      this._last.next = enqueued;
-      this._last = enqueued;
-      return;
-    }
-    this._current = enqueued;
-    this._last = enqueued;
-    if (this._active) {
-      this.flush();
-    }
-  }
-  flush() {
-    while (this._current) {
-      // atm the given _process is responsible for implementing proper try/catch handling
-      // we assume here that this won't throw in a way that can affect this mailbox
-      const consumed = this._current;
-      this._process(consumed.value);
-      // something could have been prepended in the meantime
-      // so we need to be defensive here to avoid skipping over a prepended item
-      if (consumed === this._current) {
-        this._current = this._current.next;
-      }
-    }
-    this._last = null;
-  }
-}
-
-/**
- * This function makes sure that unhandled errors are thrown in a separate macrotask.
- * It allows those errors to be detected by global error handlers and reported to bug tracking services
- * without interrupting our own stack of execution.
- *
- * @param err error to be thrown
- */
-function reportUnhandledError(err) {
-  setTimeout(() => {
-    throw err;
-  });
-}
-
-const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
-
-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;
-}
-
-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, self) {
-  if (typeof mapper === 'function') {
-    return mapper({
-      context,
-      event,
-      self
-    });
-  }
-  if (typeof mapper === 'object' && Object.values(mapper).some(val => typeof val === 'function')) {
-    console.warn(`Dynamically mapping values to individual properties is deprecated. Use a single function that returns the mapped object instead.\nFound object containing properties whose values are possibly mapping functions: ${Object.entries(mapper).filter(([key, value]) => typeof value === 'function').map(([key, value]) => `\n - ${key}: ${value.toString().replace(/\n\s*/g, '')}`).join('')}`);
-  }
-  return mapper;
-}
-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 toObserver(nextHandler, errorHandler, completionHandler) {
-  const isObserver = typeof nextHandler === 'object';
-  const self = isObserver ? nextHandler : undefined;
-  return {
-    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
-    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
-  };
-}
-function createInvokeId(stateNodeId, index) {
-  return `${stateNodeId}:invocation[${index}]`;
-}
-function resolveReferencedActor(referenced) {
-  return referenced ? 'transition' in referenced ? {
-    src: referenced,
-    input: undefined
-  } : referenced : undefined;
-}
-
-let ActorStatus = /*#__PURE__*/function (ActorStatus) {
-  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
-  ActorStatus[ActorStatus["Running"] = 1] = "Running";
-  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
-  return ActorStatus;
-}({});
-
-/**
- * @deprecated Use `ActorStatus` instead.
- */
-const InterpreterStatus = 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 Actor {
-  /**
-   * The current internal state of the actor.
-   */
-
-  /**
-   * 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 actor instance for the given logic with the provided options, if any.
-   *
-   * @param logic The logic to create an actor from
-   * @param options Actor 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 Actor 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) {
-      // TODO: should observers be notified in case of the error?
-      try {
-        observer.next?.(snapshot);
-      } catch (err) {
-        reportUnhandledError(err);
-      }
-    }
-    const status = this.logic.getStatus?.(state);
-    switch (status?.status) {
-      case 'done':
-        this._stopProcedure();
-        this._complete();
-        this._doneEvent = doneInvoke(this.id, status.data);
-        this._parent?.send(this._doneEvent);
-        break;
-      case 'error':
-        this._stopProcedure();
-        this._error(status.data);
-        this._parent?.send(error(this.id, status.data));
-        break;
-    }
-  }
-  subscribe(nextListenerOrObserver, errorListener, completeListener) {
-    const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
-    if (this.status !== ActorStatus.Stopped) {
-      this.observers.add(observer);
-    } else {
-      try {
-        observer.complete?.();
-      } catch (err) {
-        reportUnhandledError(err);
-      }
-    }
-    return {
-      unsubscribe: () => {
-        this.observers.delete(observer);
-      }
-    };
-  }
-
-  /**
-   * Starts the Actor 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;
-    const status = this.logic.getStatus?.(this._state);
-    switch (status?.status) {
-      case 'done':
-        // a state machine can be "done" upon intialization (it could reach a final state using initial microsteps)
-        // we still need to complete observers, flush deferreds etc
-        this.update(this._state);
-      // fallthrough
-      case 'error':
-        // TODO: rethink cleanup of observers, mailbox, etc
-        return this;
-    }
-    if (this.logic.start) {
-      try {
-        this.logic.start(this._state, this._actorContext);
-      } catch (err) {
-        this._stopProcedure();
-        this._error(err);
-        this._parent?.send(error(this.id, err));
-        return this;
-      }
-    }
-
-    // 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) {
-    // TODO: reexamine what happens when an action (or a guard or smth) throws
-    let nextState;
-    let caughtError;
-    try {
-      nextState = this.logic.transition(this._state, event, this._actorContext);
-    } catch (err) {
-      // we wrap it in a box so we can rethrow it later even if falsy value gets caught here
-      caughtError = {
-        err
-      };
-    }
-    if (caughtError) {
-      const {
-        err
-      } = caughtError;
-      this._stopProcedure();
-      this._error(err);
-      this._parent?.send(error(this.id, err));
-      return;
-    }
-    this.update(nextState);
-    if (event.type === XSTATE_STOP) {
-      this._stopProcedure();
-      this._complete();
-    }
-  }
-  _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: XSTATE_STOP
-    });
-    return this;
-  }
-
-  /**
-   * Stops the Actor 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) {
-      try {
-        observer.complete?.();
-      } catch (err) {
-        reportUnhandledError(err);
-      }
-    }
-    this.observers.clear();
-  }
-  _error(err) {
-    if (!this.observers.size) {
-      if (!this._parent) {
-        reportUnhandledError(err);
-      }
-      return;
-    }
-    let reportError = false;
-    for (const observer of this.observers) {
-      const errorListener = observer.error;
-      reportError ||= !errorListener;
-      try {
-        errorListener?.(err);
-      } catch (err2) {
-        reportUnhandledError(err2);
-      }
-    }
-    this.observers.clear();
-    if (reportError) {
-      reportUnhandledError(err);
-    }
-  }
-  _stopProcedure() {
-    if (this.status !== ActorStatus.Running) {
-      // Actor 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 Actor 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 : 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 `ActorRef` instance for the given machine with the provided options, if any.
- *
- * @param machine The machine to create an actor from
- * @param options `ActorRef` options
- */
-
-function createActor(logic, options) {
-  const interpreter = new Actor(logic, options);
-  return interpreter;
-}
-
-/**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
- *
- * @deprecated Use `createActor` instead
- */
-const interpret = createActor;
-
-/**
- * @deprecated Use `Actor` instead.
- */
-
-function resolve$6(actorContext, state, actionArgs, {
+function resolve$2(actorContext, state, actionArgs, {
   id,
   systemId,
   src,
   input
 }) {
-  const referenced = resolveReferencedActor(state.machine.implementations.actors[src]);
+  const referenced = interpreter.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 = createActor(referenced.src, {
+    actorRef = interpreter.createActor(referenced.src, {
       id,
       src,
       parent: actorContext?.self,
@@ -968,9 +65,6 @@ function resolve$6(actorContext, state, actionArgs, {
       }) : configuredInput
     });
   }
-  if (!actorRef) {
-    console.warn(`Actor type '${src}' not found in machine '${actorContext.id}'.`);
-  }
   return [cloneState(state, {
     children: {
       ...state.children,
@@ -981,7 +75,7 @@ function resolve$6(actorContext, state, actionArgs, {
     actorRef
   }];
 }
-function execute$3(actorContext, {
+function execute$2(actorContext, {
   id,
   actorRef
 }) {
@@ -989,13 +83,13 @@ function execute$3(actorContext, {
     return;
   }
   actorContext.defer(() => {
-    if (actorRef.status === ActorStatus.Stopped) {
+    if (actorRef.status === interpreter.ActorStatus.Stopped) {
       return;
     }
     try {
       actorRef.start?.();
     } catch (err) {
-      actorContext.self.send(error(id, err));
+      actorContext.self.send(interpreter.createErrorActorEvent(id, err));
       return;
     }
   });
@@ -1010,20 +104,61 @@ function invoke({
   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;
+  invoke.resolve = resolve$2;
+  invoke.execute = execute$2;
   return invoke;
 }
 
+function resolve$1(_, 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$1(actorContext, actorRef) {
+  if (!actorRef) {
+    return;
+  }
+  if (actorRef.status !== interpreter.ActorStatus.Running) {
+    actorContext.stopChild(actorRef);
+    return;
+  }
+  // TODO: recheck why this one has to be deferred
+  actorContext.defer(() => {
+    actorContext.stopChild(actorRef);
+  });
+}
+/**
+ * Stops an actor.
+ *
+ * @param actorRef The actor to stop.
+ */
+function stop(actorRef) {
+  function stop(_) {
+  }
+  stop.type = 'xstate.stop';
+  stop.actorRef = actorRef;
+  stop.resolve = resolve$1;
+  stop.execute = execute$1;
+  return stop;
+}
+
 function checkStateIn(state, _, {
   stateValue
 }) {
@@ -1034,9 +169,7 @@ function checkStateIn(state, _, {
 }
 function stateIn(stateValue) {
   function stateIn(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
+    return false;
   }
   stateIn.check = checkStateIn;
   stateIn.stateValue = stateValue;
@@ -1052,9 +185,7 @@ function checkNot(state, {
 }
 function not(guard) {
   function not(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
+    return false;
   }
   not.check = checkNot;
   not.guards = [guard];
@@ -1070,9 +201,7 @@ function checkAnd(state, {
 }
 function and(guards) {
   function and(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
+    return false;
   }
   and.check = checkAnd;
   and.guards = guards;
@@ -1088,9 +217,7 @@ function checkOr(state, {
 }
 function or(guards) {
   function or(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
+    return false;
   }
   or.check = checkOr;
   or.guards = guards;
@@ -1137,7 +264,7 @@ function evaluateGuard(guard, context, event, state) {
 function getOutput(configuration, context, event, self) {
   const machine = configuration[0].machine;
   const finalChildStateNode = configuration.find(stateNode => stateNode.type === 'final' && stateNode.parent === machine.root);
-  return finalChildStateNode && finalChildStateNode.output ? mapContext(finalChildStateNode.output, context, event, self) : undefined;
+  return finalChildStateNode && finalChildStateNode.output ? interpreter.mapContext(finalChildStateNode.output, context, event, self) : undefined;
 }
 const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
 function getChildren(stateNode) {
@@ -1240,20 +367,17 @@ function isInFinalState(configuration, stateNode = configuration[0].machine.root
   }
   return false;
 }
-const isStateId = str => str[0] === STATE_IDENTIFIER;
+const isStateId = str => str[0] === interpreter.STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
   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 (descriptor === WILDCARD) {
+    if (descriptor === interpreter.WILDCARD) {
       return true;
     }
     if (!descriptor.endsWith('.*')) {
       return false;
     }
-    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 = descriptor.split('.');
     const eventTokens = receivedEventType.split('.');
     for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
@@ -1261,9 +385,6 @@ function getCandidates(stateNode, receivedEventType) {
       const eventToken = eventTokens[tokenIndex];
       if (partialEventToken === '*') {
         const isLastToken = tokenIndex === partialEventTokens.length - 1;
-        if (!isLastToken) {
-          console.warn(`Infix wildcards in transition events are not allowed. Check the "${descriptor}" transition.`);
-        }
         return isLastToken;
       }
       if (partialEventToken !== eventToken) {
@@ -1285,17 +406,16 @@ function getDelayedTransitions(stateNode) {
   }
   const mutateEntryExit = (delay, i) => {
     const delayRef = typeof delay === 'function' ? `${stateNode.id}:delay[${i}]` : delay;
-    const eventType = after(delayRef, stateNode.id);
-    stateNode.entry.push(raise({
-      type: eventType
-    }, {
+    const afterEvent = interpreter.createAfterEvent(delayRef, stateNode.id);
+    const eventType = afterEvent.type;
+    stateNode.entry.push(raise(afterEvent, {
       id: eventType,
       delay
     }));
     stateNode.exit.push(cancel(eventType));
     return eventType;
   };
-  const delayedTransitions = isArray(afterConfig) ? afterConfig.map((transition, i) => {
+  const delayedTransitions = interpreter.isArray(afterConfig) ? afterConfig.map((transition, i) => {
     const eventType = mutateEntryExit(transition.delay, i);
     return {
       ...transition,
@@ -1308,7 +428,7 @@ function getDelayedTransitions(stateNode) {
     } : configTransition;
     const resolvedDelay = !isNaN(+delay) ? +delay : delay;
     const eventType = mutateEntryExit(resolvedDelay, i);
-    return toArray(resolvedTransition).map(transition => ({
+    return interpreter.toArray(resolvedTransition).map(transition => ({
       ...transition,
       event: eventType,
       delay: resolvedDelay
@@ -1325,17 +445,12 @@ function getDelayedTransitions(stateNode) {
   });
 }
 function formatTransition(stateNode, descriptor, transitionConfig) {
-  const normalizedTarget = normalizeTarget(transitionConfig.target);
+  const normalizedTarget = interpreter.normalizeTarget(transitionConfig.target);
   const reenter = transitionConfig.reenter ?? false;
   const target = resolveTarget(stateNode, normalizedTarget);
-
-  // TODO: should this be part of a lint rule instead?
-  if (transitionConfig.cond) {
-    throw new Error(`State "${stateNode.id}" has declared \`cond\` for one of its transitions. This property has been renamed to \`guard\`. Please update your code.`);
-  }
   const transition = {
     ...transitionConfig,
-    actions: toArray(transitionConfig.actions),
+    actions: interpreter.toArray(transitionConfig.actions),
     guard: transitionConfig.guard,
     target,
     source: stateNode,
@@ -1353,29 +468,29 @@ function formatTransitions(stateNode) {
   const transitions = new Map();
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
-      if (descriptor === NULL_EVENT) {
+      if (descriptor === interpreter.NULL_EVENT) {
         throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
       }
       const transitionsConfig = stateNode.config.on[descriptor];
-      transitions.set(descriptor, toTransitionConfigArray(transitionsConfig).map(t => formatTransition(stateNode, descriptor, t)));
+      transitions.set(descriptor, interpreter.toTransitionConfigArray(transitionsConfig).map(t => formatTransition(stateNode, descriptor, t)));
     }
   }
   if (stateNode.config.onDone) {
-    const descriptor = String(done(stateNode.id));
-    transitions.set(descriptor, toTransitionConfigArray(stateNode.config.onDone).map(t => formatTransition(stateNode, descriptor, t)));
+    const descriptor = `xstate.done.state.${stateNode.id}`;
+    transitions.set(descriptor, interpreter.toTransitionConfigArray(stateNode.config.onDone).map(t => formatTransition(stateNode, descriptor, t)));
   }
   for (const invokeDef of stateNode.invoke) {
     if (invokeDef.onDone) {
-      const descriptor = `done.invoke.${invokeDef.id}`;
-      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onDone).map(t => formatTransition(stateNode, descriptor, t)));
+      const descriptor = `xstate.done.actor.${invokeDef.id}`;
+      transitions.set(descriptor, interpreter.toTransitionConfigArray(invokeDef.onDone).map(t => formatTransition(stateNode, descriptor, t)));
     }
     if (invokeDef.onError) {
-      const descriptor = `error.platform.${invokeDef.id}`;
-      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onError).map(t => formatTransition(stateNode, descriptor, t)));
+      const descriptor = `xstate.error.actor.${invokeDef.id}`;
+      transitions.set(descriptor, interpreter.toTransitionConfigArray(invokeDef.onError).map(t => formatTransition(stateNode, descriptor, t)));
     }
     if (invokeDef.onSnapshot) {
       const descriptor = `xstate.snapshot.${invokeDef.id}`;
-      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onSnapshot).map(t => formatTransition(stateNode, descriptor, t)));
+      transitions.set(descriptor, interpreter.toTransitionConfigArray(invokeDef.onSnapshot).map(t => formatTransition(stateNode, descriptor, t)));
     }
   }
   for (const delayedTransition of stateNode.after) {
@@ -1389,8 +504,8 @@ function formatTransitions(stateNode) {
   return transitions;
 }
 function formatInitialTransition(stateNode, _target) {
-  if (typeof _target === 'string' || isArray(_target)) {
-    const targets = toArray(_target).map(t => {
+  if (typeof _target === 'string' || interpreter.isArray(_target)) {
+    const targets = interpreter.toArray(_target).map(t => {
       // Resolve state string keys (which represent children)
       // to their state node
       const descStateNode = typeof t === 'string' ? isStateId(t) ? stateNode.machine.getStateNodeById(t) : stateNode.states[t] : t;
@@ -1418,9 +533,9 @@ function formatInitialTransition(stateNode, _target) {
     return transition;
   }
   return formatTransition(stateNode, '__INITIAL__', {
-    target: toArray(_target.target).map(t => {
+    target: interpreter.toArray(_target.target).map(t => {
       if (typeof t === 'string') {
-        return isStateId(t) ? t : `${STATE_DELIMITER}${t}`;
+        return isStateId(t) ? t : `${interpreter.STATE_DELIMITER}${t}`;
       }
       return t;
     }),
@@ -1439,7 +554,7 @@ function resolveTarget(stateNode, targets) {
     if (isStateId(target)) {
       return stateNode.machine.getStateNodeById(target);
     }
-    const isInternalTarget = target[0] === STATE_DELIMITER;
+    const isInternalTarget = target[0] === interpreter.STATE_DELIMITER;
     // If internal target is defined on machine,
     // do not include machine key on target
     if (isInternalTarget && !stateNode.parent) {
@@ -1459,7 +574,7 @@ function resolveTarget(stateNode, targets) {
   });
 }
 function resolveHistoryTarget(stateNode) {
-  const normalizedTarget = normalizeTarget(stateNode.config.target);
+  const normalizedTarget = interpreter.normalizeTarget(stateNode.config.target);
   if (!normalizedTarget) {
     return stateNode.parent.initial.target;
   }
@@ -1522,7 +637,7 @@ function getStateNodeByPath(stateNode, statePath) {
       // throw e;
     }
   }
-  const arrayStatePath = toStatePath(statePath).slice();
+  const arrayStatePath = interpreter.toStatePath(statePath).slice();
   let currentStateNode = stateNode;
   while (arrayStatePath.length) {
     const key = arrayStatePath.shift();
@@ -1540,7 +655,7 @@ function getStateNodeByPath(stateNode, statePath) {
  * @param state The state value or State instance
  */
 function getStateNodes(stateNode, state) {
-  const stateValue = state instanceof State ? state.value : toStateValue(state);
+  const stateValue = state instanceof State ? state.value : interpreter.toStateValue(state);
   if (typeof stateValue === 'string') {
     return [stateNode, stateNode.states[stateValue]];
   }
@@ -1815,12 +930,12 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
       if (!parent.parent) {
         continue;
       }
-      internalQueue.push(done(parent.id, stateNodeToEnter.output ? mapContext(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
+      internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.mapContext(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
       if (parent.parent) {
         const grandparent = parent.parent;
         if (grandparent.type === 'parallel') {
           if (getChildren(grandparent).every(parentNode => isInFinalState([...mutConfiguration], parentNode))) {
-            internalQueue.push(done(grandparent.id));
+            internalQueue.push(interpreter.createDoneStateEvent(grandparent.id));
           }
         }
       }
@@ -1959,7 +1074,7 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       action
     };
     if (!('resolve' in resolved)) {
-      if (actorCtx?.self.status === ActorStatus.Running) {
+      if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
         resolved(actionArgs);
       } else {
         actorCtx?.defer(() => resolved(actionArgs));
@@ -1972,7 +1087,7 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
 
     intermediateState = nextState;
     if ('execute' in resolved) {
-      if (actorCtx?.self.status === ActorStatus.Running) {
+      if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
         actorCtx?.defer(builtinAction.execute.bind(null, actorCtx, params));
@@ -1985,14 +1100,11 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
   return intermediateState;
 }
 function macrostep(state, event, actorCtx) {
-  if (event.type === WILDCARD) {
-    throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
-  }
   let nextState = state;
   const states = [];
 
   // Handle stop event
-  if (event.type === XSTATE_STOP) {
+  if (event.type === interpreter.XSTATE_STOP) {
     nextState = stopStep(event, nextState, actorCtx);
     states.push(nextState);
     return {
@@ -2004,7 +1116,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 !== XSTATE_INIT) {
+  if (nextEvent.type !== interpreter.XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
     nextState = microstep(transitions, state, actorCtx, nextEvent, false);
     states.push(nextState);
@@ -2159,7 +1271,7 @@ class State {
     this.configuration = config.configuration ?? Array.from(getConfiguration(getStateNodes(machine.root, config.value)));
     this.children = config.children;
     this.value = getStateValue(machine.root, this.configuration);
-    this.tags = new Set(flatten(this.configuration.map(sn => sn.tags)));
+    this.tags = new Set(interpreter.flatten(this.configuration.map(sn => sn.tags)));
     this.done = config.done ?? false;
     this.output = config.output;
     this.error = config.error;
@@ -2175,7 +1287,7 @@ class State {
       return [stateValue];
     }
     const valueKeys = Object.keys(stateValue);
-    return valueKeys.concat(...valueKeys.map(key => this.toStrings(stateValue[key]).map(s => key + STATE_DELIMITER + s)));
+    return valueKeys.concat(...valueKeys.map(key => this.toStrings(stateValue[key]).map(s => key + interpreter.STATE_DELIMITER + s)));
   }
   toJSON() {
     const {
@@ -2196,7 +1308,7 @@ class State {
    * @param parentStateValue
    */
   matches(parentStateValue) {
-    return matchesState(parentStateValue, this.value);
+    return interpreter.matchesState(parentStateValue, this.value);
   }
 
   /**
@@ -2216,9 +1328,6 @@ class State {
    * @returns Whether the event will cause a transition
    */
   can(event) {
-    if (!this.machine) {
-      console.warn(`state.can(...) used outside of a machine-created State object; this will always return false.`);
-    }
     const transitionData = this.machine.getTransitionData(this, event);
     return !!transitionData?.length &&
     // Check that at least one transition is not forbidden
@@ -2230,7 +1339,7 @@ class State {
    */
   get nextEvents() {
     return memo(this, 'nextEvents', () => {
-      return [...new Set(flatten([...this.configuration.map(sn => sn.ownEvents)]))];
+      return [...new Set(interpreter.flatten([...this.configuration.map(sn => sn.ownEvents)]))];
     });
   }
   get meta() {
@@ -2269,209 +1378,7 @@ 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.
- *
- * @param actorRef The actor to stop.
- */
-function stop(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);
-  }
-}
-/**
- *
- * @param expr The expression function to evaluate which will be logged.
- *  Takes in 2 arguments:
- *  - `ctx` - the current state context
- *  - `event` - the event that caused this action to be executed.
- * @param label The label to give to the logged expression.
- */
-function log(value = ({
-  context,
-  event
-}) => ({
-  context,
-  event
-}), label) {
-  function log(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  log.type = 'xstate.log';
-  log.value = value;
-  log.label = label;
-  log.resolve = resolve$4;
-  log.execute = execute$1;
-  return log;
-}
-
-function createSpawner(actorContext, {
-  machine,
-  context
-}, event, spawnedChildren) {
-  const spawn = (src, options = {}) => {
-    const {
-      systemId
-    } = options;
-    if (typeof src === 'string') {
-      const referenced = resolveReferencedActor(machine.implementations.actors[src]);
-      if (!referenced) {
-        throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
-      }
-      const input = 'input' in options ? options.input : referenced.input;
-
-      // TODO: this should also receive `src`
-      const actor = createActor(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`
-      return createActor(src, {
-        id: options.id,
-        parent: actorContext.self,
-        input: options.input,
-        systemId
-      });
-    }
-  };
-  return (src, options) => {
-    const actorRef = spawn(src, options); // TODO: fix types
-    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
-  })];
-}
-/**
- * Updates the current context of the machine.
- *
- * @param assignment An object that represents the partial context to update.
- */
-function assign(assignment) {
-  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, {
+function resolve(_, state, args, {
   event: eventOrExpr,
   id,
   delay
@@ -2510,126 +1417,42 @@ function execute(actorContext, params) {
  */
 function raise(eventOrExpr, options) {
   function raise(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
   }
   raise.type = 'xstate.raise';
   raise.event = eventOrExpr;
   raise.id = options?.id;
   raise.delay = options?.delay;
-  raise.resolve = resolve$2;
+  raise.resolve = resolve;
   raise.execute = execute;
   return raise;
 }
 
-function resolve$1(_, state, actionArgs, {
-  branches
-}) {
-  const matchedActions = branches.find(condition => {
-    return !condition.guard || evaluateGuard(condition.guard, state.context, actionArgs.event, state);
-  })?.actions;
-  return [state, undefined, toArray(matchedActions)];
-}
-function choose(branches) {
-  function choose(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  choose.type = 'xstate.choose';
-  choose.branches = branches;
-  choose.resolve = resolve$1;
-  return choose;
-}
-
-function resolve(_, state, args, {
-  get
-}) {
-  return [state, undefined, toArray(get({
-    context: args.context,
-    event: args.event
-  }))];
-}
-function pure(getActions) {
-  function pure(_) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  pure.type = 'xstate.pure';
-  pure.get = getActions;
-  pure.resolve = resolve;
-  return pure;
-}
-
-/**
- * Returns an event type that represents an implicit event that
- * is sent after the specified `delay`.
- *
- * @param delayRef The delay in milliseconds
- * @param id The state node ID where this event is handled
- */
-function after(delayRef, id) {
-  const idSuffix = id ? `#${id}` : '';
-  return `${ConstantPrefix.After}(${delayRef})${idSuffix}`;
-}
-
-/**
- * Returns an event that represents that a final state node
- * has been reached in the parent state node.
- *
- * @param id The final state node's parent state node `id`
- * @param output The data to pass into the event
- */
-function done(id, output) {
-  const type = `${ConstantPrefix.DoneState}.${id}`;
-  const eventObject = {
-    type,
-    output
-  };
-  eventObject.toString = () => type;
-  return eventObject;
-}
-function doneInvokeEventType(invokeId) {
-  return `${ConstantPrefix.DoneInvoke}.${invokeId}`;
-}
-
-/**
- * Returns an event that represents that an invoked service has terminated.
- *
- * An invoked service is terminated when it has reached a top-level final state node,
- * but not when it is canceled.
- *
- * @param invokeId The invoked service ID
- * @param output The data to pass into the event
- */
-function doneInvoke(invokeId, output) {
-  const type = doneInvokeEventType(invokeId);
-  const eventObject = {
-    type,
-    output
-  };
-  eventObject.toString = () => type;
-  return eventObject;
-}
-function errorEventType(id) {
-  return `${ConstantPrefix.ErrorPlatform}.${id}`;
-}
-function error(id, data) {
-  const type = errorEventType(id);
-  const eventObject = {
-    type,
-    data
-  };
-  eventObject.toString = () => type;
-  return eventObject;
-}
-function createInitEvent(input) {
-  return {
-    type: XSTATE_INIT,
-    input
-  };
-}
-
-export { stateIn as $, isStateId as A, getStateNodeByPath as B, getPersistedState as C, resolveReferencedActor as D, createActor as E, matchesState as F, Actor as G, ActorStatus as H, doneInvoke as I, interpret as J, InterpreterStatus as K, cancel as L, choose as M, NULL_EVENT as N, log as O, pure as P, raise as Q, forwardTo as R, STATE_DELIMITER as S, sendParent as T, sendTo as U, stop as V, pathToStateValue as W, toObserver as X, and as Y, not as Z, or as _, toTransitionConfigArray as a, ConstantPrefix as a0, SpecialTargets as a1, XSTATE_INIT as a2, isPromiseLike as a3, error as a4, XSTATE_STOP as a5, symbolObservable as a6, constantPrefixes as a7, after as a8, done as a9, doneInvokeEventType as aa, errorEventType as ab, escalate as ac, formatTransition as b, memo as c, createInvokeId as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, formatInitialTransition as h, getCandidates as i, getConfiguration as j, getStateNodes as k, isInFinalState as l, mapValues as m, State as n, isErrorEvent as o, cloneState as p, macrostep as q, resolveStateValue as r, transitionNode as s, toArray as t, getInitialConfiguration as u, resolveActionsAndContext as v, assign as w, createInitEvent as x, microstep as y, isAtomicStateNode as z };
+exports.State = State;
+exports.and = and;
+exports.cancel = cancel;
+exports.cloneState = cloneState;
+exports.evaluateGuard = evaluateGuard;
+exports.formatInitialTransition = formatInitialTransition;
+exports.formatTransition = formatTransition;
+exports.formatTransitions = formatTransitions;
+exports.getCandidates = getCandidates;
+exports.getConfiguration = getConfiguration;
+exports.getDelayedTransitions = getDelayedTransitions;
+exports.getInitialConfiguration = getInitialConfiguration;
+exports.getPersistedState = getPersistedState;
+exports.getStateNodeByPath = getStateNodeByPath;
+exports.getStateNodes = getStateNodes;
+exports.isAtomicStateNode = isAtomicStateNode;
+exports.isInFinalState = isInFinalState;
+exports.isStateId = isStateId;
+exports.macrostep = macrostep;
+exports.memo = memo;
+exports.microstep = microstep;
+exports.not = not;
+exports.or = or;
+exports.raise = raise;
+exports.resolveActionsAndContext = resolveActionsAndContext;
+exports.resolveStateValue = resolveStateValue;
+exports.stateIn = stateIn;
+exports.stop = stop;
+exports.transitionNode = transitionNode;