xstate 5.0.0-beta.41 → 5.0.0-beta.43

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

@@ -1,7 +1,7 @@
-import { MachineSnapshot } from "./StateMachine.js";
 import type { StateNode } from "./StateNode.js";
+import type { StateMachine } from "./StateMachine.js";
 import { TypegenDisabled, TypegenEnabled } from "./typegenTypes.js";
-import type { ProvidedActor, ActorRefFrom, AnyState, AnyStateMachine, EventObject, HistoryValue, MachineContext, Prop, StateConfig, StateValue, TODO, AnyActorRef, Compute, EventDescriptor, Snapshot } from "./types.js";
+import type { ProvidedActor, ActorRefFrom, AnyState, AnyStateMachine, EventObject, HistoryValue, MachineContext, Prop, StateConfig, StateValue, AnyActorRef, Compute, EventDescriptor, Snapshot, ParameterizedObject } from "./types.js";
 type ComputeConcreteChildren<TActor extends ProvidedActor> = {
     [A in TActor as 'id' extends keyof A ? A['id'] & string : never]?: ActorRefFrom<A['logic']>;
 };
@@ -10,20 +10,14 @@ type ComputeChildren<TActor extends ProvidedActor> = string extends TActor['src'
 } : {})>;
 export declare function isStateConfig<TContext extends MachineContext, TEvent extends EventObject>(state: any): state is StateConfig<TContext, TEvent>;
 /**
- * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.
+ * @deprecated Use `isStateConfig(object)`
  */
 export declare const isState: typeof isStateConfig;
