xstate 5.4.1 → 5.5.0

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

@@ -4,11 +4,30 @@ export interface CancelAction<TContext extends MachineContext, TExpressionEvent
     (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
 }
 /**
- * Cancels an in-flight `send(...)` action. A canceled sent action will not
- * be executed, nor will its event be sent, unless it has already been sent
- * (e.g., if `cancel(...)` is called after the `send(...)` action's `delay`).
+ * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The canceled `sendTo(...)` action
+ * will not send its event or execute, unless the `delay` has already elapsed before `cancel(...)` is called.
  *
- * @param sendId The `id` of the `send(...)` action to cancel.
+ * @param sendId The `id` of the `sendTo(...)` action to cancel.
+ *
+ * @example
+  ```ts
+  import { createMachine, sendTo, cancel } from 'xstate';
+
+  const machine = createMachine({
+    // ...
+    on: {
+      sendEvent: {
+        actions: sendTo('some-actor', { type: 'someEvent' }, {
+          id: 'some-id',
+          delay: 1000
+        })
+      },
+      cancelEvent: {
+        actions: cancel('some-id')
+      }
+    }
+  });
+  ```
  */
 export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(sendId: ResolvableSendId<TContext, TExpressionEvent, TParams, TEvent>): CancelAction<TContext, TExpressionEvent, TParams, TEvent>;
 export {};

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

@@ -28,5 +28,25 @@ interface CollectActionsArg<TContext extends MachineContext, TExpressionEvent ex
     enqueue: ActionEnqueuer<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>;
 }
 type CollectActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = ({ context, event, check, enqueue, self }: CollectActionsArg<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>) => void;
+/**
+ * Creates an action object that will execute actions that are queued by the `enqueue(action)` function.
+ *
+ * @example
+  ```ts
+  import { createMachine, enqueueActions } from 'xstate';
+
+  const machine = createMachine({
+    entry: enqueueActions(({ enqueue, check }) => {
+      enqueue.assign({ count: 0 });
+
+      if (check('someGuard')) {
+        enqueue.assign({ count: 1 });
+      }
+
+      enqueue('someAction');
+    })
+  })
+  ```
+ */
 export declare function enqueueActions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string>(collect: CollectActions<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>): EnqueueActionsAction<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>;
 export {};

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

