xstate 5.0.0-beta.37 → 5.0.0-beta.39

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

@@ -1,6 +1,6 @@
 import { ActionArgs, ActorRef, AnyActorRef, AnyEventObject, Cast, EventFrom, EventObject, InferEvent, MachineContext, SendExpr, SendToActionOptions, SendToActionParams, UnifiedArg, ParameterizedObject, NoInfer } from "../types.js";
-export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> {
-    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
+export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
     _out_TDelay?: TDelay;
 }
 /**
@@ -12,22 +12,22 @@ export interface SendToAction<TContext extends MachineContext, TExpressionEvent
  *  - `id` - The unique send event identifier (used with `cancel()`).
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  */
-export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject, TDelay extends string>(to: TTargetActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => TTargetActor | string), eventOrExpr: EventFrom<TTargetActor> | SendExpr<TContext, TExpressionEvent, TExpressionAction, InferEvent<Cast<EventFrom<TTargetActor>, EventObject>>, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, NoInfer<TEvent>, NoInfer<TDelay>>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
+export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject, TDelay extends string>(to: TTargetActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => TTargetActor | string), eventOrExpr: EventFrom<TTargetActor> | SendExpr<TContext, TExpressionEvent, TParams, InferEvent<Cast<EventFrom<TTargetActor>, EventObject>>, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, NoInfer<TEvent>, NoInfer<TDelay>>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
 /**
  * Sends an event to this machine's parent.
  *
  * @param event The event to send to the parent machine.
  * @param options Options to pass into the send event.
  */
-export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject = AnyEventObject, TEvent extends EventObject = AnyEventObject, TDelay extends string = string>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TSentEvent, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
-type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => string | ActorRef<any, any>);
+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.
  *
  * @param target The target service 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, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string>(target: Target<TContext, TExpressionEvent, TExpressionAction, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
+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>;
 /**
  * Escalates an error by sending it as an event to this machine's parent.
  *
@@ -35,5 +35,5 @@ export declare function forwardTo<TContext extends MachineContext, TExpressionEv
  * takes in the `context`, `event`, and `meta`, and returns the error data to send.
  * @param options Options to pass into the send action creator.
  */
-export declare function escalate<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TErrorData = any, TEvent extends EventObject = AnyEventObject>(errorData: TErrorData | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TErrorData), options?: SendToActionParams<TContext, TExpressionEvent, TExpressionAction, EventObject, TEvent, string>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, string>;
+export declare function escalate<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TErrorData = any, TEvent extends EventObject = AnyEventObject>(errorData: TErrorData | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TErrorData), options?: SendToActionParams<TContext, TExpressionEvent, TParams, EventObject, TEvent, string>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, string>;
 export {};

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

@@ -0,0 +1,34 @@
+import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg } from "../types.js";
+type ResolvableActorId<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TId extends string | undefined> = TId | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TId);
+export interface SpawnAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+    _out_TActor?: TActor;
+}
+type DistributeActors<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = TActor extends any ? 'id' extends keyof TActor ? [
+    src: TActor['src'],
+    options: {
+        id: ResolvableActorId<TContext, TExpressionEvent, TEvent, TActor['id']>;
+        systemId?: string;
+        input?: InputFrom<TActor['logic']>;
+        syncSnapshot?: boolean;
+    }
+] : [
+    src: TActor['src'],
+    options?: {
+        id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
+        systemId?: string;
+        input?: InputFrom<TActor['logic']>;
+        syncSnapshot?: boolean;
+    }
+] : never;
+type SpawnArguments<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TExpressionEvent, TEvent, TActor> : [
+    src: string | AnyActorLogic,
+    options?: {
+        id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
+        systemId?: string;
+        input?: unknown;
+        syncSnapshot?: boolean;
+    }
+];
+export declare function spawn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor>(...[src, { id, systemId, input, syncSnapshot }]: SpawnArguments<TContext, TExpressionEvent, TEvent, TActor>): SpawnAction<TContext, TExpressionEvent, TParams, TEvent, TActor>;
+export {};

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

@@ -1,12 +1,12 @@
 import { ActionArgs, ActorRef, EventObject, MachineContext, ParameterizedObject } from "../types.js";
-type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => ActorRef<any, any> | string);
-export interface StopAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> {
-    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
+type ResolvableActorRef<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) => ActorRef<any, any> | string);
+export interface StopAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
 }
 /**
  * Stops an actor.
  *
  * @param actorRef The actor to stop.
  */
-export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TExpressionAction, TEvent>): StopAction<TContext, TExpressionEvent, TExpressionAction, TEvent>;
+export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TParams, TEvent>): StopAction<TContext, TExpressionEvent, TParams, TEvent>;
 export {};

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

