xstate 5.0.0-beta.43 → 5.0.0-beta.44

package/dist/{raise-e0fe5c2d.cjs.js → raise-348cc74e.development.esm.js}

@@ -1,6 +1,866 @@
-'use strict';
+import { devToolsAdapter } from '../dev/dist/xstate-dev.development.esm.js';
 
-var interpreter = require('./interpreter-36d5556e.cjs.js');
+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;
+    }
+  }
+  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);
+      this._current = consumed.next;
+    }
+    this._last = null;
+  }
+}
+
+const STATE_DELIMITER = '.';
+const TARGETLESS_KEY = '';
+const NULL_EVENT = '';
+const STATE_IDENTIFIER = '#';
+const WILDCARD = '*';
+const XSTATE_INIT = 'xstate.init';
+const XSTATE_ERROR = 'xstate.error';
+const XSTATE_STOP = 'xstate.stop';
+
+/**
+ * Returns an event 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 createAfterEvent(delayRef, id) {
+  const idSuffix = id ? `#${id}` : '';
+  return {
+    type: `xstate.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 createDoneStateEvent(id, output) {
+  return {
+    type: `xstate.done.state.${id}`,
+    output
+  };
+}
+
+/**
+ * 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 createDoneActorEvent(invokeId, output) {
+  return {
+    type: `xstate.done.actor.${invokeId}`,
+    output
+  };
+}
+function createErrorActorEvent(id, data) {
+  return {
+    type: `xstate.error.actor.${id}`,
+    data
+  };
+}
+function createInitEvent(input) {
+  return {
+    type: XSTATE_INIT,
+    input
+  };
+}
+
+/**
+ * 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')();
+
+let idCounter = 0;
+function createSystem(rootActor) {
+  const children = new Map();
+  const keyedActors = new Map();
+  const reverseKeyedActors = new WeakMap();
+  const observers = new Set();
+  const system = {
+    _bookId: () => `x:${idCounter++}`,
+    _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);
+    },
+    inspect: observer => {
+      observers.add(observer);
+    },
+    _sendInspectionEvent: event => {
+      const resolvedInspectionEvent = {
+        ...event,
+        rootId: rootActor.sessionId
+      };
+      observers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+    },
+    _relay: (source, target, event) => {
+      system._sendInspectionEvent({
+        type: '@xstate.event',
+        sourceRef: source,
+        actorRef: target,
+        event
+      });
+      target._send(event);
+    }
+  };
+  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.split(STATE_DELIMITER);
+  } catch (e) {
+    throw new Error(`'${stateId}' is not a valid state path.`);
+  }
+}
+function toStateValue(stateValue) {
+  if (isMachineSnapshot(stateValue)) {
+    return stateValue.value;
+  }
+  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 resolveOutput(mapper, context, event, self) {
+  if (typeof mapper === 'function') {
+    return mapper({
+      context,
+      event,
+      self
+    });
+  }
+  if (!!mapper && 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 isArray(value) {
+  return Array.isArray(value);
+}
+function isErrorActorEvent(event) {
+  return event.type.startsWith('xstate.error.actor');
+}
+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}[${index}]`;
+}
+function resolveReferencedActor(machine, src) {
+  if (src.startsWith('xstate#')) {
+    const [, indexStr] = src.match(/\[(\d+)\]$/);
+    const node = machine.getStateNodeById(src.slice(7, -(indexStr.length + 2)));
+    const invokeConfig = node.config.invoke;
+    return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
+  }
+  return machine.implementations.actors[src];
+}
+
+const $$ACTOR_TYPE = 1;
+// those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync
+let ProcessingStatus = /*#__PURE__*/function (ProcessingStatus) {
+  ProcessingStatus[ProcessingStatus["NotStarted"] = 0] = "NotStarted";
+  ProcessingStatus[ProcessingStatus["Running"] = 1] = "Running";
+  ProcessingStatus[ProcessingStatus["Stopped"] = 2] = "Stopped";
+  return ProcessingStatus;
+}({});
+const defaultOptions = {
+  clock: {
+    setTimeout: (fn, ms) => {
+      return setTimeout(fn, ms);
+    },
+    clearTimeout: id => {
+      return clearTimeout(id);
+    }
+  },
+  logger: console.log.bind(console),
+  devTools: false
+};
+
+/**
+ * An Actor is a running process that can receive events, send events and change its behavior based on the events it receives, which can cause effects outside of the actor. When you run a state machine, it becomes an actor.
+ */
+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.
+   */
+
+  /** @internal */
+
+  // Actor Ref
+
+  // TODO: add typings for system
+
+  /**
+   * The globally unique process ID for this invocation.
+   */
+
+  /**
+   * The system to which this actor belongs.
+   */
+
+  /**
+   * 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._processingStatus = ProcessingStatus.NotStarted;
+    this._parent = void 0;
+    this.ref = void 0;
+    this._actorScope = 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,
+      inspect
+    } = resolvedOptions;
+    this.system = parent?.system ?? createSystem(this);
+    if (inspect && !parent) {
+      // Always inspect at the system-level
+      this.system.inspect(toObserver(inspect));
+    }
+    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 ?? logic;
+    this.ref = this;
+    this._actorScope = {
+      self: this,
+      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.system._sendInspectionEvent({
+      type: '@xstate.actor',
+      actorRef: this
+    });
+    if (systemId) {
+      this._systemId = systemId;
+      this.system._set(systemId, this);
+    }
+    this._initState(options?.state);
+    if (systemId && this._state.status !== 'active') {
+      this.system._unregister(this);
+    }
+  }
+  _initState(persistedState) {
+    this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
+  }
+
+  // array of functions to defer
+
+  update(snapshot, event) {
+    // Update state
+    this._state = snapshot;
+
+    // Execute deferred effects
+    let deferredFn;
+    while (deferredFn = this._deferred.shift()) {
+      deferredFn();
+    }
+    for (const observer of this.observers) {
+      try {
+        observer.next?.(snapshot);
+      } catch (err) {
+        reportUnhandledError(err);
+      }
+    }
+    switch (this._state.status) {
+      case 'done':
+        this._stopProcedure();
+        this._complete();
+        this._doneEvent = createDoneActorEvent(this.id, this._state.output);
+        if (this._parent) {
+          this.system._relay(this, this._parent, this._doneEvent);
+        }
+        break;
+      case 'error':
+        this._stopProcedure();
+        this._error(this._state.error);
+        if (this._parent) {
+          this.system._relay(this, this._parent, createErrorActorEvent(this.id, this._state.error));
+        }
+        break;
+    }
+    this.system._sendInspectionEvent({
+      type: '@xstate.snapshot',
+      actorRef: this,
+      event,
+      snapshot
+    });
+  }
+
+  /**
+   * Subscribe an observer to an actor’s snapshot values.
+   *
+   * @remarks
+   * The observer will receive the actor’s snapshot value when it is emitted. The observer can be:
+   * - A plain function that receives the latest snapshot, or
+   * - An observer object whose `.next(snapshot)` method receives the latest snapshot
+   *
+   * @example
+   * ```ts
+   * // Observer as a plain function
+   * const subscription = actor.subscribe((snapshot) => {
+   *   console.log(snapshot);
+   * });
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Observer as an object
+   * const subscription = actor.subscribe({
+   *   next(snapshot) {
+   *     console.log(snapshot);
+   *   },
+   *   error(err) {
+   *     // ...
+   *   },
+   *   complete() {
+   *     // ...
+   *   },
+   * });
+   * ```
+   *
+   * The return value of `actor.subscribe(observer)` is a subscription object that has an `.unsubscribe()` method. You can call `subscription.unsubscribe()` to unsubscribe the observer:
+   *
+   * @example
+   * ```ts
+   * const subscription = actor.subscribe((snapshot) => {
+   *   // ...
+   * });
+   *
+   * // Unsubscribe the observer
+   * subscription.unsubscribe();
+   * ```
+   *
+   * When the actor is stopped, all of its observers will automatically be unsubscribed.
+   *
+   * @param observer - Either a plain function that receives the latest snapshot, or an observer object whose `.next(snapshot)` method receives the latest snapshot
+   */
+
+  subscribe(nextListenerOrObserver, errorListener, completeListener) {
+    const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
+    if (this._processingStatus !== ProcessingStatus.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._processingStatus === ProcessingStatus.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._processingStatus = ProcessingStatus.Running;
+
+    // TODO: this isn't correct when rehydrating
+    const initEvent = createInitEvent(this.options.input);
+    this.system._sendInspectionEvent({
+      type: '@xstate.event',
+      sourceRef: this._parent,
+      actorRef: this,
+      event: initEvent
+    });
+    const status = this._state.status;
+    switch (status) {
+      case 'done':
+        // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
+        // we still need to complete observers, flush deferreds etc
+        this.update(this._state, initEvent);
+      // fallthrough
+      case 'error':
+        // TODO: rethink cleanup of observers, mailbox, etc
+        return this;
+    }
+    if (this.logic.start) {
+      try {
+        this.logic.start(this._state, this._actorScope);
+      } catch (err) {
+        this._stopProcedure();
+        this._error(err);
+        this._parent?.send(createErrorActorEvent(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, initEvent);
+    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._actorScope);
+    } 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(createErrorActorEvent(this.id, err));
+      return;
+    }
+    this.update(nextState, event);
+    if (event.type === XSTATE_STOP) {
+      this._stopProcedure();
+      this._complete();
+    }
+  }
+  _stop() {
+    if (this._processingStatus === ProcessingStatus.Stopped) {
+      return this;
+    }
+    this.mailbox.clear();
+    if (this._processingStatus === ProcessingStatus.NotStarted) {
+      this._processingStatus = ProcessingStatus.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._processingStatus !== ProcessingStatus.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._processingStatus = ProcessingStatus.Stopped;
+    this.system._unregister(this);
+    return this;
+  }
+
+  /**
+   * @internal
+   */
+  _send(event) {
+    if (this._processingStatus === ProcessingStatus.Stopped) {
+      // do nothing
+      {
+        const eventString = JSON.stringify(event);
+        console.warn(`Event "${event.type}" was sent to stopped actor "${this.id} (${this.sessionId})". This actor has already reached its final state, and will not transition.\nEvent: ${eventString}`);
+      }
+      return;
+    }
+    this.mailbox.enqueue(event);
+  }
+
+  /**
+   * 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`);
+    }
+    this.system._relay(undefined, this, event);
+  }
+
+  /**
+   * TODO: figure out a way to do this within the machine
+   * @internal
+   */
+  delaySend(params) {
+    const {
+      event,
+      id,
+      delay
+    } = params;
+    const timerId = this.clock.setTimeout(() => {
+      this.system._relay(this, params.to ?? this, event);
+    }, delay);
+
+    // TODO: consider the rehydration story here
+    if (id) {
+      this.delayedEventsMap[id] = timerId;
+    }
+  }
+
+  /**
+   * TODO: figure out a way to do this within the machine
+   * @internal
+   */
+  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 {
+      xstate$$type: $$ACTOR_TYPE,
+      id: this.id
+    };
+  }
+
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.state}
+   *
+   * @see https://stately.ai/docs/persistence
+   */
+
+  getPersistedState(options) {
+    return this.logic.getPersistedState(this._state, options);
+  }
+  [symbolObservable]() {
+    return this;
+  }
+
+  /**
+   * Read an actor’s snapshot synchronously.
+   *
+   * @remarks
+   * The snapshot represent an actor's last emitted value.
+   *
+   * When an actor receives an event, its internal state may change.
+   * An actor may emit a snapshot when a state transition occurs.
+   *
+   * Note that some actors, such as callback actors generated with `fromCallback`, will not emit snapshots.
+   *
+   * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
+   * @see {@link Actor.getPersistedState} to persist the internal state of an actor (which is more than just a snapshot).
+   */
+  getSnapshot() {
+    return 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.
+ */
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -34,6 +894,9 @@ function executeCancel(actorScope, resolvedSendId) {
  */
 function cancel(sendId) {
   function cancel(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
   cancel.type = 'xstate.cancel';
   cancel.sendId = sendId;
@@ -49,11 +912,11 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   input,
   syncSnapshot
 }) {
-  const logic = typeof src === 'string' ? interpreter.resolveReferencedActor(state.machine, src) : src;
+  const logic = typeof src === 'string' ? resolveReferencedActor(state.machine, src) : src;
   const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
   if (logic) {
-    actorRef = interpreter.createActor(logic, {
+    actorRef = createActor(logic, {
       id: resolvedId,
       src,
       parent: actorScope?.self,
@@ -78,6 +941,9 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
       });
     }
   }
+  if (!actorRef) {
+    console.warn(`Actor type '${src}' not found in machine '${actorScope.id}'.`);
+  }
   return [cloneMachineSnapshot(state, {
     children: {
       ...state.children,
@@ -96,13 +962,13 @@ function executeSpawn(actorScope, {
     return;
   }
   actorScope.defer(() => {
-    if (actorRef._processingStatus === interpreter.ProcessingStatus.Stopped) {
+    if (actorRef._processingStatus === ProcessingStatus.Stopped) {
       return;
     }
     try {
       actorRef.start?.();
     } catch (err) {
-      actorScope.self.send(interpreter.createErrorActorEvent(id, err));
+      actorScope.self.send(createErrorActorEvent(id, err));
       return;
     }
   });
@@ -114,6 +980,9 @@ function spawn(...[src, {
   syncSnapshot = false
 } = {}]) {
   function spawn(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
   spawn.type = 'xstate.spawn';
   spawn.id = id;
@@ -154,7 +1023,7 @@ function executeStop(actorScope, actorRef) {
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
-  if (actorRef._processingStatus !== interpreter.ProcessingStatus.Running) {
+  if (actorRef._processingStatus !== ProcessingStatus.Running) {
     actorScope.stopChild(actorRef);
     return;
   }
@@ -173,6 +1042,9 @@ function executeStop(actorScope, actorRef) {
  */
 function stop(actorRef) {
   function stop(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
   stop.type = 'xstate.stop';
   stop.actorRef = actorRef;
@@ -192,7 +1064,9 @@ function checkStateIn(state, _, {
 }
 function stateIn(stateValue) {
   function stateIn(args, params) {
-    return false;
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
   stateIn.check = checkStateIn;
   stateIn.stateValue = stateValue;
@@ -208,7 +1082,9 @@ function checkNot(state, {
 }
 function not(guard) {
   function not(args, params) {
-    return false;
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
   not.check = checkNot;
   not.guards = [guard];
@@ -224,7 +1100,9 @@ function checkAnd(state, {
 }
 function and(guards) {
   function and(args, params) {
-    return false;
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
   and.check = checkAnd;
   and.guards = guards;
@@ -240,7 +1118,9 @@ function checkOr(state, {
 }
 function or(guards) {
   function or(args, params) {
-    return false;
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
   or.check = checkOr;
   or.guards = guards;
@@ -384,17 +1264,20 @@ function isInFinalState(configuration, stateNode) {
   }
   return stateNode.type === 'final';
 }
-const isStateId = str => str[0] === interpreter.STATE_IDENTIFIER;
+const isStateId = str => str[0] === 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 === interpreter.WILDCARD) {
+    if (descriptor === 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++) {
@@ -402,6 +1285,9 @@ 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) {
@@ -423,7 +1309,7 @@ function getDelayedTransitions(stateNode) {
   }
   const mutateEntryExit = (delay, i) => {
     const delayRef = typeof delay === 'function' ? `${stateNode.id}:delay[${i}]` : delay;
-    const afterEvent = interpreter.createAfterEvent(delayRef, stateNode.id);
+    const afterEvent = createAfterEvent(delayRef, stateNode.id);
     const eventType = afterEvent.type;
     stateNode.entry.push(raise(afterEvent, {
       id: eventType,
@@ -439,7 +1325,7 @@ function getDelayedTransitions(stateNode) {
     } : configTransition;
     const resolvedDelay = !isNaN(+delay) ? +delay : delay;
     const eventType = mutateEntryExit(resolvedDelay, i);
-    return interpreter.toArray(resolvedTransition).map(transition => ({
+    return toArray(resolvedTransition).map(transition => ({
       ...transition,
       event: eventType,
       delay: resolvedDelay
@@ -456,12 +1342,17 @@ function getDelayedTransitions(stateNode) {
   });
 }
 function formatTransition(stateNode, descriptor, transitionConfig) {
-  const normalizedTarget = interpreter.normalizeTarget(transitionConfig.target);
+  const normalizedTarget = 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: interpreter.toArray(transitionConfig.actions),
+    actions: toArray(transitionConfig.actions),
     guard: transitionConfig.guard,
     target,
     source: stateNode,
@@ -479,29 +1370,29 @@ function formatTransitions(stateNode) {
   const transitions = new Map();
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
-      if (descriptor === interpreter.NULL_EVENT) {
+      if (descriptor === 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, interpreter.toTransitionConfigArray(transitionsConfig).map(t => formatTransition(stateNode, descriptor, t)));
+      transitions.set(descriptor, toTransitionConfigArray(transitionsConfig).map(t => formatTransition(stateNode, descriptor, t)));
     }
   }
   if (stateNode.config.onDone) {
     const descriptor = `xstate.done.state.${stateNode.id}`;
-    transitions.set(descriptor, interpreter.toTransitionConfigArray(stateNode.config.onDone).map(t => formatTransition(stateNode, descriptor, t)));
+    transitions.set(descriptor, toTransitionConfigArray(stateNode.config.onDone).map(t => formatTransition(stateNode, descriptor, t)));
   }
   for (const invokeDef of stateNode.invoke) {
     if (invokeDef.onDone) {
       const descriptor = `xstate.done.actor.${invokeDef.id}`;
-      transitions.set(descriptor, interpreter.toTransitionConfigArray(invokeDef.onDone).map(t => formatTransition(stateNode, descriptor, t)));
+      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onDone).map(t => formatTransition(stateNode, descriptor, t)));
     }
     if (invokeDef.onError) {
       const descriptor = `xstate.error.actor.${invokeDef.id}`;
-      transitions.set(descriptor, interpreter.toTransitionConfigArray(invokeDef.onError).map(t => formatTransition(stateNode, descriptor, t)));
+      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onError).map(t => formatTransition(stateNode, descriptor, t)));
     }
     if (invokeDef.onSnapshot) {
       const descriptor = `xstate.snapshot.${invokeDef.id}`;
-      transitions.set(descriptor, interpreter.toTransitionConfigArray(invokeDef.onSnapshot).map(t => formatTransition(stateNode, descriptor, t)));
+      transitions.set(descriptor, toTransitionConfigArray(invokeDef.onSnapshot).map(t => formatTransition(stateNode, descriptor, t)));
     }
   }
   for (const delayedTransition of stateNode.after) {
@@ -521,7 +1412,7 @@ function formatInitialTransition(stateNode, _target) {
   }
   const transition = {
     source: stateNode,
-    actions: !_target || typeof _target === 'string' ? [] : interpreter.toArray(_target.actions),
+    actions: !_target || typeof _target === 'string' ? [] : toArray(_target.actions),
     eventType: null,
     reenter: false,
     target: resolvedTarget ? [resolvedTarget] : [],
@@ -545,7 +1436,7 @@ function resolveTarget(stateNode, targets) {
     if (isStateId(target)) {
       return stateNode.machine.getStateNodeById(target);
     }
-    const isInternalTarget = target[0] === interpreter.STATE_DELIMITER;
+    const isInternalTarget = target[0] === STATE_DELIMITER;
     // If internal target is defined on machine,
     // do not include machine key on target
     if (isInternalTarget && !stateNode.parent) {
@@ -565,7 +1456,7 @@ function resolveTarget(stateNode, targets) {
   });
 }
 function resolveHistoryDefaultTransition(stateNode) {
-  const normalizedTarget = interpreter.normalizeTarget(stateNode.config.target);
+  const normalizedTarget = normalizeTarget(stateNode.config.target);
   if (!normalizedTarget) {
     return stateNode.parent.initial;
   }
@@ -634,7 +1525,7 @@ function getStateNodeByPath(stateNode, statePath) {
       // throw e;
     }
   }
-  const arrayStatePath = interpreter.toStatePath(statePath).slice();
+  const arrayStatePath = toStatePath(statePath).slice();
   let currentStateNode = stateNode;
   while (arrayStatePath.length) {
     const key = arrayStatePath.shift();
@@ -886,8 +1777,8 @@ function getMachineOutput(state, event, actorScope, rootNode, rootCompletionNode
   if (!rootNode.output) {
     return;
   }
-  const doneStateEvent = interpreter.createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? interpreter.resolveOutput(rootCompletionNode.output, state.context, event, actorScope.self) : undefined);
-  return interpreter.resolveOutput(rootNode.output, state.context, doneStateEvent, actorScope.self);
+  const doneStateEvent = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, state.context, event, actorScope.self) : undefined);
+  return resolveOutput(rootNode.output, state.context, doneStateEvent, actorScope.self);
 }
 function enterStates(currentState, event, actorScope, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
   let nextState = currentState;
@@ -925,11 +1816,11 @@ function enterStates(currentState, event, actorScope, filteredTransitions, mutCo
       let ancestorMarker = parent?.type === 'parallel' ? parent : parent?.parent;
       let rootCompletionNode = ancestorMarker || stateNodeToEnter;
       if (parent?.type === 'compound') {
-        internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self) : undefined));
+        internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self) : undefined));
       }
       while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
         completedNodes.add(ancestorMarker);
-        internalQueue.push(interpreter.createDoneStateEvent(ancestorMarker.id));
+        internalQueue.push(createDoneStateEvent(ancestorMarker.id));
         rootCompletionNode = ancestorMarker;
         ancestorMarker = ancestorMarker.parent;
       }
@@ -1092,7 +1983,7 @@ function resolveActionsAndContextWorker(currentState, event, actorScope, actions
       event
     }) : action.params : undefined;
     if (!('resolve' in resolvedAction)) {
-      if (actorScope?.self._processingStatus === interpreter.ProcessingStatus.Running) {
+      if (actorScope?.self._processingStatus === ProcessingStatus.Running) {
         resolvedAction(actionArgs, actionParams);
       } else {
         actorScope?.defer(() => {
@@ -1110,7 +2001,7 @@ function resolveActionsAndContextWorker(currentState, event, actorScope, actions
       retries?.push([builtinAction, params]);
     }
     if ('execute' in builtinAction) {
-      if (actorScope?.self._processingStatus === interpreter.ProcessingStatus.Running) {
+      if (actorScope?.self._processingStatus === ProcessingStatus.Running) {
         builtinAction.execute(actorScope, params);
       } else {
         actorScope?.defer(builtinAction.execute.bind(null, actorScope, params));
@@ -1134,11 +2025,14 @@ function resolveActionsAndContext(currentState, event, actorScope, actions, inte
   return nextState;
 }
 function macrostep(state, event, actorScope, internalQueue = []) {
+  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 === interpreter.XSTATE_STOP) {
+  if (event.type === XSTATE_STOP) {
     nextState = cloneMachineSnapshot(stopChildren(nextState, event, actorScope), {
       status: 'stopped'
     });
@@ -1152,7 +2046,7 @@ function macrostep(state, event, actorScope, internalQueue = []) {
 
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
-  if (nextEvent.type !== interpreter.XSTATE_INIT) {
+  if (nextEvent.type !== XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
     nextState = microstep(transitions, state, actorScope, nextEvent, false, internalQueue);
     states.push(nextState);
@@ -1218,13 +2112,19 @@ function resolveStateValue(rootNode, stateValue) {
   return getStateValue(rootNode, [...configuration]);
 }
 
+function isMachineSnapshot(value) {
+  return !!value && typeof value === 'object' && 'machine' in value && 'value' in value;
+}
 const machineSnapshotMatches = function matches(testValue) {
-  return interpreter.matchesState(testValue, this.value);
+  return matchesState(testValue, this.value);
 };
 const machineSnapshotHasTag = function hasTag(tag) {
   return this.tags.has(tag);
 };
 const machineSnapshotCan = function 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
@@ -1249,7 +2149,7 @@ const machineSnapshotToJSON = function toJSON() {
 };
 const machineSnapshotNextEvents = function nextEvents() {
   return memo(this, 'nextEvents', () => {
-    return [...new Set(interpreter.flatten([...this.configuration.map(sn => sn.ownEvents)]))];
+    return [...new Set(flatten([...this.configuration.map(sn => sn.ownEvents)]))];
   });
 };
 const machineSnapshotMeta = function nextEvents() {
@@ -1269,7 +2169,7 @@ function createMachineSnapshot(config, machine) {
     context: config.context,
     configuration: config.configuration,
     value: getStateValue(machine.root, config.configuration),
-    tags: new Set(interpreter.flatten(config.configuration.map(sn => sn.tags))),
+    tags: new Set(flatten(config.configuration.map(sn => sn.tags))),
     children: config.children,
     historyValue: config.historyValue || {},
     // this one is generic in the target and it's hard to create a matching non-generic source signature
@@ -1317,6 +2217,9 @@ function getPersistedState(state, options) {
   const childrenJson = {};
   for (const id in children) {
     const child = children[id];
+    if (typeof child.src !== 'string' && (!options || !('__unsafeAllowInlineActors' in options))) {
+      throw new Error('An inline child actor cannot be persisted.');
+    }
     childrenJson[id] = {
       state: child.getPersistedState(options),
       src: child.src,
@@ -1340,7 +2243,7 @@ function persistContext(contextPart) {
           ...contextPart
         };
         copy[key] = {
-          xstate$$type: interpreter.$$ACTOR_TYPE,
+          xstate$$type: $$ACTOR_TYPE,
           id: value.id
         };
       } else {
@@ -1399,6 +2302,9 @@ function executeRaise(actorScope, params) {
  */
 function raise(eventOrExpr, options) {
   function raise(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
   }
   raise.type = 'xstate.raise';
   raise.event = eventOrExpr;
@@ -1409,32 +2315,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-exports.and = and;
-exports.cancel = cancel;
-exports.cloneMachineSnapshot = cloneMachineSnapshot;
-exports.createMachineSnapshot = createMachineSnapshot;
-exports.evaluateGuard = evaluateGuard;
-exports.formatInitialTransition = formatInitialTransition;
-exports.formatTransition = formatTransition;
-exports.formatTransitions = formatTransitions;
-exports.getCandidates = getCandidates;
-exports.getConfiguration = getConfiguration;
-exports.getDelayedTransitions = getDelayedTransitions;
-exports.getInitialStateNodes = getInitialStateNodes;
-exports.getPersistedState = getPersistedState;
-exports.getStateNodeByPath = getStateNodeByPath;
-exports.getStateNodes = getStateNodes;
-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.spawn = spawn;
-exports.stateIn = stateIn;
-exports.stop = stop;
-exports.transitionNode = transitionNode;
+export { $$ACTOR_TYPE as $, getPersistedState as A, resolveReferencedActor as B, createActor as C, Actor as D, interpret as E, isMachineSnapshot as F, matchesState as G, pathToStateValue as H, toObserver as I, and as J, not as K, or as L, stateIn as M, NULL_EVENT as N, cancel as O, raise as P, stop as Q, spawn as R, STATE_DELIMITER as S, ProcessingStatus as T, createErrorActorEvent as U, XSTATE_ERROR as V, XSTATE_STOP as X, toTransitionConfigArray as a, 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, createMachineSnapshot as l, mapValues as m, isInFinalState as n, isErrorActorEvent as o, cloneMachineSnapshot as p, macrostep as q, resolveStateValue as r, transitionNode as s, toArray as t, resolveActionsAndContext as u, createInitEvent as v, microstep as w, getInitialStateNodes as x, isStateId as y, getStateNodeByPath as z };