@@ -22,9 +22,9 @@ export declare function sendTo<TContext extends MachineContext, TExpressionEvent
 export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject = AnyEventObject, TEvent extends EventObject = AnyEventObject, TDelay extends string = string>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
 type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => string | ActorRef<any, any>);
 /**
- * Forwards (sends) an event to a specified service.
+ * Forwards (sends) an event to the `target` actor.
  *
- * @param target The target service to forward the event to.
+ * @param target The target actor to forward the event to.
  * @param options Options to pass into the send action creator.
  */
 export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string>(target: Target<TContext, TExpressionEvent, TParams, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;

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

@@ -34,7 +34,6 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
     private observers;
     private logger;
     _parent?: ActorRef<any, any>;
-    _syncSnapshot?: boolean;
     ref: ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>;
     private _actorScope;
     private _systemId;

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

@@ -15,6 +15,46 @@ type FilterLeafValues<TLeafCandidate extends string, TNonLeaf extends {
 type ToStateValue<TTestValue extends string | TestValue> = FilterLeafValues<GroupTestValues<TTestValue>['leafCandidates'], GroupTestValues<TTestValue>['nonLeaf']> | (IsNever<GroupTestValues<TTestValue>['nonLeaf']> extends false ? {
     [K in keyof GroupTestValues<TTestValue>['nonLeaf']]: ToStateValue<NonNullable<GroupTestValues<TTestValue>['nonLeaf'][K]>>;
 } : never);
+/**
+ * Creates a state machine (statechart) with the given configuration.
+ *
+ * The state machine represents the pure logic of a state machine actor.
+ *
+ * @param config The state machine configuration.
+ * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })` to provide machine implementations instead.
+ *
+ * @example
+  ```ts
+  import { createMachine } from 'xstate';
+
+  const lightMachine = createMachine({
+    id: 'light',
+    initial: 'green',
+    states: {
+      green: {
+        on: {
+          TIMER: { target: 'yellow' }
+        }
+      },
+      yellow: {
+        on: {
+          TIMER: { target: 'red' }
+        }
+      },
+      red: {
+        on: {
+          TIMER: { target: 'green' }
+        }
+      }
+    }
+  });
+
+  const lightActor = createActor(lightMachine);
+  lightActor.start();
+
+  lightActor.send({ type: 'TIMER' });
+  ```
+ */
 export declare function createMachine<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
 TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, TActor, TAction, TGuard, TDelay, 'matchesStates' extends keyof TTypesMeta ? ToStateValue<Cast<TTypesMeta['matchesStates'], TestValue>> : StateValue, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>['resolved'], 'tags'> & string, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
 export {};

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

@@ -0,0 +1,32 @@
+import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom } from "./types.js";
+export declare function getInitialSnapshot<T extends AnyActorLogic>(actorLogic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): SnapshotFrom<T>;
+/**
+ * Determines the next snapshot for the given `actorLogic` based on
+ * the given `snapshot` and `event`.
+ *
+ * If the `snapshot` is `undefined`, the initial snapshot of the
+ * `actorLogic` is used.
+ *
+ * @example
+  ```ts
+  import { getNextSnapshot } from 'xstate';
+  import { trafficLightMachine } from './trafficLightMachine.ts';
+
+  const nextSnapshot = getNextSnapshot(
+    trafficLightMachine, // actor logic
+    undefined, // snapshot (or initial state if undefined)
+    { type: 'TIMER' }); // event object
+
+  console.log(nextSnapshot.value);
+  // => 'yellow'
+
+  const nextSnapshot2 = getNextSnapshot(
+    trafficLightMachine, // actor logic
+    nextSnapshot, // snapshot
+    { type: 'TIMER' }); // event object
+
+  console.log(nextSnapshot2.value);
+  // =>'red'
+  ```
+ */
+export declare function getNextSnapshot<T extends AnyActorLogic>(actorLogic: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): SnapshotFrom<T>;

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

@@ -26,12 +26,98 @@ export type UnknownGuard = UnknownReferencedGuard | UnknownInlineGuard;
 type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedObject['params'], ParameterizedObject>;
 type UnknownInlineGuard = Guard<MachineContext, EventObject, undefined, ParameterizedObject>;
 export declare function stateIn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TParams, any>;
+/**
+ * Higher-order guard that evaluates to `true` if the `guard` passed to it evaluates to `false`.
+ *
+ * @category Guards
+ * @example
+  ```ts
+  import { setup, not } from 'xstate';
+
+  const machine = setup({
+    guards: {
+      someNamedGuard: () => false
+    }
+  }).createMachine({
+    on: {
+      someEvent: {
+        guard: not('someNamedGuard'),
+        actions: () => {
+          // will be executed if guard in `not(...)`
+          // evaluates to `false`
+        }
+      }
+    }
+  });
+  ```
+ * @returns A guard
+ */
 export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg>(guard: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg>): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArg<NoInfer<TArg>>>;
+/**
+ * Higher-order guard that evaluates to `true` if all `guards` passed to it
+ * evaluate to `true`.
+ *
+ * @category Guards
+ * @example
+  ```ts
+  import { setup, and } from 'xstate';
+
+  const machine = setup({
+    guards: {
+      someNamedGuard: () => true
+    }
+  }).createMachine({
+    on: {
+      someEvent: {
+        guard: and([
+          ({ context }) => context.value > 0,
+          'someNamedGuard'
+        ]),
+        actions: () => {
+          // will be executed if all guards in `and(...)`
+          // evaluate to true
+        }
+      }
+    }
+  });
+  ```
+ * @returns A guard action object
+ */
 export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
     ...{
         [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;
     }
 ]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<NoInfer<TArg>>>;
+/**
+ * Higher-order guard that evaluates to `true` if any of the `guards` passed to it
+ * evaluate to `true`.
+ *
+ * @category Guards
+ * @example
+  ```ts
+  import { setup, or } from 'xstate';
+
+  const machine = setup({
+    guards: {
+      someNamedGuard: () => true
+    }
+  }).createMachine({
+    on: {
+      someEvent: {
+        guard: or([
+          ({ context }) => context.value > 0,
+          'someNamedGuard'
+        ]),
+        actions: () => {
+          // will be executed if any of the guards in `or(...)`
+          // evaluate to true
+        }
+      }
+    }
+  });
+  ```
+ * @returns A guard action object
+ */
 export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
     ...{
         [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;

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

@@ -9,6 +9,7 @@ export * from "./typegenTypes.js";
 export * from "./types.js";
 export { waitFor } from "./waitFor.js";
 import { createMachine } from "./createMachine.js";
+export { 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";

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

@@ -1,4 +1,4 @@
-import { ActorRefFrom, AnyActorScope, AnyActorLogic, AnyActorRef, AnyEventObject, AnyMachineSnapshot, InputFrom, IsLiteralString, ProvidedActor, RequiredActorOptions, IsNotNever, ConditionalRequired } from "./types.js";
+import { ActorRefFrom, AnyActorLogic, AnyActorRef, AnyActorScope, AnyEventObject, AnyMachineSnapshot, ConditionalRequired, InputFrom, IsLiteralString, IsNotNever, ProvidedActor, RequiredActorOptions } from "./types.js";
 type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
     src: TSrc;
 } ? ConditionalRequired<[
@@ -17,7 +17,7 @@ type GetConcreteLogic<TActor extends ProvidedActor, TSrc extends TActor['src']>
 export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>) => ActorRefFrom<GetConcreteLogic<TActor, TSrc>> : <TLogic extends AnyActorLogic | string>(src: TLogic, options?: {
     id?: string;
     systemId?: string;
-    input?: unknown;
+    input?: TLogic extends string ? unknown : InputFrom<TLogic>;
     syncSnapshot?: boolean;
 }) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>;
 export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyMachineSnapshot, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;

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

@@ -1,10 +1,19 @@
 import { EventObject, IndexByType, IsNever, Prop, ParameterizedObject, ProvidedActor, OutputFrom, AnyActorLogic, IndexByProp } from "./types.js";
+/**
+ * @deprecated
+ */
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
+/**
+ * @deprecated
+ */
 export interface TypegenEnabled {
     '@@xstate/typegen': true;
 }
+/**
+ * @deprecated
+ */
 export interface TypegenMeta extends TypegenEnabled {
     /**
      * Allows you to specify all the results of state.matches
@@ -77,6 +86,9 @@ export interface TypegenMeta extends TypegenEnabled {
      */
     eventsCausingActors: Record<string, string>;
 }
+/**
+ * @deprecated
+ */
 export interface ResolvedTypegenMeta extends TypegenMeta {
     resolved: TypegenMeta & {
         indexedActors: Record<string, ProvidedActor>;
@@ -86,11 +98,17 @@ export interface ResolvedTypegenMeta extends TypegenMeta {
         indexedDelays: Record<string, ParameterizedObject>;
     };
 }
+/**
+ * @deprecated
+ */
 export type TypegenConstraint = TypegenEnabled | TypegenDisabled;
 /**
  * @deprecated Always resolves to `true`
  */
 export type AreAllImplementationsAssumedToBeProvided<_TResolvedTypesMeta, _TMissingImplementations> = true;
+/**
+ * @deprecated
+ */
 interface AllImplementationsProvided {
     missingImplementations: {
         actions: never;
@@ -114,6 +132,9 @@ type IndexParameterizedImplementation<TParameterizedImplementation extends Param
 type WrapIntoParameterizedObject<T extends string> = T extends any ? {
     type: T;
 } : never;
+/**
+ * @deprecated
+ */
 export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string> {
     '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
     resolved: {

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

@@ -3,7 +3,7 @@ import type { StateMachine } from "./StateMachine.js";
 import type { StateNode } from "./StateNode.js";
 import { AssignArgs } from "./actions/assign.js";
 import { PromiseActorLogic } from "./actors/promise.js";
-import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
+import { Guard, UnknownGuard } from "./guards.js";
 import type { Actor } from "./createActor.js";
 import { Spawner } from "./spawn.js";
 import { AnyActorSystem, InspectionEvent, Clock } from './system.js';
@@ -383,22 +383,8 @@ export type ActionFunctionMap<TContext extends MachineContext, TEvent extends Ev
         type: K;
     } ? TAction : never>, TActor, TAction, TGuard, TDelay>;
 };
-type GuardMap<TContext extends MachineContext, TEvent extends EventObject, TGuard extends ParameterizedObject> = {
-    [K in TGuard['type']]?: GuardPredicate<TContext, TEvent, GetParameterizedParams<TGuard extends {
-        type: K;
-    } ? TGuard : never>, TGuard>;
-};
 export type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject> = Record<string, DelayConfig<TContext, TEvent, TAction['params'], TEvent>>;
 export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>;
-export interface MachineImplementationsSimplified<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject> {
-    guards: GuardMap<TContext, TEvent, TGuard>;
-    actions: ActionFunctionMap<TContext, TEvent, TActor, TAction>;
-    actors: Record<string, AnyActorLogic | {
-        src: AnyActorLogic;
-        input: Mapper<TContext, TEvent, unknown, TEvent> | NonReducibleUnknown;
-    }>;
-    delays: DelayFunctionMap<TContext, TEvent, TAction>;
-}
 type MaybeNarrowedEvent<TIndexedEvents, TCausingLookup, K> = Cast<Prop<TIndexedEvents, K extends keyof TCausingLookup ? TCausingLookup[K] : TIndexedEvents[keyof TIndexedEvents]>, EventObject>;
 type MachineImplementationsActions<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActions'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedGuards'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
     [K in keyof TIndexedActions]?: ActionFunction<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingActions, K>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>, GetParameterizedParams<Cast<TIndexedActions[K], ParameterizedObject>>, Cast<Prop<TIndexedActors, keyof TIndexedActors>, ProvidedActor>, Cast<Prop<TIndexedActions, keyof TIndexedActions>, ParameterizedObject>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>, Cast<Prop<TIndexedDelays, keyof TIndexedDelays>, ParameterizedObject>['type']>;
@@ -588,21 +574,20 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      */
     clock?: Clock;
     /**
-     * Specifies the logger to be used for log(...) actions. Defaults to the native console.log method.
+     * Specifies the logger to be used for `log(...)` actions. Defaults to the native `console.log(...)` method.
      */
     logger?: (...args: any[]) => void;
+    parent?: ActorRef<any, any>;
     /**
      * The custom `id` for referencing this service.
      */
     id?: string;
     /**
-     * If `true`, states and events will be logged to Redux DevTools.
-     *
-     * Default: `false`
+     * @deprecated Use `inspect` instead.
      */
-    devTools?: boolean | DevToolsAdapter;
+    devTools?: never;
     /**
-     * The system ID to register this actor under
+     * The system ID to register this actor under.
      */
     systemId?: string;
     /**
@@ -628,7 +613,7 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      */
     state?: Snapshot<unknown>;
     /**
-     * The source definition.
+     * The source actor logic.
      */
     src?: string | AnyActorLogic;
     /**
@@ -720,17 +705,12 @@ export type Observer<T> = {
 export interface Subscription {
     unsubscribe(): void;
 }
-export interface InteropObservable<T> {
-    [Symbol.observable]: () => InteropSubscribable<T>;
-}
-export interface InteropSubscribable<T> {
-    subscribe(observer: Observer<T>): Subscription;
-}
 export interface Subscribable<T> extends InteropSubscribable<T> {
     subscribe(observer: Observer<T>): Subscription;
     subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
 }
-export type ExtractEvent<TEvent extends EventObject, TDescriptor extends EventDescriptor<TEvent>> = string extends TEvent['type'] ? TEvent : NormalizeDescriptor<TDescriptor> extends infer TNormalizedDescriptor ? TEvent extends any ? TEvent['type'] extends TNormalizedDescriptor ? TEvent : never : never : never;
+type EventDescriptorMatches<TEventType extends string, TNormalizedDescriptor> = TEventType extends TNormalizedDescriptor ? true : false;
+export type ExtractEvent<TEvent extends EventObject, TDescriptor extends EventDescriptor<TEvent>> = string extends TEvent['type'] ? TEvent : NormalizeDescriptor<TDescriptor> extends infer TNormalizedDescriptor ? TEvent extends any ? true extends EventDescriptorMatches<TEvent['type'], TNormalizedDescriptor> ? TEvent : never : never : never;
 export interface BaseActorRef<TEvent extends EventObject> {
     send: (event: TEvent) => void;
 }

package/dist/{log-88b333eb.esm.js → log-22b3587f.esm.js}

@@ -1,4 +1,4 @@
-import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, U as XSTATE_ERROR, V as createErrorActorEvent, e as evaluateGuard, L as cancel, M as raise, O as spawnChild, Q as stopChild } from './raise-3b380e4b.esm.js';
+import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, U as XSTATE_ERROR, V as createErrorActorEvent, e as evaluateGuard, L as cancel, M as raise, O as spawnChild, Q as stopChild } from './raise-0e64ee6e.esm.js';
 
 // it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
 // but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)
@@ -67,8 +67,8 @@ function resolveAssign(actorScope, snapshot, actionArgs, actionParams, {
     context: snapshot.context,
     event: actionArgs.event,
     spawn: createSpawner(actorScope, snapshot, actionArgs.event, spawnedChildren),
-    self: actorScope?.self,
-    system: actorScope?.system
+    self: actorScope.self,
+    system: actorScope.system
   };
   let partialUpdate = {};
   if (typeof assignment === 'function') {
@@ -91,7 +91,34 @@ function resolveAssign(actorScope, snapshot, actionArgs, actionParams, {
 /**
  * Updates the current context of the machine.
  *
- * @param assignment An object that represents the partial context to update.
+ * @param assignment An object that represents the partial context to update, or a
+ * function that returns an object that represents the partial context to update.
+ * 
+ * @example
+  ```ts
+  import { createMachine, assign } from 'xstate';
+
+  const countMachine = createMachine({
+    context: {
+      count: 0,
+      message: ''
+    },
+    on: {
+      inc: {
+        actions: assign({
+          count: ({ context }) => context.count + 1
+        })
+      },
+      updateMessage: {
+        actions: assign(({ context, event }) => {
+          return {
+            message: event.message.trim()
+          }
+        })
+      }
+    }
+  });
+  ```
  */
 function assign(assignment) {
   function assign(args, params) {
@@ -138,7 +165,9 @@ function assign(assignment) {
 /** @deprecated use `AnyMachineSnapshot` instead */
 
 // TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
-
+/**
+ * @internal
+ */
 let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
   SpecialTargets["Parent"] = "#_parent";
   SpecialTargets["Internal"] = "#_internal";
@@ -151,6 +180,14 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
 
 // Based on RxJS types
 
+/**
+ * @internal
+ */
+
+/**
+ * @internal
+ */
+
 /**
  * @deprecated Use `Actor<T>` instead.
  */
@@ -188,9 +225,9 @@ function resolveSendTo(actorScope, snapshot, args, actionParams, {
   let targetActorRef;
   if (typeof resolvedTarget === 'string') {
     if (resolvedTarget === SpecialTargets.Parent) {
-      targetActorRef = actorScope?.self._parent;
+      targetActorRef = actorScope.self._parent;
     } else if (resolvedTarget === SpecialTargets.Internal) {
-      targetActorRef = actorScope?.self;
+      targetActorRef = actorScope.self;
     } else if (resolvedTarget.startsWith('#_')) {
       // SCXML compatibility: https://www.w3.org/TR/scxml/#SCXMLEventProcessor
       // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
@@ -202,7 +239,7 @@ function resolveSendTo(actorScope, snapshot, args, actionParams, {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${snapshot.machine.id}'.`);
     }
   } else {
-    targetActorRef = resolvedTarget || actorScope?.self;
+    targetActorRef = resolvedTarget || actorScope.self;
   }
   return [snapshot, {
     to: targetActorRef,
@@ -269,9 +306,9 @@ function sendParent(event, options) {
   return sendTo(SpecialTargets.Parent, event, options);
 }
 /**
- * Forwards (sends) an event to a specified service.
+ * Forwards (sends) an event to the `target` actor.
  *
- * @param target The target service to forward the event to.
+ * @param target The target actor to forward the event to.
  * @param options Options to pass into the send action creator.
  */
 function forwardTo(target, options) {
@@ -315,6 +352,26 @@ function resolveEnqueueActions(actorScope, snapshot, args, _actionParams, {
   });
   return [snapshot, undefined, actions];
 }
+/**
+ * Creates an action object that will execute actions that are queued by the `enqueue(action)` function.
+ * 
+ * @example
+  ```ts
+  import { createMachine, enqueueActions } from 'xstate';
+
+  const machine = createMachine({
+    entry: enqueueActions(({ enqueue, check }) => {
+      enqueue.assign({ count: 0 });
+
+      if (check('someGuard')) {
+        enqueue.assign({ count: 1 });
+      }
+
+      enqueue('someAction');
+    })
+  })
+  ```
+ */
 function enqueueActions(collect) {
   function enqueueActions(args, params) {
   }