xstate 5.0.0-beta.7 → 5.0.0-beta.9

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/interpreter.d.ts

@@ -1,5 +1,5 @@
 import { symbolObservable } from './symbolObservable.ts';
-import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes.ts';
+import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from './typegenTypes.ts';
 import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from './types.ts';
 import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, Subscription } from './types.ts';
 export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
@@ -77,6 +77,7 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
      */
     stop(): this;
     private _complete;
+    private _error;
     private _stopProcedure;
     /**
      * Sends an event to the running interpreter to trigger a transition.
@@ -100,5 +101,5 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
  * @param machine The machine to interpret
  * @param options Interpreter options
  */
-export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
+export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
 export declare function interpret<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): Interpreter<TBehavior>;

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

@@ -1,4 +1,4 @@
-import { EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
+import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
@@ -86,6 +86,12 @@ export type TypegenConstraint = TypegenEnabled | TypegenDisabled;
 export type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
     [K in keyof TMissingImplementations]: TMissingImplementations[K];
 }>> extends true ? true : false : true;
+export type MissingImplementationsError<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<[
+    'Some implementations missing',
+    Values<{
+        [K in keyof TMissingImplementations]: TMissingImplementations[K];
+    }>
+]>;
 interface AllImplementationsProvided {
     missingImplementations: {
         actions: never;

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

@@ -92,7 +92,7 @@ export type ActionFunction<TContext extends MachineContext, TExpressionEvent ext
     event: TExpressionEvent;
 } & ActionMeta<TEvent, TAction>) => void;
 export interface ChooseCondition<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> {
-    guard?: GuardConfig<TContext, TEvent>;
+    guard?: GuardConfig<TContext, TExpressionEvent>;
     actions: Actions<TContext, TExpressionEvent, TEvent>;
 }
 export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = ActionType | ParameterizedObject | ActionFunction<TContext, TExpressionEvent, ParameterizedObject, TEvent> | BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, any, any>;
@@ -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';
@@ -1010,6 +1010,7 @@ export type InferEvent<E extends EventObject> = {
 }[E['type']];
 export type TODO = any;
 export type StateValueFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['matches']>[0];
+export type TagsFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['hasTag']>[0];
 export type StateFromMachine<TMachine extends AnyStateMachine> = TMachine['initialState'];
 export interface ActorSystemInfo {
     actors: Record<string, AnyActorRef>;

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/index-0f3fdf0c.cjs.prod.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var IS_PRODUCTION =         "production" === 'production';
+
+// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
+function getGlobal() {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  }
+  if (typeof self !== 'undefined') {
+    return self;
+  }
+  if (typeof window !== 'undefined') {
+    return window;
+  }
+  if (typeof global !== 'undefined') {
+    return global;
+  }
+  if (!IS_PRODUCTION) {
+    console.warn('XState could not find a global object in this environment. Please let the maintainers know and raise an issue here: https://github.com/statelyai/xstate/issues');
+  }
+}
+function getDevTools() {
+  var w = getGlobal();
+  if (!!w.__xstate__) {
+    return w.__xstate__;
+  }
+  return undefined;
+}
+function registerService(service) {
+  if (typeof window === 'undefined') {
+    return;
+  }
+  var devTools = getDevTools();
+  if (devTools) {
+    devTools.register(service);
+  }
+}
+var devToolsAdapter = function devToolsAdapter(service) {
+  if (typeof window === 'undefined') {
+    return;
+  }
+  var devTools = getDevTools();
+  if (devTools) {
+    devTools.register(service);
+  }
+};
+
+exports.IS_PRODUCTION = IS_PRODUCTION;
+exports.devToolsAdapter = devToolsAdapter;
+exports.getGlobal = getGlobal;
+exports.registerService = registerService;

package/dist/xstate.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index.js";
+//# sourceMappingURL=xstate.cjs.d.mts.map

package/dist/xstate.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xstate.cjs.d.mts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}

package/dist/xstate.cjs.d.ts

@@ -1 +1,2 @@
 export * from "./declarations/src/index";
+//# sourceMappingURL=xstate.cjs.d.ts.map

package/dist/xstate.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xstate.cjs.d.ts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}

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-b6357569.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 () {
@@ -235,9 +214,9 @@ var StateNode = /*#__PURE__*/function () {
             id: resolvedId,
             systemId: systemId,
             toJSON: function toJSON() {
-              var onDone = invokeConfig.onDone,
-                onError = invokeConfig.onError,
-                invokeDefValues = actors_dist_xstateActors._objectWithoutProperties(invokeConfig, _excluded);
+              invokeConfig.onDone;
+                invokeConfig.onError;
+                var invokeDefValues = actors_dist_xstateActors._objectWithoutProperties(invokeConfig, _excluded);
               return actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, invokeDefValues), {}, {
                 type: actors_dist_xstateActors.invoke,
                 src: resolvedSrc,
@@ -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);
@@ -832,12 +806,12 @@ var SimulatedClock = /*#__PURE__*/function () {
     value: function flushTimeouts() {
       var _this = this;
       actors_dist_xstateActors._toConsumableArray(this.timeouts).sort(function (_ref, _ref2) {
-        var _ref3 = actors_dist_xstateActors._slicedToArray(_ref, 2),
-          _idA = _ref3[0],
-          timeoutA = _ref3[1];
-        var _ref4 = actors_dist_xstateActors._slicedToArray(_ref2, 2),
-          _idB = _ref4[0],
-          timeoutB = _ref4[1];
+        var _ref3 = actors_dist_xstateActors._slicedToArray(_ref, 2);
+          _ref3[0];
+          var timeoutA = _ref3[1];
+        var _ref4 = actors_dist_xstateActors._slicedToArray(_ref2, 2);
+          _ref4[0];
+          var timeoutB = _ref4[1];
         var endA = timeoutA.start + timeoutA.timeout;
         var endB = timeoutB.start + timeoutB.timeout;
         return endB > endA ? -1 : 1;
@@ -861,61 +835,116 @@ 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 () {
-    return actors_dist_xstateActors.ActionTypes;
-  }
+  get: function () { return actors_dist_xstateActors.ActionTypes; }
 });
 exports.Interpreter = actors_dist_xstateActors.Interpreter;
 Object.defineProperty(exports, 'InterpreterStatus', {
   enumerable: true,
-  get: function () {
-    return actors_dist_xstateActors.ActorStatus;
-  }
+  get: function () { return actors_dist_xstateActors.ActorStatus; }
 });
 Object.defineProperty(exports, 'SpecialTargets', {
   enumerable: true,
-  get: function () {
-    return actors_dist_xstateActors.SpecialTargets;
-  }
+  get: function () { return actors_dist_xstateActors.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;

package/dist/xstate.cjs.mjs

@@ -0,0 +1,39 @@
+export {
+  ActionTypes,
+  Interpreter,
+  InterpreterStatus,
+  SimulatedClock,
+  SpecialTargets,
+  State,
+  StateMachine,
+  StateNode,
+  and,
+  assign,
+  cancel,
+  choose,
+  createMachine,
+  doneInvoke,
+  forwardTo,
+  fromCallback,
+  fromEventObservable,
+  fromObservable,
+  fromPromise,
+  fromTransition,
+  getStateNodes,
+  interpret,
+  log,
+  mapState,
+  matchesState,
+  not,
+  or,
+  pathToStateValue,
+  pure,
+  raise,
+  sendParent,
+  sendTo,
+  stateIn,
+  stop,
+  toObserver,
+  toSCXMLEvent,
+  waitFor
+} from "./xstate.cjs.js";