-export declare class State<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TResolvedTypesMeta = TypegenDisabled> {
-    machine: AnyStateMachine;
+interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> {
+    machine: StateMachine<TContext, TEvent, TActor, ParameterizedObject, ParameterizedObject, string, TTag, unknown, TOutput, TResolvedTypesMeta>;
     tags: Set<string>;
     value: StateValue;
-    /**
-     * Indicates whether the state is a final state.
-     */
     status: 'active' | 'done' | 'error' | 'stopped';
-    /**
-     * The output data of the top-level finite state.
-     */
     error: unknown;
     context: TContext;
     historyValue: Readonly<HistoryValue<TContext, TEvent>>;
@@ -36,39 +30,20 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      */
     children: ComputeChildren<TActor>;
     /**
-     * Creates a new State instance for the given `stateValue` and `context`.
-     * @param stateValue
-     * @param context
-     */
-    static from<TContext extends MachineContext, TEvent extends EventObject = EventObject>(stateValue: State<TContext, TEvent, TODO, any, // tags
-    any> | StateValue, context: TContext | undefined, machine: AnyStateMachine): State<TContext, TEvent, TODO, any, // tags
-    any>;
-    /**
-     * Creates a new `State` instance that represents the current state of a running machine.
-     *
-     * @param config
-     */
-    constructor(config: StateConfig<TContext, TEvent>, machine: AnyStateMachine);
-    /**
-     * Returns an array of all the string leaf state node paths.
-     * @param stateValue
-     * @param delimiter The character(s) that separate each subpath in the string state node path.
+     * The next events that will cause a transition from the current state.
      */
-    toStrings(stateValue?: StateValue): string[];
-    toJSON(): Omit<this, "toJSON" | "meta" | "tags" | "configuration" | "machine" | "toStrings" | "matches" | "hasTag" | "can" | "nextEvents"> & {
-        tags: string[];
-        meta: Record<string, any>;
-    };
+    nextEvents: Array<EventDescriptor<TEvent>>;
+    meta: Record<string, any>;
     /**
      * Whether the current state value is a subset of the given parent state value.
-     * @param parentStateValue
+     * @param testValue
      */
-    matches<TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'matchesStates'> : StateValue>(parentStateValue: TSV): boolean;
+    matches: <TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'matchesStates'> : StateValue>(this: MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, testValue: TSV) => boolean;
     /**
      * Whether the current state configuration has a state node with the specified `tag`.
      * @param tag
      */
-    hasTag(tag: TTag): boolean;
+    hasTag: (this: MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, tag: TTag) => boolean;
     /**
      * Determines whether sending the `event` will cause a non-forbidden transition
      * to be selected, even if the transitions have no actions nor
@@ -77,13 +52,31 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * @param event The event to test
      * @returns Whether the event will cause a transition
      */
-    can(event: TEvent): boolean;
-    /**
-     * The next events that will cause a transition from the current state.
-     */
-    get nextEvents(): Array<EventDescriptor<TEvent>>;
-    get meta(): Record<string, any>;
+    can: (this: MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, event: TEvent) => boolean;
+    toJSON: (this: MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>) => unknown;
+}
+interface ActiveMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> extends MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> {
+    status: 'active';
+    output: undefined;
+    error: undefined;
+}
+interface DoneMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> extends MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> {
+    status: 'done';
+    output: TOutput;
+    error: undefined;
+}
+interface ErrorMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> extends MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> {
+    status: 'error';
+    output: undefined;
+    error: unknown;
+}
+interface StoppedMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> extends MachineSnapshotBase<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> {
+    status: 'stopped';
+    output: undefined;
+    error: undefined;
 }
-export declare function cloneState<TState extends AnyState>(state: TState, config?: Partial<StateConfig<any, any>>): TState;
+export type MachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> = ActiveMachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> | DoneMachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> | ErrorMachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> | StoppedMachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
+export declare function createMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TResolvedTypesMeta = TypegenDisabled>(config: StateConfig<TContext, TEvent>, machine: AnyStateMachine): MachineSnapshot<TContext, TEvent, TActor, TTag, undefined, TResolvedTypesMeta>;
+export declare function cloneMachineSnapshot<TState extends AnyState>(state: TState, config?: Partial<StateConfig<any, any>>): TState;
 export declare function getPersistedState<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled>(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, options?: unknown): Snapshot<unknown>;
 export {};

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.
@@ -93,7 +77,6 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     get definition(): StateMachineDefinition<TContext, TEvent>;
     toJSON(): StateMachineDefinition<TContext, TEvent>;
     getPersistedState(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, options?: unknown): Snapshot<unknown>;
-    createState(stateConfig: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta> | StateConfig<TContext, TEvent>): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
     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/actions/spawn.d.ts

@@ -1,4 +1,4 @@
-import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg } from "../types.js";
+import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg, Mapper } 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;
@@ -9,7 +9,7 @@ type DistributeActors<TContext extends MachineContext, TExpressionEvent extends
     options: {
         id: ResolvableActorId<TContext, TExpressionEvent, TEvent, TActor['id']>;
         systemId?: string;
-        input?: InputFrom<TActor['logic']>;
+        input?: Mapper<TContext, TEvent, InputFrom<TActor['logic']>, TEvent> | InputFrom<TActor['logic']>;
         syncSnapshot?: boolean;
     }
 ] : [
@@ -17,7 +17,7 @@ type DistributeActors<TContext extends MachineContext, TExpressionEvent extends
     options?: {
         id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
         systemId?: string;
-        input?: InputFrom<TActor['logic']>;
+        input?: Mapper<TContext, TEvent, InputFrom<TActor['logic']>, TEvent> | InputFrom<TActor['logic']>;
         syncSnapshot?: boolean;
     }
 ] : never;

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

@@ -20,9 +20,62 @@ export type PromiseActorLogic<TOutput, TInput = unknown> = ActorLogic<PromiseSna
 }, TInput, // input
 ActorSystem<any>>;
 export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, unknown>>;
+/**
+ * An actor logic creator which returns promise logic as defined by an async process that resolves or rejects after some time.
+ *
+ * Actors created from promise actor logic (“promise actors”) can:
+ * - Emit the resolved value of the promise
+ * - Output the resolved value of the promise
+ *
+ * Sending events to promise actors will have no effect.
+ *
+ * @param promiseCreator
+ *   A function which returns a Promise, and accepts an object with the following properties:
+ *   - `input` - Data that was provided to the promise actor
+ *   - `self` - The parent actor of the promise actor
+ *   - `system` - The actor system to which the promise actor belongs
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ *
+ * @example
+ * ```ts
+ * const promiseLogic = fromPromise(async () => {
+ *   const result = await fetch('https://example.com/...')
+ *     .then((data) => data.json());
+ *
+ *   return result;
+ * });
+ *
+ * const promiseActor = createActor(promiseLogic);
+ * promiseActor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ * promiseActor.start();
+ * // => {
+ * //   output: undefined,
+ * //   status: 'active'
+ * //   ...
+ * // }
+ *
+ * // After promise resolves
+ * // => {
+ * //   output: { ... },
+ * //   status: 'done',
+ * //   ...
+ * // }
+ * ```
+ */
 export declare function fromPromise<TOutput, TInput = unknown>(promiseCreator: ({ input, system }: {
+    /**
+     * Data that was provided to the promise actor
+     */
     input: TInput;
+    /**
+     * The actor system to which the promise actor belongs
+     */
     system: AnyActorSystem;
+    /**
+     * The parent actor of the promise actor
+     */
     self: PromiseActorRef<TOutput>;
 }) => PromiseLike<TOutput>): PromiseActorLogic<TOutput, TInput>;
 export {};

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, 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, createActor, createMachine, interpret, 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

