xstate 5.0.0-beta.13 → 5.0.0-beta.14

package/dist/{actions-d9c19f35.development.cjs.js → actions-73b8d456.development.cjs.js}

@@ -12,10 +12,10 @@ var dev_dist_xstateDev = require('../dev/dist/xstate-dev.development.cjs.js');
  */
 
 // TODO: do not accept machines without all implementations
-// we should also accept a raw machine as a behavior here
-// or just make machine a behavior
+// we should also accept a raw machine as actor logic here
+// or just make machine actor logic
 
-// TODO: narrow this to behaviors from machine
+// TODO: narrow this to logic from machine
 
 // TODO: fix last param
 
@@ -479,6 +479,59 @@ function sendTo(actor, event, options) {
   });
 }
 
+const cache = new WeakMap();
+function memo(object, key, fn) {
+  let memoizedData = cache.get(object);
+  if (!memoizedData) {
+    memoizedData = {
+      [key]: fn()
+    };
+    cache.set(object, memoizedData);
+  } else if (!(key in memoizedData)) {
+    memoizedData[key] = fn();
+  }
+  return memoizedData[key];
+}
+
+/**
+ * Cancels an in-flight `send(...)` action. A canceled sent action will not
+ * be executed, nor will its event be sent, unless it has already been sent
+ * (e.g., if `cancel(...)` is called after the `send(...)` action's `delay`).
+ *
+ * @param sendId The `id` of the `send(...)` action to cancel.
+ */
+
+function cancel(sendId) {
+  return createDynamicAction({
+    type: cancel$1,
+    params: {
+      sendId
+    }
+  }, (event, {
+    state,
+    actorContext
+  }) => {
+    const resolvedSendId = isFunction(sendId) ? sendId({
+      context: state.context,
+      event,
+      self: actorContext?.self ?? {},
+      system: actorContext?.system
+    }) : sendId;
+    return [state, {
+      type: 'xstate.cancel',
+      params: {
+        sendId: resolvedSendId
+      },
+      execute: actorCtx => {
+        const interpreter = actorCtx.self;
+        interpreter.cancel(resolvedSendId);
+      }
+    }];
+  });
+}
+
+const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
+
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -546,537 +599,92 @@ class Mailbox {
   }
 }
 
-const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
-
-/**
- * Returns an actor behavior from a transition function and its initial state.
- *
- * A transition function is a function that takes the current state and an event and returns the next state.
- *
- * @param transition The transition function that returns the next state given the current state and event.
- * @param initialState The initial state of the transition function.
- * @returns An actor behavior
- */
-function fromTransition(transition, initialState) {
-  const behavior = {
-    config: transition,
-    transition: (state, event, actorContext) => {
-      return transition(state, event, actorContext);
-    },
-    getInitialState: (_, input) => {
-      return typeof initialState === 'function' ? initialState({
-        input
-      }) : initialState;
-    },
-    getSnapshot: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
-  };
-  return behavior;
-}
-
-function fromPromise(
-// TODO: add types
-promiseCreator) {
-  const resolveEventType = '$$xstate.resolve';
-  const rejectEventType = '$$xstate.reject';
-
-  // TODO: add event types
-  const behavior = {
-    config: promiseCreator,
-    transition: (state, event) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case resolveEventType:
-          return {
-            ...state,
-            status: 'done',
-            data: event.data,
-            input: undefined
-          };
-        case rejectEventType:
-          return {
-            ...state,
-            status: 'error',
-            data: event.data,
-            input: undefined
-          };
-        case stopSignalType:
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined
-          };
-        default:
-          return state;
-      }
+function createSystem() {
+  let sessionIdCounter = 0;
+  const children = new Map();
+  const keyedActors = new Map();
+  const reverseKeyedActors = new WeakMap();
+  const system = {
+    _bookId: () => `x:${sessionIdCounter++}`,
+    _register: (sessionId, actorRef) => {
+      children.set(sessionId, actorRef);
+      return sessionId;
     },
-    start: (state, {
-      self
-    }) => {
-      // TODO: determine how to allow customizing this so that promises
-      // can be restarted if necessary
-      if (state.status !== 'active') {
-        return;
+    _unregister: actorRef => {
+      children.delete(actorRef.sessionId);
+      const systemId = reverseKeyedActors.get(actorRef);
+      if (systemId !== undefined) {
+        keyedActors.delete(systemId);
+        reverseKeyedActors.delete(actorRef);
       }
-      const resolvedPromise = Promise.resolve(promiseCreator({
-        input: state.input
-      }));
-      resolvedPromise.then(response => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: resolveEventType,
-          data: response
-        });
-      }, errorData => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: rejectEventType,
-          data: errorData
-        });
-      });
     },
-    getInitialState: (_, input) => {
-      return {
-        status: 'active',
-        data: undefined,
-        input
-      };
+    get: systemId => {
+      return keyedActors.get(systemId);
     },
-    getSnapshot: state => state.data,
-    getStatus: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
+    _set: (systemId, actorRef) => {
+      const existing = keyedActors.get(systemId);
+      if (existing && existing !== actorRef) {
+        throw new Error(`Actor with system ID '${systemId}' already exists.`);
+      }
+      keyedActors.set(systemId, actorRef);
+      reverseKeyedActors.set(actorRef, systemId);
+    }
   };
-  return behavior;
+  return system;
 }
 
