xstate 5.0.0-beta.7 → 5.0.0-beta.8

package/dist/{actions-0fcf4fd9.cjs.dev.js → actions-d06ca158.cjs.dev.js}

@@ -535,6 +535,9 @@ function send$1(eventOrExpr, options) {
     var delaysMap = state.machine.options.delays;
 
     // TODO: helper function for resolving Expr
+    if (typeof eventOrExpr === 'string') {
+      throw new Error("Only event objects may be used with sendTo; use sendTo({ type: \"".concat(eventOrExpr, "\" }) instead"));
+    }
     var resolvedEvent = toSCXMLEvent(isFunction(eventOrExpr) ? eventOrExpr(args) : eventOrExpr);
     var resolvedDelay;
     if (isString(params.delay)) {
@@ -832,25 +835,28 @@ promiseCreator) {
   var behavior = {
     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) {
         case resolveEventType:
-          state.status = 'done';
-          state.data = eventObject.data;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'done',
+            data: eventObject.data,
+            input: undefined
+          });
         case rejectEventType:
-          state.status = 'error';
-          state.data = eventObject.data;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'error',
+            data: eventObject.data,
+            input: undefined
+          });
         case stopSignalType:
-          state.canceled = true;
-          delete state.input;
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            status: 'canceled',
+            input: undefined
+          });
         default:
           return state;
       }
