xstate 5.0.0-beta.49 → 5.0.0-beta.51

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

@@ -1,9 +1,10 @@
 export { assign, type AssignAction, type AssignArgs } from "./actions/assign.js";
 export { cancel, type CancelAction } from "./actions/cancel.js";
 export { choose, type ChooseAction } from "./actions/choose.js";
+export { enqueueActions, type EnqueueActionsAction } from "./actions/enqueueActions.js";
 export { log, type LogAction } from "./actions/log.js";
-export { pure, type PureAction } from "./actions/pure.js";
+export { pure } from "./actions/pure.js";
 export { raise, type RaiseAction } from "./actions/raise.js";
 export { escalate, forwardTo, sendParent, sendTo, type SendToAction } from "./actions/send.js";
-export { stop, stopChild, type StopAction } from "./actions/stopChild.js";
 export { spawnChild, type SpawnAction } from "./actions/spawnChild.js";
+export { stop, stopChild, type StopAction } from "./actions/stopChild.js";

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

@@ -1,13 +1,13 @@
-import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot } from "../types.js";
+import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot, NonReducibleUnknown } from "../types.js";
 export type CallbackSnapshot<TInput> = Snapshot<undefined> & {
     input: TInput;
 };
-export type CallbackActorLogic<TEvent extends EventObject, TInput = unknown> = ActorLogic<CallbackSnapshot<TInput>, TEvent, TInput, ActorSystem<any>>;
-export type CallbackActorRef<TEvent extends EventObject, TInput = unknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
+export type CallbackActorLogic<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorLogic<CallbackSnapshot<TInput>, TEvent, TInput, ActorSystem<any>>;
+export type CallbackActorRef<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
 export type Receiver<TEvent extends EventObject> = (listener: {
     bivarianceHack(event: TEvent): void;
 }['bivarianceHack']) => void;
-export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = unknown> = ({ input, system, self, sendBack, receive }: {
+export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown> = ({ input, system, self, sendBack, receive }: {
     /**
      * Data that was provided to the callback actor
      * @see {@link https://stately.ai/docs/input | Input docs}
@@ -88,4 +88,4 @@ export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEve
  * });
  * ```
  */
-export declare function fromCallback<TEvent extends EventObject, TInput = unknown>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput>): CallbackActorLogic<TEvent, TInput>;
+export declare function fromCallback<TEvent extends EventObject, TInput = NonReducibleUnknown>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput>): CallbackActorLogic<TEvent, TInput>;

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

@@ -1,10 +1,10 @@
-import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot } from "../types.js";
-export type ObservableSnapshot<TContext, TInput> = Snapshot<undefined> & {
+import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot, NonReducibleUnknown } from "../types.js";
+export type ObservableSnapshot<TContext, TInput extends NonReducibleUnknown> = Snapshot<undefined> & {
     context: TContext | undefined;
     input: TInput | undefined;
     _subscription: Subscription | undefined;
 };
-export type ObservableActorLogic<TContext, TInput> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
+export type ObservableActorLogic<TContext, TInput extends NonReducibleUnknown> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
     type: string;
     [k: string]: unknown;
 }, TInput, AnyActorSystem>;
