xstate 5.0.0-beta.8 → 5.0.0

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

@@ -1,13 +1,68 @@
-import { ActorBehavior, ActorContext, ActorSystem, EventObject } from '../types';
+import { ActorLogic, ActorScope, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot, NonReducibleUnknown } from "../types.js";
+export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
+    context: TContext;
+};
+export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput extends NonReducibleUnknown> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>;
+export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>>;
 /**
- * Returns an actor behavior from a transition function and its initial state.
+ * Returns actor logic given a transition function and its initial state.
  *
- * A transition function is a function that takes the current state and an event and returns the next state.
+ * A “transition function” is a function that takes the current `state` and received `event` object as arguments, and returns the next state, similar to a reducer.
  *
- * @param transition The transition function that returns the next state given the current state and event.
- * @param initialState The initial state of the transition function.
- * @returns An actor behavior
+ * Actors created from transition logic (“transition actors”) can:
+ *
+ * - Receive events
+ * - Emit snapshots of its state
+ *
+ * The transition function’s `state` is used as its transition actor’s `context`.
+ *
+ * Note that the "state" for a transition function is provided by the initial state argument, and is not the same as the State object of an actor or a state within a machine configuration.
+ *
+ * @param transition The transition function used to describe the transition logic. It should return the next state given the current state and event. It receives the following arguments:
+ * - `state` - the current state.
+ * - `event` - the received event.
+ * - `actorScope` - the actor scope object, with properties like `self` and `system`.
+ * @param initialContext The initial state of the transition function, either an object representing the state, or a function which returns a state object. If a function, it will receive as its only argument an object with the following properties:
+ * - `input` - the `input` provided to its parent transition actor.
+ * - `self` - a reference to its parent transition actor.
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ * @returns Actor logic
+ *
+ * @example
+ * ```ts
+ * const transitionLogic = fromTransition(
+ *   (state, event) => {
+ *     if (event.type === 'increment') {
+ *       return {
+ *         ...state,
+ *         count: state.count + 1,
+ *       };
+ *     }
+ *     return state;
+ *   },
+ *   { count: 0 },
+ * );
+ *
+ * const transitionActor = createActor(transitionLogic);
+ * transitionActor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ * transitionActor.start();
+ * // => {
+ * //   status: 'active',
+ * //   context: { count: 0 },
+ * //   ...
+ * // }
+ *
+ * transitionActor.send({ type: 'increment' });
+ * // => {
+ * //   status: 'active',
+ * //   context: { count: 1 },
+ * //   ...
+ * // }
+ * ```
  */