@@ -6,3 +6,4 @@ export { pure, type PureAction } 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, type StopAction } from "./actions/stop.js";
+export { spawn, type SpawnAction } from "./actions/spawn.js";

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

@@ -1,20 +1,94 @@
-import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot, HomomorphicOmit } from "../types.js";
+import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot } from "../types.js";
 type CallbackSnapshot<TInput, TEvent> = Snapshot<undefined> & {
     input: TInput;
     _receivers: Set<(e: TEvent) => void>;
     _dispose: (() => void) | void;
 };
-export type CallbackActorLogic<TEvent extends EventObject, TInput = unknown> = ActorLogic<CallbackSnapshot<TInput, TEvent>, TEvent, TInput, HomomorphicOmit<CallbackSnapshot<TInput, TEvent>, '_receivers' | '_dispose'>, ActorSystem<any>>;
+export type CallbackActorLogic<TEvent extends EventObject, TInput = unknown> = ActorLogic<CallbackSnapshot<TInput, TEvent>, TEvent, TInput, ActorSystem<any>>;
 export type CallbackActorRef<TEvent extends EventObject, TInput = unknown> = 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 }: {
+    /**
+     * Data that was provided to the callback actor
+     * @see {@link https://stately.ai/docs/input | Input docs}
+     */
     input: TInput;
+    /**
+     * The actor system to which the callback actor belongs
+     */
     system: AnyActorSystem;
+    /**
+     * The parent actor of the callback actor
+     */
     self: CallbackActorRef<TEvent>;
+    /**
+     * A function that can send events back to the parent actor
+     */
     sendBack: (event: TSentEvent) => void;
+    /**
+     * A function that can be called with a listener function argument;
+     * the listener is then called whenever events are received by the callback actor
+     */
     receive: Receiver<TEvent>;
 }) => (() => void) | void;
+/**
+ * An actor logic creator which returns callback logic as defined by a callback function.
+ *
+ * @remarks
+ * Useful for subscription-based or other free-form logic that can send events back to the parent actor.
+ *
+ * Actors created from callback logic (“callback actors”) can:
+ * - Receive events via the `receive` function
+ * - Send events to the parent actor via the `sendBack` function
+ *
+ * Callback actors are a bit different from other actors in that they:
+ * - Do not work with `onDone` or `onError`
+ * - Do not produce a snapshot using `.getSnapshot()`
+ * - Do not emit values when used with `.subscribe()`
+ * - Can not be stopped with `.stop()`
+ *
+ * @param invokeCallback - The callback function used to describe the callback logic
+ * The callback function is passed an object with the following properties:
+ * - `receive` - A function that can send events back to the parent actor; the listener is then called whenever events are received by the callback actor
+ * - `sendBack` - A function that can send events back to the parent actor
+ * - `input` - Data that was provided to the callback actor
+ * - `self` - The parent actor of the callback actor
+ * - `system` - The actor system to which the callback actor belongs
+ * The callback function can (optionally) return a cleanup function, which is called when the actor is stopped.
+ * @see {@link InvokeCallback} for more information about the callback function and its object argument
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+
+ * @returns Callback logic
+ *
+ * @example
+ * ```typescript
+ * const callbackLogic = fromCallback(({ sendBack, receive }) => {
+ *   let lockStatus = 'unlocked';
+ *
+ *   const handler = (event) => {
+ *     if (lockStatus === 'locked') {
+ *       return;
+ *     }
+ *     sendBack(event);
+ *   };
+ *
+ *   receive((event) => {
+ *     if (event.type === 'lock') {
+ *       lockStatus = 'locked';
+ *     } else if (event.type === 'unlock') {
+ *       lockStatus = 'unlocked';
+ *     }
+ *   });
+ *
+ *   document.body.addEventListener('click', handler);
+ *
+ *   return () => {
+ *     document.body.removeEventListener('click', handler);
+ *   };
+ * });
+ * ```
+ */
 export declare function fromCallback<TEvent extends EventObject, TInput = unknown>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput>): CallbackActorLogic<TEvent, TInput>;
 export {};

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

@@ -1,14 +1,13 @@
-import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot, HomomorphicOmit } from "../types.js";
+import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot } from "../types.js";
 export type ObservableSnapshot<TContext, TInput> = Snapshot<undefined> & {
     context: TContext | undefined;
     input: TInput | undefined;
     _subscription: Subscription | undefined;
 };
-export type ObservablePersistedState<TContext, TInput> = HomomorphicOmit<ObservableSnapshot<TContext, TInput>, '_subscription'>;
 export type ObservableActorLogic<TContext, TInput> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
     type: string;
     [k: string]: unknown;
