xstate 5.0.0-beta.43 → 5.0.0-beta.45

package/dist/{raise-e0fe5c2d.cjs.js → raise-fabffc3d.cjs.js}

@@ -1,21 +1,874 @@
 'use strict';
 
-var interpreter = require('./interpreter-36d5556e.cjs.js');
-
-const cache = new WeakMap();
-function memo(object, key, fn) {
-  let memoizedData = cache.get(object);
-  if (!memoizedData) {
-    memoizedData = {
-      [key]: fn()
+var dev_dist_xstateDev = require('../dev/dist/xstate-dev.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
+    });
+  }
+  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._syncSnapshot = 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,
+      syncSnapshot,
+      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._syncSnapshot = syncSnapshot;
+    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);
+      }
     };
-    cache.set(object, memoizedData);
-  } else if (!(key in memoizedData)) {
-    memoizedData[key] = fn();
   }
-  return memoizedData[key];
+
+  /**
+   * 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;
+    }
+    if (this._syncSnapshot) {
+      this.subscribe({
+        next: snapshot => {
+          if (snapshot.status === 'active') {
+            this._parent.send({
+              type: `xstate.snapshot.${this.id}`,
+              snapshot
+            });
+          }
+        },
+        error: () => {}
+      });
+    }
+    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) {
+      return;
+    }
+    this.mailbox.enqueue(event);
+  }
+
+  /**
+   * Sends an event to the running Actor to trigger a transition.
+   *
+   * @param event The event to send
+   */
+  send(event) {
+    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 : dev_dist_xstateDev.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.
+ */
+
 function resolveCancel(_, state, actionArgs, actionParams, {
   sendId
 }) {
@@ -49,14 +902,15 @@ 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,
+      syncSnapshot,
       systemId,
       input: typeof input === 'function' ? input({
         context: state.context,
@@ -64,19 +918,6 @@ function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
         self: actorScope?.self
       }) : input
     });
-    if (syncSnapshot) {
-      actorRef.subscribe({
-        next: snapshot => {
-          if (snapshot.status === 'active') {
-            actorScope.self.send({
-              type: `xstate.snapshot.${id}`,
-              snapshot
-            });
-          }
-        },
-        error: () => {}
-      });
-    }
   }
   return [cloneMachineSnapshot(state, {
     children: {
@@ -96,13 +937,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;
     }
   });
@@ -154,7 +995,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;
   }
@@ -186,7 +1027,7 @@ function checkStateIn(state, _, {
 }) {
   if (typeof stateValue === 'string' && isStateId(stateValue)) {
     const target = state.machine.getStateNodeById(stateValue);
-    return state.configuration.some(sn => sn === target);
+    return state._nodes.some(sn => sn === target);
   }
   return state.matches(stateValue);
 }
@@ -297,26 +1138,25 @@ function getProperAncestors(stateNode, toStateNode) {
   }
   return ancestors;
 }