@@ -136,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 { MachineSnapshot } from "./State.js";
 import type { Clock, Actor } from "./interpreter.js";
-import type { MachineSnapshot, StateMachine } from "./StateMachine.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>;
@@ -391,11 +387,8 @@ type MaybeNarrowedEvent<TIndexedEvents, TCausingLookup, K> = Cast<Prop<TIndexedE
 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']>;
 };
-type MachineImplementationsActors<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActors'>, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
-    [K in keyof TIndexedActors]?: Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic> | {
-        src: Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>;
-        input: Mapper<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingActors, K>, InputFrom<Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>> | InputFrom<Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>>;
-    };
+type MachineImplementationsActors<_TContext extends MachineContext, TResolvedTypesMeta, TIndexedActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActors'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
+    [K in keyof TIndexedActors]?: Cast<Prop<TIndexedActors[K], 'logic'>, AnyActorLogic>;
 };
 type MachineImplementationsDelays<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
     [K in keyof TIndexedDelays]?: DelayConfig<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingDelays, K>, Cast<Prop<Prop<TIndexedActions, keyof TIndexedActions>, 'params'>, ParameterizedObject['params'] | undefined> | undefined, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
@@ -546,22 +539,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> {
+    /**
+     * 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}
+     */
     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.
      */
@@ -572,7 +580,6 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      * Default: `false`
      */
     devTools?: boolean | DevToolsAdapter;
-    sync?: boolean;
     /**
      * The system ID to register this actor under
      */
@@ -581,11 +588,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 | 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>;
@@ -680,14 +774,52 @@ export type Snapshot<TOutput> = {
     output: undefined;
     error: undefined;
 };
+/**
+ * Represents logic which can be used by an actor.
+ *
+ * @template TSnapshot - The type of the snapshot.
+ * @template TEvent - The type of the event object.
+ * @template TInput - The type of the input.
+ * @template TSystem - The type of the actor system.
+ */
 export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = unknown, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+    /** The initial setup/configuration used to create the actor logic. */
     config?: unknown;
+    /**
+     * Transition function that processes the current state and an incoming message
+     * to produce a new state.
+     * @param state - The current state.
+     * @param message - The incoming message.
+     * @param ctx - The actor scope.
+     * @returns The new state.
+     */
     transition: (state: TSnapshot, message: TEvent, ctx: ActorScope<TSnapshot, TEvent, TSystem>) => TSnapshot;
+    /**
+     * Called to provide the initial state of the actor.
+     * @param actorScope - The actor scope.
+     * @param input - The input for the initial state.
+     * @returns The initial state.
+     */
     getInitialState: (actorScope: ActorScope<TSnapshot, TEvent, TSystem>, input: TInput) => TSnapshot;
+    /**
+     * Called when Actor is created to restore the internal state of the actor given a persisted state.
+     * The persisted state can be created by `getPersistedState`.
+     * @param persistedState - The persisted state to restore from.
+     * @param actorScope - The actor scope.
+     * @returns The restored state.
+     */
     restoreState?: (persistedState: Snapshot<unknown>, actorScope: ActorScope<TSnapshot, TEvent>) => TSnapshot;
+    /**
+     * Called when the actor is started.
+     * @param state - The starting state.
+     * @param actorScope - The actor scope.
+     */
     start?: (state: TSnapshot, actorScope: ActorScope<TSnapshot, TEvent>) => void;
     /**
-     * @returns Persisted state
+     * Obtains the internal state of the actor in a representation which can be be persisted.
+     * The persisted state can be restored by `restoreState`.
+     * @param state - The current state.
+     * @returns The a representation of the internal state to be persisted.
      */
     getPersistedState: (state: TSnapshot, options?: unknown) => Snapshot<unknown>;
 }
@@ -697,9 +829,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;