-}, TInput, ObservablePersistedState<TContext, TInput>, AnyActorSystem>;
+}, TInput, AnyActorSystem>;
 export type ObservableActorRef<TContext> = ActorRefFrom<ObservableActorLogic<TContext, any>>;
 export declare function fromObservable<TContext, TInput>(observableCreator: ({ input, system }: {
     input: TInput;

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

@@ -18,7 +18,6 @@ export type PromiseActorLogic<TOutput, TInput = unknown> = ActorLogic<PromiseSna
     type: string;
     [k: string]: unknown;
 }, TInput, // input
-PromiseSnapshot<TOutput, TInput>, // persisted state
 ActorSystem<any>>;
 export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, unknown>>;
 export declare function fromPromise<TOutput, TInput = unknown>(promiseCreator: ({ input, system }: {

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

@@ -1,8 +1,8 @@
-import { ActorLogic, ActorContext, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot } from "../types.js";
+import { ActorLogic, ActorScope, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot } from "../types.js";
 export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
     context: TContext;
 };
-export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, TransitionSnapshot<TContext>, AnyActorSystem>;
+export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>;
 export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>>;
 /**
  * Returns actor logic from a transition function and its initial state.
@@ -13,7 +13,7 @@ export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefF
  * @param initialContext The initial state of the transition function.
  * @returns Actor logic
  */
-export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput>(transition: (state: TContext, event: TEvent, actorContext: ActorContext<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
+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 }: {
     input: TInput;
     self: TransitionActorRef<TContext, TEvent>;
 }) => TContext)): TransitionActorLogic<TContext, TEvent, TInput>;

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

@@ -1,20 +1,19 @@
 import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyState, NoRequiredParams, NoInfer, WithDynamicParams } from "./types.js";
-export type GuardPredicate<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject> = {
-    (args: GuardArgs<TContext, TExpressionEvent, TExpressionGuard>): boolean;
+export type GuardPredicate<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = {
+    (args: GuardArgs<TContext, TExpressionEvent>, params: TParams): boolean;
     _out_TGuard?: TGuard;
 };
-export interface GuardArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined> {
+export interface GuardArgs<TContext extends MachineContext, TExpressionEvent extends EventObject> {
     context: TContext;
     event: TExpressionEvent;
-    guard: TExpressionGuard;
 }
-export type Guard<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject> = NoRequiredParams<TGuard> | WithDynamicParams<TContext, TExpressionEvent, TGuard> | GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, TGuard>;
+export type Guard<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = NoRequiredParams<TGuard> | WithDynamicParams<TContext, TExpressionEvent, TGuard> | GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
 export type UnknownGuard = UnknownReferencedGuard | UnknownInlineGuard;
-type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedObject, ParameterizedObject>;
+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, TExpressionGuard extends ParameterizedObject | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, any>;
-export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject>(guard: Guard<TContext, TExpressionEvent, TExpressionGuard, NoInfer<TGuard>>): GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, TGuard>;
-export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TExpressionGuard, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, TGuard>;
-export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionGuard extends ParameterizedObject | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TExpressionGuard, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TExpressionGuard, TGuard>;
+export declare function stateIn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TParams, any>;
+export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guard: Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
+export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
+export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
 export declare function evaluateGuard<TContext extends MachineContext, TExpressionEvent extends EventObject>(guard: UnknownGuard | UnknownInlineGuard, context: TContext, event: TExpressionEvent, state: AnyState): boolean;
 export {};

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

@@ -1,6 +1,6 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
-import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, PersistedStateFrom, SnapshotFrom, AnyActorRef } from "./types.js";
+import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, SnapshotFrom, Snapshot } from "./types.js";
 import { ActorRef, EventObject, InteropSubscribable, ActorOptions, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
 export type SnapshotListener<TLogic extends AnyActorLogic> = (state: SnapshotFrom<TLogic>) => void;
@@ -20,6 +20,9 @@ export declare enum ActorStatus {
  * @deprecated Use `ActorStatus` instead.
  */
 export declare const InterpreterStatus: typeof ActorStatus;
+/**
+ * An Actor is a running process that can receive events, send events and change its behavior based on the events it receives, which can cause effects outside of the actor. When you run a state machine, it becomes an actor.
+ */
 export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<EventFromLogic<TLogic>, SnapshotFrom<TLogic>> {
     logic: TLogic;
     /**
@@ -45,12 +48,15 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
     status: ActorStatus;
     _parent?: ActorRef<any, any>;
     ref: ActorRef<EventFromLogic<TLogic>, SnapshotFrom<TLogic>>;
-    private _actorContext;
+    private _actorScope;
     private _systemId;
     /**
      * The globally unique process ID for this invocation.
      */
     sessionId: string;
+    /**
+     * The system to which this actor belongs.
+     */
     system: ActorSystem<any>;
     private _doneEvent?;
     src?: string;
@@ -64,6 +70,54 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
     private _initState;
     private _deferred;
     private update;
+    /**
+     * Subscribe an observer to an actor’s snapshot values.
+     *
+     * @remarks
+     * The observer will receive the actor’s snapshot value when it is emitted. The observer can be:
+     * - A plain function that receives the latest snapshot, or
+     * - An observer object whose `.next(snapshot)` method receives the latest snapshot
+     *
+     * @example
+     * ```ts
+     * // Observer as a plain function
+     * const subscription = actor.subscribe((snapshot) => {
+     *   console.log(snapshot);
+     * });
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Observer as an object
+     * const subscription = actor.subscribe({
+     *   next(snapshot) {
+     *     console.log(snapshot);
+     *   },
+     *   error(err) {
+     *     // ...
+     *   },
+     *   complete() {
+     *     // ...
+     *   },
+     * });
+     * ```
+     *
+     * The return value of `actor.subscribe(observer)` is a subscription object that has an `.unsubscribe()` method. You can call `subscription.unsubscribe()` to unsubscribe the observer:
+     *
+     * @example
+     * ```ts
+     * const subscription = actor.subscribe((snapshot) => {
+     *   // ...
+     * });
+     *
+     * // Unsubscribe the observer
+     * subscription.unsubscribe();
+     * ```
+     *
+     * When the actor is stopped, all of its observers will automatically be unsubscribed.
+     *
+     * @param observer - Either a plain function that receives the latest snapshot, or an observer object whose `.next(snapshot)` method receives the latest snapshot
+     */
     subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
     subscribe(nextListener?: (state: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     /**
@@ -85,20 +139,27 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
      * @param event The event to send
      */
     send(event: EventFromLogic<TLogic>): void;
-    delaySend(params: {
-        event: EventObject;
-        id: string | undefined;
-        delay: number;
-        to?: AnyActorRef;
-    }): void;
-    cancel(sendId: string | number): void;
     private attachDevTools;
     toJSON(): {
         xstate$$type: number;
         id: string;
     };
-    getPersistedState(): PersistedStateFrom<TLogic> | undefined;
+    getPersistedState(): Snapshot<unknown>;
     [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>>;
+    /**
+     * Read an actor’s snapshot synchronously.
+     *
+     * @remarks
+     * The snapshot represent an actor's last emitted value.
+     *
+     * When an actor receives an event, its internal state may change.
+     * An actor may emit a snapshot when a state transition occurs.
+     *
+     * Note that some actors, such as callback actors generated with `fromCallback`, will not emit snapshots.
+     *
+     * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
+     * @see {@link Actor.getPersistedState} to persist the internal state of an actor (which is more than just a snapshot).
+     */
     getSnapshot(): SnapshotFrom<TLogic>;
 }
 /**

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

@@ -1,5 +1,5 @@
-import { ActorRefFrom, AnyActorContext, AnyActorLogic, AnyActorRef, AnyEventObject, AnyState, InputFrom, IsLiteralString, ProvidedActor } from "./types.js";
-type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
+import { ActorRefFrom, AnyActorScope, AnyActorLogic, AnyActorRef, AnyEventObject, AnyState, InputFrom, IsLiteralString, ProvidedActor } from "./types.js";
+export type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
     src: TSrc;
 } ? 'id' extends keyof TActor ? [
     options: {
@@ -24,5 +24,4 @@ export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src'
     input?: unknown;
     syncSnapshot?: boolean;
 }) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>;
-export declare function createSpawner(actorContext: AnyActorContext, { machine, context }: AnyState, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;
-export {};
+export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyState, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;

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

@@ -1,6 +1,6 @@
 import { State } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { AnyActorContext, AnyEventObject, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, StateValueMap, TransitionDefinition, TODO, UnknownAction, AnyTransitionConfig } from "./types.js";
+import { AnyEventObject, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, StateValueMap, TransitionDefinition, TODO, UnknownAction, AnyTransitionConfig, AnyActorScope } from "./types.js";
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyConfiguration = Configuration<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
@@ -44,15 +44,10 @@ export declare function transitionNode<TContext extends MachineContext, TEvent e
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
- *
- * @private
- * @param transitions
- * @param currentState
- * @param mutConfiguration
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentState: AnyState, actorCtx: AnyActorContext, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyState;
-export declare function resolveActionsAndContext(currentState: AnyState, event: AnyEventObject, actorCtx: AnyActorContext, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyState;
-export declare function macrostep(state: AnyState, event: EventObject, actorCtx: AnyActorContext, internalQueue?: AnyEventObject[]): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentState: AnyState, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyState;
+export declare function resolveActionsAndContext(currentState: AnyState, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyState;
+export declare function macrostep(state: AnyState, event: EventObject, actorScope: AnyActorScope, internalQueue?: AnyEventObject[]): {
     state: typeof state;
     microstates: Array<typeof state>;
 };