xstate 5.0.0-alpha.6 → 5.0.0-beta.10

package/dist/{actions-bf7bb1c5.cjs.dev.js → actions-109712d3.cjs.dev.js}

@@ -3,6 +3,38 @@
 var dev_dist_xstateDev = require('./index-ebaab3c9.cjs.dev.js');
 
 // https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
+
+// TODO: replace in v5 with:
+// export type IndexByType<T extends { type: string }> = { [E in T as E['type']]: E; };
+
+/**
+ * The full definition of an event, with a string `type`.
+ */
+
+// TODO: do not accept machines without all implementations
+// we should also accept a raw machine as a behavior here
+// or just make machine a behavior
+
+// TODO: narrow this to behaviors from machine
+
+// TODO: fix last param
+
+/**
+ * Extracts action objects that have no extra properties.
+ */
+
+/**
+ * The string or object representing the state value relative to the parent state node.
+ *
+ * - For a child atomic state node, this is a string, e.g., `"pending"`.
+ * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
+ */
+
+// TODO: remove once TS fixes this type-widening issue
+
+// TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
+
+exports.ActionTypes = void 0;
 (function (ActionTypes) {
   ActionTypes["Stop"] = "xstate.stop";
   ActionTypes["Raise"] = "xstate.raise";
@@ -22,45 +54,46 @@ var dev_dist_xstateDev = require('./index-ebaab3c9.cjs.dev.js');
   ActionTypes["Pure"] = "xstate.pure";
   ActionTypes["Choose"] = "xstate.choose";
 })(exports.ActionTypes || (exports.ActionTypes = {}));
+exports.SpecialTargets = void 0;
 (function (SpecialTargets) {
   SpecialTargets["Parent"] = "#_parent";
   SpecialTargets["Internal"] = "#_internal";
 })(exports.SpecialTargets || (exports.SpecialTargets = {}));
 
 // xstate-specific action types
-var stop = exports.ActionTypes.Stop;
-var raise = exports.ActionTypes.Raise;
-var send = exports.ActionTypes.Send;
-var cancel = exports.ActionTypes.Cancel;
-var assign = exports.ActionTypes.Assign;
-var after = exports.ActionTypes.After;
+var stop$1 = exports.ActionTypes.Stop;
+var raise$1 = exports.ActionTypes.Raise;
+var send$1 = exports.ActionTypes.Send;
+var cancel$1 = exports.ActionTypes.Cancel;
+var assign$1 = exports.ActionTypes.Assign;
+var after$1 = exports.ActionTypes.After;
 var doneState = exports.ActionTypes.DoneState;
-var log = exports.ActionTypes.Log;
+var log$1 = exports.ActionTypes.Log;
 var init = exports.ActionTypes.Init;
-var invoke = exports.ActionTypes.Invoke;
+var invoke$1 = exports.ActionTypes.Invoke;
 var errorExecution = exports.ActionTypes.ErrorExecution;
 var errorPlatform = exports.ActionTypes.ErrorPlatform;
-var error = exports.ActionTypes.ErrorCustom;
-var choose = exports.ActionTypes.Choose;
-var pure = exports.ActionTypes.Pure;
+var error$1 = exports.ActionTypes.ErrorCustom;
+var choose$1 = exports.ActionTypes.Choose;
+var pure$1 = exports.ActionTypes.Pure;
 
 var actionTypes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  stop: stop,
-  raise: raise,
-  send: send,
-  cancel: cancel,
-  assign: assign,
-  after: after,
+  stop: stop$1,
+  raise: raise$1,
+  send: send$1,
+  cancel: cancel$1,
+  assign: assign$1,
+  after: after$1,
   doneState: doneState,
-  log: log,
+  log: log$1,
   init: init,
-  invoke: invoke,
+  invoke: invoke$1,
   errorExecution: errorExecution,
   errorPlatform: errorPlatform,
