xstate 5.0.0-beta.40 → 5.0.0-beta.42

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

@@ -1,26 +1,9 @@
-import { State } from "./State.js";
+import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import type { ActorScope, ActorLogic, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, ParameterizedObject, AnyActorScope, ProvidedActor, Equals, TODO, Snapshot } from "./types.js";
+import type { ActorScope, ActorLogic, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateMachineDefinition, StateValue, TransitionDefinition, ParameterizedObject, AnyActorScope, ProvidedActor, Equals, TODO, Snapshot, HistoryValue } from "./types.js";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export type MachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> = (State<TContext, TEvent, TActor, TTag, TResolvedTypesMeta> & {
-    status: 'active';
-    output: undefined;
-    error: undefined;
-}) | (State<TContext, TEvent, TActor, TTag, TResolvedTypesMeta> & {
-    status: 'done';
-    output: TOutput;
-    error: undefined;
-}) | (State<TContext, TEvent, TActor, TTag, TResolvedTypesMeta> & {
-    status: 'error';
-    output: undefined;
-    error: unknown;
-}) | (State<TContext, TEvent, TActor, TTag, TResolvedTypesMeta> & {
-    status: 'stopped';
-    output: undefined;
-    error: undefined;
-});
 export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag>> implements ActorLogic<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, TODO> {
     /**
      * The raw config used to create the machine.
@@ -53,15 +36,16 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @returns A new `StateMachine` instance with the provided implementations.
      */
     provide(implementations: InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
-    /**
-     * Resolves the given `state` to a new `State` instance relative to this machine.
-     *
-     * This ensures that `.nextEvents` represent the correct values.
-     *
-     * @param state The state to resolve
-     */
-    resolveState(state: State<TContext, TEvent, TActor, TTag, TResolvedTypesMeta>): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
-    resolveStateValue(stateValue: StateValue, ...[context]: Equals<TContext, MachineContext> extends true ? [] : [TContext]): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
+    resolveState(config: {
+        value: StateValue;
+        context?: TContext;
+        historyValue?: HistoryValue<TContext, TEvent>;
+        status?: 'active' | 'done' | 'error' | 'stopped';
+        output?: TOutput;
+        error?: unknown;
+    } & (Equals<TContext, MachineContext> extends false ? {
+        context: unknown;
+    } : {})): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and received `event`.
      * Calculates a full macrostep from all microsteps.
@@ -92,8 +76,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;
     toJSON(): StateMachineDefinition<TContext, TEvent>;
-    getPersistedState(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>): Snapshot<unknown>;
-    createState(stateConfig: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> | StateConfig<TContext, TEvent>): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
+    getPersistedState(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, options?: unknown): Snapshot<unknown>;
     restoreState(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent>): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
     /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TContext: TContext;

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

@@ -1,4 +1,4 @@
-import type { State } from "./State.js";
+import { MachineSnapshot } from "./State.js";
 import type { StateMachine } from "./StateMachine.js";
 import type { DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, InvokeDefinition, MachineContext, Mapper, StateNodeConfig, StateNodeDefinition, StateNodesConfig, TransitionDefinition, TransitionDefinitionMap, TODO, UnknownAction, ParameterizedObject, AnyStateMachine, ProvidedActor, NonReducibleUnknown } from "./types.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
@@ -113,7 +113,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     get on(): TransitionDefinitionMap<TContext, TEvent>;
     get after(): Array<DelayedTransitionDefinition<TContext, TEvent>>;
     get initial(): InitialTransitionDefinition<TContext, TEvent>;
-    next(state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): TransitionDefinition<TContext, TEvent>[] | undefined;
+    next(state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): TransitionDefinition<TContext, TEvent>[] | undefined;
     /**
      * All the event types accepted by this state node and its descendants.
      */

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

@@ -2,18 +2,17 @@ export * from "./actions.js";
 export * from "./actors/index.js";
 export { SimulatedClock } from "./SimulatedClock.js";
 export { type Spawner } from "./spawn.js";
-export { StateMachine, type MachineSnapshot } from "./StateMachine.js";
+export { StateMachine } from "./StateMachine.js";
 export { getStateNodes } from "./stateUtils.js";
 export * from "./typegenTypes.js";
 export * from "./types.js";
 export { waitFor } from "./waitFor.js";
-import { Actor, ActorStatus, createActor, interpret, Interpreter, InterpreterStatus } from "./interpreter.js";
+import { Actor, createActor, interpret, Interpreter } from "./interpreter.js";
 import { createMachine } from "./Machine.js";
-import { mapState } from "./mapState.js";
-import { State } from "./State.js";
+export { type MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 export { matchesState, pathToStateValue, toObserver } from "./utils.js";
-export { Actor, ActorStatus, createActor, createMachine, interpret, InterpreterStatus, mapState, State, StateNode, type Interpreter };
+export { Actor, createActor, createMachine, interpret, StateNode, type Interpreter };
 export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./system.js";
 export { and, not, or, stateIn } from "./guards.js";
 declare global {

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

@@ -11,15 +11,11 @@ export interface Clock {
     setTimeout(fn: (...args: any[]) => void, timeout: number): any;
     clearTimeout(id: any): void;
 }
-export declare enum ActorStatus {
+export declare enum ProcessingStatus {
     NotStarted = 0,
     Running = 1,
     Stopped = 2
 }
-/**
- * @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.
  */
@@ -42,10 +38,6 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
     private delayedEventsMap;
     private observers;
     private logger;
-    /**
-     * Whether the service is started.
-     */
-    status: ActorStatus;
     _parent?: ActorRef<any, any>;
     ref: ActorRef<EventFromLogic<TLogic>, SnapshotFrom<TLogic>>;
     private _actorScope;
@@ -59,7 +51,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
      */
     system: ActorSystem<any>;
     private _doneEvent?;
-    src?: string;
+    src: string | AnyActorLogic;
     /**
      * Creates a new actor instance for the given logic with the provided options, if any.
      *
@@ -144,6 +136,18 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
         xstate$$type: number;
         id: string;
     };
+    /**
+     * Obtain the internal state of the actor, which can be persisted.
+     *
+     * @remarks
+     * The internal state can be persisted from any actor, not only machines.
+     *
+     * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+     *
+     * Can be restored with {@link ActorOptions.state}
+     *
+     * @see https://stately.ai/docs/persistence
+     */
     getPersistedState(): Snapshot<unknown>;
     [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>>;
     /**

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

@@ -1,4 +1,4 @@
-import { State } from "./State.js";
+import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.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>>;
@@ -34,13 +34,13 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
 /**
  * Returns the state nodes represented by the current state value.
  *
- * @param state The state value or State instance
+ * @param stateValue The state value or State instance
  */
-export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent, TODO, TODO, TODO>): Array<AnyStateNode>;
-export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+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, state: MachineSnapshot<TContext, TEvent, 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, state: MachineSnapshot<TContext, TEvent, 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, state: MachineSnapshot<TContext, TEvent, 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, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -58,5 +58,4 @@ export declare function macrostep(state: AnyState, event: EventObject, actorScop
  */
 export declare function resolveStateValue(rootNode: AnyStateNode, stateValue: StateValue): StateValue;
 export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
-export declare function getInitialConfiguration(rootNode: AnyStateNode): AnyStateNode[];
 export {};

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

@@ -1,7 +1,7 @@
 import type { StateNode } from "./StateNode.js";
-import type { State } from "./State.js";
-import type { ActorStatus, Clock, Actor } from "./interpreter.js";
-import type { MachineSnapshot, StateMachine } from "./StateMachine.js";
+import type { MachineSnapshot } from "./State.js";
+import type { Clock, Actor } from "./interpreter.js";
+import type { StateMachine } from "./StateMachine.js";
 import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from "./typegenTypes.js";
 import { PromiseActorLogic } from "./actors/promise.js";
 import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
@@ -347,11 +347,7 @@ export interface StateMachineDefinition<TContext extends MachineContext, TEvent
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
-export type AnyState = State<any, // context
-any, // event
-any, // actor
-any, // tags
-any>;
+export type AnyState = MachineSnapshot<any, any, any, any, any, any>;
 export type AnyStateMachine = StateMachine<any, any, any, any, any, any, any, any, any, // delays
 any>;
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
@@ -546,26 +542,37 @@ export interface StateLike<TContext extends MachineContext> {
     event: EventObject;
 }
 export interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
-    value: StateValue;
     context: TContext;
     historyValue?: HistoryValue<TContext, TEvent>;
-    meta?: any;
-    configuration?: Array<StateNode<TContext, TEvent>>;
+    configuration: Array<StateNode<TContext, TEvent>>;
     children: Record<string, ActorRef<any, any>>;
     status: 'active' | 'done' | 'error' | 'stopped';
     output?: any;
     error?: unknown;
-    tags?: Set<string>;
     machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any>;
 }
 export interface ActorOptions<TLogic extends AnyActorLogic> {
     /**
-     * Whether state actions should be executed immediately upon transition. Defaults to `true`.
+     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     *
+     * @remarks
+     * You can create your own “clock”. The clock interface is an object with two functions/methods:
+     *
+     * - `setTimeout` - same arguments as `window.setTimeout(fn, timeout)`
+     * - `clearTimeout` - same arguments as `window.clearTimeout(id)`
+     *
+     * By default, the native `setTimeout` and `clearTimeout` functions are used.
+     *
+     * For testing, XState provides `SimulatedClock`.
+     *
+     * @see {@link Clock}
+     * @see {@link SimulatedClock}
      */
-    execute?: boolean;
     clock?: Clock;
+    /**
+     * 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.
      */
@@ -576,7 +583,6 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      * Default: `false`
      */
     devTools?: boolean | DevToolsAdapter;
-    sync?: boolean;
     /**
      * The system ID to register this actor under
      */
@@ -585,11 +591,98 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      * The input data to pass to the actor.
      */
     input?: InputFrom<TLogic>;
+    /**
+     * Initializes actor logic from a specific persisted internal state.
+     *
+     * @remarks
+     *
+     * If the state is compatible with the actor logic, when the actor is started it will be at that persisted state.
+     * Actions from machine actors will not be re-executed, because they are assumed to have been already executed.
+     * However, invocations will be restarted, and spawned actors will be restored recursively.
+     *
+     * Can be generated with {@link Actor.getPersistedState}.
+     *
+     * @see https://stately.ai/docs/persistence
+     */
     state?: any;
     /**
      * The source definition.
      */
-    src?: string;
+    src?: string | AnyActorLogic;
+    /**
+     * A callback function or observer object which can be used to inspect actor system updates.
+     *
+     * @remarks
+     * If a callback function is provided, it can accept an inspection event argument. The types of inspection events that can be observed include:
+     *
+     * - `@xstate.actor` - An actor ref has been created in the system
+     * - `@xstate.event` - An event was sent from a source actor ref to a target actor ref in the system
+     * - `@xstate.snapshot` - An actor ref emitted a snapshot due to a received event
+     *
+     * @example
+     * ```ts
+     * import { createMachine } from 'xstate';
+     *
+     * const machine = createMachine({
+     *   // ...
+     * });
+     *
+     * const actor = createActor(machine, {
+     *   inspect: (inspectionEvent) => {
+     *     if (inspectionEvent.actorRef === actor) {
+     *       // This event is for the root actor
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.actor') {
+     *       console.log(inspectionEvent.actorRef);
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.event') {
+     *       console.log(inspectionEvent.sourceRef);
+     *       console.log(inspectionEvent.actorRef);
+     *       console.log(inspectionEvent.event);
+     *     }
+     *
+     *     if (inspectionEvent.type === '@xstate.snapshot') {
+     *       console.log(inspectionEvent.actorRef);
+     *       console.log(inspectionEvent.event);
+     *       console.log(inspectionEvent.snapshot);
+     *     }
+     *   }
+     * });
+     * ```
+     *
+     * Alternately, an observer object (`{ next?, error?, complete? }`) can be provided:
+     *
+     * @example
+     * ```ts
+     * const actor = createActor(machine, {
+     *   inspect: {
+     *     next: (inspectionEvent) => {
+     *       if (inspectionEvent.actorRef === actor) {
+     *         // This event is for the root actor
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.actor') {
+     *         console.log(inspectionEvent.actorRef);
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.event') {
+     *         console.log(inspectionEvent.sourceRef);
+     *         console.log(inspectionEvent.actorRef);
+     *         console.log(inspectionEvent.event);
+     *       }
+     *
+     *       if (inspectionEvent.type === '@xstate.snapshot') {
+     *         console.log(inspectionEvent.actorRef);
+     *         console.log(inspectionEvent.event);
+     *         console.log(inspectionEvent.snapshot);
+     *       }
+     *     }
+     *   }
+     * });
+     * ```
+     */
     inspect?: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void);
 }
 export type AnyActor = Actor<any>;
@@ -636,8 +729,7 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot extends Snapshot
     toJSON?: () => any;
     _parent?: ActorRef<any, any>;
     system?: ActorSystem<any>;
-    status: ActorStatus;
-    src?: string;
+    src: string | AnyActorLogic;
 }
 export type AnyActorRef = ActorRef<any, any>;
 export type ActorLogicFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<any, any, any, any, any, any, any, any, any> ? R : R extends Promise<infer U> ? PromiseActorLogic<U> : never : never;
@@ -694,7 +786,7 @@ export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends
     /**
      * @returns Persisted state
      */
-    getPersistedState: (state: TSnapshot) => Snapshot<unknown>;
+    getPersistedState: (state: TSnapshot, options?: unknown) => Snapshot<unknown>;
 }
 export type AnyActorLogic = ActorLogic<any, // snapshot
 any, // event
@@ -702,9 +794,9 @@ any, // input
 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 StateMachine<infer _TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? StateFrom<R> : R extends ActorLogic<any, any, any, any> ? 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 _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends State<infer _TContext, infer TEvent, infer _TActor, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
+type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TActor, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
 export type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
-export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends State<infer TContext, infer _TEvent, infer _TActor, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
+export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends MachineSnapshot<infer TContext, infer _TEvent, infer _TActor, infer _TTag, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
 export type InferEvent<E extends EventObject> = {
     [T in E['type']]: {
         type: T;

package/dist/{interpreter-bae5c279.development.cjs.js → interpreter-23e4041c.development.cjs.js}

@@ -2,15 +2,6 @@
 
 var dev_dist_xstateDev = require('../dev/dist/xstate-dev.development.cjs.js');
 
-const STATE_DELIMITER = '.';
-const TARGETLESS_KEY = '';
-const NULL_EVENT = '';
-const STATE_IDENTIFIER = '#';
-const WILDCARD = '*';
-const XSTATE_INIT = 'xstate.init';
-const XSTATE_ERROR = 'xstate.error';
-const XSTATE_STOP = 'xstate.stop';
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -58,6 +49,15 @@ class Mailbox {
   }
 }
 
+const STATE_DELIMITER = '.';
+const TARGETLESS_KEY = '';
+const NULL_EVENT = '';
+const STATE_IDENTIFIER = '#';
+const WILDCARD = '*';
+const XSTATE_INIT = 'xstate.init';
+const XSTATE_ERROR = 'xstate.error';
+const XSTATE_STOP = 'xstate.stop';
+
 /**
  * Returns an event that represents an implicit event that
  * is sent after the specified `delay`.
@@ -336,17 +336,13 @@ function resolveReferencedActor(machine, src) {
 }
 
 const $$ACTOR_TYPE = 1;
-let ActorStatus = /*#__PURE__*/function (ActorStatus) {
-  ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
-  ActorStatus[ActorStatus["Running"] = 1] = "Running";
-  ActorStatus[ActorStatus["Stopped"] = 2] = "Stopped";
-  return ActorStatus;
+// those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync
+let ProcessingStatus = /*#__PURE__*/function (ProcessingStatus) {
+  ProcessingStatus[ProcessingStatus["NotStarted"] = 0] = "NotStarted";
+  ProcessingStatus[ProcessingStatus["Running"] = 1] = "Running";
+  ProcessingStatus[ProcessingStatus["Stopped"] = 2] = "Stopped";
+  return ProcessingStatus;
 }({});
-
-/**
- * @deprecated Use `ActorStatus` instead.
- */
-const InterpreterStatus = ActorStatus;
 const defaultOptions = {
   clock: {
     setTimeout: (fn, ms) => {
@@ -376,9 +372,7 @@ class Actor {
    * The unique identifier for this actor relative to its parent.
    */
 
-  /**
-   * Whether the service is started.
-   */
+  /** @internal */
 
   // Actor Ref
 
@@ -408,7 +402,7 @@ class Actor {
     this.delayedEventsMap = {};
     this.observers = new Set();
     this.logger = void 0;
-    this.status = ActorStatus.NotStarted;
+    this._processingStatus = ProcessingStatus.NotStarted;
     this._parent = void 0;
     this.ref = void 0;
     this._actorScope = void 0;
@@ -441,7 +435,7 @@ class Actor {
     this.clock = clock;
     this._parent = parent;
     this.options = resolvedOptions;
-    this.src = resolvedOptions.src;
+    this.src = resolvedOptions.src ?? logic;
     this.ref = this;
     this._actorScope = {
       self: this,
@@ -467,14 +461,14 @@ class Actor {
       type: '@xstate.actor',
       actorRef: this
     });
-    this._initState();
+    this._initState(options?.state);
     if (systemId && this._state.status === 'active') {
       this._systemId = systemId;
       this.system._set(systemId, this);
     }
   }
-  _initState() {
-    this._state = this.options.state ? this.logic.restoreState ? this.logic.restoreState(this.options.state, this._actorScope) : this.options.state : this.logic.getInitialState(this._actorScope, this.options?.input);
+  _initState(persistedState) {
+    this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
   }
 
   // array of functions to defer
@@ -489,7 +483,6 @@ class Actor {
       deferredFn();
     }
     for (const observer of this.observers) {
-      // TODO: should observers be notified in case of the error?
       try {
         observer.next?.(snapshot);
       } catch (err) {
@@ -572,7 +565,7 @@ class Actor {
 
   subscribe(nextListenerOrObserver, errorListener, completeListener) {
     const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
-    if (this.status !== ActorStatus.Stopped) {
+    if (this._processingStatus !== ProcessingStatus.Stopped) {
       this.observers.add(observer);
     } else {
       try {
@@ -592,7 +585,7 @@ class Actor {
    * Starts the Actor from the initial state
    */
   start() {
-    if (this.status === ActorStatus.Running) {
+    if (this._processingStatus === ProcessingStatus.Running) {
       // Do not restart the service if it is already started
       return this;
     }
@@ -600,7 +593,9 @@ class Actor {
     if (this._systemId) {
       this.system._set(this._systemId, this);
     }
-    this.status = ActorStatus.Running;
+    this._processingStatus = ProcessingStatus.Running;
+
+    // TODO: this isn't correct when rehydrating
     const initEvent = createInitEvent(this.options.input);
     this.system._sendInspectionEvent({
       type: '@xstate.event',
@@ -668,12 +663,12 @@ class Actor {
     }
   }
   _stop() {
-    if (this.status === ActorStatus.Stopped) {
+    if (this._processingStatus === ProcessingStatus.Stopped) {
       return this;
     }
     this.mailbox.clear();
-    if (this.status === ActorStatus.NotStarted) {
-      this.status = ActorStatus.Stopped;
+    if (this._processingStatus === ProcessingStatus.NotStarted) {
+      this._processingStatus = ProcessingStatus.Stopped;
       return this;
     }
     this.mailbox.enqueue({
@@ -724,7 +719,7 @@ class Actor {
     }
   }
   _stopProcedure() {
-    if (this.status !== ActorStatus.Running) {
+    if (this._processingStatus !== ProcessingStatus.Running) {
       // Actor already stopped; do nothing
       return this;
     }
@@ -741,7 +736,7 @@ class Actor {
     // it seems like this should be the common behavior for all of our consumers
     // so perhaps this should be unified somehow for all of them
     this.mailbox = new Mailbox(this._process.bind(this));
-    this.status = ActorStatus.Stopped;
+    this._processingStatus = ProcessingStatus.Stopped;
     this.system._unregister(this);
     return this;
   }
@@ -750,7 +745,7 @@ class Actor {
    * @internal
    */
   _send(event) {
-    if (this.status === ActorStatus.Stopped) {
+    if (this._processingStatus === ProcessingStatus.Stopped) {
       // do nothing
       {
         const eventString = JSON.stringify(event);
@@ -816,8 +811,22 @@ class Actor {
       id: this.id
     };
   }
-  getPersistedState() {
-    return this.logic.getPersistedState(this._state);
+
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.state}
+   *
+   * @see https://stately.ai/docs/persistence
+   */
+
+  getPersistedState(options) {
+    return this.logic.getPersistedState(this._state, options);
   }
   [symbolObservable]() {
     return this;
@@ -867,9 +876,8 @@ const interpret = createActor;
 
 exports.$$ACTOR_TYPE = $$ACTOR_TYPE;
 exports.Actor = Actor;
-exports.ActorStatus = ActorStatus;
-exports.InterpreterStatus = InterpreterStatus;
 exports.NULL_EVENT = NULL_EVENT;
+exports.ProcessingStatus = ProcessingStatus;
 exports.STATE_DELIMITER = STATE_DELIMITER;
 exports.STATE_IDENTIFIER = STATE_IDENTIFIER;
 exports.WILDCARD = WILDCARD;
@@ -894,5 +902,4 @@ exports.resolveReferencedActor = resolveReferencedActor;
 exports.toArray = toArray;
 exports.toObserver = toObserver;
 exports.toStatePath = toStatePath;
-exports.toStateValue = toStateValue;
 exports.toTransitionConfigArray = toTransitionConfigArray;