@@ -49,7 +49,7 @@ export type ObservableActorRef<TContext> = ActorRefFrom<ObservableActorLogic<TCo
  * @see {@link https://rxjs.dev} for documentation on RxJS Observable and observable creators.
  * @see {@link Subscribable} interface in XState, which is based on and compatible with RxJS Observable.
  */
-export declare function fromObservable<TContext, TInput>(observableCreator: ({ input, system }: {
+export declare function fromObservable<TContext, TInput extends NonReducibleUnknown>(observableCreator: ({ input, system }: {
     input: TInput;
     system: AnyActorSystem;
     self: ObservableActorRef<TContext>;
@@ -98,7 +98,7 @@ export declare function fromObservable<TContext, TInput>(observableCreator: ({ i
  * canvasActor.start();
  * ```
  */
-export declare function fromEventObservable<T extends EventObject, TInput>(lazyObservable: ({ input, system }: {
+export declare function fromEventObservable<T extends EventObject, TInput extends NonReducibleUnknown>(lazyObservable: ({ input, system }: {
     input: TInput;
     system: AnyActorSystem;
     self: ObservableActorRef<T>;

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

@@ -1,5 +1,5 @@
-import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem, Snapshot } from "../types.js";
 import { XSTATE_STOP } from "../constants.js";
+import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem, NonReducibleUnknown, Snapshot } from "../types.js";
 export type PromiseSnapshot<TOutput, TInput> = Snapshot<TOutput> & {
     input: TInput | undefined;
 };
@@ -64,7 +64,7 @@ export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, u
  * // }
  * ```
  */
-export declare function fromPromise<TOutput, TInput = unknown>(promiseCreator: ({ input, system }: {
+export declare function fromPromise<TOutput, TInput = NonReducibleUnknown>(promiseCreator: ({ input, system }: {
     /**
      * Data that was provided to the promise actor
      */

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

@@ -1,8 +1,8 @@
-import { ActorLogic, ActorScope, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot } from "../types.js";
+import { ActorLogic, ActorScope, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot, NonReducibleUnknown } from "../types.js";
 export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
     context: TContext;
 };
-export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>;
+export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput extends NonReducibleUnknown> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>;
 export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>>;
 /**
  * Returns actor logic given a transition function and its initial state.
@@ -62,7 +62,7 @@ export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefF
  * // }
  * ```
  */
-export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput>(transition: (state: TContext, event: TEvent, actorScope: ActorScope<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
+export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput extends NonReducibleUnknown>(transition: (state: TContext, event: TEvent, actorScope: ActorScope<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
     input: TInput;
     self: TransitionActorRef<TContext, TEvent>;
 }) => TContext)): TransitionActorLogic<TContext, TEvent, TInput>;

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

@@ -124,6 +124,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
      */
     stop(): this;
     private _complete;
+    private _reportError;
     private _error;
     private _stopProcedure;
     /**

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

@@ -1,7 +1,7 @@
 import { StateMachine } from "./StateMachine.js";
 import { GuardPredicate } from "./guards.js";
 import { ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import { ActionFunction, AnyActorLogic, AnyActorRef, AnyEventObject, Cast, ConditionalRequired, DelayConfig, Invert, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateSchema, ToChildren, Values } from "./types.js";
+import { ActionFunction, AnyActorLogic, AnyActorRef, AnyEventObject, Cast, ConditionalRequired, DelayConfig, Invert, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateSchema, ToChildren, UnknownActorLogic, Values } from "./types.js";
 type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
     [K in keyof TParameterizedMap & string]: {
         type: K;
@@ -33,7 +33,7 @@ type ToStateValue<T extends StateSchema> = T extends {
     type: 'parallel';
 } ? true : false> : never) : {};
 export declare function setup<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
-TActors extends Record<Values<TChildrenMap>, AnyActorLogic>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TChildrenMap extends Record<string, string> = never>({ actors, actions, guards, delays }: {
+TActors extends Record<Values<TChildrenMap>, UnknownActorLogic>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TChildrenMap extends Record<string, string> = never>({ actors, actions, guards, delays }: {
     types?: SetupTypes<TContext, TEvent, TChildrenMap, TTag, TInput, TOutput>;
     actors?: TActors;
     actions?: {

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

@@ -736,7 +736,7 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot extends Snapshot
     id: string;
     sessionId: string;
     send: (event: TEvent) => void;
-    start?: () => void;
+    start: () => void;
     getSnapshot: () => TSnapshot;
     getPersistedState: () => Snapshot<unknown>;
     stop: () => void;
@@ -800,7 +800,7 @@ export type Snapshot<TOutput> = {
  * @template TInput - The type of the input.
  * @template TSystem - The type of the actor system.
  */
-export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = unknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = NonReducibleUnknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
     /** The initial setup/configuration used to create the actor logic. */
     config?: unknown;
     /**
@@ -811,7 +811,7 @@ export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends
      * @param ctx - The actor scope.
      * @returns The new state.
      */
-    transition: (state: TSnapshot, message: TEvent, ctx: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
+    transition: (snapshot: TSnapshot, message: TEvent, ctx: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
     /**
      * Called to provide the initial state of the actor.
      * @param actorScope - The actor scope.
@@ -845,6 +845,8 @@ export type AnyActorLogic = ActorLogic<any, // snapshot
 any, // event
 any, // input
 any>;
+export type UnknownActorLogic = ActorLogic<any, // this is invariant and it's hard to figure out a better default than `any`
+EventObject, NonReducibleUnknown, ActorSystem<any>>;
 export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends ActorLogic<infer _, infer __, infer ___, infer ____> ? ReturnType<R['transition']> : R extends ActorScope<infer TSnapshot, infer _, infer __> ? TSnapshot : never : never;
 export type EventFromLogic<TLogic extends ActorLogic<any, any, any, any>> = TLogic extends ActorLogic<infer _, infer TEvent, infer __, infer _____> ? TEvent : never;
 type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;

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

@@ -1,6 +1,5 @@
 import type { StateNode } from "./StateNode.js";
-import type { ActorLogic, AnyEventObject, EventObject, MachineContext, Mapper, Observer, ErrorActorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfigTarget, AnyActorRef, AnyTransitionConfig, NonReducibleUnknown, AnyStateMachine, AnyMachineSnapshot } from "./types.js";
-export declare function keys<T extends object>(value: T): Array<keyof T & string>;
+import type { ActorLogic, AnyActorRef, AnyEventObject, AnyMachineSnapshot, AnyStateMachine, AnyTransitionConfig, ErrorActorEvent, EventObject, MachineContext, Mapper, NonReducibleUnknown, Observer, SingleOrArray, StateLike, StateValue, TransitionConfigTarget } from "./types.js";
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue): boolean;
 export declare function toStatePath(stateId: string | string[]): string[];
 export declare function toStateValue(stateValue: StateLike<any> | StateValue): StateValue;
@@ -8,32 +7,14 @@ export declare function pathToStateValue(statePath: string[]): StateValue;
 export declare function mapValues<P, O extends Record<string, unknown>>(collection: O, iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P): {
     [key in keyof O]: P;
 };
-export declare function mapFilterValues<T, P>(collection: {
-    [key: string]: T;
-}, iteratee: (item: T, key: string, collection: {
-    [key: string]: T;
-}) => P, predicate: (item: T) => boolean): {
-    [key: string]: P;
-};
-/**
- * Retrieves a value at the given path.
- * @param props The deep path to the prop of the desired value
- */
-export declare function path<T extends Record<string, any>>(props: string[]): any;
-export declare function toStatePaths(stateValue: StateValue | undefined): string[][];
 export declare function toArrayStrict<T>(value: readonly T[] | T): readonly T[];
 export declare function toArray<T>(value: readonly T[] | T | undefined): readonly T[];
 export declare function resolveOutput<TContext extends MachineContext, TExpressionEvent extends EventObject>(mapper: Mapper<TContext, TExpressionEvent, unknown, EventObject> | NonReducibleUnknown, context: TContext, event: TExpressionEvent, self: AnyActorRef): unknown;
-export declare function isBuiltInEvent(eventType: string): boolean;
-export declare function isPromiseLike(value: any): value is PromiseLike<any>;
 export declare function isActorLogic(value: any): value is ActorLogic<any, any>;
-export declare function partition<T, A extends T, B extends T>(items: T[], predicate: (item: T) => item is A): [A[], B[]];
 export declare function isArray(value: any): value is readonly any[];
-export declare function isObservable<T>(value: any): value is Subscribable<T>;
 export declare function isErrorActorEvent(event: AnyEventObject): event is ErrorActorEvent;
 export declare function toTransitionConfigArray<TContext extends MachineContext, TEvent extends EventObject>(configLike: SingleOrArray<AnyTransitionConfig | TransitionConfigTarget>): Array<AnyTransitionConfig>;
 export declare function normalizeTarget<TContext extends MachineContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, TEvent>> | undefined): ReadonlyArray<string | StateNode<TContext, TEvent>> | undefined;
-export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
 export declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;
 export declare function resolveReferencedActor(machine: AnyStateMachine, src: string): any;

package/dist/{send-0a381ca2.development.esm.js → pure-296f8ebd.development.esm.js}

@@ -1,4 +1,4 @@
-import { U as ProcessingStatus, V as createErrorActorEvent, B as resolveReferencedActor, C as createActor, p as cloneMachineSnapshot, e as evaluateGuard, t as toArray, W as XSTATE_ERROR } from './raise-1873c645.development.esm.js';
+import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, e as evaluateGuard, t as toArray, U as XSTATE_ERROR, V as createErrorActorEvent, L as cancel, M as raise, O as spawnChild, Q as stopChild } from './raise-acaa3884.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -47,12 +47,7 @@ function createSpawner(actorScope, {
       if (actorRef._processingStatus === ProcessingStatus.Stopped) {
         return;
       }
-      try {
-        actorRef.start?.();
-      } catch (err) {
-        actorScope.self.send(createErrorActorEvent(actorRef.id, err));
-        return;
-      }
+      actorRef.start();
     });
     return actorRef;
   };
@@ -127,75 +122,6 @@ function choose(branches) {
   return choose;
 }
 
-function resolveLog(_, state, actionArgs, actionParams, {
-  value,
-  label
-}) {
-  return [state, {
-    value: typeof value === 'function' ? value(actionArgs, actionParams) : value,
-    label
-  }];
-}
-function executeLog({
-  logger
-}, {
-  value,
-  label
-}) {
-  if (label) {
-    logger(label, value);
-  } else {
-    logger(value);
-  }
-}
-/**
- *
- * @param expr The expression function to evaluate which will be logged.
- *  Takes in 2 arguments:
- *  - `ctx` - the current state context
- *  - `event` - the event that caused this action to be executed.
- * @param label The label to give to the logged expression.
- */
-function log(value = ({
-  context,
-  event
-}) => ({
-  context,
-  event
-}), label) {
-  function log(args, params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  log.type = 'xstate.log';
-  log.value = value;
-  log.label = label;
-  log.resolve = resolveLog;
-  log.execute = executeLog;
-  return log;
-}
-
-function resolvePure(_, state, args, _actionParams, {
-  get
-}) {
-  return [state, undefined, toArray(get({
-    context: args.context,
-    event: args.event
-  }))];
-}
-function pure(getActions) {
-  function pure(args, params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  pure.type = 'xstate.pure';
-  pure.get = getActions;
-  pure.resolve = resolvePure;
-  return pure;
-}
-
 /**
  *
  * @remarks
@@ -399,4 +325,115 @@ function escalate(errorData, options) {
   }, options);
 }
 
-export { SpecialTargets as S, assign as a, sendTo as b, choose as c, escalate as e, forwardTo as f, log as l, pure as p, sendParent as s };
+function resolveEnqueueActions(_, state, args, _actionParams, {
+  collect
+}) {
+  const actions = [];
+  const enqueue = function enqueue(action) {
+    actions.push(action);
+  };
+  enqueue.assign = (...args) => {
+    actions.push(assign(...args));
+  };
+  enqueue.cancel = (...args) => {
+    actions.push(cancel(...args));
+  };
+  enqueue.raise = (...args) => {
+    actions.push(raise(...args));
+  };
+  enqueue.sendTo = (...args) => {
+    actions.push(sendTo(...args));
+  };
+  enqueue.spawnChild = (...args) => {
+    actions.push(spawnChild(...args));
+  };
+  enqueue.stopChild = (...args) => {
+    actions.push(stopChild(...args));
+  };
+  collect({
+    context: args.context,
+    event: args.event,
+    enqueue,
+    check: guard => evaluateGuard(guard, state.context, args.event, state)
+  });
+  return [state, undefined, actions];
+}
+function enqueueActions(collect) {
+  function enqueueActions(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  enqueueActions.type = 'xstate.enqueueActions';
+  enqueueActions.collect = collect;
+  enqueueActions.resolve = resolveEnqueueActions;
+  return enqueueActions;
+}
+
+function resolveLog(_, state, actionArgs, actionParams, {
+  value,
+  label
+}) {
+  return [state, {
+    value: typeof value === 'function' ? value(actionArgs, actionParams) : value,
+    label
+  }];
+}
+function executeLog({
+  logger
+}, {
+  value,
+  label
+}) {
+  if (label) {
+    logger(label, value);
+  } else {
+    logger(value);
+  }
+}
+/**
+ *
+ * @param expr The expression function to evaluate which will be logged.
+ *  Takes in 2 arguments:
+ *  - `ctx` - the current state context
+ *  - `event` - the event that caused this action to be executed.
+ * @param label The label to give to the logged expression.
+ */
+function log(value = ({
+  context,
+  event
+}) => ({
+  context,
+  event
+}), label) {
+  function log(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  log.type = 'xstate.log';
+  log.value = value;
+  log.label = label;
+  log.resolve = resolveLog;
+  log.execute = executeLog;
+  return log;
+}
+
+/**
+ *
+ * @deprecated Use `enqueueActions(...)` instead
+ */
+function pure(getActions) {
+  return enqueueActions(({
+    context,
+    event,
+    enqueue
+  }) => {
+    toArray(getActions({
+      context,
+      event
+    })).forEach(enqueue);
+  });
+}
+
+export { SpecialTargets as S, assign as a, escalate as b, choose as c, sendTo as d, enqueueActions as e, forwardTo as f, log as l, pure as p, sendParent as s };

package/dist/{send-8d30b415.development.cjs.js → pure-a0f16134.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-495f4b9f.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-528386de.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -49,12 +49,7 @@ function createSpawner(actorScope, {
       if (actorRef._processingStatus === guards_dist_xstateGuards.ProcessingStatus.Stopped) {
         return;
       }
-      try {
-        actorRef.start?.();
-      } catch (err) {
-        actorScope.self.send(guards_dist_xstateGuards.createErrorActorEvent(actorRef.id, err));
-        return;
-      }
+      actorRef.start();
     });
     return actorRef;
   };
@@ -129,75 +124,6 @@ function choose(branches) {
   return choose;
 }
 
-function resolveLog(_, state, actionArgs, actionParams, {
-  value,
-  label
-}) {
-  return [state, {
-    value: typeof value === 'function' ? value(actionArgs, actionParams) : value,
-    label
-  }];
-}
-function executeLog({
-  logger
-}, {
-  value,
-  label
-}) {
-  if (label) {
-    logger(label, value);
-  } else {
-    logger(value);
-  }
-}
-/**
- *
- * @param expr The expression function to evaluate which will be logged.
- *  Takes in 2 arguments:
- *  - `ctx` - the current state context
- *  - `event` - the event that caused this action to be executed.
- * @param label The label to give to the logged expression.
- */
-function log(value = ({
-  context,
-  event
-}) => ({
-  context,
-  event
-}), label) {
-  function log(args, params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  log.type = 'xstate.log';
-  log.value = value;
-  log.label = label;
-  log.resolve = resolveLog;
-  log.execute = executeLog;
-  return log;
-}
-
-function resolvePure(_, state, args, _actionParams, {
-  get
-}) {
-  return [state, undefined, guards_dist_xstateGuards.toArray(get({
-    context: args.context,
-    event: args.event
-  }))];
-}
-function pure(getActions) {
-  function pure(args, params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  pure.type = 'xstate.pure';
-  pure.get = getActions;
-  pure.resolve = resolvePure;
-  return pure;
-}
-
 /**
  *
  * @remarks
@@ -401,9 +327,121 @@ function escalate(errorData, options) {
   }, options);
 }
 
+function resolveEnqueueActions(_, state, args, _actionParams, {
+  collect
+}) {
+  const actions = [];
+  const enqueue = function enqueue(action) {
+    actions.push(action);
+  };
+  enqueue.assign = (...args) => {
+    actions.push(assign(...args));
+  };
+  enqueue.cancel = (...args) => {
+    actions.push(guards_dist_xstateGuards.cancel(...args));
+  };
+  enqueue.raise = (...args) => {
+    actions.push(guards_dist_xstateGuards.raise(...args));
+  };
+  enqueue.sendTo = (...args) => {
+    actions.push(sendTo(...args));
+  };
+  enqueue.spawnChild = (...args) => {
+    actions.push(guards_dist_xstateGuards.spawnChild(...args));
+  };
+  enqueue.stopChild = (...args) => {
+    actions.push(guards_dist_xstateGuards.stopChild(...args));
+  };
+  collect({
+    context: args.context,
+    event: args.event,
+    enqueue,
+    check: guard => guards_dist_xstateGuards.evaluateGuard(guard, state.context, args.event, state)
+  });
+  return [state, undefined, actions];
+}
+function enqueueActions(collect) {
+  function enqueueActions(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  enqueueActions.type = 'xstate.enqueueActions';
+  enqueueActions.collect = collect;
+  enqueueActions.resolve = resolveEnqueueActions;
+  return enqueueActions;
+}
+
+function resolveLog(_, state, actionArgs, actionParams, {
+  value,
+  label
+}) {
+  return [state, {
+    value: typeof value === 'function' ? value(actionArgs, actionParams) : value,
+    label
+  }];
+}
+function executeLog({
+  logger
+}, {
+  value,
+  label
+}) {
+  if (label) {
+    logger(label, value);
+  } else {
+    logger(value);
+  }
+}
+/**
+ *
+ * @param expr The expression function to evaluate which will be logged.
+ *  Takes in 2 arguments:
+ *  - `ctx` - the current state context
+ *  - `event` - the event that caused this action to be executed.
+ * @param label The label to give to the logged expression.
+ */
+function log(value = ({
+  context,
+  event
+}) => ({
+  context,
+  event
+}), label) {
+  function log(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  log.type = 'xstate.log';
+  log.value = value;
+  log.label = label;
+  log.resolve = resolveLog;
+  log.execute = executeLog;
+  return log;
+}
+
+/**
+ *
+ * @deprecated Use `enqueueActions(...)` instead
+ */
+function pure(getActions) {
+  return enqueueActions(({
+    context,
+    event,
+    enqueue
+  }) => {
+    guards_dist_xstateGuards.toArray(getActions({
+      context,
+      event
+    })).forEach(enqueue);
+  });
+}
+
 exports.SpecialTargets = SpecialTargets;
 exports.assign = assign;
 exports.choose = choose;
+exports.enqueueActions = enqueueActions;
 exports.escalate = escalate;
 exports.forwardTo = forwardTo;
 exports.log = log;