-  error: error,
-  choose: choose,
-  pure: pure
+  error: error$1,
+  choose: choose$1,
+  pure: pure$1
 });
 
 function _toPrimitive(input, hint) {
@@ -288,7 +321,7 @@ function toStatePath(stateId, delimiter) {
   }
 }
 function isStateLike(state) {
-  return _typeof(state) === 'object' && 'value' in state && 'context' in state && 'event' in state && '_event' in state;
+  return _typeof(state) === 'object' && 'value' in state && 'context' in state && 'event' in state;
 }
 function toStateValue(stateValue, delimiter) {
   if (isStateLike(stateValue)) {
@@ -344,17 +377,17 @@ function toArray(value) {
   }
   return toArrayStrict(value);
 }
-function mapContext(mapper, context, _event) {
+function mapContext(mapper, context, event) {
   if (isFunction(mapper)) {
     return mapper({
       context: context,
-      event: _event.data
+      event: event
     });
   }
   var result = {};
   var args = {
     context: context,
-    event: _event.data
+    event: event
   };
   for (var _i4 = 0, _Object$keys2 = Object.keys(mapper); _i4 < _Object$keys2.length; _i4++) {
     var _key3 = _Object$keys2[_i4];
@@ -407,22 +440,8 @@ function isFunction(value) {
 function isString(value) {
   return typeof value === 'string';
 }
-function isSCXMLEvent(event) {
-  return '$$type' in event && event.$$type === 'scxml';
-}
-function isSCXMLErrorEvent(event) {
-  return typeof event.name === 'string' && (event.name === errorExecution || event.name.startsWith(errorPlatform));
-}
-function toSCXMLEvent(event, scxmlEvent) {
-  if (isSCXMLEvent(event)) {
-    return event;
-  }
-  return _objectSpread2({
-    name: event.type,
-    data: event,
-    $$type: 'scxml',
-    type: 'external'
-  }, scxmlEvent);
+function isErrorEvent(event) {
+  return typeof event.type === 'string' && (event.type === errorExecution || event.type.startsWith(errorPlatform));
 }
 function toTransitionConfigArray(event, configLike) {
   var transitions = toArrayStrict(configLike).map(function (transitionLike) {
@@ -504,16 +523,16 @@ function isDynamicAction(action) {
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  *  - `to` - The target of this event (by default, the machine the event was sent from).
  */
-function send$1(eventOrExpr, options) {
+function send(eventOrExpr, options) {
   return createDynamicAction({
-    type: send,
+    type: send$1,
     params: {
       to: options ? options.to : undefined,
       delay: options ? options.delay : undefined,
       event: eventOrExpr,
       id: options && options.id !== undefined ? options.id : isFunction(eventOrExpr) ? eventOrExpr.name : eventOrExpr.type
     }
-  }, function (_event, _ref) {
+  }, function (event, _ref) {
     var _actorContext$self;
     var actorContext = _ref.actorContext,
       state = _ref.state;
@@ -527,15 +546,17 @@ function send$1(eventOrExpr, options) {
     };
     var args = {
       context: state.context,
-      event: _event.data,
-      _event: _event,
+      event: event,
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : null,
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     };
     var delaysMap = state.machine.options.delays;
 
     // TODO: helper function for resolving Expr
-    var resolvedEvent = toSCXMLEvent(isFunction(eventOrExpr) ? eventOrExpr(args) : eventOrExpr);
+    if (typeof eventOrExpr === 'string') {
+      throw new Error("Only event objects may be used with sendTo; use sendTo({ type: \"".concat(eventOrExpr, "\" }) instead"));
+    }
+    var resolvedEvent = isFunction(eventOrExpr) ? eventOrExpr(args) : eventOrExpr;
     var resolvedDelay;
     if (isString(params.delay)) {
       var configDelay = delaysMap && delaysMap[params.delay];
@@ -564,11 +585,10 @@ function send$1(eventOrExpr, options) {
       targetActorRef = resolvedTarget || (actorContext === null || actorContext === void 0 ? void 0 : actorContext.self);
     }
     var resolvedAction = {
-      type: send,
+      type: send$1,
       params: _objectSpread2(_objectSpread2({}, params), {}, {
         to: targetActorRef,
-        _event: resolvedEvent,
-        event: resolvedEvent.data,
+        event: resolvedEvent,
         delay: resolvedDelay,
         internal: resolvedTarget === exports.SpecialTargets.Internal
       }),
@@ -579,14 +599,12 @@ function send$1(eventOrExpr, options) {
           return;
         } else {
           var target = sendAction.params.to;
-          var _event2 = sendAction.params._event;
+          var sentEvent = sendAction.params.event;
           actorCtx.defer(function () {
-            var origin = actorCtx.self;
-            var resolvedEvent = _objectSpread2(_objectSpread2({}, _event2), {}, {
-              name: _event2.name === error ? "".concat(error$1(origin.id)) : _event2.name,
-              origin: origin
-            });
-            target.send(resolvedEvent);
+            target.send(sentEvent.type === error$1 ? {
+              type: "".concat(error(actorCtx.self.id)),
+              data: sentEvent.data
+            } : sendAction.params.event);
           });
         }
       }
@@ -602,26 +620,11 @@ function send$1(eventOrExpr, options) {
  * @param options Options to pass into the send event.
  */
 function sendParent(event, options) {
-  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
+  return send(event, _objectSpread2(_objectSpread2({}, options), {}, {
     to: exports.SpecialTargets.Parent
   }));
 }
 
-/**
- * Sends an event back to the sender of the original event.
- *
- * @param event The event to send back to the sender
- * @param options Options to pass into the send event
- */
-function respond(event, options) {
-  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
-    to: function to(_ref2) {
-      var _event = _ref2._event;
-      return _event.origin; // TODO: handle when _event.origin is undefined
-    }
-  }));
-}
-
 /**
  * Forwards (sends) an event to a specified service.
  *
@@ -629,7 +632,7 @@ function respond(event, options) {
  * @param options Options to pass into the send action creator.
  */
 function forwardTo(target, options) {
-  if (process.env.NODE_END !== 'production' && (!target || typeof target === 'function')) {
+  if (process.env.NODE_ENV !== 'production' && (!target || typeof target === 'function')) {
     var originalTarget = target;
     target = function target() {
       var resolvedTarget = typeof originalTarget === 'function' ? originalTarget.apply(void 0, arguments) : originalTarget;
@@ -639,8 +642,8 @@ function forwardTo(target, options) {
       return resolvedTarget;
     };
   }
-  return send$1(function (_ref3) {
-    var event = _ref3.event;
+  return send(function (_ref2) {
+    var event = _ref2.event;
     return event;
   }, _objectSpread2(_objectSpread2({}, options), {}, {
     to: target
@@ -657,7 +660,7 @@ function forwardTo(target, options) {
 function escalate(errorData, options) {
   return sendParent(function (arg) {
     return {
-      type: error,
+      type: error$1,
       data: isFunction(errorData) ? errorData(arg) : errorData
     };
   }, _objectSpread2(_objectSpread2({}, options), {}, {
@@ -674,7 +677,7 @@ function escalate(errorData, options) {
  * @returns An XState send action object
  */
 function sendTo(actor, event, options) {
-  return send$1(event, _objectSpread2(_objectSpread2({}, options), {}, {
+  return send(event, _objectSpread2(_objectSpread2({}, options), {}, {
     to: actor
   }));
 }
@@ -798,11 +801,9 @@ var symbolObservable = function () {
  */
 function fromTransition(_transition, initialState) {
   var behavior = {
+    config: _transition,
     transition: function transition(state, event, actorContext) {
-      // @ts-ignore TODO
-      var resolvedEvent = isSCXMLEvent(event) ? event.data : event;
-      // @ts-ignore TODO
-      return _transition(state, resolvedEvent, actorContext);
+      return _transition(state, event, actorContext);
     },
     getInitialState: function getInitialState(_, input) {
       return typeof initialState === 'function' ? initialState({
@@ -830,27 +831,29 @@ promiseCreator) {
 
   // TODO: add event types
   var behavior = {
+    config: promiseCreator,
     transition: function transition(state, event) {
-      var _event = toSCXMLEvent(event);
-      if (state.canceled) {
+      if (state.status !== 'active') {
         return state;
       }
-      var eventObject = _event.data;
-      switch (_event.name) {
+      switch (event.type) {
         case resolveEventType:
-          state.status = 'done';
-          state.data = eventObject.data;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'done',
+            data: event.data,
+            input: undefined
+          });
         case rejectEventType:
-          state.status = 'error';
-          state.data = eventObject.data;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'error',
+            data: event.data,
+            input: undefined
+          });
         case stopSignalType:
-          state.canceled = true;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'canceled',
+            input: undefined
+          });
         default:
           return state;
       }
@@ -866,11 +869,19 @@ promiseCreator) {
         input: state.input
       }));
       resolvedPromise.then(function (response) {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
         self.send({
           type: resolveEventType,
           data: response
         });
       }, function (errorData) {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
         self.send({
           type: rejectEventType,
           data: errorData
@@ -879,7 +890,6 @@ promiseCreator) {
     },
     getInitialState: function getInitialState(_, input) {
       return {
-        canceled: false,
         status: 'active',
         data: undefined,
         input: input
@@ -909,43 +919,48 @@ function fromObservable(observableCreator) {
 
   // TODO: add event types
   var behavior = {
+    config: observableCreator,
     transition: function transition(state, event, _ref) {
       var self = _ref.self,
         id = _ref.id,
         defer = _ref.defer;
-      var _event = toSCXMLEvent(event);
-      if (state.canceled) {
+      if (state.status !== 'active') {
         return state;
       }
-      switch (_event.name) {
+      switch (event.type) {
         case nextEventType:
-          state.data = event.data.data;
           // match the exact timing of events sent by machines
           // send actions are not executed immediately
           defer(function () {
             var _self$_parent;
-            (_self$_parent = self._parent) === null || _self$_parent === void 0 ? void 0 : _self$_parent.send(toSCXMLEvent({
+            (_self$_parent = self._parent) === null || _self$_parent === void 0 ? void 0 : _self$_parent.send({
               type: "xstate.snapshot.".concat(id),
-              data: _event.data.data
-            }, {
-              origin: self
-            }));
+              data: event.data
+            });
+          });
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            data: event.data
           });
-          return state;
         case errorEventType:
-          state.status = 'error';
-          delete state.input;
-          state.data = _event.data.data;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'error',
+            input: undefined,
+            data: event.data,
+            subscription: undefined
+          });
         case completeEventType:
-          state.status = 'done';
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'done',
+            input: undefined,
+            subscription: undefined
+          });
         case stopSignalType:
-          state.canceled = true;
-          delete state.input;
           state.subscription.unsubscribe();
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'canceled',
+            input: undefined,
+            subscription: undefined
+          });
         default:
           return state;
       }
@@ -953,7 +968,6 @@ function fromObservable(observableCreator) {
     getInitialState: function getInitialState(_, input) {
       return {
         subscription: undefined,
-        canceled: false,
         status: 'active',
         data: undefined,
         input: input
@@ -991,12 +1005,10 @@ function fromObservable(observableCreator) {
       return state.data;
     },
     getPersistedState: function getPersistedState(_ref3) {
-      var canceled = _ref3.canceled,
-        status = _ref3.status,
+      var status = _ref3.status,
         data = _ref3.data,
         input = _ref3.input;
       return {
-        canceled: canceled,
         status: status,
         data: data,
         input: input
@@ -1029,26 +1041,32 @@ function fromEventObservable(lazyObservable) {
 
   // TODO: event types
   var behavior = {
+    config: lazyObservable,
     transition: function transition(state, event) {
-      var _event = toSCXMLEvent(event);
-      if (state.canceled) {
+      if (state.status !== 'active') {
         return state;
       }
-      switch (_event.name) {
+      switch (event.type) {
         case errorEventType:
-          state.status = 'error';
-          delete state.input;
-          state.data = _event.data.data;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'error',
+            input: undefined,
+            data: event.data,
+            subscription: undefined
+          });
         case completeEventType:
-          state.status = 'done';
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'done',
+            input: undefined,
+            subscription: undefined
+          });
         case stopSignalType:
-          state.canceled = true;
-          delete state.input;
           state.subscription.unsubscribe();
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'canceled',
+            input: undefined,
+            subscription: undefined
+          });
         default:
           return state;
       }
@@ -1056,7 +1074,6 @@ function fromEventObservable(lazyObservable) {
     getInitialState: function getInitialState() {
       return {
         subscription: undefined,
-        canceled: false,
         status: 'active',
         data: undefined
       };
@@ -1072,9 +1089,7 @@ function fromEventObservable(lazyObservable) {
       }).subscribe({
         next: function next(value) {
           var _self$_parent2;
-          (_self$_parent2 = self._parent) === null || _self$_parent2 === void 0 ? void 0 : _self$_parent2.send(toSCXMLEvent(value, {
-            origin: self
-          }));
+          (_self$_parent2 = self._parent) === null || _self$_parent2 === void 0 ? void 0 : _self$_parent2.send(value);
         },
         error: function error(err) {
           self.send({
@@ -1093,12 +1108,10 @@ function fromEventObservable(lazyObservable) {
       return undefined;
     },
     getPersistedState: function getPersistedState(_ref5) {
-      var canceled = _ref5.canceled,
-        status = _ref5.status,
+      var status = _ref5.status,
         data = _ref5.data,
         input = _ref5.input;
       return {
-        canceled: canceled,
         status: status,
         data: data,
         input: input
@@ -1118,6 +1131,7 @@ function fromEventObservable(lazyObservable) {
 
 function fromCallback(invokeCallback) {
   var behavior = {
+    config: invokeCallback,
     start: function start(_state, _ref) {
       var self = _ref.self;
       self.send({
@@ -1127,16 +1141,13 @@ function fromCallback(invokeCallback) {
     transition: function transition(state, event, _ref2) {
       var self = _ref2.self,
         id = _ref2.id;
-      var _event = toSCXMLEvent(event);
-      if (_event.name === startSignalType) {
+      if (event.type === startSignalType) {
         var sender = function sender(eventForParent) {
           var _self$_parent;
           if (state.canceled) {
-            return state;
+            return;
           }
-          (_self$_parent = self._parent) === null || _self$_parent === void 0 ? void 0 : _self$_parent.send(toSCXMLEvent(eventForParent, {
-            origin: self
-          }));
+          (_self$_parent = self._parent) === null || _self$_parent === void 0 ? void 0 : _self$_parent.send(eventForParent);
         };
         var receiver = function receiver(newListener) {
           state.receivers.add(newListener);
@@ -1147,36 +1158,30 @@ function fromCallback(invokeCallback) {
         if (isPromiseLike(state.dispose)) {
           state.dispose.then(function (resolved) {
             var _self$_parent2;
-            (_self$_parent2 = self._parent) === null || _self$_parent2 === void 0 ? void 0 : _self$_parent2.send(toSCXMLEvent(doneInvoke(id, resolved), {
-              origin: self
-            }));
+            (_self$_parent2 = self._parent) === null || _self$_parent2 === void 0 ? void 0 : _self$_parent2.send(doneInvoke(id, resolved));
             state.canceled = true;
           }, function (errorData) {
             var _self$_parent3;
-            var errorEvent = error$1(id, errorData);
-            (_self$_parent3 = self._parent) === null || _self$_parent3 === void 0 ? void 0 : _self$_parent3.send(toSCXMLEvent(errorEvent, {
-              origin: self
-            }));
             state.canceled = true;
+            (_self$_parent3 = self._parent) === null || _self$_parent3 === void 0 ? void 0 : _self$_parent3.send(error(id, errorData));
           });
         }
         return state;
       }
-      if (_event.name === stopSignalType) {
+      if (event.type === stopSignalType) {
         state.canceled = true;
         if (isFunction(state.dispose)) {
           state.dispose();
         }
         return state;
       }
-      if (isSignal(_event.name)) {
+      if (isSignal(event.type)) {
         // TODO: unrecognized signal
         return state;
       }
-      var plainEvent = isSCXMLEvent(event) ? event.data : event;
-      if (!isSignal(plainEvent.type)) {
+      if (!isSignal(event.type)) {
         state.receivers.forEach(function (receiver) {
-          return receiver(plainEvent);
+          return receiver(event);
         });
       }
       return state;
@@ -1247,6 +1252,12 @@ function toActorRef(actorRefLike) {
     return void 0;
   }), _objectSpread2$1), actorRefLike);
 }
+var emptyBehavior = fromTransition(function (_) {
+  return undefined;
+}, undefined);
+function createEmptyActor() {
+  return interpret(emptyBehavior);
+}
 
 function createSystem() {
   var sessionIdCounter = 0;
@@ -1284,6 +1295,7 @@ function createSystem() {
   return system;
 }
 
+exports.ActorStatus = void 0;
 (function (ActorStatus) {
   ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
   ActorStatus[ActorStatus["Running"] = 1] = "Running";
@@ -1439,9 +1451,9 @@ var Interpreter = /*#__PURE__*/function () {
         _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _observer2$next;
-          var _observer2 = _step.value;
-          (_observer2$next = _observer2.next) === null || _observer2$next === void 0 ? void 0 : _observer2$next.call(_observer2, snapshot);
+          var _observer$next;
+          var _observer = _step.value;
+          (_observer$next = _observer.next) === null || _observer$next === void 0 ? void 0 : _observer$next.call(_observer, snapshot);
         }
       } catch (err) {
         _iterator.e(err);
@@ -1451,30 +1463,15 @@ var Interpreter = /*#__PURE__*/function () {
       var status = (_this$behavior$getSta = (_this$behavior = this.behavior).getStatus) === null || _this$behavior$getSta === void 0 ? void 0 : _this$behavior$getSta.call(_this$behavior, state);
       switch (status === null || status === void 0 ? void 0 : status.status) {
         case 'done':
-          this._doneEvent = doneInvoke(this.id, status.data);
-          (_this$_parent = this._parent) === null || _this$_parent === void 0 ? void 0 : _this$_parent.send(toSCXMLEvent(this._doneEvent, {
-            origin: this,
-            invokeid: this.id
-          }));
           this._stopProcedure();
+          this._doneEvent = doneInvoke(this.id, status.data);
+          (_this$_parent = this._parent) === null || _this$_parent === void 0 ? void 0 : _this$_parent.send(this._doneEvent);
+          this._complete();
           break;
         case 'error':
-          (_this$_parent2 = this._parent) === null || _this$_parent2 === void 0 ? void 0 : _this$_parent2.send(toSCXMLEvent(error$1(this.id, status.data), {
-            origin: this
-          }));
-          var _iterator2 = _createForOfIteratorHelper(this.observers),
-            _step2;
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var _observer$error;
-              var _observer = _step2.value;
-              (_observer$error = _observer.error) === null || _observer$error === void 0 ? void 0 : _observer$error.call(_observer, status.data);
-            }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
-          }
+          this._stopProcedure();
+          (_this$_parent2 = this._parent) === null || _this$_parent2 === void 0 ? void 0 : _this$_parent2.send(error(this.id, status.data));
+          this._error(status.data);
           break;
       }
     }
@@ -1553,15 +1550,16 @@ var Interpreter = /*#__PURE__*/function () {
       try {
         var nextState = this.behavior.transition(this._state, event, this._actorContext);
         this.update(nextState);
-        if (event.name === stopSignalType) {
+        if (event.type === stopSignalType) {
           this._stopProcedure();
+          this._complete();
         }
       } catch (err) {
         // TODO: properly handle errors
         if (this.observers.size > 0) {
           this.observers.forEach(function (observer) {
-            var _observer$error2;
-            (_observer$error2 = observer.error) === null || _observer$error2 === void 0 ? void 0 : _observer$error2.call(observer, err);
+            var _observer$error;
+            (_observer$error = observer.error) === null || _observer$error === void 0 ? void 0 : _observer$error.call(observer, err);
           });
           this.stop();
         } else {
@@ -1580,9 +1578,9 @@ var Interpreter = /*#__PURE__*/function () {
         this.status = exports.ActorStatus.Stopped;
         return this;
       }
-      this.mailbox.enqueue(toSCXMLEvent({
+      this.mailbox.enqueue({
         type: stopSignalType
-      }));
+      });
       return this;
     }
 
@@ -1600,13 +1598,31 @@ var Interpreter = /*#__PURE__*/function () {
   }, {
     key: "_complete",
     value: function _complete() {
+      var _iterator2 = _createForOfIteratorHelper(this.observers),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _observer2$complete;
+          var _observer2 = _step2.value;
+          (_observer2$complete = _observer2.complete) === null || _observer2$complete === void 0 ? void 0 : _observer2$complete.call(_observer2);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      this.observers.clear();
+    }
+  }, {
+    key: "_error",
+    value: function _error(data) {
       var _iterator3 = _createForOfIteratorHelper(this.observers),
         _step3;
       try {
         for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _observer3$complete;
+          var _observer3$error;
           var _observer3 = _step3.value;
-          (_observer3$complete = _observer3.complete) === null || _observer3$complete === void 0 ? void 0 : _observer3$complete.call(_observer3);
+          (_observer3$error = _observer3.error) === null || _observer3$error === void 0 ? void 0 : _observer3$error.call(_observer3, data);
         }
       } catch (err) {
         _iterator3.e(err);
@@ -1618,7 +1634,6 @@ var Interpreter = /*#__PURE__*/function () {
   }, {
     key: "_stopProcedure",
     value: function _stopProcedure() {
-      this._complete();
       if (this.status !== exports.ActorStatus.Running) {
         // Interpreter already stopped; do nothing
         return this;
@@ -1650,21 +1665,23 @@ var Interpreter = /*#__PURE__*/function () {
   }, {
     key: "send",
     value: function send(event) {
-      var _event = toSCXMLEvent(event);
+      if (typeof event === 'string') {
+        throw new Error("Only event objects may be sent to actors; use .send({ type: \"".concat(event, "\" }) instead"));
+      }
       if (this.status === exports.ActorStatus.Stopped) {
         // do nothing
         if (!dev_dist_xstateDev.IS_PRODUCTION) {
-          var eventString = JSON.stringify(_event.data);
-          warn(false, "Event \"".concat(_event.name.toString(), "\" was sent to stopped actor \"").concat(this.id, " (").concat(this.sessionId, ")\". This actor has already reached its final state, and will not transition.\nEvent: ").concat(eventString));
+          var eventString = JSON.stringify(event);
+          warn(false, "Event \"".concat(event.type.toString(), "\" was sent to stopped actor \"").concat(this.id, " (").concat(this.sessionId, ")\". This actor has already reached its final state, and will not transition.\nEvent: ").concat(eventString));
         }
         return;
       }
       if (this.status !== exports.ActorStatus.Running && !this.options.deferEvents) {
-        throw new Error("Event \"".concat(_event.name, "\" was sent to uninitialized actor \"").concat(this.id
+        throw new Error("Event \"".concat(event.type, "\" was sent to uninitialized actor \"").concat(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: ").concat(JSON.stringify(_event.data)));
+        , "\". Make sure .start() is called for this actor, or set { deferEvents: true } in the actor options.\nEvent: ").concat(JSON.stringify(event)));
       }
-      this.mailbox.enqueue(_event);
+      this.mailbox.enqueue(event);
     }
 
     // TODO: make private (and figure out a way to do this within the machine)
@@ -1674,9 +1691,9 @@ var Interpreter = /*#__PURE__*/function () {
       var _this4 = this;
       this.delayedEventsMap[sendAction.params.id] = this.clock.setTimeout(function () {
         if ('to' in sendAction.params && sendAction.params.to) {
-          sendAction.params.to.send(sendAction.params._event);
+          sendAction.params.to.send(sendAction.params.event);
         } else {
-          _this4.send(sendAction.params._event);
+          _this4.send(sendAction.params.event);
         }
       }, sendAction.params.delay);
     }
@@ -1742,18 +1759,18 @@ function interpret(behavior, options) {
  * @param actorRef The actor to stop.
  */
 
-function stop$1(actorRef) {
+function stop(actorRef) {
   var actor = actorRef;
   return createDynamicAction({
-    type: stop,
+    type: stop$1,
     params: {
       actor: actor
     }
-  }, function (_event, _ref) {
+  }, function (event, _ref) {
     var state = _ref.state;
     var actorRefOrString = isFunction(actor) ? actor({
       context: state.context,
-      event: _event.data
+      event: event
     }) : actor;
     var actorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
     return [state, {
@@ -1795,23 +1812,22 @@ var defaultLogExpr = function defaultLogExpr(_ref) {
  * @param label The label to give to the logged expression.
  */
 
-function log$1() {
+function log() {
   var expr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultLogExpr;
   var label = arguments.length > 1 ? arguments[1] : undefined;
   return createDynamicAction({
-    type: log,
+    type: log$1,
     params: {
       label: label,
       expr: expr
     }
-  }, function (_event, _ref2) {
+  }, function (event, _ref2) {
     var _actorContext$self;
     var state = _ref2.state,
       actorContext = _ref2.actorContext;
     var resolvedValue = typeof expr === 'function' ? expr({
       context: state.context,
-      event: _event.data,
-      _event: _event,
+      event: event,
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : {},
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     }) : expr;
@@ -1842,20 +1858,19 @@ function log$1() {
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
 
-function cancel$1(sendId) {
+function cancel(sendId) {
   return createDynamicAction({
-    type: cancel,
+    type: cancel$1,
     params: {
       sendId: sendId
     }
-  }, function (_event, _ref) {
+  }, function (event, _ref) {
     var _actorContext$self;
     var state = _ref.state,
       actorContext = _ref.actorContext;
     var resolvedSendId = isFunction(sendId) ? sendId({
       context: state.context,
-      event: _event.data,
-      _event: _event,
+      event: event,
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : {},
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     }) : sendId;
@@ -1941,9 +1956,9 @@ function not(guard) {
       var evaluate = _ref2.evaluate,
         guard = _ref2.guard,
         context = _ref2.context,
-        _event = _ref2._event,
+        event = _ref2.event,
         state = _ref2.state;
-      return !evaluate(guard.children[0], context, _event, state);
+      return !evaluate(guard.children[0], context, event, state);
     }
   };
 }
@@ -1960,10 +1975,10 @@ function and(guards) {
       var evaluate = _ref3.evaluate,
         guard = _ref3.guard,
         context = _ref3.context,
-        _event = _ref3._event,
+        event = _ref3.event,
         state = _ref3.state;
       return guard.children.every(function (childGuard) {
-        return evaluate(childGuard, context, _event, state);
+        return evaluate(childGuard, context, event, state);
       });
     }
   };
@@ -1981,15 +1996,15 @@ function or(guards) {
       var evaluate = _ref4.evaluate,
         guard = _ref4.guard,
         context = _ref4.context,
-        _event = _ref4._event,
+        event = _ref4.event,
         state = _ref4.state;
       return guard.children.some(function (childGuard) {
-        return evaluate(childGuard, context, _event, state);
+        return evaluate(childGuard, context, event, state);
       });
     }
   };
 }
-function evaluateGuard(guard, context, _event, state) {
+function evaluateGuard(guard, context, event, state) {
   var _machine$options$guar, _machine$options, _machine$options$guar2;
   var machine = state.machine;
   var predicate = (_machine$options$guar = machine === null || machine === void 0 ? void 0 : (_machine$options = machine.options) === null || _machine$options === void 0 ? void 0 : (_machine$options$guar2 = _machine$options.guards) === null || _machine$options$guar2 === void 0 ? void 0 : _machine$options$guar2[guard.type]) !== null && _machine$options$guar !== void 0 ? _machine$options$guar : guard.predicate;
@@ -1998,10 +2013,9 @@ function evaluateGuard(guard, context, _event, state) {
   }
   return predicate({
     context: context,
-    event: _event.data,
+    event: event,
     state: state,
     guard: guard,
-    _event: _event,
     evaluate: evaluateGuard
   });
 }
@@ -2036,12 +2050,12 @@ function toGuardDefinition(guardConfig, getPredicate) {
   };
 }
 
-function getOutput(configuration, context, _event) {
+function getOutput(configuration, context, event) {
   var machine = configuration[0].machine;
   var finalChildStateNode = configuration.find(function (stateNode) {
     return stateNode.type === 'final' && stateNode.parent === machine.root;
   });
-  return finalChildStateNode && finalChildStateNode.output ? mapContext(finalChildStateNode.output, context, _event) : undefined;
+  return finalChildStateNode && finalChildStateNode.output ? mapContext(finalChildStateNode.output, context, event) : undefined;
 }
 var isAtomicStateNode = function isAtomicStateNode(stateNode) {
   return stateNode.type === 'atomic' || stateNode.type === 'final';
@@ -2205,7 +2219,6 @@ var isStateId = function isStateId(str) {
   return str[0] === STATE_IDENTIFIER;
 };
 function getCandidates(stateNode, receivedEventType) {
-  var partialMatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   var candidates = stateNode.transitions.filter(function (transition) {
     var eventType = transition.eventType;
     // First, check the trivial case: event names are exactly equal
@@ -2218,7 +2231,7 @@ function getCandidates(stateNode, receivedEventType) {
     if (eventType === WILDCARD) {
       return true;
     }
-    if (!partialMatch && !eventType.endsWith('.*')) {
+    if (!eventType.endsWith('.*')) {
       return false;
     }
     if (!dev_dist_xstateDev.IS_PRODUCTION) {
@@ -2255,13 +2268,13 @@ function getDelayedTransitions(stateNode) {
   }
   var mutateEntryExit = function mutateEntryExit(delay, i) {
     var delayRef = isFunction(delay) ? "".concat(stateNode.id, ":delay[").concat(i, "]") : delay;
-    var eventType = after$1(delayRef, stateNode.id);
-    stateNode.entry.push(send$1({
+    var eventType = after(delayRef, stateNode.id);
+    stateNode.entry.push(raise({
       type: eventType
     }, {
       delay: delay
     }));
-    stateNode.exit.push(cancel$1(eventType));
+    stateNode.exit.push(cancel(eventType));
     return eventType;
   };
   var delayedTransitions = isArray(afterConfig) ? afterConfig.map(function (transition, i) {
@@ -2291,9 +2304,9 @@ function getDelayedTransitions(stateNode) {
   });
 }
 function formatTransition(stateNode, transitionConfig) {
-  var _transitionConfig$ext;
+  var _transitionConfig$ree;
   var normalizedTarget = normalizeTarget(transitionConfig.target);
-  var external = (_transitionConfig$ext = transitionConfig.external) !== null && _transitionConfig$ext !== void 0 ? _transitionConfig$ext : false;
+  var reenter = (_transitionConfig$ree = transitionConfig.reenter) !== null && _transitionConfig$ree !== void 0 ? _transitionConfig$ree : false;
   var guards = stateNode.machine.options.guards;
   var target = resolveTarget(stateNode, normalizedTarget);
 
@@ -2308,7 +2321,7 @@ function formatTransition(stateNode, transitionConfig) {
     }) : undefined,
     target: target,
     source: stateNode,
-    external: external,
+    reenter: reenter,
     eventType: transitionConfig.event,
     toJSON: function toJSON() {
       return _objectSpread2(_objectSpread2({}, transition), {}, {
@@ -2395,7 +2408,7 @@ function formatInitialTransition(stateNode, _target) {
       source: stateNode,
       actions: [],
       eventType: null,
-      external: false,
+      reenter: false,
       target: resolvedTarget,
       toJSON: function toJSON() {
         return _objectSpread2(_objectSpread2({}, transition), {}, {
@@ -2578,24 +2591,24 @@ function getStateNodes(stateNode, state) {
     return allSubStateNodes.concat(subStateNodes);
   }, []));
 }
-function transitionAtomicNode(stateNode, stateValue, state, _event) {
+function transitionAtomicNode(stateNode, stateValue, state, event) {
   var childStateNode = getStateNode(stateNode, stateValue);
-  var next = childStateNode.next(state, _event);
+  var next = childStateNode.next(state, event);
   if (!next || !next.length) {
-    return stateNode.next(state, _event);
+    return stateNode.next(state, event);
   }
   return next;
 }
-function transitionCompoundNode(stateNode, stateValue, state, _event) {
+function transitionCompoundNode(stateNode, stateValue, state, event) {
   var subStateKeys = Object.keys(stateValue);
   var childStateNode = getStateNode(stateNode, subStateKeys[0]);
-  var next = transitionNode(childStateNode, stateValue[subStateKeys[0]], state, _event);
+  var next = transitionNode(childStateNode, stateValue[subStateKeys[0]], state, event);
   if (!next || !next.length) {
-    return stateNode.next(state, _event);
+    return stateNode.next(state, event);
   }
   return next;
 }
-function transitionParallelNode(stateNode, stateValue, state, _event) {
+function transitionParallelNode(stateNode, stateValue, state, event) {
   var allInnerTransitions = [];
   for (var _i3 = 0, _Object$keys2 = Object.keys(stateValue); _i3 < _Object$keys2.length; _i3++) {
     var subStateKey = _Object$keys2[_i3];
@@ -2604,29 +2617,29 @@ function transitionParallelNode(stateNode, stateValue, state, _event) {
       continue;
     }
     var subStateNode = getStateNode(stateNode, subStateKey);
-    var innerTransitions = transitionNode(subStateNode, subStateValue, state, _event);
+    var innerTransitions = transitionNode(subStateNode, subStateValue, state, event);
     if (innerTransitions) {
       allInnerTransitions.push.apply(allInnerTransitions, _toConsumableArray(innerTransitions));
     }
   }
   if (!allInnerTransitions.length) {
-    return stateNode.next(state, _event);
+    return stateNode.next(state, event);
   }
   return allInnerTransitions;
 }
-function transitionNode(stateNode, stateValue, state, _event) {
+function transitionNode(stateNode, stateValue, state, event) {
   // leaf node
   if (isString(stateValue)) {
-    return transitionAtomicNode(stateNode, stateValue, state, _event);
+    return transitionAtomicNode(stateNode, stateValue, state, event);
   }
 
   // compound node
   if (Object.keys(stateValue).length === 1) {
-    return transitionCompoundNode(stateNode, stateValue, state, _event);
+    return transitionCompoundNode(stateNode, stateValue, state, event);
   }
 
   // parallel node
-  return transitionParallelNode(stateNode, stateValue, state, _event);
+  return transitionParallelNode(stateNode, stateValue, state, event);
 }
 function getHistoryNodes(stateNode) {
   return Object.keys(stateNode.states).map(function (key) {
@@ -2818,7 +2831,7 @@ function getTransitionDomain(transition, historyValue) {
   if (!targetStates) {
     return null;
   }
-  if (!transition.external && transition.source.type === 'compound' && targetStates.every(function (targetStateNode) {
+  if (!transition.reenter && transition.source.type !== 'parallel' && targetStates.every(function (targetStateNode) {
     return isDescendant(targetStateNode, transition.source);
   })) {
     return transition.source;
@@ -2869,7 +2882,7 @@ function computeExitSet(transitions, configuration, historyValue) {
  * @param mutConfiguration
  */
 
-function microstep(transitions, currentState, actorCtx, scxmlEvent) {
+function microstep(transitions, currentState, actorCtx, event) {
   var machine = currentState.machine;
   // Transition will "apply" if:
   // - the state node is the initial state (there is no current state)
@@ -2878,7 +2891,7 @@ function microstep(transitions, currentState, actorCtx, scxmlEvent) {
   var mutConfiguration = new Set(currentState.configuration);
   if (!currentState._initial && !willTransition) {
     var inertState = cloneState(currentState, {
-      _event: scxmlEvent,
+      event: event,
       actions: [],
       transitions: []
     });
@@ -2888,11 +2901,11 @@ function microstep(transitions, currentState, actorCtx, scxmlEvent) {
   var microstate = microstepProcedure(currentState._initial ? [{
     target: _toConsumableArray(currentState.configuration).filter(isAtomicStateNode),
     source: machine.root,
-    external: true,
+    reenter: true,
     actions: [],
     eventType: null,
     toJSON: null // TODO: fix
-  }] : transitions, currentState, mutConfiguration, scxmlEvent, actorCtx);
+  }] : transitions, currentState, mutConfiguration, event, actorCtx);
   var context = microstate.context,
     nonRaisedActions = microstate.actions;
   var children = setChildren(currentState, nonRaisedActions);
@@ -2912,12 +2925,12 @@ function setChildren(currentState, nonRaisedActions) {
   try {
     for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
       var action = _step21.value;
-      if (action.type === invoke && action.params.ref) {
+      if (action.type === invoke$1 && action.params.ref) {
         var ref = action.params.ref;
         if (ref) {
           children[ref.id] = ref;
         }
-      } else if (action.type === stop) {
+      } else if (action.type === stop$1) {
         var _ref = action.params.actor;
         if (_ref) {
           delete children[_ref.id];
@@ -2931,8 +2944,7 @@ function setChildren(currentState, nonRaisedActions) {
   }
   return children;
 }
-function microstepProcedure(transitions, currentState, mutConfiguration, scxmlEvent, actorCtx) {
-  var machine = currentState.machine;
+function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx) {
   var actions = [];
   var historyValue = _objectSpread2({}, currentState.historyValue);
   var filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
@@ -2961,9 +2973,9 @@ function microstepProcedure(transitions, currentState, mutConfiguration, scxmlEv
     actions.push.apply(actions, _toConsumableArray(finalActions));
   }
   try {
-    var _resolveActionsAndCon = resolveActionsAndContext(actions, scxmlEvent, currentState, actorCtx),
+    var _resolveActionsAndCon = resolveActionsAndContext(actions, event, currentState, actorCtx),
       nextState = _resolveActionsAndCon.nextState;
-    var output = done ? getOutput(nextConfiguration, nextState.context, scxmlEvent) : undefined;
+    var output = done ? getOutput(nextConfiguration, nextState.context, event) : undefined;
     internalQueue.push.apply(internalQueue, _toConsumableArray(nextState._internalQueue));
     return cloneState(currentState, {
       actions: nextState.actions,
@@ -2971,7 +2983,7 @@ function microstepProcedure(transitions, currentState, mutConfiguration, scxmlEv
       historyValue: historyValue,
       _internalQueue: internalQueue,
       context: nextState.context,
-      _event: scxmlEvent,
+      event: event,
       done: done,
       output: output,
       children: nextState.children
@@ -2979,19 +2991,7 @@ function microstepProcedure(transitions, currentState, mutConfiguration, scxmlEv
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
     // See https://github.com/statelyai/rfcs/pull/4
-    if (machine.config.scxml) {
-      return cloneState(currentState, {
-        actions: [],
-        configuration: Array.from(mutConfiguration),
-        historyValue: historyValue,
-        _internalQueue: [toSCXMLEvent({
-          type: 'error.execution'
-        })],
-        context: currentState.context
-      });
-    } else {
-      throw e;
-    }
+    throw e;
   }
 }
 function enterStates(filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue) {
@@ -3016,7 +3016,7 @@ function enterStates(filteredTransitions, mutConfiguration, actions, internalQue
       try {
         for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
           var invokeDef = _step23.value;
-          actions.push(invoke$1(invokeDef));
+          actions.push(invoke(invokeDef));
         }
 
         // Add entry actions
@@ -3046,14 +3046,14 @@ function enterStates(filteredTransitions, mutConfiguration, actions, internalQue
         if (!parent.parent) {
           continue;
         }
-        internalQueue.push(toSCXMLEvent(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, currentState.event) : undefined));
         if (parent.parent) {
           var grandparent = parent.parent;
           if (grandparent.type === 'parallel') {
             if (getChildren(grandparent).every(function (parentNode) {
               return isInFinalState(_toConsumableArray(mutConfiguration), parentNode);
             })) {
-              internalQueue.push(toSCXMLEvent(done(grandparent.id)));
+              internalQueue.push(done(grandparent.id));
             }
           }
         }
@@ -3326,7 +3326,7 @@ function exitStates(transitions, mutConfiguration, historyValue, actions) {
     for (_iterator40.s(); !(_step40 = _iterator40.n()).done;) {
       var s = _step40.value;
       actions.push.apply(actions, _toConsumableArray(s.exit.flat()).concat(_toConsumableArray(s.invoke.map(function (def) {
-        return stop$1(def.id);
+        return stop(def.id);
       }))));
       mutConfiguration["delete"](s);
     }
@@ -3336,7 +3336,7 @@ function exitStates(transitions, mutConfiguration, historyValue, actions) {
     _iterator40.f();
   }
 }
-function resolveActionsAndContext(actions, scxmlEvent, currentState, actorCtx) {
+function resolveActionsAndContext(actions, event, currentState, actorCtx) {
   var machine = currentState.machine;
   var resolvedActions = [];
   var raiseActions = [];
@@ -3354,7 +3354,7 @@ function resolveActionsAndContext(actions, scxmlEvent, currentState, actorCtx) {
     var executableActionObject = resolveActionObject(actionObject, machine.options.actions);
     if (isDynamicAction(executableActionObject)) {
       var _resolvedAction$param;
-      var _executableActionObje = executableActionObject.resolve(scxmlEvent, {
+      var _executableActionObje = executableActionObject.resolve(event, {
           state: intermediateState,
           action: actionObject,
           actorContext: actorCtx
@@ -3364,12 +3364,12 @@ function resolveActionsAndContext(actions, scxmlEvent, currentState, actorCtx) {
         resolvedAction = _executableActionObje2[1];
       var matchedActions = (_resolvedAction$param = resolvedAction.params) === null || _resolvedAction$param === void 0 ? void 0 : _resolvedAction$param.actions;
       intermediateState = nextState;
-      if ((resolvedAction.type === raise || resolvedAction.type === send && resolvedAction.params.internal) && typeof resolvedAction.params.delay !== 'number') {
+      if ((resolvedAction.type === raise$1 || resolvedAction.type === send$1 && resolvedAction.params.internal) && typeof resolvedAction.params.delay !== 'number') {
         raiseActions.push(resolvedAction);
       }
 
       // TODO: remove the check; just handleAction
-      if (resolvedAction.type !== pure) {
+      if (resolvedAction.type !== pure$1) {
         handleAction(resolvedAction);
       }
       toActionObjects(matchedActions).forEach(resolveAction);
@@ -3393,21 +3393,21 @@ function resolveActionsAndContext(actions, scxmlEvent, currentState, actorCtx) {
     nextState: cloneState(intermediateState, {
       actions: resolvedActions,
       _internalQueue: raiseActions.map(function (a) {
-        return a.params._event;
+        return a.params.event;
       })
     })
   };
 }
-function macrostep(state, scxmlEvent, actorCtx) {
-  if (!dev_dist_xstateDev.IS_PRODUCTION && scxmlEvent.name === WILDCARD) {
+function macrostep(state, event, actorCtx) {
+  if (!dev_dist_xstateDev.IS_PRODUCTION && event.type === WILDCARD) {
     throw new Error("An event cannot have the wildcard type ('".concat(WILDCARD, "')"));
   }
   var nextState = state;
   var states = [];
 
   // Handle stop event
-  if ((scxmlEvent === null || scxmlEvent === void 0 ? void 0 : scxmlEvent.name) === stopSignalType) {
-    nextState = stopStep(scxmlEvent, nextState, actorCtx);
+  if (event.type === stopSignalType) {
+    nextState = stopStep(event, nextState, actorCtx);
     states.push(nextState);
     return {
       state: nextState,
@@ -3417,9 +3417,9 @@ function macrostep(state, scxmlEvent, actorCtx) {
 
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
-  if (scxmlEvent.name !== init) {
-    var transitions = selectTransitions(scxmlEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, scxmlEvent);
+  if (event.type !== init) {
+    var transitions = selectTransitions(event, nextState);
+    nextState = microstep(transitions, state, actorCtx, event);
     states.push(nextState);
   }
   while (!nextState.done) {
@@ -3451,21 +3451,21 @@ function macrostep(state, scxmlEvent, actorCtx) {
     if (enabledTransitions.length) {
       var _nextState$actions2;
       var _currentActions = nextState.actions;
-      nextState = microstep(enabledTransitions, nextState, actorCtx, nextState._event);
+      nextState = microstep(enabledTransitions, nextState, actorCtx, nextState.event);
       (_nextState$actions2 = nextState.actions).unshift.apply(_nextState$actions2, _toConsumableArray(_currentActions));
       states.push(nextState);
     }
   }
   if (nextState.done) {
     // Perform the stop step to ensure that child actors are stopped
-    stopStep(nextState._event, nextState, actorCtx);
+    stopStep(nextState.event, nextState, actorCtx);
   }
   return {
     state: nextState,
     microstates: states
   };
 }
-function stopStep(scxmlEvent, nextState, actorCtx) {
+function stopStep(event, nextState, actorCtx) {
   var actions = [];
   var _iterator43 = _createForOfIteratorHelper(nextState.configuration.sort(function (a, b) {
       return b.order - a.order;
@@ -3483,14 +3483,14 @@ function stopStep(scxmlEvent, nextState, actorCtx) {
   }
   for (var _i4 = 0, _Object$values = Object.values(nextState.children); _i4 < _Object$values.length; _i4++) {
     var child = _Object$values[_i4];
-    actions.push(stop$1(child));
+    actions.push(stop(child));
   }
-  var _resolveActionsAndCon2 = resolveActionsAndContext(actions, scxmlEvent, nextState, actorCtx),
+  var _resolveActionsAndCon2 = resolveActionsAndContext(actions, event, nextState, actorCtx),
     stoppedState = _resolveActionsAndCon2.nextState;
   return stoppedState;
 }
-function selectTransitions(scxmlEvent, nextState) {
-  return nextState.machine.getTransitionData(nextState, scxmlEvent);
+function selectTransitions(event, nextState) {
+  return nextState.machine.getTransitionData(nextState, event);
 }
 function selectEventlessTransitions(nextState) {
   var enabledTransitionSet = new Set();
@@ -3513,7 +3513,7 @@ function selectEventlessTransitions(nextState) {
           try {
             for (_iterator46.s(); !(_step46 = _iterator46.n()).done;) {
               var transition = _step46.value;
-              if (transition.guard === undefined || evaluateGuard(transition.guard, nextState.context, nextState._event, nextState)) {
+              if (transition.guard === undefined || evaluateGuard(transition.guard, nextState.context, nextState.event, nextState)) {
                 enabledTransitionSet.add(transition);
                 break loop;
               }
@@ -3607,16 +3607,14 @@ var State = /*#__PURE__*/function () {
     _defineProperty(this, "actions", []);
     _defineProperty(this, "event", void 0);
     _defineProperty(this, "_internalQueue", void 0);
-    _defineProperty(this, "_event", void 0);
     _defineProperty(this, "_initial", false);
     _defineProperty(this, "changed", void 0);
     _defineProperty(this, "configuration", void 0);
     _defineProperty(this, "transitions", void 0);
     _defineProperty(this, "children", void 0);
     this.context = config.context;
-    this._event = config._event;
     this._internalQueue = (_config$_internalQueu = config._internalQueue) !== null && _config$_internalQueu !== void 0 ? _config$_internalQueu : [];
-    this.event = this._event.data;
+    this.event = config.event;
     this.historyValue = config.historyValue || {};
     this.actions = (_config$actions = config.actions) !== null && _config$actions !== void 0 ? _config$actions : [];
     this.matches = this.matches.bind(this);
@@ -3656,11 +3654,11 @@ var State = /*#__PURE__*/function () {
   }, {
     key: "toJSON",
     value: function toJSON() {
-      var configuration = this.configuration,
-        transitions = this.transitions,
-        tags = this.tags,
-        machine = this.machine,
-        jsonValues = _objectWithoutProperties(this, _excluded);
+      this.configuration;
+        this.transitions;
+        var tags = this.tags;
+        this.machine;
+        var jsonValues = _objectWithoutProperties(this, _excluded);
       return _objectSpread2(_objectSpread2({}, jsonValues), {}, {
         tags: Array.from(tags),
         meta: this.meta
@@ -3701,7 +3699,7 @@ var State = /*#__PURE__*/function () {
       if (dev_dist_xstateDev.IS_PRODUCTION) {
         warn(!!this.machine, "state.can(...) used outside of a machine-created State object; this will always return false.");
       }
-      var transitionData = this.machine.getTransitionData(this, toSCXMLEvent(event));
+      var transitionData = this.machine.getTransitionData(this, event);
       return !!(transitionData !== null && transitionData !== void 0 && transitionData.length) &&
       // Check that at least one transition is not forbidden
       transitionData.some(function (t) {
@@ -3778,7 +3776,7 @@ var State = /*#__PURE__*/function () {
           return new State({
             value: stateValue.value,
             context: context,
-            _event: stateValue._event,
+            event: stateValue.event,
             actions: [],
             meta: {},
             configuration: [],
@@ -3789,13 +3787,13 @@ var State = /*#__PURE__*/function () {
         }
         return stateValue;
       }
-      var _event = createInitEvent({}); // TODO: fix
+      var event = createInitEvent({}); // TODO: fix
 
       var configuration = getConfiguration(getStateNodes(machine.root, stateValue));
       return new State({
         value: stateValue,
         context: context,
-        _event: _event,
+        event: event,
         actions: [],
         meta: undefined,
         configuration: Array.from(configuration),
@@ -3811,11 +3809,11 @@ function cloneState(state) {
   return new State(_objectSpread2(_objectSpread2({}, state), config), state.machine);
 }
 function getPersistedState(state) {
-  var configuration = state.configuration,
-    transitions = state.transitions,
-    tags = state.tags,
-    machine = state.machine,
-    children = state.children,
+  state.configuration;
+    state.transitions;
+    state.tags;
+    state.machine;
+    var children = state.children,
     jsonValues = _objectWithoutProperties(state, _excluded2);
   var childrenJson = {};
   for (var id in children) {
@@ -3830,14 +3828,14 @@ function getPersistedState(state) {
   });
 }
 
-function invoke$1(invokeDef) {
+function invoke(invokeDef) {
   return createDynamicAction({
-    type: invoke,
+    type: invoke$1,
     params: invokeDef
-  }, function (_event, _ref) {
+  }, function (event, _ref) {
     var state = _ref.state,
       actorContext = _ref.actorContext;
-    var type = invoke;
+    var type = invoke$1;
     var id = invokeDef.id,
       src = invokeDef.src;
     var resolvedInvokeAction;
@@ -3864,7 +3862,7 @@ function invoke$1(invokeDef) {
           systemId: invokeDef.systemId,
           input: typeof input === 'function' ? input({
             context: state.context,
-            event: _event.data,
+            event: event,
             self: actorContext === null || actorContext === void 0 ? void 0 : actorContext.self
           }) : input
         });
@@ -3899,7 +3897,7 @@ function invoke$1(invokeDef) {
           var _actorRef$start;
           (_actorRef$start = actorRef.start) === null || _actorRef$start === void 0 ? void 0 : _actorRef$start.call(actorRef);
         } catch (err) {
-          parent.send(error$1(id, err));
+          parent.send(error(id, err));
           return;
         }
       });
@@ -3908,7 +3906,7 @@ function invoke$1(invokeDef) {
   });
 }
 
-function createSpawner(self, machine, context, _event, mutCapturedActions) {
+function createSpawner(self, machine, context, event, mutCapturedActions) {
   return function (src) {
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     if (isString(src)) {
@@ -3924,11 +3922,11 @@ function createSpawner(self, machine, context, _event, mutCapturedActions) {
           parent: self,
           input: typeof input === 'function' ? input({
             context: context,
-            event: _event.data,
+            event: event,
             self: self
           }) : input
         });
-        mutCapturedActions.push(invoke$1({
+        mutCapturedActions.push(invoke({
           id: actorRef.id,
           // @ts-ignore TODO: fix types
           src: actorRef,
@@ -3949,7 +3947,7 @@ function createSpawner(self, machine, context, _event, mutCapturedActions) {
         parent: self,
         input: options.input
       });
-      mutCapturedActions.push(invoke$1({
+      mutCapturedActions.push(invoke({
         // @ts-ignore TODO: fix types
         src: _actorRef,
         ref: _actorRef,
@@ -3967,13 +3965,13 @@ function createSpawner(self, machine, context, _event, mutCapturedActions) {
  *
  * @param assignment An object that represents the partial context to update.
  */
-function assign$1(assignment) {
+function assign(assignment) {
   return createDynamicAction({
-    type: assign,
+    type: assign$1,
     params: {
       assignment: assignment
     }
-  }, function (_event, _ref) {
+  }, function (event, _ref) {
     var _actorContext$self;
     var state = _ref.state,
       action = _ref.action,
@@ -3984,10 +3982,9 @@ function assign$1(assignment) {
     }
     var args = {
       context: state.context,
-      event: _event.data,
+      event: event,
       action: action,
-      _event: _event,
-      spawn: createSpawner(actorContext === null || actorContext === void 0 ? void 0 : actorContext.self, state.machine, state.context, _event, capturedActions),
+      spawn: createSpawner(actorContext === null || actorContext === void 0 ? void 0 : actorContext.self, state.machine, state.context, event, capturedActions),
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : {},
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     };
@@ -4005,7 +4002,7 @@ function assign$1(assignment) {
     return [cloneState(state, {
       context: updatedContext
     }), {
-      type: assign,
+      type: assign$1,
       params: {
         context: updatedContext,
         actions: capturedActions
@@ -4021,15 +4018,15 @@ function assign$1(assignment) {
  * @param eventType The event to raise.
  */
 
-function raise$1(eventOrExpr, options) {
+function raise(eventOrExpr, options) {
   return createDynamicAction({
-    type: raise,
+    type: raise$1,
     params: {
       delay: options ? options.delay : undefined,
       event: eventOrExpr,
       id: options && options.id !== undefined ? options.id : typeof eventOrExpr === 'function' ? eventOrExpr.name : eventOrExpr.type
     }
-  }, function (_event, _ref) {
+  }, function (event, _ref) {
     var _actorContext$self;
     var state = _ref.state,
       actorContext = _ref.actorContext;
@@ -4040,15 +4037,17 @@ function raise$1(eventOrExpr, options) {
     };
     var args = {
       context: state.context,
-      event: _event.data,
-      _event: _event,
+      event: event,
       self: (_actorContext$self = actorContext === null || actorContext === void 0 ? void 0 : actorContext.self) !== null && _actorContext$self !== void 0 ? _actorContext$self : {},
       system: actorContext === null || actorContext === void 0 ? void 0 : actorContext.system
     };
     var delaysMap = state.machine.options.delays;
 
     // TODO: helper function for resolving Expr
-    var resolvedEvent = toSCXMLEvent(typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr);
+    if (typeof eventOrExpr === 'string') {
+      throw new Error("Only event objects may be used with raise; use raise({ type: \"".concat(eventOrExpr, "\" }) instead"));
+    }
+    var resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr;
     var resolvedDelay;
     if (typeof params.delay === 'string') {
       var configDelay = delaysMap && delaysMap[params.delay];
@@ -4057,10 +4056,9 @@ function raise$1(eventOrExpr, options) {
       resolvedDelay = typeof params.delay === 'function' ? params.delay(args) : params.delay;
     }
     var resolvedAction = {
-      type: raise,
+      type: raise$1,
       params: _objectSpread2(_objectSpread2({}, params), {}, {
-        _event: resolvedEvent,
-        event: resolvedEvent.data,
+        event: resolvedEvent,
         delay: resolvedDelay
       }),
       execute: function execute(actorCtx) {
@@ -4074,23 +4072,23 @@ function raise$1(eventOrExpr, options) {
   });
 }
 
-function choose$1(guards) {
+function choose(guards) {
   return createDynamicAction({
-    type: choose,
+    type: choose$1,
     params: {
       guards: guards
     }
-  }, function (_event, _ref) {
+  }, function (event, _ref) {
     var _guards$find;
     var state = _ref.state;
     var matchedActions = (_guards$find = guards.find(function (condition) {
       var guard = condition.guard && toGuardDefinition(condition.guard, function (guardType) {
         return state.machine.options.guards[guardType];
       });
-      return !guard || evaluateGuard(guard, state.context, _event, state);
+      return !guard || evaluateGuard(guard, state.context, event, state);
     })) === null || _guards$find === void 0 ? void 0 : _guards$find.actions;
     return [state, {
-      type: choose,
+      type: choose$1,
       params: {
         actions: toActionObjects(matchedActions)
       }
@@ -4098,9 +4096,30 @@ function choose$1(guards) {
   });
 }
 
-var initEvent = toSCXMLEvent({
+function pure(getActions) {
+  return createDynamicAction({
+    type: pure$1,
+    params: {
+      get: getActions
+    }
+  }, function (event, _ref) {
+    var _toArray;
+    var state = _ref.state;
+    return [state, {
+      type: pure$1,
+      params: {
+        actions: (_toArray = toArray(toActionObjects(getActions({
+          context: state.context,
+          event: event
+        })))) !== null && _toArray !== void 0 ? _toArray : []
+      }
+    }];
+  });
+}
+
+var initEvent = {
   type: init
-});
+};
 function resolveActionObject(actionObject, actionFunctionMap) {
   if (isDynamicAction(actionObject)) {
     return actionObject;
@@ -4111,7 +4130,7 @@ function resolveActionObject(actionObject, actionFunctionMap) {
     return createDynamicAction({
       type: 'xstate.function',
       params: (_actionObject$params = actionObject.params) !== null && _actionObject$params !== void 0 ? _actionObject$params : {}
-    }, function (_event, _ref) {
+    }, function (event, _ref) {
       var state = _ref.state;
       var a = {
         type: actionObject.type,
@@ -4119,9 +4138,8 @@ function resolveActionObject(actionObject, actionFunctionMap) {
         execute: function execute(actorCtx) {
           return dereferencedAction({
             context: state.context,
-            event: state.event,
+            event: event,
             action: a,
-            _event: state._event,
             system: actorCtx.system,
             self: actorCtx.self
           });
@@ -4150,7 +4168,7 @@ function toActionObject(action) {
     return createDynamicAction({
       type: type,
       params: {}
-    }, function (_event, _ref2) {
+    }, function (event, _ref2) {
       var state = _ref2.state;
       var actionObject = {
         type: type,
@@ -4160,9 +4178,8 @@ function toActionObject(action) {
         execute: function execute(actorCtx) {
           return action({
             context: state.context,
-            event: _event.data,
+            event: event,
             action: actionObject,
-            _event: _event,
             self: actorCtx.self,
             system: actorCtx.system
           });
@@ -4190,7 +4207,7 @@ var toActionObjects = function toActionObjects(action) {
  * @param delayRef The delay in milliseconds
  * @param id The state node ID where this event is handled
  */
-function after$1(delayRef, id) {
+function after(delayRef, id) {
   var idSuffix = id ? "#".concat(id) : '';
   return "".concat(exports.ActionTypes.After, "(").concat(delayRef, ")").concat(idSuffix);
 }
@@ -4234,7 +4251,7 @@ function doneInvoke(invokeId, output) {
   };
   return eventObject;
 }
-function error$1(id, data) {
+function error(id, data) {
   var type = "".concat(exports.ActionTypes.ErrorPlatform, ".").concat(id);
   var eventObject = {
     type: type,
@@ -4246,10 +4263,10 @@ function error$1(id, data) {
   return eventObject;
 }
 function createInitEvent(input) {
-  return toSCXMLEvent({
+  return {
     type: init,
     input: input
-  });
+  };
 }
 
 exports.Interpreter = Interpreter;
@@ -4265,18 +4282,18 @@ exports._objectWithoutProperties = _objectWithoutProperties;
 exports._slicedToArray = _slicedToArray;
 exports._toConsumableArray = _toConsumableArray;
 exports.actionTypes = actionTypes;
-exports.after = after$1;
+exports.after = after;
 exports.and = and;
-exports.assign = assign$1;
-exports.cancel = cancel$1;
-exports.choose = choose$1;
-exports.createDynamicAction = createDynamicAction;
+exports.assign = assign;
+exports.cancel = cancel;
+exports.choose = choose;
+exports.createEmptyActor = createEmptyActor;
 exports.createInitEvent = createInitEvent;
 exports.createInvokeId = createInvokeId;
 exports.createSpawner = createSpawner;
 exports.done = done;
 exports.doneInvoke = doneInvoke;
-exports.error = error$1;
+exports.error = error;
 exports.escalate = escalate;
 exports.evaluateGuard = evaluateGuard;
 exports.flatten = flatten;
@@ -4298,14 +4315,14 @@ exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.initEvent = initEvent;
 exports.interpret = interpret;
-exports.invoke = invoke;
+exports.invoke = invoke$1;
 exports.isActorRef = isActorRef;
+exports.isErrorEvent = isErrorEvent;
 exports.isInFinalState = isInFinalState;
-exports.isSCXMLErrorEvent = isSCXMLErrorEvent;
 exports.isSignal = isSignal;
 exports.isStateId = isStateId;
 exports.isString = isString;
-exports.log = log$1;
+exports.log = log;
 exports.macrostep = macrostep;
 exports.mapValues = mapValues;
 exports.matchesState = matchesState;
@@ -4315,19 +4332,18 @@ exports.not = not;
 exports.or = or;
 exports.pathToStateValue = pathToStateValue;
 exports.pure = pure;
-exports.raise = raise$1;
+exports.raise = raise;
 exports.resolveActionObject = resolveActionObject;
 exports.resolveActionsAndContext = resolveActionsAndContext;
 exports.resolveReferencedActor = resolveReferencedActor;
 exports.resolveStateValue = resolveStateValue;
-exports.respond = respond;
-exports.send = send$1;
+exports.send = send;
 exports.sendParent = sendParent;
 exports.sendTo = sendTo;
 exports.startSignal = startSignal;
 exports.startSignalType = startSignalType;
 exports.stateIn = stateIn;
-exports.stop = stop$1;
+exports.stop = stop;
 exports.stopSignal = stopSignal;
 exports.stopSignalType = stopSignalType;
 exports.toActionObject = toActionObject;
@@ -4337,6 +4353,5 @@ exports.toArray = toArray;
 exports.toGuardDefinition = toGuardDefinition;
 exports.toInvokeConfig = toInvokeConfig;
 exports.toObserver = toObserver;
-exports.toSCXMLEvent = toSCXMLEvent;
 exports.toTransitionConfigArray = toTransitionConfigArray;
 exports.transitionNode = transitionNode;