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

package/dist/{actions-b34f6ce7.esm.js → actions-444a17c3.esm.js}

@@ -10,10 +10,10 @@ import { devToolsAdapter } from '../dev/dist/xstate-dev.esm.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
 
@@ -467,6 +467,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;
@@ -534,496 +587,51 @@ 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
-      };
-    },
-    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;
-}
-
-/**
- * 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
- */
-
-function fromEventObservable(lazyObservable) {
-  const errorEventType = '$$xstate.error';
-  const completeEventType = '$$xstate.complete';
-
-  // 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;
-}
-
-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;
-}
-
-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
- */
-
-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);
+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);
@@ -1034,7 +642,7 @@ const defaultOptions = {
 };
 class Interpreter {
   /**
-   * The current state of the interpreted behavior.
+   * The current state of the interpreted logic.
    */
 
   /**
@@ -1058,13 +666,13 @@ class Interpreter {
    */
 
   /**
-   * 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;
@@ -1131,7 +739,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
@@ -1144,12 +752,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();
@@ -1191,8 +799,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
@@ -1207,7 +815,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();
@@ -1284,221 +892,611 @@ class Interpreter {
     return this;
   }
 
-  /**
-   * Sends an event to the running interpreter to trigger a transition.
-   *
-   * @param event The event to send
-   */
-  send(event) {
-    if (typeof event === 'string') {
-      throw new Error(`Only event objects may be sent to actors; use .send({ type: "${event}" }) instead`);
-    }
-    if (this.status === ActorStatus.Stopped) {
-      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);
-  }
+  /**
+   * Sends an event to the running interpreter to trigger a transition.
+   *
+   * @param event The event to send
+   */
+  send(event) {
+    if (typeof event === 'string') {
+      throw new Error(`Only event objects may be sent to actors; use .send({ type: "${event}" }) instead`);
+    }
+    if (this.status === ActorStatus.Stopped) {
+      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 : 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: 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);
+  // TODO: add event types
+  const logic = {
+    config: observableCreator,
+    transition: (state, event, {
+      self,
+      id,
+      defer
+    }) => {
+      if (state.status !== 'active') {
+        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 : 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;
-  }
+      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 a new Interpreter instance for the given machine with the provided options, if any.
+ * Creates event observable logic that listens to an observable
+ * that delivers event objects.
  *
- * @param machine The machine to interpret
- * @param options Interpreter options
+ *
+ * @param lazyObservable A function that creates an observable
+ * @returns Event observable logic
  */
 
-function interpret(behavior, options) {
-  const interpreter = new Interpreter(behavior, options);
-  return interpreter;
+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;
 }
 
-/**
- * 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;
+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));
+          });
         }
-        if (actorRef.status !== ActorStatus.Running) {
-          actorCtx.stopChild(actorRef);
-          return;
+        return state;
+      }
+      if (event.type === stopSignalType) {
+        state.canceled = true;
+        if (isFunction(state.dispose)) {
+          state.dispose();
         }
-        actorCtx.defer(() => {
-          actorCtx.stopChild(actorRef);
-        });
+        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 logic;
 }
 
-const defaultLogExpr = ({
-  context,
-  event
-}) => ({
-  context,
-  event
-});
-
+const startSignalType = 'xstate.init';
+const stopSignalType = 'xstate.stop';
+const startSignal = {
+  type: 'xstate.init'
+};
+const stopSignal = {
+  type: 'xstate.stop'
+};
 /**
+ * An object that expresses the actor logic in reaction to received events,
+ * as well as an optionally emitted stream of values.
  *
- * @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.
+ * @template TReceived The received event
+ * @template TSnapshot The emitted value
  */
 
-function log(expr = defaultLogExpr, label) {
+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(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 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) {
+        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) {
@@ -2230,15 +2228,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,
@@ -2247,38 +2241,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 = {
@@ -2296,7 +2268,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) {
@@ -2304,29 +2276,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);
@@ -2354,7 +2322,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') {
@@ -2472,8 +2440,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) {
@@ -2502,12 +2470,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) {
   let nextState = state;
@@ -2515,54 +2480,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,
@@ -2577,15 +2530,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) {
@@ -2594,7 +2544,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;
         }
@@ -2662,10 +2612,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.
    */
@@ -2681,8 +2627,6 @@ class State {
         return new State({
           value: stateValue.value,
           context,
-          event: stateValue.event,
-          actions: [],
           meta: {},
           configuration: [],
           // TODO: fix,
@@ -2692,17 +2636,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);
   }
@@ -2720,23 +2659,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)));
@@ -2759,7 +2692,6 @@ class State {
   toJSON() {
     const {
       configuration,
-      transitions,
       tags,
       machine,
       ...jsonValues
@@ -2828,7 +2760,6 @@ function cloneState(state, config = {}) {
 function getPersistedState(state) {
   const {
     configuration,
-    transitions,
     tags,
     machine,
     children,
@@ -2847,86 +2778,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) {
-        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);
+        }
+      }
+    }];
   });
 }
 
@@ -2964,7 +2914,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
@@ -3289,4 +3239,4 @@ function createInitEvent(input) {
   };
 }
 