-// TODO: this likely shouldn't accept TEvent, observable actor doesn't accept external events
-function fromObservable(observableCreator) {
-  const nextEventType = '$$xstate.next';
-  const errorEventType = '$$xstate.error';
-  const completeEventType = '$$xstate.complete';
-
-  // TODO: add event types
-  const behavior = {
-    config: observableCreator,
-    transition: (state, event, {
-      self,
-      id,
-      defer
-    }) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case nextEventType:
-          // match the exact timing of events sent by machines
-          // send actions are not executed immediately
-          defer(() => {
-            self._parent?.send({
-              type: `xstate.snapshot.${id}`,
-              data: event.data
-            });
-          });
-          return {
-            ...state,
-            data: event.data
-          };
-        case errorEventType:
-          return {
-            ...state,
-            status: 'error',
-            input: undefined,
-            data: event.data,
-            subscription: undefined
-          };
-        case completeEventType:
-          return {
-            ...state,
-            status: 'done',
-            input: undefined,
-            subscription: undefined
-          };
-        case stopSignalType:
-          state.subscription.unsubscribe();
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined,
-            subscription: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    getInitialState: (_, input) => {
-      return {
-        subscription: undefined,
-        status: 'active',
-        data: undefined,
-        input
-      };
+let ActorStatus = /*#__PURE__*/function (ActorStatus) {
+  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
+  ActorStatus[ActorStatus["Running"] = 1] = "Running";
+  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
+  return ActorStatus;
+}({});
+const defaultOptions = {
+  deferEvents: true,
+  clock: {
+    setTimeout: (fn, ms) => {
+      return setTimeout(fn, ms);
     },
-    start: (state, {
-      self
-    }) => {
-      if (state.status === 'done') {
-        // Do not restart a completed observable
-        return;
-      }
-      state.subscription = observableCreator({
-        input: state.input
-      }).subscribe({
-        next: value => {
-          self.send({
-            type: nextEventType,
-            data: value
-          });
-        },
-        error: err => {
-          self.send({
-            type: errorEventType,
-            data: err
-          });
-        },
-        complete: () => {
-          self.send({
-            type: completeEventType
-          });
-        }
-      });
-    },
-    getSnapshot: state => state.data,
-    getPersistedState: ({
-      status,
-      data,
-      input
-    }) => ({
-      status,
-      data,
-      input
-    }),
-    getStatus: state => state,
-    restoreState: state => ({
-      ...state,
-      subscription: undefined
-    })
-  };
-  return behavior;
-}
+    clearTimeout: id => {
+      return clearTimeout(id);
+    }
+  },
+  logger: console.log.bind(console),
+  devTools: false
+};
+class Interpreter {
+  /**
+   * The current state of the interpreted logic.
+   */
 
-/**
- * Creates an event observable behavior that listens to an observable
- * that delivers event objects.
- *
- *
- * @param lazyObservable A function that creates an observable
- * @returns An event observable behavior
- */
+  /**
+   * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+   */
 
-function fromEventObservable(lazyObservable) {
-  const errorEventType = '$$xstate.error';
-  const completeEventType = '$$xstate.complete';
+  /**
+   * The unique identifier for this actor relative to its parent.
+   */
 
-  // TODO: event types
-  const behavior = {
-    config: lazyObservable,
-    transition: (state, event) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case errorEventType:
-          return {
-            ...state,
-            status: 'error',
-            input: undefined,
-            data: event.data,
-            subscription: undefined
-          };
-        case completeEventType:
-          return {
-            ...state,
-            status: 'done',
-            input: undefined,
-            subscription: undefined
-          };
-        case stopSignalType:
-          state.subscription.unsubscribe();
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined,
-            subscription: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    getInitialState: (_, input) => {
-      return {
-        subscription: undefined,
-        status: 'active',
-        data: undefined,
-        input
-      };
-    },
-    start: (state, {
-      self
-    }) => {
-      if (state.status === 'done') {
-        // Do not restart a completed observable
-        return;
-      }
-      state.subscription = lazyObservable({
-        input: state.input
-      }).subscribe({
-        next: value => {
-          self._parent?.send(value);
-        },
-        error: err => {
-          self.send({
-            type: errorEventType,
-            data: err
-          });
-        },
-        complete: () => {
-          self.send({
-            type: completeEventType
-          });
-        }
-      });
-    },
-    getSnapshot: _ => undefined,
-    getPersistedState: ({
-      status,
-      data,
-      input
-    }) => ({
-      status,
-      data,
-      input
-    }),
-    getStatus: state => state,
-    restoreState: state => ({
-      ...state,
-      subscription: undefined
-    })
-  };
-  return behavior;
-}
+  /**
+   * Whether the service is started.
+   */
 
-function fromCallback(invokeCallback) {
-  const behavior = {
-    config: invokeCallback,
-    start: (_state, {
-      self
-    }) => {
-      self.send({
-        type: startSignalType
-      });
-    },
-    transition: (state, event, {
-      self,
-      id
-    }) => {
-      if (event.type === startSignalType) {
-        const sender = eventForParent => {
-          if (state.canceled) {
-            return;
-          }
-          self._parent?.send(eventForParent);
-        };
-        const receiver = newListener => {
-          state.receivers.add(newListener);
-        };
-        state.dispose = invokeCallback(sender, receiver, {
-          input: state.input
-        });
-        if (isPromiseLike(state.dispose)) {
-          state.dispose.then(resolved => {
-            self._parent?.send(doneInvoke(id, resolved));
-            state.canceled = true;
-          }, errorData => {
-            state.canceled = true;
-            self._parent?.send(error(id, errorData));
-          });
-        }
-        return state;
-      }
-      if (event.type === stopSignalType) {
-        state.canceled = true;
-        if (isFunction(state.dispose)) {
-          state.dispose();
-        }
-        return state;
-      }
-      if (isSignal(event.type)) {
-        // TODO: unrecognized signal
-        return state;
-      }
-      if (!isSignal(event.type)) {
-        state.receivers.forEach(receiver => receiver(event));
-      }
-      return state;
-    },
-    getInitialState: (_, input) => {
-      return {
-        canceled: false,
-        receivers: new Set(),
-        dispose: undefined,
-        input
-      };
-    },
-    getSnapshot: () => undefined,
-    getPersistedState: ({
-      input
-    }) => input
-  };
-  return behavior;
-}
+  // Actor Ref
 
-const startSignalType = 'xstate.init';
-const stopSignalType = 'xstate.stop';
-const startSignal = {
-  type: 'xstate.init'
-};
-const stopSignal = {
-  type: 'xstate.stop'
-};
-/**
- * An object that expresses the behavior of an actor in reaction to received events,
- * as well as an optionally emitted stream of values.
- *
- * @template TReceived The received event
- * @template TSnapshot The emitted value
- */
+  // TODO: add typings for system
 
-function isSignal(eventType) {
-  return eventType === startSignalType || eventType === stopSignalType;
-}
-function isActorRef(item) {
-  return !!item && typeof item === 'object' && typeof item.send === 'function';
-}
-
-// TODO: refactor the return type, this could be written in a better way
-// but it's best to avoid unneccessary breaking changes now
-// @deprecated use `interpret(behavior)` instead
-function toActorRef(actorRefLike) {
-  return {
-    subscribe: () => ({
-      unsubscribe: () => void 0
-    }),
-    id: 'anonymous',
-    sessionId: '',
-    getSnapshot: () => undefined,
-    [symbolObservable]: function () {
-      return this;
-    },
-    status: ActorStatus.Running,
-    stop: () => void 0,
-    ...actorRefLike
-  };
-}
-const emptyBehavior = fromTransition(_ => undefined, undefined);
-function createEmptyActor() {
-  return interpret(emptyBehavior);
-}
-
-function createSystem() {
-  let sessionIdCounter = 0;
-  const children = new Map();
-  const keyedActors = new Map();
-  const reverseKeyedActors = new WeakMap();
-  const system = {
-    _bookId: () => `x:${sessionIdCounter++}`,
-    _register: (sessionId, actorRef) => {
-      children.set(sessionId, actorRef);
-      return sessionId;
-    },
-    _unregister: actorRef => {
-      children.delete(actorRef.sessionId);
-      const systemId = reverseKeyedActors.get(actorRef);
-      if (systemId !== undefined) {
-        keyedActors.delete(systemId);
-        reverseKeyedActors.delete(actorRef);
-      }
-    },
-    get: systemId => {
-      return keyedActors.get(systemId);
-    },
-    _set: (systemId, actorRef) => {
-      const existing = keyedActors.get(systemId);
-      if (existing && existing !== actorRef) {
-        throw new Error(`Actor with system ID '${systemId}' already exists.`);
-      }
-      keyedActors.set(systemId, actorRef);
-      reverseKeyedActors.set(actorRef, systemId);
-    }
-  };
-  return system;
-}
-
-let ActorStatus = /*#__PURE__*/function (ActorStatus) {
-  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
-  ActorStatus[ActorStatus["Running"] = 1] = "Running";
-  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
-  return ActorStatus;
-}({});
-const defaultOptions = {
-  deferEvents: true,
-  clock: {
-    setTimeout: (fn, ms) => {
-      return setTimeout(fn, ms);
-    },
-    clearTimeout: id => {
-      return clearTimeout(id);
-    }
-  },
-  logger: console.log.bind(console),
-  devTools: false
-};
-class Interpreter {
-  /**
-   * The current state of the interpreted behavior.
-   */
-
-  /**
-   * 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.
-   */
+  /**
+   * The globally unique process ID for this invocation.
+   */
 
   /**
-   * Whether the service is started.
-   */
-
-  // Actor Ref
-
-  // TODO: add typings for system
-
-  /**
-   * The globally unique process ID for this invocation.
-   */
-
-  /**
-   * Creates a new Interpreter instance (i.e., service) for the given behavior with the provided options, if any.
+   * Creates a new Interpreter instance (i.e., service) for the given logic with the provided options, if any.
    *
-   * @param behavior The behavior to be interpreted
+   * @param logic The logic to be interpreted
    * @param options Interpreter options
    */
-  constructor(behavior, options) {
-    this.behavior = behavior;
+  constructor(logic, options) {
+    this.logic = logic;
     this._state = void 0;
     this.clock = void 0;
     this.options = void 0;
@@ -1143,7 +751,7 @@ class Interpreter {
     this._initState();
   }
   _initState() {
-    this._state = this.options.state ? this.behavior.restoreState ? this.behavior.restoreState(this.options.state, this._actorContext) : this.options.state : this.behavior.getInitialState(this._actorContext, this.options?.input);
+    this._state = this.options.state ? this.logic.restoreState ? this.logic.restoreState(this.options.state, this._actorContext) : this.options.state : this.logic.getInitialState(this._actorContext, this.options?.input);
   }
 
   // array of functions to defer
@@ -1156,12 +764,12 @@ class Interpreter {
     // Execute deferred effects
     let deferredFn;
     while (deferredFn = this._deferred.shift()) {
-      deferredFn(state);
+      deferredFn();
     }
     for (const observer of this.observers) {
       observer.next?.(snapshot);
     }
-    const status = this.behavior.getStatus?.(state);
+    const status = this.logic.getStatus?.(state);
     switch (status?.status) {
       case 'done':
         this._stopProcedure();
@@ -1203,8 +811,8 @@ class Interpreter {
       this.system._set(this._systemId, this);
     }
     this.status = ActorStatus.Running;
-    if (this.behavior.start) {
-      this.behavior.start(this._state, this._actorContext);
+    if (this.logic.start) {
+      this.logic.start(this._state, this._actorContext);
     }
 
     // TODO: this notifies all subscribers but usually this is redundant
@@ -1219,7 +827,7 @@ class Interpreter {
   }
   _process(event) {
     try {
-      const nextState = this.behavior.transition(this._state, event, this._actorContext);
+      const nextState = this.logic.transition(this._state, event, this._actorContext);
       this.update(nextState);
       if (event.type === stopSignalType) {
         this._stopProcedure();
@@ -1311,211 +919,604 @@ class Interpreter {
         const eventString = JSON.stringify(event);
         console.warn(`Event "${event.type.toString()}" was sent to stopped actor "${this.id} (${this.sessionId})". This actor has already reached its final state, and will not transition.\nEvent: ${eventString}`);
       }
-      return;
-    }
-    if (this.status !== ActorStatus.Running && !this.options.deferEvents) {
-      throw new Error(`Event "${event.type}" was sent to uninitialized actor "${this.id
-      // tslint:disable-next-line:max-line-length
-      }". Make sure .start() is called for this actor, or set { deferEvents: true } in the actor options.\nEvent: ${JSON.stringify(event)}`);
-    }
-    this.mailbox.enqueue(event);
-  }
-
-  // TODO: make private (and figure out a way to do this within the machine)
-  delaySend(sendAction) {
-    this.delayedEventsMap[sendAction.params.id] = this.clock.setTimeout(() => {
-      if ('to' in sendAction.params && sendAction.params.to) {
-        sendAction.params.to.send(sendAction.params.event);
-      } else {
-        this.send(sendAction.params.event);
+      return;
+    }
+    if (this.status !== ActorStatus.Running && !this.options.deferEvents) {
+      throw new Error(`Event "${event.type}" was sent to uninitialized actor "${this.id
+      // tslint:disable-next-line:max-line-length
+      }". Make sure .start() is called for this actor, or set { deferEvents: true } in the actor options.\nEvent: ${JSON.stringify(event)}`);
+    }
+    this.mailbox.enqueue(event);
+  }
+
+  // TODO: make private (and figure out a way to do this within the machine)
+  delaySend(sendAction) {
+    this.delayedEventsMap[sendAction.params.id] = this.clock.setTimeout(() => {
+      if ('to' in sendAction.params && sendAction.params.to) {
+        sendAction.params.to.send(sendAction.params.event);
+      } else {
+        this.send(sendAction.params.event);
+      }
+    }, sendAction.params.delay);
+  }
+
+  // TODO: make private (and figure out a way to do this within the machine)
+  cancel(sendId) {
+    this.clock.clearTimeout(this.delayedEventsMap[sendId]);
+    delete this.delayedEventsMap[sendId];
+  }
+  attachDevTools() {
+    const {
+      devTools
+    } = this.options;
+    if (devTools) {
+      const resolvedDevToolsAdapter = typeof devTools === 'function' ? devTools : dev_dist_xstateDev.devToolsAdapter;
+      resolvedDevToolsAdapter(this);
+    }
+  }
+  toJSON() {
+    return {
+      id: this.id
+    };
+  }
+  getPersistedState() {
+    return this.logic.getPersistedState?.(this._state);
+  }
+  [symbolObservable]() {
+    return this;
+  }
+  getSnapshot() {
+    return this.logic.getSnapshot ? this.logic.getSnapshot(this._state) : this._state;
+  }
+}
+
+/**
+ * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ *
+ * @param machine The machine to interpret
+ * @param options Interpreter options
+ */
+
+function interpret(logic, options) {
+  const interpreter = new Interpreter(logic, options);
+  return interpreter;
+}
+
+/**
+ * Returns actor logic from a transition function and its initial state.
+ *
+ * A transition function is a function that takes the current state and an event and returns the next state.
+ *
+ * @param transition The transition function that returns the next state given the current state and event.
+ * @param initialState The initial state of the transition function.
+ * @returns Actor logic
+ */
+function fromTransition(transition, initialState) {
+  const logic = {
+    config: transition,
+    transition: (state, event, actorContext) => {
+      return transition(state, event, actorContext);
+    },
+    getInitialState: (_, input) => {
+      return typeof initialState === 'function' ? initialState({
+        input
+      }) : initialState;
+    },
+    getSnapshot: state => state,
+    getPersistedState: state => state,
+    restoreState: state => state
+  };
+  return logic;
+}
+
+function fromPromise(
+// TODO: add types
+promiseCreator) {
+  const resolveEventType = '$$xstate.resolve';
+  const rejectEventType = '$$xstate.reject';
+
+  // TODO: add event types
+  const logic = {
+    config: promiseCreator,
+    transition: (state, event) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      switch (event.type) {
+        case resolveEventType:
+          return {
+            ...state,
+            status: 'done',
+            data: event.data,
+            input: undefined
+          };
+        case rejectEventType:
+          return {
+            ...state,
+            status: 'error',
+            data: event.data,
+            input: undefined
+          };
+        case stopSignalType:
+          return {
+            ...state,
+            status: 'canceled',
+            input: undefined
+          };
+        default:
+          return state;
+      }
+    },
+    start: (state, {
+      self,
+      system
+    }) => {
+      // TODO: determine how to allow customizing this so that promises
+      // can be restarted if necessary
+      if (state.status !== 'active') {
+        return;
+      }
+      const resolvedPromise = Promise.resolve(promiseCreator({
+        input: state.input,
+        system
+      }));
+      resolvedPromise.then(response => {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
+        self.send({
+          type: resolveEventType,
+          data: response
+        });
+      }, errorData => {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
+        self.send({
+          type: rejectEventType,
+          data: errorData
+        });
+      });
+    },
+    getInitialState: (_, input) => {
+      return {
+        status: 'active',
+        data: undefined,
+        input
+      };
+    },
+    getSnapshot: state => state.data,
+    getStatus: state => state,
+    getPersistedState: state => state,
+    restoreState: state => state
+  };
+  return logic;
+}
+
+// TODO: this likely shouldn't accept TEvent, observable actor doesn't accept external events
+function fromObservable(observableCreator) {
+  const nextEventType = '$$xstate.next';
+  const errorEventType = '$$xstate.error';
+  const completeEventType = '$$xstate.complete';
+
+  // TODO: add event types
+  const logic = {
+    config: observableCreator,
+    transition: (state, event, {
+      self,
+      id,
+      defer
+    }) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      switch (event.type) {
+        case nextEventType:
+          // match the exact timing of events sent by machines
+          // send actions are not executed immediately
+          defer(() => {
+            self._parent?.send({
+              type: `xstate.snapshot.${id}`,
+              data: event.data
+            });
+          });
+          return {
+            ...state,
+            data: event.data
+          };
+        case errorEventType:
+          return {
+            ...state,
+            status: 'error',
+            input: undefined,
+            data: event.data,
+            subscription: undefined
+          };
+        case completeEventType:
+          return {
+            ...state,
+            status: 'done',
+            input: undefined,
+            subscription: undefined
+          };
+        case stopSignalType:
+          state.subscription.unsubscribe();
+          return {
+            ...state,
+            status: 'canceled',
+            input: undefined,
+            subscription: undefined
+          };
+        default:
+          return state;
+      }
+    },
+    getInitialState: (_, input) => {
+      return {
+        subscription: undefined,
+        status: 'active',
+        data: undefined,
+        input
+      };
+    },
+    start: (state, {
+      self,
+      system
+    }) => {
+      if (state.status === 'done') {
+        // Do not restart a completed observable
+        return;
+      }
+      state.subscription = observableCreator({
+        input: state.input,
+        system
+      }).subscribe({
+        next: value => {
+          self.send({
+            type: nextEventType,
+            data: value
+          });
+        },
+        error: err => {
+          self.send({
+            type: errorEventType,
+            data: err
+          });
+        },
+        complete: () => {
+          self.send({
+            type: completeEventType
+          });
+        }
+      });
+    },
+    getSnapshot: state => state.data,
+    getPersistedState: ({
+      status,
+      data,
+      input
+    }) => ({
+      status,
+      data,
+      input
+    }),
+    getStatus: state => state,
+    restoreState: state => ({
+      ...state,
+      subscription: undefined
+    })
+  };
+  return logic;
+}
+
+/**
+ * Creates event observable logic that listens to an observable
+ * that delivers event objects.
+ *
+ *
+ * @param lazyObservable A function that creates an observable
+ * @returns Event observable logic
+ */
+
+function fromEventObservable(lazyObservable) {
+  const errorEventType = '$$xstate.error';
+  const completeEventType = '$$xstate.complete';
+
+  // TODO: event types
+  const logic = {
+    config: lazyObservable,
+    transition: (state, event) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      switch (event.type) {
+        case errorEventType:
+          return {
+            ...state,
+            status: 'error',
+            input: undefined,
+            data: event.data,
+            subscription: undefined
+          };
+        case completeEventType:
+          return {
+            ...state,
+            status: 'done',
+            input: undefined,
+            subscription: undefined
+          };
+        case stopSignalType:
+          state.subscription.unsubscribe();
+          return {
+            ...state,
+            status: 'canceled',
+            input: undefined,
+            subscription: undefined
+          };
+        default:
+          return state;
+      }
+    },
+    getInitialState: (_, input) => {
+      return {
+        subscription: undefined,
+        status: 'active',
+        data: undefined,
+        input
+      };
+    },
+    start: (state, {
+      self,
+      system
+    }) => {
+      if (state.status === 'done') {
+        // Do not restart a completed observable
+        return;
+      }
+      state.subscription = lazyObservable({
+        input: state.input,
+        system
+      }).subscribe({
+        next: value => {
+          self._parent?.send(value);
+        },
+        error: err => {
+          self.send({
+            type: errorEventType,
+            data: err
+          });
+        },
+        complete: () => {
+          self.send({
+            type: completeEventType
+          });
+        }
+      });
+    },
+    getSnapshot: _ => undefined,
+    getPersistedState: ({
+      status,
+      data,
+      input
+    }) => ({
+      status,
+      data,
+      input
+    }),
+    getStatus: state => state,
+    restoreState: state => ({
+      ...state,
+      subscription: undefined
+    })
+  };
+  return logic;
+}
+
+function fromCallback(invokeCallback) {
+  const logic = {
+    config: invokeCallback,
+    start: (_state, {
+      self
+    }) => {
+      self.send({
+        type: startSignalType
+      });
+    },
+    transition: (state, event, {
+      self,
+      id,
+      system
+    }) => {
+      if (event.type === startSignalType) {
+        const sender = eventForParent => {
+          if (state.canceled) {
+            return;
+          }
+          self._parent?.send(eventForParent);
+        };
+        const receiver = newListener => {
+          state.receivers.add(newListener);
+        };
+        state.dispose = invokeCallback(sender, receiver, {
+          input: state.input,
+          system
+        });
+        if (isPromiseLike(state.dispose)) {
+          state.dispose.then(resolved => {
+            self._parent?.send(doneInvoke(id, resolved));
+            state.canceled = true;
+          }, errorData => {
+            state.canceled = true;
+            self._parent?.send(error(id, errorData));
+          });
+        }
+        return state;
+      }
+      if (event.type === stopSignalType) {
+        state.canceled = true;
+        if (isFunction(state.dispose)) {
+          state.dispose();
+        }
+        return state;
       }
-    }, sendAction.params.delay);
-  }
-
-  // TODO: make private (and figure out a way to do this within the machine)
-  cancel(sendId) {
-    this.clock.clearTimeout(this.delayedEventsMap[sendId]);
-    delete this.delayedEventsMap[sendId];
-  }
-  attachDevTools() {
-    const {
-      devTools
-    } = this.options;
-    if (devTools) {
-      const resolvedDevToolsAdapter = typeof devTools === 'function' ? devTools : dev_dist_xstateDev.devToolsAdapter;
-      resolvedDevToolsAdapter(this);
-    }
-  }
-  toJSON() {
-    return {
-      id: this.id
-    };
-  }
-  getPersistedState() {
-    return this.behavior.getPersistedState?.(this._state);
-  }
-  [symbolObservable]() {
-    return this;
-  }
-  getSnapshot() {
-    return this.behavior.getSnapshot ? this.behavior.getSnapshot(this._state) : this._state;
-  }
+      if (isSignal(event.type)) {
+        // TODO: unrecognized signal
+        return state;
+      }
+      if (!isSignal(event.type)) {
+        state.receivers.forEach(receiver => receiver(event));
+      }
+      return state;
+    },
+    getInitialState: (_, input) => {
+      return {
+        canceled: false,
+        receivers: new Set(),
+        dispose: undefined,
+        input
+      };
+    },
+    getSnapshot: () => undefined,
+    getPersistedState: ({
+      input
+    }) => input
+  };
+  return logic;
 }
 
+const startSignalType = 'xstate.init';
+const stopSignalType = 'xstate.stop';
+const startSignal = {
+  type: 'xstate.init'
+};
+const stopSignal = {
+  type: 'xstate.stop'
+};
 /**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ * An object that expresses the actor logic in reaction to received events,
+ * as well as an optionally emitted stream of values.
  *
- * @param machine The machine to interpret
- * @param options Interpreter options
+ * @template TReceived The received event
+ * @template TSnapshot The emitted value
  */
 
-function interpret(behavior, options) {
-  const interpreter = new Interpreter(behavior, options);
-  return interpreter;
+function isSignal(eventType) {
+  return eventType === startSignalType || eventType === stopSignalType;
 }
-
-/**
- * Stops an actor.
- *
- * @param actorRef The actor to stop.
- */
-
-function stop(actorRef) {
-  const actor = actorRef;
-  return createDynamicAction({
-    type: stop$1,
-    params: {
-      actor
-    }
-  }, (event, {
-    state
-  }) => {
-    const actorRefOrString = isFunction(actor) ? actor({
-      context: state.context,
-      event
-    }) : actor;
-    const actorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
-    return [state, {
-      type: 'xstate.stop',
-      params: {
-        actor: actorRef
-      },
-      execute: actorCtx => {
-        if (!actorRef) {
-          return;
-        }
-        if (actorRef.status !== ActorStatus.Running) {
-          actorCtx.stopChild(actorRef);
-          return;
-        }
-        actorCtx.defer(() => {
-          actorCtx.stopChild(actorRef);
-        });
-      }
-    }];
-  });
+function isActorRef(item) {
+  return !!item && typeof item === 'object' && typeof item.send === 'function';
 }
 
-const defaultLogExpr = ({
-  context,
-  event
-}) => ({
-  context,
-  event
-});
-
-/**
- *
- * @param expr The expression function to evaluate which will be logged.
- *  Takes in 2 arguments:
- *  - `ctx` - the current state context
- *  - `event` - the event that caused this action to be executed.
- * @param label The label to give to the logged expression.
- */
+// TODO: refactor the return type, this could be written in a better way
+// but it's best to avoid unneccessary breaking changes now
+// @deprecated use `interpret(actorLogic)` instead
+function toActorRef(actorRefLike) {
+  return {
+    subscribe: () => ({
+      unsubscribe: () => void 0
+    }),
+    id: 'anonymous',
+    sessionId: '',
+    getSnapshot: () => undefined,
+    [symbolObservable]: function () {
+      return this;
+    },
+    status: ActorStatus.Running,
+    stop: () => void 0,
+    ...actorRefLike
+  };
+}
+const emptyLogic = fromTransition(_ => undefined, undefined);
+function createEmptyActor() {
+  return interpret(emptyLogic);
+}
 
-function log(expr = defaultLogExpr, label) {
+function invoke(invokeDef) {
   return createDynamicAction({
-    type: log$1,
-    params: {
-      label,
-      expr
-    }
+    type: invoke$1,
+    params: invokeDef
   }, (event, {
     state,
     actorContext
   }) => {
-    const resolvedValue = typeof expr === 'function' ? expr({
-      context: state.context,
-      event,
-      self: actorContext?.self ?? {},
-      system: actorContext?.system
-    }) : expr;
-    return [state, {
-      type: 'xstate.log',
-      params: {
-        label,
-        value: resolvedValue
-      },
-      execute: actorCtx => {
-        if (label) {
-          actorCtx.logger?.(label, resolvedValue);
-        } else {
-          actorCtx.logger?.(resolvedValue);
+    const type = invoke$1;
+    const {
+      id,
+      src
+    } = invokeDef;
+    let resolvedInvokeAction;
+    if (isActorRef(src)) {
+      resolvedInvokeAction = {
+        type,
+        params: {
+          ...invokeDef,
+          ref: src
         }
-      }
-    }];
-  });
-}
-
-/**
- * Cancels an in-flight `send(...)` action. A canceled sent action will not
- * be executed, nor will its event be sent, unless it has already been sent
- * (e.g., if `cancel(...)` is called after the `send(...)` action's `delay`).
- *
- * @param sendId The `id` of the `send(...)` action to cancel.
- */
-
-function cancel(sendId) {
-  return createDynamicAction({
-    type: cancel$1,
-    params: {
-      sendId
+      };
+    } else {
+      const referenced = resolveReferencedActor(state.machine.options.actors[src]);
+      if (!referenced) {
+        resolvedInvokeAction = {
+          type,
+          params: invokeDef
+        };
+      } else {
+        const input = 'input' in invokeDef ? invokeDef.input : referenced.input;
+        const ref = interpret(referenced.src, {
+          id,
+          src,
+          parent: actorContext?.self,
+          systemId: invokeDef.systemId,
+          input: typeof input === 'function' ? input({
+            context: state.context,
+            event,
+            self: actorContext?.self
+          }) : input
+        });
+        resolvedInvokeAction = {
+          type,
+          params: {
+            ...invokeDef,
+            ref
+          }
+        };
+      }
     }
-  }, (event, {
-    state,
-    actorContext
-  }) => {
-    const resolvedSendId = isFunction(sendId) ? sendId({
-      context: state.context,
-      event,
-      self: actorContext?.self ?? {},
-      system: actorContext?.system
-    }) : sendId;
-    return [state, {
-      type: 'xstate.cancel',
-      params: {
-        sendId: resolvedSendId
-      },
-      execute: actorCtx => {
-        const interpreter = actorCtx.self;
-        interpreter.cancel(resolvedSendId);
+    const actorRef = resolvedInvokeAction.params.ref;
+    const invokedState = cloneState(state, {
+      children: {
+        ...state.children,
+        [id]: actorRef
       }
-    }];
-  });
-}
-
-const cache = new WeakMap();
-function memo(object, key, fn) {
-  let memoizedData = cache.get(object);
-  if (!memoizedData) {
-    memoizedData = {
-      [key]: fn()
+    });
+    resolvedInvokeAction.execute = actorCtx => {
+      const parent = actorCtx.self;
+      const {
+        id,
+        ref
+      } = resolvedInvokeAction.params;
+      if (!ref) {
+        {
+          console.warn(`Actor type '${resolvedInvokeAction.params.src}' not found in machine '${actorCtx.id}'.`);
+        }
+        return;
+      }
+      actorCtx.defer(() => {
+        if (actorRef.status === ActorStatus.Stopped) {
+          return;
+        }
+        try {
+          actorRef.start?.();
+        } catch (err) {
+          parent.send(error(id, err));
+          return;
+        }
+      });
     };
-    cache.set(object, memoizedData);
-  } else if (!(key in memoizedData)) {
-    memoizedData[key] = fn();
-  }
-  return memoizedData[key];
+    return [invokedState, resolvedInvokeAction];
+  });
 }
 
 function stateIn(stateValue) {
@@ -2258,15 +2259,11 @@ function microstep(transitions, currentState, actorCtx, event) {
   const willTransition = currentState._initial || transitions.length > 0;
   const mutConfiguration = new Set(currentState.configuration);
   if (!currentState._initial && !willTransition) {
-    const inertState = cloneState(currentState, {
-      event,
-      actions: [],
-      transitions: []
-    });
+    const inertState = cloneState(currentState, {});
     inertState.changed = false;
     return inertState;
   }
-  const microstate = microstepProcedure(currentState._initial ? [{
+  const [microstate, actions] = microstepProcedure(currentState._initial ? [{
     target: [...currentState.configuration].filter(isAtomicStateNode),
     source: machine.root,
     reenter: true,
@@ -2275,38 +2272,16 @@ function microstep(transitions, currentState, actorCtx, event) {
     toJSON: null // TODO: fix
   }] : transitions, currentState, mutConfiguration, event, actorCtx);
   const {
-    context,
-    actions: nonRaisedActions
+    context
   } = microstate;
-  const children = setChildren(currentState, nonRaisedActions);
   const nextState = cloneState(microstate, {
     value: {},
     // TODO: make optional
-    transitions,
-    children
+    transitions
   });
-  nextState.changed = currentState._initial ? undefined : !stateValuesEqual(nextState.value, currentState.value) || nextState.actions.length > 0 || context !== currentState.context;
+  nextState.changed = currentState._initial ? undefined : !stateValuesEqual(nextState.value, currentState.value) || actions.length > 0 || context !== currentState.context;
   return nextState;
 }
-function setChildren(currentState, nonRaisedActions) {
-  const children = {
-    ...currentState.children
-  };
-  for (const action of nonRaisedActions) {
-    if (action.type === invoke$1 && action.params.ref) {
-      const ref = action.params.ref;
-      if (ref) {
-        children[ref.id] = ref;
-      }
-    } else if (action.type === stop$1) {
-      const ref = action.params.actor;
-      if (ref) {
-        delete children[ref.id];
-      }
-    }
-  }
-  return children;
-}
 function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx) {
   const actions = [];
   const historyValue = {
@@ -2324,7 +2299,7 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
   actions.push(...filteredTransitions.flatMap(t => t.actions));
 
   // Enter states
-  enterStates(filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue);
+  enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue);
   const nextConfiguration = [...mutConfiguration];
   const done = isInFinalState(nextConfiguration);
   if (done) {
@@ -2332,29 +2307,25 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
     actions.push(...finalActions);
   }
   try {
-    const {
-      nextState
-    } = resolveActionsAndContext(actions, event, currentState, actorCtx);
+    const [nextState, resolvedActions] = resolveActionsAndContext(actions, event, currentState, actorCtx);
     const output = done ? getOutput(nextConfiguration, nextState.context, event) : undefined;
     internalQueue.push(...nextState._internalQueue);
-    return cloneState(currentState, {
-      actions: nextState.actions,
+    return [cloneState(currentState, {
       configuration: nextConfiguration,
       historyValue,
       _internalQueue: internalQueue,
       context: nextState.context,
-      event,
       done,
       output,
       children: nextState.children
-    });
+    }), resolvedActions];
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
     // See https://github.com/statelyai/rfcs/pull/4
     throw e;
   }
 }
-function enterStates(filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue) {
+function enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue) {
   const statesToEnter = new Set();
   const statesForDefaultEntry = new Set();
   computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
@@ -2382,7 +2353,7 @@ function enterStates(filteredTransitions, mutConfiguration, actions, internalQue
       if (!parent.parent) {
         continue;
       }
-      internalQueue.push(done(parent.id, stateNodeToEnter.output ? mapContext(stateNodeToEnter.output, currentState.context, currentState.event) : undefined));
+      internalQueue.push(done(parent.id, stateNodeToEnter.output ? mapContext(stateNodeToEnter.output, currentState.context, event) : undefined));
       if (parent.parent) {
         const grandparent = parent.parent;
         if (grandparent.type === 'parallel') {
@@ -2500,8 +2471,8 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     resolvedActions.push(action);
     if (actorCtx?.self.status === ActorStatus.Running) {
       action.execute?.(actorCtx);
-      // TODO: this is hacky; re-evaluate
-      delete action.execute;
+    } else {
+      actorCtx?.defer(() => action.execute?.(actorCtx));
     }
   }
   function resolveAction(actionObject) {
@@ -2530,12 +2501,9 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
   for (const actionObject of actions) {
     resolveAction(actionObject);
   }
-  return {
-    nextState: cloneState(intermediateState, {
-      actions: resolvedActions,
-      _internalQueue: raiseActions.map(a => a.params.event)
-    })
-  };
+  return [cloneState(intermediateState, {
+    _internalQueue: raiseActions.map(a => a.params.event)
+  }), resolvedActions];
 }
 function macrostep(state, event, actorCtx) {
   if (event.type === WILDCARD) {
@@ -2546,54 +2514,42 @@ function macrostep(state, event, actorCtx) {
 
   // Handle stop event
   if (event.type === stopSignalType) {
-    nextState = stopStep(event, nextState, actorCtx);
+    nextState = stopStep(event, nextState, actorCtx)[0];
     states.push(nextState);
     return {
       state: nextState,
       microstates: states
     };
   }
+  let nextEvent = event;
 
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
-  if (event.type !== init) {
-    const transitions = selectTransitions(event, nextState);
-    nextState = microstep(transitions, state, actorCtx, event);
+  if (nextEvent.type !== init) {
+    const transitions = selectTransitions(nextEvent, nextState);
+    nextState = microstep(transitions, state, actorCtx, nextEvent);
     states.push(nextState);
   }
   while (!nextState.done) {
-    let enabledTransitions = selectEventlessTransitions(nextState);
-    if (enabledTransitions.length === 0) {
-      // TODO: this is a bit of a hack, we need to review this
-      // this matches the behavior from v4 for eventless transitions
-      // where for `hasAlwaysTransitions` we were always trying to resolve with a NULL event
-      // and if a transition was not selected the `state.transitions` stayed empty
-      // without this we get into an infinite loop in the dieHard test in `@xstate/test` for the `simplePathsTo`
-      if (nextState.configuration.some(state => state.always)) {
-        nextState.transitions = [];
-      }
+    let enabledTransitions = selectEventlessTransitions(nextState, nextEvent);
+    if (!enabledTransitions.length) {
       if (!nextState._internalQueue.length) {
         break;
       } else {
-        const currentActions = nextState.actions;
-        const nextEvent = nextState._internalQueue[0];
+        nextEvent = nextState._internalQueue[0];
         const transitions = selectTransitions(nextEvent, nextState);
         nextState = microstep(transitions, nextState, actorCtx, nextEvent);
         nextState._internalQueue.shift();
-        nextState.actions.unshift(...currentActions);
         states.push(nextState);
       }
-    }
-    if (enabledTransitions.length) {
-      const currentActions = nextState.actions;
-      nextState = microstep(enabledTransitions, nextState, actorCtx, nextState.event);
-      nextState.actions.unshift(...currentActions);
+    } else {
+      nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent);
       states.push(nextState);
     }
   }
   if (nextState.done) {
     // Perform the stop step to ensure that child actors are stopped
-    stopStep(nextState.event, nextState, actorCtx);
+    stopStep(nextEvent, nextState, actorCtx);
   }
   return {
     state: nextState,
@@ -2608,15 +2564,12 @@ function stopStep(event, nextState, actorCtx) {
   for (const child of Object.values(nextState.children)) {
     actions.push(stop(child));
   }
-  const {
-    nextState: stoppedState
-  } = resolveActionsAndContext(actions, event, nextState, actorCtx);
-  return stoppedState;
+  return resolveActionsAndContext(actions, event, nextState, actorCtx);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
 }
-function selectEventlessTransitions(nextState) {
+function selectEventlessTransitions(nextState, event) {
   const enabledTransitionSet = new Set();
   const atomicStates = nextState.configuration.filter(isAtomicStateNode);
   for (const stateNode of atomicStates) {
@@ -2625,7 +2578,7 @@ function selectEventlessTransitions(nextState) {
         continue;
       }
       for (const transition of s.always) {
-        if (transition.guard === undefined || evaluateGuard(transition.guard, nextState.context, nextState.event, nextState)) {
+        if (transition.guard === undefined || evaluateGuard(transition.guard, nextState.context, event, nextState)) {
           enabledTransitionSet.add(transition);
           break loop;
         }
@@ -2693,10 +2646,6 @@ class State {
    * The enabled state nodes representative of the state value.
    */
 
-  /**
-   * The transition definitions that resulted in this state.
-   */
-
   /**
    * An object mapping actor names to spawned/invoked actors.
    */
@@ -2712,8 +2661,6 @@ class State {
         return new State({
           value: stateValue.value,
           context,
-          event: stateValue.event,
-          actions: [],
           meta: {},
           configuration: [],
           // TODO: fix,
@@ -2723,17 +2670,12 @@ class State {
       }
       return stateValue;
     }
-    const event = createInitEvent({}); // TODO: fix
-
     const configuration = getConfiguration(getStateNodes(machine.root, stateValue));
     return new State({
       value: stateValue,
       context,
-      event,
-      actions: [],
       meta: undefined,
       configuration: Array.from(configuration),
-      transitions: [],
       children: {}
     }, machine);
   }
@@ -2751,23 +2693,17 @@ class State {
     this.output = void 0;
     this.context = void 0;
     this.historyValue = {};
-    this.actions = [];
-    this.event = void 0;
     this._internalQueue = void 0;
     this._initial = false;
     this.changed = void 0;
     this.configuration = void 0;
-    this.transitions = void 0;
     this.children = void 0;
     this.context = config.context;
     this._internalQueue = config._internalQueue ?? [];
-    this.event = config.event;
     this.historyValue = config.historyValue || {};
-    this.actions = config.actions ?? [];
     this.matches = this.matches.bind(this);
     this.toStrings = this.toStrings.bind(this);
     this.configuration = config.configuration ?? Array.from(getConfiguration(getStateNodes(machine.root, config.value)));
-    this.transitions = config.transitions;
     this.children = config.children;
     this.value = getStateValue(machine.root, this.configuration);
     this.tags = new Set(flatten(this.configuration.map(sn => sn.tags)));
@@ -2790,7 +2726,6 @@ class State {
   toJSON() {
     const {
       configuration,
-      transitions,
       tags,
       machine,
       ...jsonValues
@@ -2862,7 +2797,6 @@ function cloneState(state, config = {}) {
 function getPersistedState(state) {
   const {
     configuration,
-    transitions,
     tags,
     machine,
     children,
@@ -2881,89 +2815,105 @@ function getPersistedState(state) {
   };
 }
 
-function invoke(invokeDef) {
+/**
+ * Stops an actor.
+ *
+ * @param actorRef The actor to stop.
+ */
+
+function stop(actorRef) {
+  const actor = actorRef;
   return createDynamicAction({
-    type: invoke$1,
-    params: invokeDef
+    type: stop$1,
+    params: {
+      actor
+    }
   }, (event, {
-    state,
-    actorContext
+    state
   }) => {
-    const type = invoke$1;
-    const {
-      id,
-      src
-    } = invokeDef;
-    let resolvedInvokeAction;
-    if (isActorRef(src)) {
-      resolvedInvokeAction = {
-        type,
-        params: {
-          ...invokeDef,
-          ref: src
-        }
+    const actorRefOrString = isFunction(actor) ? actor({
+      context: state.context,
+      event
+    }) : actor;
+    const actorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
+    let children = state.children;
+    if (actorRef) {
+      children = {
+        ...children
       };
-    } else {
-      const referenced = resolveReferencedActor(state.machine.options.actors[src]);
-      if (!referenced) {
-        resolvedInvokeAction = {
-          type,
-          params: invokeDef
-        };
-      } else {
-        const input = 'input' in invokeDef ? invokeDef.input : referenced.input;
-        const ref = interpret(referenced.src, {
-          id,
-          src,
-          parent: actorContext?.self,
-          systemId: invokeDef.systemId,
-          input: typeof input === 'function' ? input({
-            context: state.context,
-            event,
-            self: actorContext?.self
-          }) : input
-        });
-        resolvedInvokeAction = {
-          type,
-          params: {
-            ...invokeDef,
-            ref
-          }
-        };
-      }
+      delete children[actorRef.id];
     }
-    const actorRef = resolvedInvokeAction.params.ref;
-    const invokedState = cloneState(state, {
-      children: {
-        ...state.children,
-        [id]: actorRef
-      }
-    });
-    resolvedInvokeAction.execute = actorCtx => {
-      const parent = actorCtx.self;
-      const {
-        id,
-        ref
-      } = resolvedInvokeAction.params;
-      if (!ref) {
-        {
-          console.warn(`Actor type '${resolvedInvokeAction.params.src}' not found in machine '${actorCtx.id}'.`);
-        }
-        return;
-      }
-      actorCtx.defer(() => {
-        if (actorRef.status === ActorStatus.Stopped) {
+    return [cloneState(state, {
+      children
+    }), {
+      type: 'xstate.stop',
+      params: {
+        actor: actorRef
+      },
+      execute: actorCtx => {
+        if (!actorRef) {
           return;
         }
-        try {
-          actorRef.start?.();
-        } catch (err) {
-          parent.send(error(id, err));
+        if (actorRef.status !== ActorStatus.Running) {
+          actorCtx.stopChild(actorRef);
           return;
         }
-      });
-    };
-    return [invokedState, resolvedInvokeAction];
+        actorCtx.defer(() => {
+          actorCtx.stopChild(actorRef);
+        });
+      }
+    }];
+  });
+}
+
+const defaultLogExpr = ({
+  context,
+  event
+}) => ({
+  context,
+  event
+});
+
+/**
+ *
+ * @param expr The expression function to evaluate which will be logged.
+ *  Takes in 2 arguments:
+ *  - `ctx` - the current state context
+ *  - `event` - the event that caused this action to be executed.
+ * @param label The label to give to the logged expression.
+ */
+
+function log(expr = defaultLogExpr, label) {
+  return createDynamicAction({
+    type: log$1,
+    params: {
+      label,
+      expr
+    }
+  }, (event, {
+    state,
+    actorContext
+  }) => {
+    const resolvedValue = typeof expr === 'function' ? expr({
+      context: state.context,
+      event,
+      self: actorContext?.self ?? {},
+      system: actorContext?.system
+    }) : expr;
+    return [state, {
+      type: 'xstate.log',
+      params: {
+        label,
+        value: resolvedValue
+      },
+      execute: actorCtx => {
+        if (label) {
+          actorCtx.logger?.(label, resolvedValue);
+        } else {
+          actorCtx.logger?.(resolvedValue);
+        }
+      }
+    }];
   });
 }
 
@@ -3001,7 +2951,7 @@ function createSpawner(self, machine, context, event, mutCapturedActions) {
         return actorRef; // TODO: fix types
       }
 
-      throw new Error(`Behavior '${src}' not implemented in machine '${machine.id}'`);
+      throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
     } else {
       // TODO: this should also receive `src`
       // TODO: instead of anonymous, it should be a unique stable ID