-export declare function fromTransition<TState, TEvent extends EventObject, TSystem extends ActorSystem<any>>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState, TSystem>) => TState, initialState: TState | (({ input }: {
-    input: any;
-}) => TState)): ActorBehavior<TEvent, TState, TState>;
+export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput extends NonReducibleUnknown>(transition: (snapshot: 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/constants.d.ts

@@ -3,3 +3,6 @@ export declare const TARGETLESS_KEY = "";
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
+export declare const XSTATE_INIT = "xstate.init";
+export declare const XSTATE_ERROR = "xstate.error";
+export declare const XSTATE_STOP = "xstate.stop";

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

@@ -0,0 +1,20 @@
+import { StateMachine } from "./StateMachine.js";
+import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from "./typegenTypes.js";
+import { AnyActorRef, AnyEventObject, Cast, InternalMachineImplementations, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, Prop, ProvidedActor, StateValue, ToChildren } from "./types.js";
+type TestValue = string | {
+    [k: string]: TestValue | undefined;
+};
+type _GroupTestValues<TTestValue extends string | TestValue> = TTestValue extends string ? TTestValue extends `${string}.${string}` ? [never, never] : [TTestValue, never] : [never, TTestValue];
+type GroupTestValues<TTestValue extends string | TestValue> = {
+    leafCandidates: _GroupTestValues<TTestValue>[0];
+    nonLeaf: _GroupTestValues<TTestValue>[1];
+};
+type FilterLeafValues<TLeafCandidate extends string, TNonLeaf extends {
+    [k: string]: TestValue | undefined;
+}> = IsNever<TNonLeaf> extends true ? TLeafCandidate : TLeafCandidate extends string ? TLeafCandidate extends keyof TNonLeaf ? never : TLeafCandidate : never;
+type ToStateValue<TTestValue extends string | TestValue> = FilterLeafValues<GroupTestValues<TTestValue>['leafCandidates'], GroupTestValues<TTestValue>['nonLeaf']> | (IsNever<GroupTestValues<TTestValue>['nonLeaf']> extends false ? {
+    [K in keyof GroupTestValues<TTestValue>['nonLeaf']]: ToStateValue<NonNullable<GroupTestValues<TTestValue>['nonLeaf'][K]>>;
+} : never);
+export declare function createMachine<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
+TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, TActor, TAction, TGuard, TDelay, 'matchesStates' extends keyof TTypesMeta ? ToStateValue<Cast<TTypesMeta['matchesStates'], TestValue>> : StateValue, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>['resolved'], 'tags'> & string, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
+export {};

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

@@ -1,14 +1,14 @@
-import { AnyInterpreter, DevToolsAdapter } from '../types.ts';
-type ServiceListener = (service: AnyInterpreter) => void;
+import { AnyActor, DevToolsAdapter } from "../types.js";
+type ServiceListener = (service: AnyActor) => void;
 export interface XStateDevInterface {
-    register: (service: AnyInterpreter) => void;
-    unregister: (service: AnyInterpreter) => void;
+    register: (service: AnyActor) => void;
+    unregister: (service: AnyActor) => void;
     onRegister: (listener: ServiceListener) => {
         unsubscribe: () => void;
     };
-    services: Set<AnyInterpreter>;
+    services: Set<AnyActor>;
 }
 export declare function getGlobal(): typeof globalThis | undefined;
-export declare function registerService(service: AnyInterpreter): void;
+export declare function registerService(service: AnyActor): void;
 export declare const devToolsAdapter: DevToolsAdapter;
 export {};

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

@@ -1,8 +1,41 @@
-import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, SCXML, GuardPredicate, MachineContext } from './types.ts';
-import type { State } from './State.ts';
-export declare function stateIn<TContext extends MachineContext, TEvent extends EventObject>(stateValue: StateValue): GuardDefinition<TContext, TEvent>;
-export declare function not<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardConfig<TContext, TEvent>): BooleanGuardDefinition<TContext, TEvent>;
-export declare function and<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;
-export declare function or<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;
-export declare function evaluateGuard<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardDefinition<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
-export declare function toGuardDefinition<TContext extends MachineContext, TEvent extends EventObject>(guardConfig: GuardConfig<TContext, TEvent>, getPredicate?: (guardType: string) => GuardPredicate<TContext, TEvent>): GuardDefinition<TContext, TEvent>;
+import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyMachineSnapshot, NoRequiredParams, NoInfer, WithDynamicParams, Identity, Elements } from "./types.js";
+type SingleGuardArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuardArg> = [TGuardArg] extends [{
+    type: string;
+}] ? Identity<TGuardArg> : [TGuardArg] extends [string] ? TGuardArg : GuardPredicate<TContext, TExpressionEvent, TParams, ParameterizedObject>;
+type NormalizeGuardArg<TGuardArg> = TGuardArg extends {
+    type: string;
+} ? Identity<TGuardArg> & {
+    params: unknown;
+} : TGuardArg extends string ? {
+    type: TGuardArg;
+    params: undefined;
+} : '_out_TGuard' extends keyof TGuardArg ? TGuardArg['_out_TGuard'] & ParameterizedObject : never;
+type NormalizeGuardArgArray<TArg extends unknown[]> = Elements<{
+    [K in keyof TArg]: NormalizeGuardArg<TArg[K]>;
+}>;
+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> {
+    context: TContext;
+    event: TExpressionEvent;
+}
+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['params'], ParameterizedObject>;
+type UnknownInlineGuard = Guard<MachineContext, EventObject, undefined, ParameterizedObject>;
+export declare function stateIn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TParams, any>;
+export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg>(guard: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg>): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArg<NoInfer<TArg>>>;
+export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
+    ...{
+        [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;
+    }
+]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<NoInfer<TArg>>>;
+export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
+    ...{
+        [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;
+    }
+]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<NoInfer<TArg>>>;
+export declare function evaluateGuard<TContext extends MachineContext, TExpressionEvent extends EventObject>(guard: UnknownGuard | UnknownInlineGuard, context: TContext, event: TExpressionEvent, snapshot: AnyMachineSnapshot): boolean;
+export {};

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