-function getConfiguration(stateNodes) {
-  const configuration = new Set(stateNodes);
-  const configurationSet = new Set(stateNodes);
-  const adjList = getAdjList(configurationSet);
+function getAllStateNodes(stateNodes) {
+  const nodeSet = new Set(stateNodes);
+  const adjList = getAdjList(nodeSet);
 
   // add descendants
-  for (const s of configuration) {
+  for (const s of nodeSet) {
     // if previously active, add existing child nodes
     if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
-      getInitialStateNodesWithTheirAncestors(s).forEach(sn => configurationSet.add(sn));
+      getInitialStateNodesWithTheirAncestors(s).forEach(sn => nodeSet.add(sn));
     } else {
       if (s.type === 'parallel') {
         for (const child of getChildren(s)) {
           if (child.type === 'history') {
             continue;
           }
-          if (!configurationSet.has(child)) {
+          if (!nodeSet.has(child)) {
             const initialStates = getInitialStateNodesWithTheirAncestors(child);
             for (const initialStateNode of initialStates) {
-              configurationSet.add(initialStateNode);
+              nodeSet.add(initialStateNode);
             }
           }
         }
@@ -325,14 +1165,14 @@ function getConfiguration(stateNodes) {
   }
 
   // add all ancestors
-  for (const s of configurationSet) {
+  for (const s of nodeSet) {
     let m = s.parent;
     while (m) {
-      configurationSet.add(m);
+      nodeSet.add(m);
       m = m.parent;
     }
   }
-  return configurationSet;
+  return nodeSet;
 }
 function getValueFromAdj(baseNode, adjList) {
   const childStateNodes = adjList.get(baseNode);
@@ -356,9 +1196,9 @@ function getValueFromAdj(baseNode, adjList) {
   }
   return stateValue;
 }
-function getAdjList(configuration) {
+function getAdjList(stateNodes) {
   const adjList = new Map();
-  for (const s of configuration) {
+  for (const s of stateNodes) {
     if (!adjList.has(s)) {
       adjList.set(s, []);
     }
@@ -371,25 +1211,25 @@ function getAdjList(configuration) {
   }
   return adjList;
 }
-function getStateValue(rootNode, configuration) {
-  const config = getConfiguration(configuration);
+function getStateValue(rootNode, stateNodes) {
+  const config = getAllStateNodes(stateNodes);
   return getValueFromAdj(rootNode, getAdjList(config));
 }
-function isInFinalState(configuration, stateNode) {
+function isInFinalState(stateNodeSet, stateNode) {
   if (stateNode.type === 'compound') {
-    return getChildren(stateNode).some(s => s.type === 'final' && configuration.has(s));
+    return getChildren(stateNode).some(s => s.type === 'final' && stateNodeSet.has(s));
   }
   if (stateNode.type === 'parallel') {
-    return getChildren(stateNode).every(sn => isInFinalState(configuration, sn));
+    return getChildren(stateNode).every(sn => isInFinalState(stateNodeSet, sn));
   }
   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('.*')) {
@@ -423,7 +1263,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 +1279,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 +1296,12 @@ 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);
   const transition = {
     ...transitionConfig,
-    actions: interpreter.toArray(transitionConfig.actions),
+    actions: toArray(transitionConfig.actions),
     guard: transitionConfig.guard,
     target,
     source: stateNode,
@@ -479,29 +1319,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 +1361,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 +1385,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 +1405,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 +1474,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();
@@ -740,13 +1580,13 @@ function hasIntersection(s1, s2) {
   }
   return false;
 }
-function removeConflictingTransitions(enabledTransitions, configuration, historyValue) {
+function removeConflictingTransitions(enabledTransitions, stateNodeSet, historyValue) {
   const filteredTransitions = new Set();
   for (const t1 of enabledTransitions) {
     let t1Preempted = false;
     const transitionsToRemove = new Set();
     for (const t2 of filteredTransitions) {
-      if (hasIntersection(computeExitSet([t1], configuration, historyValue), computeExitSet([t2], configuration, historyValue))) {
+      if (hasIntersection(computeExitSet([t1], stateNodeSet, historyValue), computeExitSet([t2], stateNodeSet, historyValue))) {
         if (isDescendant(t1.source, t2.source)) {
           transitionsToRemove.add(t2);
         } else {
@@ -813,7 +1653,7 @@ function getTransitionDomain(transition, historyValue) {
   }
   return transition.source.machine.root;
 }
-function computeExitSet(transitions, configuration, historyValue) {
+function computeExitSet(transitions, stateNodeSet, historyValue) {
   const statesToExit = new Set();
   for (const t of transitions) {
     if (t.target?.length) {
@@ -821,7 +1661,7 @@ function computeExitSet(transitions, configuration, historyValue) {
       if (t.reenter && t.source === domain) {
         statesToExit.add(domain);
       }
-      for (const stateNode of configuration) {
+      for (const stateNode of stateNodeSet) {
         if (isDescendant(stateNode, domain)) {
           statesToExit.add(stateNode);
         }
@@ -830,12 +1670,12 @@ function computeExitSet(transitions, configuration, historyValue) {
   }
   return [...statesToExit];
 }
-function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
-  if (previousConfiguration.length !== nextConfigurationSet.size) {
+function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
+  if (prevStateNodes.length !== nextStateNodeSet.size) {
     return false;
   }
-  for (const node of previousConfiguration) {
-    if (!nextConfigurationSet.has(node)) {
+  for (const node of prevStateNodes) {
+    if (!nextStateNodeSet.has(node)) {
       return false;
     }
   }
@@ -849,31 +1689,31 @@ function microstep(transitions, currentState, actorScope, event, isInitial, inte
   if (!transitions.length) {
     return currentState;
   }
-  const mutConfiguration = new Set(currentState.configuration);
+  const mutStateNodeSet = new Set(currentState._nodes);
   let historyValue = currentState.historyValue;
-  const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
+  const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
   let nextState = currentState;
 
   // Exit states
   if (!isInitial) {
-    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutConfiguration, historyValue, internalQueue);
+    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue);
   }
 
   // Execute transition content
   nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
-  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
-  const nextConfiguration = [...mutConfiguration];
+  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
+  const nextStateNodes = [...mutStateNodeSet];
   if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorScope, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
+    nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
+    if (historyValue === currentState.historyValue && areStateNodeCollectionsEqual(currentState._nodes, mutStateNodeSet)) {
       return nextState;
     }
     return cloneMachineSnapshot(nextState, {
-      configuration: nextConfiguration,
+      _nodes: nextStateNodes,
       historyValue
     });
   } catch (e) {
@@ -886,10 +1726,10 @@ 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) {
+function enterStates(currentState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial) {
   let nextState = currentState;
   const statesToEnter = new Set();
   // those are states that were directly targeted or indirectly targeted by the explicit target
@@ -904,7 +1744,7 @@ function enterStates(currentState, event, actorScope, filteredTransitions, mutCo
   }
   const completedNodes = new Set();
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
-    mutConfiguration.add(stateNodeToEnter);
+    mutStateNodeSet.add(stateNodeToEnter);
     const actions = [];
 
     // Add entry actions
@@ -925,11 +1765,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)) {
+      while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutStateNodeSet, ancestorMarker)) {
         completedNodes.add(ancestorMarker);
-        internalQueue.push(interpreter.createDoneStateEvent(ancestorMarker.id));
+        internalQueue.push(createDoneStateEvent(ancestorMarker.id));
         rootCompletionNode = ancestorMarker;
         ancestorMarker = ancestorMarker.parent;
       }
@@ -1037,9 +1877,9 @@ function addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultE
 function addProperAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
   addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, getProperAncestors(stateNode, toStateNode));
 }
-function exitStates(currentState, event, actorScope, transitions, mutConfiguration, historyValue, internalQueue) {
+function exitStates(currentState, event, actorScope, transitions, mutStateNodeSet, historyValue, internalQueue) {
   let nextState = currentState;
-  const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
+  const statesToExit = computeExitSet(transitions, mutStateNodeSet, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
   let changedHistory;
 
@@ -1057,12 +1897,12 @@ function exitStates(currentState, event, actorScope, transitions, mutConfigurati
       changedHistory ??= {
         ...historyValue
       };
-      changedHistory[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
+      changedHistory[historyNode.id] = Array.from(mutStateNodeSet).filter(predicate);
     }
   }
   for (const s of statesToExit) {
     nextState = resolveActionsAndContext(nextState, event, actorScope, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
-    mutConfiguration.delete(s);
+    mutStateNodeSet.delete(s);
   }
   return [nextState, changedHistory || historyValue];
 }
@@ -1092,7 +1932,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 +1950,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));
@@ -1138,7 +1978,7 @@ function macrostep(state, event, actorScope, internalQueue = []) {
   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 +1992,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);
@@ -1191,7 +2031,7 @@ function selectTransitions(event, nextState) {
 }
 function selectEventlessTransitions(nextState, event) {
   const enabledTransitionSet = new Set();
-  const atomicStates = nextState.configuration.filter(isAtomicStateNode);
+  const atomicStates = nextState._nodes.filter(isAtomicStateNode);
   for (const stateNode of atomicStates) {
     loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, undefined))) {
       if (!s.always) {
@@ -1205,7 +2045,7 @@ function selectEventlessTransitions(nextState, event) {
       }
     }
   }
-  return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(nextState.configuration), nextState.historyValue);
+  return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(nextState._nodes), nextState.historyValue);
 }
 
 /**
@@ -1214,12 +2054,15 @@ function selectEventlessTransitions(nextState, event) {
  * @param stateValue The partial state value to resolve.
  */
 function resolveStateValue(rootNode, stateValue) {
-  const configuration = getConfiguration(getStateNodes(rootNode, stateValue));
-  return getStateValue(rootNode, [...configuration]);
+  const allStateNodes = getAllStateNodes(getStateNodes(rootNode, stateValue));
+  return getStateValue(rootNode, [...allStateNodes]);
 }
 
+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);
@@ -1232,10 +2075,11 @@ const machineSnapshotCan = function can(event) {
 };
 const machineSnapshotToJSON = function toJSON() {
   const {
-    configuration,
+    _nodes: nodes,
     tags,
     machine,
-    nextEvents,
+    getNextEvents,
+    getMeta,
     toJSON,
     can,
     hasTag,
@@ -1247,13 +2091,11 @@ const machineSnapshotToJSON = function toJSON() {
     tags: Array.from(tags)
   };
 };
-const machineSnapshotNextEvents = function nextEvents() {
-  return memo(this, 'nextEvents', () => {
-    return [...new Set(interpreter.flatten([...this.configuration.map(sn => sn.ownEvents)]))];
-  });
+const machineSnapshotGetNextEvents = function getNextEvents() {
+  return [...new Set(flatten([...this._nodes.map(sn => sn.ownEvents)]))];
 };
-const machineSnapshotMeta = function nextEvents() {
-  return this.configuration.reduce((acc, stateNode) => {
+const machineSnapshotGetMeta = function getMeta() {
+  return this._nodes.reduce((acc, stateNode) => {
     if (stateNode.meta !== undefined) {
       acc[stateNode.id] = stateNode.meta;
     }
@@ -1261,48 +2103,35 @@ const machineSnapshotMeta = function nextEvents() {
   }, {});
 };
 function createMachineSnapshot(config, machine) {
-  const snapshot = {
+  return {
     status: config.status,
     output: config.output,
     error: config.error,
     machine,
     context: config.context,
-    configuration: config.configuration,
-    value: getStateValue(machine.root, config.configuration),
-    tags: new Set(interpreter.flatten(config.configuration.map(sn => sn.tags))),
+    _nodes: config._nodes,
+    value: getStateValue(machine.root, config._nodes),
+    tags: new Set(flatten(config._nodes.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
     matches: machineSnapshotMatches,
     hasTag: machineSnapshotHasTag,
     can: machineSnapshotCan,
+    getNextEvents: machineSnapshotGetNextEvents,
+    getMeta: machineSnapshotGetMeta,
     toJSON: machineSnapshotToJSON
   };
-  Object.defineProperties(snapshot, {
-    nextEvents: {
-      get: machineSnapshotNextEvents,
-      configurable: true,
-      enumerable: true
-    },
-    meta: {
-      get: machineSnapshotMeta,
-      configurable: true,
-      enumerable: true
-    }
-  });
-  return snapshot;
 }
 function cloneMachineSnapshot(state, config = {}) {
-  return createMachineSnapshot(
-  // TODO: it's wasteful that this spread triggers getters
-  {
+  return createMachineSnapshot({
     ...state,
     ...config
   }, state.machine);
 }
 function getPersistedState(state, options) {
   const {
-    configuration,
+    _nodes: nodes,
     tags,
     machine,
     children,
@@ -1310,8 +2139,9 @@ function getPersistedState(state, options) {
     can,
     hasTag,
     matches,
+    getNextEvents,
+    getMeta,
     toJSON,
-    nextEvents,
     ...jsonValues
   } = state;
   const childrenJson = {};
@@ -1320,7 +2150,8 @@ function getPersistedState(state, options) {
     childrenJson[id] = {
       state: child.getPersistedState(options),
       src: child.src,
-      systemId: child._systemId
+      systemId: child._systemId,
+      syncSnapshot: child._syncSnapshot
     };
   }
   const persisted = {
@@ -1340,7 +2171,7 @@ function persistContext(contextPart) {
           ...contextPart
         };
         copy[key] = {
-          xstate$$type: interpreter.$$ACTOR_TYPE,
+          xstate$$type: $$ACTOR_TYPE,
           id: value.id
         };
       } else {
@@ -1409,32 +2240,52 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
+exports.$$ACTOR_TYPE = $$ACTOR_TYPE;
+exports.Actor = Actor;
+exports.NULL_EVENT = NULL_EVENT;
+exports.ProcessingStatus = ProcessingStatus;
+exports.STATE_DELIMITER = STATE_DELIMITER;
+exports.XSTATE_ERROR = XSTATE_ERROR;
+exports.XSTATE_STOP = XSTATE_STOP;
 exports.and = and;
 exports.cancel = cancel;
 exports.cloneMachineSnapshot = cloneMachineSnapshot;
+exports.createActor = createActor;
+exports.createErrorActorEvent = createErrorActorEvent;
+exports.createInitEvent = createInitEvent;
+exports.createInvokeId = createInvokeId;
 exports.createMachineSnapshot = createMachineSnapshot;
 exports.evaluateGuard = evaluateGuard;
 exports.formatInitialTransition = formatInitialTransition;
 exports.formatTransition = formatTransition;
 exports.formatTransitions = formatTransitions;
+exports.getAllStateNodes = getAllStateNodes;
 exports.getCandidates = getCandidates;
-exports.getConfiguration = getConfiguration;
 exports.getDelayedTransitions = getDelayedTransitions;
 exports.getInitialStateNodes = getInitialStateNodes;
 exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
+exports.interpret = interpret;
+exports.isErrorActorEvent = isErrorActorEvent;
 exports.isInFinalState = isInFinalState;
+exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;
 exports.macrostep = macrostep;
-exports.memo = memo;
+exports.mapValues = mapValues;
+exports.matchesState = matchesState;
 exports.microstep = microstep;
 exports.not = not;
 exports.or = or;
+exports.pathToStateValue = pathToStateValue;
 exports.raise = raise;
 exports.resolveActionsAndContext = resolveActionsAndContext;
+exports.resolveReferencedActor = resolveReferencedActor;
 exports.resolveStateValue = resolveStateValue;
 exports.spawn = spawn;
 exports.stateIn = stateIn;
 exports.stop = stop;
+exports.toArray = toArray;
+exports.toObserver = toObserver;
+exports.toTransitionConfigArray = toTransitionConfigArray;
 exports.transitionNode = transitionNode;