-export { toObserver as $, createInitEvent as A, resolveActionsAndContext as B, microstep as C, error as D, isStateId as E, getStateNodeByPath as F, getPersistedState as G, resolveReferencedActor as H, interpret as I, initEvent as J, matchesState as K, sendTo as L, sendParent as M, NULL_EVENT as N, forwardTo as O, Interpreter as P, ActorStatus as Q, doneInvoke as R, STATE_DELIMITER as S, assign as T, cancel as U, choose as V, log as W, pure as X, raise as Y, stop as Z, pathToStateValue as _, toArray as a, fromPromise as a0, fromObservable as a1, fromCallback as a2, fromEventObservable as a3, fromTransition as a4, stateIn as a5, not as a6, and as a7, or as a8, ActionTypes as a9, SpecialTargets as aa, startSignalType as ab, stopSignalType as ac, startSignal as ad, stopSignal as ae, isSignal as af, isActorRef as ag, toActorRef as ah, createEmptyActor as ai, toGuardDefinition as aj, actionTypes as ak, resolveActionObject as al, toActionObject as am, after as an, done as ao, send as ap, escalate as aq, toTransitionConfigArray as b, formatTransition as c, memo as d, evaluateGuard as e, formatTransitions as f, flatten as g, createInvokeId as h, isString as i, invoke$1 as j, getDelayedTransitions as k, formatInitialTransition as l, mapValues as m, getCandidates as n, toInvokeConfig as o, createSpawner as p, getConfiguration as q, getStateNodes as r, resolveStateValue as s, toActionObjects as t, isInFinalState as u, State as v, isErrorEvent as w, macrostep as x, transitionNode as y, getInitialConfiguration as z };
+export { toObserver as $, resolveActionsAndContext as A, microstep as B, error as C, isStateId as D, getStateNodeByPath as E, getPersistedState as F, resolveReferencedActor as G, interpret as H, createInitEvent as I, initEvent as J, matchesState as K, sendTo as L, sendParent as M, NULL_EVENT as N, forwardTo as O, Interpreter as P, ActorStatus as Q, doneInvoke as R, STATE_DELIMITER as S, assign as T, cancel as U, choose as V, log as W, pure as X, raise as Y, stop as Z, pathToStateValue as _, toArray as a, fromPromise as a0, fromObservable as a1, fromCallback as a2, fromEventObservable as a3, fromTransition as a4, stateIn as a5, not as a6, and as a7, or as a8, ActionTypes as a9, SpecialTargets as aa, startSignalType as ab, stopSignalType as ac, startSignal as ad, stopSignal as ae, isSignal as af, isActorRef as ag, toActorRef as ah, createEmptyActor as ai, toGuardDefinition as aj, actionTypes as ak, resolveActionObject as al, toActionObject as am, after as an, done as ao, send as ap, escalate as aq, toTransitionConfigArray as b, formatTransition as c, memo as d, evaluateGuard as e, formatTransitions as f, flatten as g, createInvokeId as h, isString as i, invoke$1 as j, getDelayedTransitions as k, formatInitialTransition as l, mapValues as m, getCandidates as n, toInvokeConfig as o, createSpawner as p, getConfiguration as q, getStateNodes as r, resolveStateValue as s, toActionObjects as t, isInFinalState as u, State as v, isErrorEvent as w, macrostep as x, transitionNode as y, getInitialConfiguration as z };