@@ -1,26 +1,21 @@
-import { doneInvoke, forwardTo, sendParent, sendTo } from './actions.ts';
-export { assign } from './actions/assign.ts';
-export { cancel } from './actions/cancel.ts';
-export { choose } from './actions/choose.ts';
-export { log } from './actions/log.ts';
-export { pure } from './actions/pure.ts';
-export { raise } from './actions/raise.ts';
-export { stop } from './actions/stop.ts';
-import { interpret, Interpreter, ActorStatus } from './interpreter.ts';
-import { createMachine } from './Machine.ts';
-import { mapState } from './mapState.ts';
-import { State } from './State.ts';
-import { StateNode } from './StateNode.ts';
-export { SimulatedClock } from './SimulatedClock.ts';
-export { StateMachine } from './StateMachine.ts';
-export { getStateNodes } from './stateUtils.ts';
-export { waitFor } from './waitFor.ts';
-export * from './typegenTypes.ts';
-export * from './types.ts';
-export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.ts';
-export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
-export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from './actors/index.ts';
-export { stateIn, not, and, or } from './guards.ts';
+export * from "./actions.js";
+export * from "./actors/index.js";
+export { SimulatedClock } from "./SimulatedClock.js";
+export { type Spawner } from "./spawn.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 "./createMachine.js";
+export { type MachineSnapshot, isMachineSnapshot } from "./State.js";
+import { StateNode } from "./StateNode.js";
+export { matchesState, pathToStateValue, toObserver, getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors } from "./utils.js";
+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";
+export { setup } from "./setup.js";
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -1,8 +1,9 @@
-import { symbolObservable } from './symbolObservable.ts';
-import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes.ts';
-import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from './types.ts';
-import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, Subscription } from './types.ts';
-export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
+import { symbolObservable } from "./symbolObservable.js";
+import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.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> = (snapshot: SnapshotFrom<TLogic>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;
 export type ErrorListener = (error: any) => void;
@@ -10,22 +11,25 @@ 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
 }