@@ -879,7 +885,6 @@ promiseCreator) {
     },
     getInitialState: function getInitialState(_, input) {
       return {
-        canceled: false,
         status: 'active',
         data: undefined,
         input: input
@@ -914,12 +919,11 @@ function fromObservable(observableCreator) {
         id = _ref.id,
         defer = _ref.defer;
       var _event = toSCXMLEvent(event);
-      if (state.canceled) {
+      if (state.status !== 'active') {
         return state;
       }
       switch (_event.name) {
         case nextEventType:
-          state.data = event.data.data;
           // match the exact timing of events sent by machines
           // send actions are not executed immediately
           defer(function () {
@@ -931,21 +935,29 @@ function fromObservable(observableCreator) {
               origin: self
             }));
           });
-          return state;
+          return _objectSpread2(_objectSpread2({}, state), {}, {
+            data: event.data.data
+          });
         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.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 +965,6 @@ function fromObservable(observableCreator) {
     getInitialState: function getInitialState(_, input) {
       return {
         subscription: undefined,
-        canceled: false,
         status: 'active',
         data: undefined,
         input: input
@@ -991,12 +1002,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
@@ -1031,24 +1040,30 @@ function fromEventObservable(lazyObservable) {
   var behavior = {
     transition: function transition(state, event) {
       var _event = toSCXMLEvent(event);
-      if (state.canceled) {
+      if (state.status !== 'active') {
         return state;
       }
       switch (_event.name) {
         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.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 +1071,6 @@ function fromEventObservable(lazyObservable) {
     getInitialState: function getInitialState() {
       return {
         subscription: undefined,
-        canceled: false,
         status: 'active',
         data: undefined
       };
@@ -1093,12 +1107,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
@@ -1132,7 +1144,7 @@ function fromCallback(invokeCallback) {
         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
@@ -1247,6 +1259,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;
@@ -1650,6 +1668,9 @@ var Interpreter = /*#__PURE__*/function () {
   }, {
     key: "send",
     value: function send(event) {
+      if (typeof event === 'string') {
+        throw new Error("Only event objects may be sent to actors; use .send({ type: \"".concat(event, "\" }) instead"));
+      }
       var _event = toSCXMLEvent(event);
       if (this.status === exports.ActorStatus.Stopped) {
         // do nothing
@@ -2256,7 +2277,7 @@ 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({
+    stateNode.entry.push(raise$1({
       type: eventType
     }, {
       delay: delay
@@ -4048,6 +4069,9 @@ function raise$1(eventOrExpr, options) {
     var delaysMap = state.machine.options.delays;
 
     // TODO: helper function for resolving Expr
+    if (typeof eventOrExpr === 'string') {
+      throw new Error("Only event objects may be used with raise; use raise({ type: \"".concat(eventOrExpr, "\" }) instead"));
+    }
     var resolvedEvent = toSCXMLEvent(typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr);
     var resolvedDelay;
     if (typeof params.delay === 'string') {
@@ -4098,6 +4122,27 @@ function choose$1(guards) {
   });
 }
 
+function pure$1(getActions) {
+  return createDynamicAction({
+    type: pure,
+    params: {
+      get: getActions
+    }
+  }, function (_event, _ref) {
+    var _toArray;
+    var state = _ref.state;
+    return [state, {
+      type: pure,
+      params: {
+        actions: (_toArray = toArray(toActionObjects(getActions({
+          context: state.context,
+          event: _event.data
+        })))) !== null && _toArray !== void 0 ? _toArray : []
+      }
+    }];
+  });
+}
+
 var initEvent = toSCXMLEvent({
   type: init
 });
@@ -4270,7 +4315,7 @@ exports.and = and;
 exports.assign = assign$1;
 exports.cancel = cancel$1;
 exports.choose = choose$1;
-exports.createDynamicAction = createDynamicAction;
+exports.createEmptyActor = createEmptyActor;
 exports.createInitEvent = createInitEvent;
 exports.createInvokeId = createInvokeId;
 exports.createSpawner = createSpawner;
@@ -4314,7 +4359,7 @@ exports.microstep = microstep;
 exports.not = not;
 exports.or = or;
 exports.pathToStateValue = pathToStateValue;
-exports.pure = pure;
+exports.pure = pure$1;
 exports.raise = raise$1;
 exports.resolveActionObject = resolveActionObject;
 exports.resolveActionsAndContext = resolveActionsAndContext;

package/dist/declarations/src/StateMachine.d.ts

@@ -1,7 +1,7 @@
 import { State } from './State.ts';
 import { StateNode } from './StateNode.ts';
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.ts';
-import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
@@ -21,7 +21,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      */
     delimiter: string;
     options: MachineImplementationsSimplified<TContext, TEvent>;
-    schema: MachineSchema<TContext, TEvent>;
+    types: MachineTypes<TContext, TEvent>;
     __xstatenode: true;
     idMap: Map<string, StateNode<TContext, TEvent>>;
     root: StateNode<TContext, TEvent>;

package/dist/declarations/src/actions.d.ts

@@ -7,6 +7,7 @@ export { cancel } from './actions/cancel.ts';
 export { assign } from './actions/assign.ts';
 export { raise } from './actions/raise.ts';
 export { choose } from './actions/choose.ts';
+export { pure } from './actions/pure.ts';
 export { actionTypes };
 export declare const initEvent: SCXML.Event<{
     type: ActionTypes;

package/dist/declarations/src/actors/index.d.ts

@@ -1,4 +1,4 @@
-import type { EventObject, ActorRef, BaseActorRef } from '../types.ts';
+import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from '../types.ts';
 export { fromTransition } from './transition.ts';
 export { fromPromise } from './promise.ts';
 export { fromObservable, fromEventObservable } from './observable.ts';
@@ -25,3 +25,4 @@ export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType
 export declare function isSignal(eventType: string): eventType is LifecycleSignalType;
 export declare function isActorRef(item: any): item is ActorRef<any>;
 export declare function toActorRef<TEvent extends EventObject, TSnapshot = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TSnapshot> & Omit<TActorRefLike, keyof ActorRef<any, any>>;
+export declare function createEmptyActor(): ActorRef<AnyEventObject, undefined>;

package/dist/declarations/src/actors/observable.d.ts

@@ -1,8 +1,7 @@
 import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
 export interface ObservableInternalState<T> {
     subscription: Subscription | undefined;
-    canceled: boolean;
-    status: 'active' | 'done' | 'error';
+    status: 'active' | 'done' | 'error' | 'canceled';
     data: T | undefined;
     input?: any;
 }

package/dist/declarations/src/actors/promise.d.ts

@@ -1,7 +1,6 @@
 import { ActorBehavior } from '../types';
 export interface PromiseInternalState<T> {
-    status: 'active' | 'error' | 'done';
-    canceled: boolean;
+    status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;
     input?: any;
 }

package/dist/declarations/src/index.d.ts

@@ -1,42 +1,26 @@
-import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions.ts';
-import { assign } from './actions/assign.ts';
-import { cancel } from './actions/cancel.ts';
-import { choose } from './actions/choose.ts';
-import { log } from './actions/log.ts';
-import { pure } from './actions/pure.ts';
-import { raise } from './actions/raise.ts';
-import { send } from './actions/send.ts';
-import { stop } from './actions/stop.ts';
+import { doneInvoke, forwardTo, sendParent, sendTo } from './actions.ts';
+export { assign } from './actions/assign.ts';
+export { cancel } from './actions/cancel.ts';
+export { choose } from './actions/choose.ts';
+export { log } from './actions/log.ts';
+export { pure } from './actions/pure.ts';
+export { raise } from './actions/raise.ts';
+export { stop } from './actions/stop.ts';
 import { interpret, Interpreter, ActorStatus } from './interpreter.ts';
 import { createMachine } from './Machine.ts';
 import { mapState } from './mapState.ts';
 import { State } from './State.ts';
 import { StateNode } from './StateNode.ts';
-export { createSchema, t } from './schema.ts';
 export { SimulatedClock } from './SimulatedClock.ts';
 export { StateMachine } from './StateMachine.ts';
 export { getStateNodes } from './stateUtils.ts';
+export { waitFor } from './waitFor.ts';
 export * from './typegenTypes.ts';
 export * from './types.ts';
 export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.ts';
-export { StateNode, State, mapState, actions, assign, send, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
-declare const actions: {
-    raise: typeof raise;
-    send: typeof send;
-    sendParent: typeof sendParent;
-    sendTo: typeof sendTo;
-    log: typeof log;
-    cancel: typeof cancel;
-    stop: typeof stop;
-    assign: typeof assign;
-    after: typeof after;
-    done: typeof done;
-    respond: typeof respond;
-    forwardTo: typeof forwardTo;
-    escalate: typeof escalate;
-    choose: typeof choose;
-    pure: typeof pure;
-};
+export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
+export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from './actors/index.ts';
+export { stateIn, not, and, or } from './guards.ts';
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

package/dist/declarations/src/types.d.ts

@@ -490,13 +490,12 @@ export interface MachineConfig<TContext extends MachineContext, TEvent extends E
      * If `true`, will use SCXML semantics, such as event token matching.
      */
     scxml?: boolean;
-    schema?: MachineSchema<TContext, TEvent, TActorMap>;
-    tsTypes?: TTypesMeta;
+    types?: MachineTypes<TContext, TEvent, TActorMap, TTypesMeta>;
 }
 export type ActorMap = Record<string, {
     output: any;
 }>;
-export interface MachineSchema<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends ActorMap = ActorMap> {
+export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta = TypegenDisabled> {
     context?: TContext;
     actions?: {
         type: string;
@@ -508,6 +507,7 @@ export interface MachineSchema<TContext extends MachineContext, TEvent extends E
         type: string;
         [key: string]: any;
     };
+    typegen?: TTypesMeta;
 }
 export interface HistoryStateNode<TContext extends MachineContext> extends StateNode<TContext> {
     history: 'shallow' | 'deep';

package/dist/declarations/src/waitFor.d.ts

@@ -0,0 +1,33 @@
+import { ActorRef, SnapshotFrom } from '.';
+interface WaitForOptions {
+    /**
+     * How long to wait before rejecting, if no emitted
+     * state satisfies the predicate.
+     *
+     * @default 10_000 (10 seconds)
+     */
+    timeout: number;
+}
+/**
+ * Subscribes to an actor ref and waits for its emitted value to satisfy
+ * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
+ *
+ * @example
+ * ```js
+ * const state = await waitFor(someService, state => {
+ *   return state.hasTag('loaded');
+ * });
+ *
+ * state.hasTag('loaded'); // true
+ * ```
+ *
+ * @param actorRef The actor ref to subscribe to
+ * @param predicate Determines if a value matches the condition to wait for
+ * @param options
+ * @returns A promise that eventually resolves to the emitted value
+ * that matches the condition
+ */
+export declare function waitFor<TActorRef extends ActorRef<any, any>>(actorRef: TActorRef, predicate: (emitted: SnapshotFrom<TActorRef>) => boolean, options?: Partial<WaitForOptions>): Promise<SnapshotFrom<TActorRef>>;
+export {};

package/dist/xstate.cjs.dev.js

@@ -2,30 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var actors_dist_xstateActors = require('./actions-0fcf4fd9.cjs.dev.js');
+var actors_dist_xstateActors = require('./actions-d06ca158.cjs.dev.js');
 require('./index-ebaab3c9.cjs.dev.js');
 
-function pure(getActions) {
-  return actors_dist_xstateActors.createDynamicAction({
-    type: actors_dist_xstateActors.pure,
-    params: {
-      get: getActions
-    }
-  }, function (_event, _ref) {
-    var _toArray;
-    var state = _ref.state;
-    return [state, {
-      type: actors_dist_xstateActors.pure,
-      params: {
-        actions: (_toArray = actors_dist_xstateActors.toArray(actors_dist_xstateActors.toActionObjects(getActions({
-          context: state.context,
-          event: _event.data
-        })))) !== null && _toArray !== void 0 ? _toArray : []
-      }
-    }];
-  });
-}
-
 var _excluded = ["onDone", "onError"];
 var EMPTY_OBJECT = {};
 var StateNode = /*#__PURE__*/function () {
@@ -426,13 +405,13 @@ var StateMachine = /*#__PURE__*/function () {
    * The raw config used to create the machine.
    */
   config, options) {
-    var _this$config$schema;
+    var _this$config$types;
     actors_dist_xstateActors._classCallCheck(this, StateMachine);
     this.config = config;
     actors_dist_xstateActors._defineProperty(this, "version", void 0);
     actors_dist_xstateActors._defineProperty(this, "delimiter", void 0);
     actors_dist_xstateActors._defineProperty(this, "options", void 0);
-    actors_dist_xstateActors._defineProperty(this, "schema", void 0);
+    actors_dist_xstateActors._defineProperty(this, "types", void 0);
     actors_dist_xstateActors._defineProperty(this, "__xstatenode", true);
     actors_dist_xstateActors._defineProperty(this, "idMap", new Map());
     actors_dist_xstateActors._defineProperty(this, "root", void 0);
@@ -448,7 +427,7 @@ var StateMachine = /*#__PURE__*/function () {
     this.options = Object.assign(createDefaultOptions(), options);
     this.delimiter = this.config.delimiter || actors_dist_xstateActors.STATE_DELIMITER;
     this.version = this.config.version;
-    this.schema = (_this$config$schema = this.config.schema) !== null && _this$config$schema !== void 0 ? _this$config$schema : {};
+    this.types = (_this$config$types = this.config.types) !== null && _this$config$types !== void 0 ? _this$config$types : {};
     this.transition = this.transition.bind(this);
     this.root = new StateNode(config, {
       _key: this.id,
@@ -780,11 +759,6 @@ function mapState(stateMap, stateId) {
   return stateMap[foundStateId];
 }
 
-function createSchema(schema) {
-  return schema;
-}
-var t = createSchema;
-
 var SimulatedClock = /*#__PURE__*/function () {
   function SimulatedClock() {
     actors_dist_xstateActors._classCallCheck(this, SimulatedClock);
@@ -861,24 +835,73 @@ var SimulatedClock = /*#__PURE__*/function () {
   return SimulatedClock;
 }();
 
-var actions = {
-  raise: actors_dist_xstateActors.raise,
-  send: actors_dist_xstateActors.send,
-  sendParent: actors_dist_xstateActors.sendParent,
-  sendTo: actors_dist_xstateActors.sendTo,
-  log: actors_dist_xstateActors.log,
-  cancel: actors_dist_xstateActors.cancel,
-  stop: actors_dist_xstateActors.stop,
-  assign: actors_dist_xstateActors.assign,
-  after: actors_dist_xstateActors.after,
-  done: actors_dist_xstateActors.done,
-  respond: actors_dist_xstateActors.respond,
-  forwardTo: actors_dist_xstateActors.forwardTo,
-  escalate: actors_dist_xstateActors.escalate,
-  choose: actors_dist_xstateActors.choose,
-  pure: pure
+var defaultWaitForOptions = {
+  timeout: 10000 // 10 seconds
 };
 
+/**
+ * Subscribes to an actor ref and waits for its emitted value to satisfy
+ * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
+ *
+ * @example
+ * ```js
+ * const state = await waitFor(someService, state => {
+ *   return state.hasTag('loaded');
+ * });
+ *
+ * state.hasTag('loaded'); // true
+ * ```
+ *
+ * @param actorRef The actor ref to subscribe to
+ * @param predicate Determines if a value matches the condition to wait for
+ * @param options
+ * @returns A promise that eventually resolves to the emitted value
+ * that matches the condition
+ */
+function waitFor(actorRef, predicate, options) {
+  var resolvedOptions = actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, defaultWaitForOptions), options);
+  return new Promise(function (res, rej) {
+    var done = false;
+    if (process.env.NODE_ENV !== 'production' && resolvedOptions.timeout < 0) {
+      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
+    }
+    var handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(function () {
+      sub.unsubscribe();
+      rej(new Error("Timeout of ".concat(resolvedOptions.timeout, " ms exceeded")));
+    }, resolvedOptions.timeout);
+    var dispose = function dispose() {
+      clearTimeout(handle);
+      done = true;
+      sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+    };
+    function checkEmitted(emitted) {
+      if (predicate(emitted)) {
+        dispose();
+        res(emitted);
+      }
+    }
+
+    // See if the current snapshot already matches the predicate
+    checkEmitted(actorRef.getSnapshot());
+    var sub = actorRef.subscribe({
+      next: checkEmitted,
+      error: function error(err) {
+        dispose();
+        rej(err);
+      },
+      complete: function complete() {
+        dispose();
+        rej(new Error("Actor terminated without satisfying predicate"));
+      }
+    });
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
+}
+
 Object.defineProperty(exports, 'ActionTypes', {
   enumerable: true,
   get: function () {
@@ -899,23 +922,35 @@ Object.defineProperty(exports, 'SpecialTargets', {
   }
 });
 exports.State = actors_dist_xstateActors.State;
+exports.and = actors_dist_xstateActors.and;
 exports.assign = actors_dist_xstateActors.assign;
+exports.cancel = actors_dist_xstateActors.cancel;
+exports.choose = actors_dist_xstateActors.choose;
 exports.doneInvoke = actors_dist_xstateActors.doneInvoke;
 exports.forwardTo = actors_dist_xstateActors.forwardTo;
+exports.fromCallback = actors_dist_xstateActors.fromCallback;
+exports.fromEventObservable = actors_dist_xstateActors.fromEventObservable;
+exports.fromObservable = actors_dist_xstateActors.fromObservable;
+exports.fromPromise = actors_dist_xstateActors.fromPromise;
+exports.fromTransition = actors_dist_xstateActors.fromTransition;
 exports.getStateNodes = actors_dist_xstateActors.getStateNodes;
 exports.interpret = actors_dist_xstateActors.interpret;
+exports.log = actors_dist_xstateActors.log;
 exports.matchesState = actors_dist_xstateActors.matchesState;
+exports.not = actors_dist_xstateActors.not;
+exports.or = actors_dist_xstateActors.or;
 exports.pathToStateValue = actors_dist_xstateActors.pathToStateValue;
-exports.send = actors_dist_xstateActors.send;
+exports.pure = actors_dist_xstateActors.pure;
+exports.raise = actors_dist_xstateActors.raise;
 exports.sendParent = actors_dist_xstateActors.sendParent;
 exports.sendTo = actors_dist_xstateActors.sendTo;
+exports.stateIn = actors_dist_xstateActors.stateIn;
+exports.stop = actors_dist_xstateActors.stop;
 exports.toObserver = actors_dist_xstateActors.toObserver;
 exports.toSCXMLEvent = actors_dist_xstateActors.toSCXMLEvent;
 exports.SimulatedClock = SimulatedClock;
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;
-exports.actions = actions;
 exports.createMachine = createMachine;
-exports.createSchema = createSchema;
 exports.mapState = mapState;
-exports.t = t;
+exports.waitFor = waitFor;