xstate 5.15.0 → 5.17.0

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

@@ -1,24 +1,23 @@
-export * from "./actions.js";
-export * from "./actors/index.js";
 export { SimulatedClock } from "./SimulatedClock.js";
-export { type Spawner } from "./spawn.js";
 export { isMachineSnapshot, type MachineSnapshot } from "./State.js";
 export { StateMachine } from "./StateMachine.js";
-export { getStateNodes } from "./stateUtils.js";
-export * from "./types.js";
-export { waitFor } from "./waitFor.js";
-import { createMachine } from "./createMachine.js";
+export { StateNode } from "./StateNode.js";
+export * from "./actions.js";
+export * from "./actors/index.js";
+export { assertEvent } from "./assert.js";
+export { Actor, createActor, interpret, type Interpreter } from "./createActor.js";
+export { createMachine } from "./createMachine.js";
 export { getInitialSnapshot, getNextSnapshot } from "./getNextSnapshot.js";
-import { Actor, createActor, interpret, Interpreter } from "./createActor.js";
-import { StateNode } from "./StateNode.js";
 export { and, not, or, stateIn } from "./guards.js";
+export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./inspection.js";
 export { setup } from "./setup.js";
+export { type Spawner } from "./spawn.js";
+export { getStateNodes } from "./stateUtils.js";
 export type { ActorSystem } from "./system.js";
-export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./inspection.js";
 export { toPromise } from "./toPromise.js";
+export * from "./types.js";
 export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, pathToStateValue, toObserver } from "./utils.js";
-export { Actor, createActor, createMachine, interpret, StateNode, type Interpreter };
-export { assertEvent } from "./assert.js";
+export { waitFor } from "./waitFor.js";
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -1,6 +1,6 @@
 import { AnyActorRef, AnyEventObject, AnyTransitionDefinition, Snapshot } from "./types.js";
 export type InspectionEvent = InspectedSnapshotEvent | InspectedEventEvent | InspectedActorEvent | InspectedMicrostepEvent | InspectedActionEvent;