-export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent extends EventObject = EventFromBehavior<TBehavior>> implements ActorRef<TEvent, SnapshotFrom<TBehavior>> {
-    behavior: TBehavior;
+/**
+ * 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<SnapshotFrom<TLogic>, EventFromLogic<TLogic>> {
+    logic: TLogic;
     /**
-     * The current state of the interpreted behavior.
+     * The current internal state of the actor.
      */
-    private _state;
+    private _snapshot;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
      */
     clock: Clock;
-    options: Readonly<InterpreterOptions<TBehavior>>;
+    options: Readonly<ActorOptions<TLogic>>;
     /**
      * The unique identifier for this actor relative to its parent.
      */
@@ -34,71 +38,176 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
     private delayedEventsMap;
     private observers;
     private logger;
-    /**
-     * Whether the service is started.
-     */
-    status: ActorStatus;
-    _parent?: ActorRef<any>;
-    ref: ActorRef<TEvent>;
-    private _actorContext;
+    _parent?: ActorRef<any, any>;
+    _syncSnapshot?: boolean;
+    ref: ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>;
+    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;
+    src: string | AnyActorLogic;
     /**
-     * Creates a new Interpreter instance (i.e., service) for the given behavior with the provided options, if any.
+     * Creates a new actor instance for the given logic with the provided options, if any.
      *
-     * @param behavior The behavior to be interpreted
-     * @param options Interpreter options
+     * @param logic The logic to create an actor from
+     * @param options Actor options
      */
-    constructor(behavior: TBehavior, options?: InterpreterOptions<TBehavior>);
+    constructor(logic: TLogic, options?: ActorOptions<TLogic>);
     private _initState;
     private _deferred;
     private update;
-    subscribe(observer: Observer<SnapshotFrom<TBehavior>>): Subscription;
-    subscribe(nextListener?: (state: SnapshotFrom<TBehavior>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     /**
-     * Adds a state listener that is notified when the statechart has reached its final state.
-     * @param listener The state listener
+     * 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
      */
-    onDone(listener: EventListener<DoneEvent>): this;
+    subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
+    subscribe(nextListener?: (snapshot: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     /**
-     * Starts the interpreter from the initial state
+     * Starts the Actor from the initial state
      */
     start(): this;
     private _process;
     private _stop;
     /**
-     * Stops the interpreter and unsubscribe all listeners.
+     * Stops the Actor and unsubscribe all listeners.
      */
     stop(): this;
     private _complete;
+    private _reportError;
+    private _error;
     private _stopProcedure;
     /**
-     * Sends an event to the running interpreter to trigger a transition.
+     * Sends an event to the running Actor to trigger a transition.
      *
      * @param event The event to send
      */
-    send(event: TEvent | SCXML.Event<TEvent>): void;
-    delaySend(sendAction: SendActionObject | RaiseActionObject<any, any, any>): void;
-    cancel(sendId: string | number): void;
+    send(event: EventFromLogic<TLogic>): void;
     private attachDevTools;
     toJSON(): {
+        xstate$$type: number;
         id: string;
     };
-    getPersistedState(): PersistedStateFrom<TBehavior> | undefined;
-    [Symbol.observable](): InteropSubscribable<SnapshotFrom<TBehavior>>;
-    getSnapshot(): SnapshotFrom<TBehavior>;
+    /**
+     * 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
+     */
+    getPersistedSnapshot(): 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.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
+     */
+    getSnapshot(): SnapshotFrom<TLogic>;
 }
+/**
+ * Creates a new actor instance for the given actor logic with the provided options, if any.
+ *
+ * @remarks
+ * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that actor system.
+ *
+ * @example
+ * ```ts
+ * import { createActor } from 'xstate';
+ * import { someActorLogic } from './someActorLogic.ts';
+ *
+ * // Creating the actor, which implicitly creates an actor system with itself as the root actor
+ * const actor = createActor(someActorLogic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * // Actors must be started by calling `actor.start()`, which will also start the actor system.
+ * actor.start();
+ *
+ * // Actors can receive events
+ * actor.send({ type: 'someEvent' });
+ *
+ * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+ * actor.stop();
+ * ```
+ *
+ * @param logic - The actor logic to create an actor from. For a state machine actor logic creator, see {@link createMachine}. Other actor logic creators include {@link fromCallback}, {@link fromEventObservable}, {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
+ * @param options - Actor options
+ */
+export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic extends AnyStateMachine ? AreAllImplementationsAssumedToBeProvided<TLogic['__TResolvedTypesMeta']> extends true ? TLogic : MissingImplementationsError<TLogic['__TResolvedTypesMeta']> : TLogic, options?: ActorOptions<TLogic>): Actor<TLogic>;
 /**
  * Creates a new Interpreter instance for the given machine with the provided options, if any.
  *
- * @param machine The machine to interpret
- * @param options Interpreter options
+ * @deprecated Use `createActor` instead
+ */
+export declare const interpret: typeof createActor;
+/**
+ * @deprecated Use `Actor` instead.
  */
-export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
-export declare function interpret<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): Interpreter<TBehavior>;
+export type Interpreter = typeof Actor;

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

@@ -0,0 +1,51 @@
+import { StateMachine } from "./StateMachine.js";
+import { GuardPredicate } from "./guards.js";
+import { ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
+import { ActionFunction, AnyActorLogic, AnyActorRef, AnyEventObject, Cast, ConditionalRequired, DelayConfig, Invert, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateSchema, ToChildren, UnknownActorLogic, Values } from "./types.js";
+type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
+    [K in keyof TParameterizedMap & string]: {
+        type: K;
+        params: TParameterizedMap[K];
+    };
+}>;
+type DefaultToAnyActors<TActors extends Record<string, AnyActorLogic>> = IsNever<keyof TActors> extends true ? Record<string, AnyActorLogic> : TActors;
+type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<Values<TChildrenMap>, AnyActorLogic>, TResolvedActors extends Record<string, AnyActorLogic> = DefaultToAnyActors<TActors>> = Values<{
+    [K in keyof TResolvedActors & string]: {
+        src: K;
+        logic: TResolvedActors[K];
+        id: IsNever<TChildrenMap> extends true ? string | undefined : K extends keyof Invert<TChildrenMap> ? Invert<TChildrenMap>[K] : string | undefined;
+    };
+}>;
+type _GroupStateKeys<T extends StateSchema, S extends keyof T['states']> = S extends any ? T['states'][S] extends {
+    type: 'history';
+} ? [never, never] : T extends {
+    type: 'parallel';
+} ? [S, never] : 'states' extends keyof T['states'][S] ? [S, never] : [never, S] : never;
+type GroupStateKeys<T extends StateSchema, S extends keyof T['states']> = {
+    nonLeaf: _GroupStateKeys<T, S & string>[0];
+    leaf: _GroupStateKeys<T, S & string>[1];
+};
+type ToStateValue<T extends StateSchema> = T extends {
+    states: Record<infer S, any>;
+} ? IsNever<S> extends true ? {} : GroupStateKeys<T, S>['leaf'] | (IsNever<GroupStateKeys<T, S>['nonLeaf']> extends false ? ConditionalRequired<{
+    [K in GroupStateKeys<T, S>['nonLeaf']]?: ToStateValue<T['states'][K]>;
+}, T extends {
+    type: 'parallel';
+} ? true : false> : never) : {};
+export declare function setup<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
+TActors extends Record<Values<TChildrenMap>, UnknownActorLogic>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TChildrenMap extends Record<string, string> = never>({ actors, actions, guards, delays }: {
+    types?: SetupTypes<TContext, TEvent, TChildrenMap, TTag, TInput, TOutput>;
+    actors?: TActors;
+    actions?: {
+        [K in keyof TActions]: ActionFunction<TContext, TEvent, TEvent, TActions[K], ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay>;
+    };
+    guards?: {
+        [K in keyof TGuards]: GuardPredicate<TContext, TEvent, TGuards[K], ToParameterizedObject<TGuards>>;
+    };
+    delays?: {
+        [K in TDelay]: DelayConfig<TContext, TEvent, ToParameterizedObject<TActions>['params'], TEvent>;
+    };
+}): {
+    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>;
+};
+export {};

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

@@ -1,2 +1,23 @@
-import { InvokeActionObject, AnyStateMachine, Spawner, ActorRef, MachineContext, EventObject, SCXML } from './index.ts';
-export declare function createSpawner<TContext extends MachineContext, TEvent extends EventObject>(self: ActorRef<any, any> | undefined, machine: AnyStateMachine, context: TContext, _event: SCXML.Event<TEvent>, mutCapturedActions: InvokeActionObject[]): Spawner;
+import { ActorRefFrom, AnyActorScope, AnyActorLogic, AnyActorRef, AnyEventObject, AnyMachineSnapshot, InputFrom, IsLiteralString, ProvidedActor, RequiredActorOptions, IsNotNever, ConditionalRequired } from "./types.js";
+type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
+    src: TSrc;
+} ? ConditionalRequired<[
+    options?: {
+        id?: TActor['id'];
+        systemId?: string;
+        input?: InputFrom<TActor['logic']>;
+        syncSnapshot?: boolean;
+    } & {
+        [K in RequiredActorOptions<TActor>]: unknown;
+    }
+], IsNotNever<RequiredActorOptions<TActor>>> : never;
+export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>) => ActorRefFrom<(TActor & {
+    src: TSrc;
+})['logic']> : <TLogic extends AnyActorLogic | string>(src: TLogic, options?: {
+    id?: string;
+    systemId?: string;
+    input?: unknown;
+    syncSnapshot?: boolean;
+}) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>;
+export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyMachineSnapshot, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;
+export {};