-export interface BaseInspectionEventProperties {
+interface BaseInspectionEventProperties {
     rootId: string;
     /**
      * The relevant actorRef for the inspection event.
@@ -16,7 +16,7 @@ export interface InspectedSnapshotEvent extends BaseInspectionEventProperties {
     event: AnyEventObject;
     snapshot: Snapshot<unknown>;
 }
-export interface InspectedMicrostepEvent extends BaseInspectionEventProperties {
+interface InspectedMicrostepEvent extends BaseInspectionEventProperties {
     type: '@xstate.microstep';
     event: AnyEventObject;
     snapshot: Snapshot<unknown>;
@@ -37,3 +37,4 @@ export interface InspectedEventEvent extends BaseInspectionEventProperties {
 export interface InspectedActorEvent extends BaseInspectionEventProperties {
     type: '@xstate.actor';
 }
+export {};

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

@@ -50,6 +50,6 @@ TActors extends Record<string, UnknownActorLogic> = {}, TChildrenMap extends Rec
 } & {
     [K in RequiredSetupKeys<TChildrenMap>]: unknown;
 }): {
-    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, TEmitted, TMeta>;
+    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, TEmitted, TMeta, TConfig>;
 };
 export {};

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

@@ -1,12 +1,9 @@
 import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { AnyEventObject, AnyHistoryValue, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, StateValueMap, TransitionDefinition, TODO, UnknownAction, ActionFunction, AnyTransitionConfig, AnyActorScope } from "./types.js";
+import { AnyEventObject, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, TransitionDefinition, TODO, UnknownAction, ActionFunction, AnyTransitionConfig, AnyActorScope } from "./types.js";
 type StateNodeIterable<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyStateNodeIterable = StateNodeIterable<any, any>;
-type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
-export declare const isAtomicStateNode: (stateNode: StateNode<any, any>) => boolean;
 export declare function getAllStateNodes(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
-export declare function getAdjList<TContext extends MachineContext, TE extends EventObject>(stateNodes: StateNodeIterable<TContext, TE>): AdjList;
 export declare function getStateValue(rootNode: AnyStateNode, stateNodes: AnyStateNodeIterable): StateValue;
 export declare function isInFinalState(stateNodeSet: Set<AnyStateNode>, stateNode: AnyStateNode): boolean;
 export declare const isStateId: (str: string) => boolean;
@@ -16,11 +13,7 @@ export declare function getDelayedTransitions(stateNode: AnyStateNode): Array<De
 export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, descriptor: string, transitionConfig: AnyTransitionConfig): AnyTransitionDefinition;
 export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Map<string, TransitionDefinition<TContext, TEvent>[]>;
 export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, _target: string | undefined | InitialTransitionConfig<TContext, TEvent, TODO, TODO, TODO, TODO>): InitialTransitionDefinition<TContext, TEvent>;
-export declare function resolveTarget(stateNode: AnyStateNode, targets: ReadonlyArray<string | AnyStateNode> | undefined): ReadonlyArray<AnyStateNode> | undefined;
-export declare function getInitialStateNodesWithTheirAncestors(stateNode: AnyStateNode): Set<AnyStateNode>;
 export declare function getInitialStateNodes(stateNode: AnyStateNode): Set<AnyStateNode>;
-/** Returns the child state node from its relative `stateKey`, or throws. */
-export declare function getStateNode(stateNode: AnyStateNode, stateKey: string): AnyStateNode;
 /**
  * Returns the relative state node from the given `statePath`, or throws.
  *
@@ -33,11 +26,7 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
  * @param stateValue The state value or State instance
  */
 export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue): Array<AnyStateNode>;
-export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, stateNodeSet: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
 export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentSnapshot: AnyMachineSnapshot, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyMachineSnapshot;
 export declare let executingCustomAction: ActionFunction<any, any, any, any, any, any, any, any, any> | false;
@@ -53,5 +42,4 @@ export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObje
  * @param stateValue The partial state value to resolve.
  */
 export declare function resolveStateValue(rootNode: AnyStateNode, stateValue: StateValue): StateValue;
-export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
 export {};

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

@@ -1,6 +1,6 @@
 import { InspectionEvent } from "./inspection.js";
 import { ActorSystemInfo, AnyActorRef, Observer, EventObject, Subscription } from "./types.js";
-export interface ScheduledEvent {
+interface ScheduledEvent {
     id: string;
     event: EventObject;
     startedAt: number;
@@ -12,7 +12,7 @@ export interface Clock {
     setTimeout(fn: (...args: any[]) => void, timeout: number): any;
     clearTimeout(id: any): void;
 }
-export interface Scheduler {
+interface Scheduler {
     schedule(source: AnyActorRef, target: AnyActorRef, event: EventObject, delay: number, id: string | undefined): void;
     cancel(source: AnyActorRef, id: string): void;
     cancelAll(actorRef: AnyActorRef): void;
@@ -34,3 +34,4 @@ export declare function createSystem<T extends ActorSystemInfo>(rootActor: AnyAc
     logger: (...args: any[]) => void;
     snapshot?: unknown;
 }): ActorSystem<T>;
+export {};

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

@@ -366,7 +366,7 @@ export interface StateMachineDefinition<TContext extends MachineContext, TEvent
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
-export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any, any>;
+export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any, any, any>;
 /** @deprecated Use `AnyMachineSnapshot` instead */
 export type AnyState = AnyMachineSnapshot;
 export type AnyStateMachine = StateMachine<any, // context
@@ -569,7 +569,7 @@ export interface StateConfig<TContext extends MachineContext, TEvent extends Eve
     context: TContext;
     historyValue?: HistoryValue<TContext, TEvent>;
     children: Record<string, AnyActorRef>;
-    status: 'active' | 'done' | 'error' | 'stopped';
+    status: SnapshotStatus;
     output?: any;
     error?: unknown;
     machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any, any, any, any, // TMeta
@@ -777,6 +777,7 @@ export interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends
 export type AnyActorScope = ActorScope<any, // TSnapshot
 any, // TEvent
 AnyActorSystem, any>;
+export type SnapshotStatus = 'active' | 'done' | 'error' | 'stopped';
 export type Snapshot<TOutput> = {
     status: 'active';
     output: undefined;
@@ -891,8 +892,14 @@ export type ToChildren<TActor extends ProvidedActor> = string extends TActor['sr
     exclude: {};
 }[undefined extends TActor['id'] ? 'include' : string extends TActor['id'] ? 'include' : 'exclude']>;
 export type StateSchema = {
+    id?: string;
     states?: Record<string, StateSchema>;
 };
+export type StateId<TSchema extends StateSchema, TKey extends string = '(machine)', TParentKey extends string | null = null> = (TSchema extends {
+    id: string;
+} ? TSchema['id'] : TParentKey extends null ? TKey : `${TParentKey}.${TKey}`) | (TSchema['states'] extends Record<string, any> ? Values<{
+    [K in keyof TSchema['states'] & string]: StateId<TSchema['states'][K], K, TParentKey extends string ? `${TParentKey}.${TKey}` : TSchema['id'] extends string ? TSchema['id'] : TKey>;
+}> : never);
 export interface StateMachineTypes {
     context: MachineContext;
     events: EventObject;

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

@@ -1,17 +1,13 @@
 import type { StateNode } from "./StateNode.js";
-import type { AnyActorLogic, AnyActorRef, AnyEventObject, AnyMachineSnapshot, AnyStateMachine, AnyTransitionConfig, ErrorActorEvent, EventObject, MachineContext, Mapper, NonReducibleUnknown, Observer, SingleOrArray, StateLike, StateValue, TransitionConfigTarget } from "./types.js";
+import type { AnyActorRef, AnyEventObject, AnyMachineSnapshot, AnyStateMachine, AnyTransitionConfig, ErrorActorEvent, EventObject, MachineContext, Mapper, NonReducibleUnknown, Observer, SingleOrArray, 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;
 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 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 isActorLogic(value: any): value is AnyActorLogic;
-export declare function isArray(value: any): value is readonly any[];
 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;

package/dist/{log-b8c93ee3.cjs.js → log-19086852.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-a6298350.cjs.js');
+var guards_dist_xstateGuards = require('./State-30c95050.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -388,6 +388,9 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, {
     // then it fails to typecheck that because `...args` use `string` in place of `TDelay
     actions.push(sendTo(...args));
   };
+  enqueue.sendParent = (...args) => {
+    actions.push(sendParent(...args));
+  };
   enqueue.spawnChild = (...args) => {
     actions.push(guards_dist_xstateGuards.spawnChild(...args));
   };

package/dist/{log-63de2429.esm.js → log-4a38a98a.esm.js}

@@ -1,4 +1,4 @@
-import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as XSTATE_ERROR, W as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-2cfe6b8f.esm.js';
+import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as XSTATE_ERROR, W as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './State-cdbc7940.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -386,6 +386,9 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, {
     // then it fails to typecheck that because `...args` use `string` in place of `TDelay
     actions.push(sendTo(...args));
   };
+  enqueue.sendParent = (...args) => {
+    actions.push(sendParent(...args));
+  };
   enqueue.spawnChild = (...args) => {
     actions.push(spawnChild(...args));
   };

package/dist/{log-e9953143.development.esm.js → log-62f17756.development.esm.js}

@@ -1,4 +1,4 @@
-import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as executingCustomAction, W as XSTATE_ERROR, Y as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-7d030497.development.esm.js';
+import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as executingCustomAction, V as cloneMachineSnapshot, W as XSTATE_ERROR, Y as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './State-34039d2a.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -417,6 +417,9 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, {
     // then it fails to typecheck that because `...args` use `string` in place of `TDelay
     actions.push(sendTo(...args));
   };
+  enqueue.sendParent = (...args) => {
+    actions.push(sendParent(...args));
+  };
   enqueue.spawnChild = (...args) => {
     actions.push(spawnChild(...args));
   };

package/dist/{log-d2c282d6.development.cjs.js → log-ec36113c.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-bad6a97b.development.cjs.js');
+var guards_dist_xstateGuards = require('./State-a2464a1e.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -419,6 +419,9 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, {
     // then it fails to typecheck that because `...args` use `string` in place of `TDelay
     actions.push(sendTo(...args));
   };
+  enqueue.sendParent = (...args) => {
+    actions.push(sendParent(...args));
+  };
   enqueue.spawnChild = (...args) => {
     actions.push(guards_dist_xstateGuards.spawnChild(...args));
   };

package/dist/xstate.cjs.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var guards_dist_xstateGuards = require('./State-30c95050.cjs.js');
+var log = require('./log-19086852.cjs.js');
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.cjs.js');
-var guards_dist_xstateGuards = require('./raise-a6298350.cjs.js');
-var log = require('./log-b8c93ee3.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 class SimulatedClock {
@@ -598,75 +598,35 @@ class StateMachine {
   }
 }
 
-const defaultWaitForOptions = {
-  timeout: Infinity // much more than 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 an optional timeout. (defaults to Infinity).
+ * Asserts that the given event object is of the specified type or types. Throws
+ * an error if the event object is not of the specified types.
  *
  * @example
  *
- * ```js
- * const state = await waitFor(someService, (state) => {
- *   return state.hasTag('loaded');
- * });
+ * ```ts
+ * // ...
+ * entry: ({ event }) => {
+ *   assertEvent(event, 'doNothing');
+ *   // event is { type: 'doNothing' }
+ * },
+ * // ...
+ * exit: ({ event }) => {
+ *   assertEvent(event, 'greet');
+ *   // event is { type: 'greet'; message: string }
  *
- * state.hasTag('loaded'); // true
+ *   assertEvent(event, ['greet', 'notify']);
+ *   // event is { type: 'greet'; message: string }
+ *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
+ * },
  * ```
- *
- * @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) {
-  const resolvedOptions = {
-    ...defaultWaitForOptions,
-    ...options
-  };
-  return new Promise((res, rej) => {
-    let done = false;
-    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
-      sub.unsubscribe();
-      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
-    }, resolvedOptions.timeout);
-    const dispose = () => {
-      clearTimeout(handle);
-      done = true;
-      sub?.unsubscribe();
-    };
-    function checkEmitted(emitted) {
-      if (predicate(emitted)) {
-        dispose();
-        res(emitted);
-      }
-    }
-    let sub; // avoid TDZ when disposing synchronously
-
-    // See if the current snapshot already matches the predicate
-    checkEmitted(actorRef.getSnapshot());
-    if (done) {
-      return;
-    }
-    sub = actorRef.subscribe({
-      next: checkEmitted,
-      error: err => {
-        dispose();
-        rej(err);
-      },
-      complete: () => {
-        dispose();
-        rej(new Error(`Actor terminated without satisfying predicate`));
-      }
-    });
-    if (done) {
-      sub.unsubscribe();
-    }
-  });
+function assertEvent(event, type) {
+  const types = guards_dist_xstateGuards.toArray(type);
+  if (!types.includes(event.type)) {
+    const typesText = types.length === 1 ? `type "${types[0]}"` : `one of types "${types.join('", "')}"`;
+    throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
+  }
 }
 
 // this is not 100% accurate since we can't make parallel regions required in the result
@@ -832,43 +792,77 @@ function toPromise(actor) {
   });
 }
 
+const defaultWaitForOptions = {
+  timeout: Infinity // much more than 10 seconds
+};
+
 /**
- * Asserts that the given event object is of the specified type or types. Throws
- * an error if the event object is not of the specified types.
+ * 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 an optional timeout. (defaults to Infinity).
  *
  * @example
  *
- * ```ts
- * // ...
- * entry: ({ event }) => {
- *   assertEvent(event, 'doNothing');
- *   // event is { type: 'doNothing' }
- * },
- * // ...
- * exit: ({ event }) => {
- *   assertEvent(event, 'greet');
- *   // event is { type: 'greet'; message: string }
+ * ```js
+ * const state = await waitFor(someService, (state) => {
+ *   return state.hasTag('loaded');
+ * });
  *
- *   assertEvent(event, ['greet', 'notify']);
- *   // event is { type: 'greet'; message: string }
- *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
- * },
+ * 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 assertEvent(event, type) {
-  const types = guards_dist_xstateGuards.toArray(type);
-  if (!types.includes(event.type)) {
-    const typesText = types.length === 1 ? `type "${types[0]}"` : `one of types "${types.join('", "')}"`;
-    throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
-  }
+function waitFor(actorRef, predicate, options) {
+  const resolvedOptions = {
+    ...defaultWaitForOptions,
+    ...options
+  };
+  return new Promise((res, rej) => {
+    let done = false;
+    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
+      sub.unsubscribe();
+      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
+    }, resolvedOptions.timeout);
+    const dispose = () => {
+      clearTimeout(handle);
+      done = true;
+      sub?.unsubscribe();
+    };
+    function checkEmitted(emitted) {
+      if (predicate(emitted)) {
+        dispose();
+        res(emitted);
+      }
+    }
+    let sub; // avoid TDZ when disposing synchronously
+
+    // See if the current snapshot already matches the predicate
+    checkEmitted(actorRef.getSnapshot());
+    if (done) {
+      return;
+    }
+    sub = actorRef.subscribe({
+      next: checkEmitted,
+      error: err => {
+        dispose();
+        rej(err);
+      },
+      complete: () => {
+        dispose();
+        rej(new Error(`Actor terminated without satisfying predicate`));
+      }
+    });
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
 }
 
-exports.createEmptyActor = actors_dist_xstateActors.createEmptyActor;
-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.Actor = guards_dist_xstateGuards.Actor;
 exports.__unsafe_getAllOwnEventDescriptors = guards_dist_xstateGuards.getAllOwnEventDescriptors;
 exports.and = guards_dist_xstateGuards.and;
@@ -895,6 +889,12 @@ exports.forwardTo = log.forwardTo;
 exports.log = log.log;
 exports.sendParent = log.sendParent;
 exports.sendTo = log.sendTo;
+exports.createEmptyActor = actors_dist_xstateActors.createEmptyActor;
+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.SimulatedClock = SimulatedClock;
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;