xstate 5.0.0-beta.20 → 5.0.0-beta.22

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

@@ -2,7 +2,7 @@ import { ActionArgs, ActorRef, AnyActorContext, AnyState, EventObject, MachineCo
 type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject> = string | ActorRef<any> | ((args: UnifiedArg<TContext, TExpressionEvent>) => ActorRef<any> | string);
 declare function resolve(_: AnyActorContext, state: AnyState, args: ActionArgs<any, any>, { actorRef }: {
     actorRef: ResolvableActorRef<any, any>;
-}): (ActorRef<any, any> | AnyState)[];
+}): (AnyState | ActorRef<any, any>)[];
 declare function execute(actorContext: AnyActorContext, actorRef: ActorRef<any, any> | undefined): void;
 /**
  * Stops an actor.

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

@@ -36,7 +36,7 @@ export declare function done(id: string, output?: any): DoneEventObject;
  */
 export declare function doneInvoke(invokeId: string, output?: any): DoneEvent;
 export declare function error(id: string, data?: any): ErrorPlatformEvent & string;
-export declare function createInitEvent(input: any): {
+export declare function createInitEvent(input: unknown): {
     readonly type: "xstate.init";
-    readonly input: any;
+    readonly input: unknown;
 };

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

@@ -1,12 +1,12 @@
 import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom } from "../types.js";
-export interface CallbackInternalState<TEvent extends EventObject> {
+export interface CallbackInternalState<TEvent extends EventObject, TInput = unknown> {
     canceled: boolean;
     receivers: Set<(e: TEvent) => void>;
     dispose: void | (() => void) | Promise<any>;
-    input?: any;
+    input: TInput;
 }
-export type CallbackActorLogic<TEvent extends EventObject, TInput = any> = ActorLogic<TEvent, undefined, CallbackInternalState<TEvent>, CallbackInternalState<TEvent>, ActorSystem<any>, TInput, any>;
-export type CallbackActorRef<TEvent extends EventObject> = ActorRefFrom<CallbackActorLogic<TEvent>>;
+export type CallbackActorLogic<TEvent extends EventObject, TInput = unknown> = ActorLogic<TEvent, undefined, CallbackInternalState<TEvent, TInput>, Pick<CallbackInternalState<TEvent, TInput>, 'input' | 'canceled'>, ActorSystem<any>, TInput, any>;
+export type CallbackActorRef<TEvent extends EventObject, TInput = unknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
 export type Receiver<TEvent extends EventObject> = (listener: {
     bivarianceHack(event: TEvent): void;
 }['bivarianceHack']) => void;

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

@@ -1,12 +1,15 @@
 import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom } from "../types.js";
-export interface ObservableInternalState<T> {
+export interface ObservableInternalState<T, TInput = unknown> {
     subscription: Subscription | undefined;
     status: 'active' | 'done' | 'error' | 'canceled';
     data: T | undefined;
-    input?: any;
+    input: TInput | undefined;
 }
-export type ObservablePersistedState<T> = Omit<ObservableInternalState<T>, 'subscription'>;
-export type ObservableActorLogic<T, TInput> = ActorLogic<EventObject, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>, AnyActorSystem, TInput>;
+export type ObservablePersistedState<T, TInput = unknown> = Omit<ObservableInternalState<T, TInput>, 'subscription'>;
+export type ObservableActorLogic<T, TInput> = ActorLogic<{
+    type: string;
+    [k: string]: unknown;
+}, T | undefined, ObservableInternalState<T, TInput>, ObservablePersistedState<T, TInput>, AnyActorSystem, TInput>;
 export type ObservableActorRef<T> = ActorRefFrom<ObservableActorLogic<T, any>>;
 export declare function fromObservable<T, TInput>(observableCreator: ({ input, system }: {
     input: TInput;

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

@@ -1,8 +1,8 @@
 import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem } from "../types.js";
-export interface PromiseInternalState<T> {
+export interface PromiseInternalState<T, TInput = unknown> {
     status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;
-    input?: any;
+    input: TInput | undefined;
 }
 declare const resolveEventType = "$$xstate.resolve";
 declare const rejectEventType = "$$xstate.reject";
@@ -18,8 +18,8 @@ export type PromiseActorEvents<T> = {
 export type PromiseActorLogic<T, TInput = unknown> = ActorLogic<{
     type: string;
     [k: string]: unknown;
-}, T | undefined, PromiseInternalState<T>, // internal state
-PromiseInternalState<T>, // persisted state
+}, T | undefined, PromiseInternalState<T, TInput>, // internal state
+PromiseInternalState<T, TInput>, // persisted state
 ActorSystem<any>, TInput, // input
 T>;
 export type PromiseActorRef<T> = ActorRefFrom<PromiseActorLogic<T>>;

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

@@ -1,14 +1,14 @@
-import { AnyInterpreter, DevToolsAdapter } from "../types.js";
-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/index.d.ts

@@ -6,7 +6,7 @@ export { log } from "./actions/log.js";
 export { pure } from "./actions/pure.js";
 export { raise } from "./actions/raise.js";
 export { stop } from "./actions/stop.js";
-import { interpret, Interpreter, ActorStatus } from "./interpreter.js";
+import { createActor, interpret, Actor, ActorStatus, InterpreterStatus, Interpreter } from "./interpreter.js";
 import { createMachine } from "./Machine.js";
 import { mapState } from "./mapState.js";
 import { State } from "./State.js";
@@ -18,7 +18,8 @@ export { waitFor } from "./waitFor.js";
 export * from "./typegenTypes.js";
 export * from "./types.js";
 export { matchesState, pathToStateValue, toObserver } from "./utils.js";
-export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
+export { StateNode, State, mapState, sendTo, sendParent, forwardTo, createActor, interpret, // deprecated
+Actor, type Interpreter, ActorStatus, InterpreterStatus, doneInvoke, createMachine };
 export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from "./actors/index.js";
 export { stateIn, not, and, or } from "./guards.js";
 declare global {

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

@@ -1,7 +1,7 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
-import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, InterpreterFrom, PersistedStateFrom, SnapshotFrom, AnyActorRef } from "./types.js";
-import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, Observer, Subscription } from "./types.js";
+import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, PersistedStateFrom, SnapshotFrom, AnyActorRef } from "./types.js";
+import { ActorRef, EventObject, InteropSubscribable, ActorOptions, Observer, Subscription } from "./types.js";
 export type SnapshotListener<TLogic extends AnyActorLogic> = (state: SnapshotFrom<TLogic>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;
@@ -15,17 +15,21 @@ export declare enum ActorStatus {
     Running = 1,
     Stopped = 2
 }
-export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends EventObject = EventFromLogic<TLogic>> implements ActorRef<TEvent, SnapshotFrom<TLogic>> {
+/**
+ * @deprecated Use `ActorStatus` instead.
+ */
+export declare const InterpreterStatus: typeof ActorStatus;
+export declare class Actor<TLogic extends AnyActorLogic, TEvent extends EventObject = EventFromLogic<TLogic>> implements ActorRef<TEvent, SnapshotFrom<TLogic>> {
     logic: TLogic;
     /**
-     * The current state of the interpreted logic.
+     * The current internal state of the actor.
      */
     private _state;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
      */
     clock: Clock;
-    options: Readonly<InterpreterOptions<TLogic>>;
+    options: Readonly<ActorOptions<TLogic>>;
     /**
      * The unique identifier for this actor relative to its parent.
      */
@@ -50,32 +54,32 @@ export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends Ev
     private _doneEvent?;
     src?: string;
     /**
-     * Creates a new Interpreter instance (i.e., service) for the given logic with the provided options, if any.
+     * Creates a new actor instance for the given logic with the provided options, if any.
      *
-     * @param logic The logic to be interpreted
-     * @param options Interpreter options
+     * @param logic The logic to create an actor from
+     * @param options Actor options
      */
-    constructor(logic: TLogic, options?: InterpreterOptions<TLogic>);
+    constructor(logic: TLogic, options?: ActorOptions<TLogic>);
     private _initState;
     private _deferred;
     private update;
     subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
     subscribe(nextListener?: (state: 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 _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
      */
@@ -95,11 +99,21 @@ export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends Ev
     [Symbol.observable](): InteropSubscribable<SnapshotFrom<TLogic>>;
     getSnapshot(): SnapshotFrom<TLogic>;
 }
+/**
+ * Creates a new `ActorRef` instance for the given machine with the provided options, if any.
+ *
+ * @param machine The machine to create an actor from
+ * @param options `ActorRef` options
+ */
+export declare function createActor<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: ActorOptions<TMachine>): Actor<TMachine>;
+export declare function createActor<TLogic extends AnyActorLogic>(logic: 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 : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
-export declare function interpret<TLogic extends AnyActorLogic>(logic: TLogic, options?: InterpreterOptions<TLogic>): Interpreter<TLogic>;
+export type Interpreter = typeof Actor;

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

@@ -1,9 +1,21 @@
 import type { StateNode } from "./StateNode.js";
 import type { State } from "./State.js";
-import type { ActorStatus, Clock, Interpreter } from "./interpreter.js";
+import type { ActorStatus, 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";
+/**
+ * `T | unknown` reduces to `unknown` and that can be problematic when it comes to contextual typing.
+ * It especially is a problem when the union has a function member, like here:
+ *
+ * ```ts
+ * declare function test(cbOrVal: ((arg: number) => unknown) | unknown): void;
+ * test((arg) => {}) // oops, implicit any
+ * ```
+ *
+ * This type can be used to avoid this problem. This union represents the same value space as `unknown`.
+ */
+export type NonReducibleUnknown = {} | null | undefined;
 export type AnyFunction = (...args: any[]) => any;
 type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export type IsNever<T> = [T] extends [never] ? true : false;
@@ -55,7 +67,7 @@ export type MachineContext = Record<string, any>;
 export interface ActionArgs<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> extends UnifiedArg<TContext, TEvent> {
     action: TAction;
 }
-export type InputFrom<T extends AnyActorLogic> = T extends ActorLogic<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer _TPersisted, infer _TSystem, infer TInput> ? TInput : never;
+export type InputFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TActions, infer _TActors, infer TInput, infer _TResolvedTypesMeta> ? TInput : T extends ActorLogic<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer _TPersisted, infer _TSystem, infer TInput> ? TInput : never;
 export type OutputFrom<T extends AnyActorLogic> = T extends ActorLogic<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer _TPersisted, infer _TSystem, infer _TInput, infer TOutput> ? TOutput : never;
 export type Spawner = <T extends AnyActorLogic | string>(// TODO: read string from machine logic keys
 logic: T, options?: Partial<{
@@ -157,7 +169,7 @@ export interface InvokeDefinition<TContext extends MachineContext, TEvent extend
      * The source of the actor logic to be invoked
      */
     src: string;
-    input?: Mapper<TContext, TEvent, any> | any;
+    input?: Mapper<TContext, TEvent, NonReducibleUnknown> | NonReducibleUnknown;
     /**
      * The transition to take upon the invoked child machine reaching its final top-level state.
      */
@@ -243,7 +255,7 @@ export type InvokeConfig<TContext extends MachineContext, TEvent extends EventOb
      * The source of the machine to be invoked, or the machine itself.
      */
     src: AnyActorLogic | string;
-    input?: Mapper<TContext, TEvent, any> | any;
+    input?: Mapper<TContext, TEvent, NonReducibleUnknown> | NonReducibleUnknown;
     /**
      * The transition to take upon the invoked child machine reaching its final top-level state.
      */
@@ -328,7 +340,7 @@ export interface StateNodeConfig<TContext extends MachineContext, TEvent extends
      * The output data will be evaluated with the current `context` and placed on the `.data` property
      * of the event.
      */
-    output?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
+    output?: Mapper<TContext, TEvent, any> | NonReducibleUnknown;
     /**
      * The unique ID of the state node, which can be referenced as a transition target via the
      * `#id` syntax.
@@ -375,7 +387,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, any, any, any>;
-export type AnyStateMachine = StateMachine<any, any, any, any, any>;
+export type AnyStateMachine = StateMachine<any, any, any, any, any, any>;
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
 export interface AtomicStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> extends StateNodeConfig<TContext, TEvent, TODO, TODO> {
     initial?: undefined;
@@ -393,7 +405,7 @@ export interface FinalStateNodeConfig<TContext extends MachineContext, TEvent ex
      * The data to be sent with the "done.state.<id>" event. The data can be
      * static or dynamic (based on assigners).
      */
-    output?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
+    output?: Mapper<TContext, TEvent, any>;
 }
 export type SimpleOrStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> = AtomicStateNodeConfig<TContext, TEvent> | StateNodeConfig<TContext, TEvent, TODO, TODO>;
 export type ActionFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> = {
@@ -447,12 +459,12 @@ type GenerateGuardsImplementationsPart<TContext extends MachineContext, TResolve
 }>;
 export type InternalMachineImplementations<TContext extends MachineContext, TEvent extends EventObject, _TAction extends ParameterizedObject, TActor extends ProvidedActor, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>>;
 export type MachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActor extends ProvidedActor = ProvidedActor, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineImplementations<TContext, TEvent, TAction, TActor, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TActor>>;
-type InitialContext<TContext extends MachineContext> = TContext | ContextFactory<TContext>;
-export type ContextFactory<TContext extends MachineContext> = ({ spawn, input }: {
+type InitialContext<TContext extends MachineContext, TInput> = TContext | ContextFactory<TContext, TInput>;
+export type ContextFactory<TContext extends MachineContext, TInput> = ({ spawn, input }: {
     spawn: Spawner;
-    input: any;
+    input: TInput;
 }) => TContext;
-export type MachineConfig<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActor extends ProvidedActor = ProvidedActor, TTypesMeta = TypegenDisabled> = (StateNodeConfig<NoInfer<TContext>, NoInfer<TEvent>, NoInfer<TAction>, NoInfer<TActor>> & {
+export type MachineConfig<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActor extends ProvidedActor = ProvidedActor, TInput = any, TTypesMeta = TypegenDisabled> = (StateNodeConfig<NoInfer<TContext>, NoInfer<TEvent>, NoInfer<TAction>, NoInfer<TActor>> & {
     /**
      * The initial context (extended state)
      */
@@ -460,18 +472,18 @@ export type MachineConfig<TContext extends MachineContext, TEvent extends EventO
      * The machine's own version.
      */
     version?: string;
-    types?: MachineTypes<TContext, TEvent, TActor, TTypesMeta>;
+    types?: MachineTypes<TContext, TEvent, TActor, TInput, TTypesMeta>;
 }) & (Equals<TContext, MachineContext> extends true ? {
-    context?: InitialContext<LowInfer<TContext>>;
+    context?: InitialContext<LowInfer<TContext>, TInput>;
 } : {
-    context: InitialContext<LowInfer<TContext>>;
+    context: InitialContext<LowInfer<TContext>, TInput>;
 });
 export interface ProvidedActor {
     src: string;
     logic: AnyActorLogic;
     id?: string;
 }
-export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTypesMeta = TypegenDisabled> {
+export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TInput, TTypesMeta = TypegenDisabled> {
     context?: TContext;
     actions?: {
         type: string;
@@ -484,6 +496,7 @@ export interface MachineTypes<TContext extends MachineContext, TEvent extends Ev
         [key: string]: any;
     };
     typegen?: TTypesMeta;
+    input?: TInput;
 }
 export interface HistoryStateNode<TContext extends MachineContext> extends StateNode<TContext> {
     history: 'shallow' | 'deep';
@@ -551,15 +564,13 @@ export type PartialAssigner<TContext extends MachineContext, TExpressionEvent ex
 export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject> = {
     [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, K> | TContext[K];
 };
-export type Mapper<TContext extends MachineContext, TEvent extends EventObject, TParams extends {}> = (args: {
+export type Mapper<TContext extends MachineContext, TEvent extends EventObject, TParams> = (args: {
     context: TContext;
     event: TEvent;
+    self: ActorRef<TEvent>;
 }) => TParams;
 export type PropertyMapper<TContext extends MachineContext, TEvent extends EventObject, TParams extends {}> = {
-    [K in keyof TParams]?: ((args: {
-        context: TContext;
-        event: TEvent;
-    }) => TParams[K]) | TParams[K];
+    [K in keyof TParams]?: Mapper<TContext, TEvent, TParams[K]> | TParams[K];
 };
 export interface TransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends Omit<TransitionConfig<TContext, TEvent>, 'target'> {
     target: Array<StateNode<TContext, TEvent>> | undefined;
@@ -629,11 +640,12 @@ export interface StateConfig<TContext extends MachineContext, TEvent extends Eve
     children: Record<string, ActorRef<any>>;
     done?: boolean;
     output?: any;
+    error?: unknown;
     tags?: Set<string>;
-    machine?: StateMachine<TContext, TEvent, any, any, any>;
+    machine?: StateMachine<TContext, TEvent, any, any, any, any>;
     _internalQueue?: Array<TEvent>;
 }
-export interface InterpreterOptions<TLogic extends AnyActorLogic> {
+export interface ActorOptions<TLogic extends AnyActorLogic> {
     /**
      * Whether state actions should be executed immediately upon transition. Defaults to `true`.
      */
@@ -674,7 +686,11 @@ export interface InterpreterOptions<TLogic extends AnyActorLogic> {
      */
     src?: string;
 }
-export type AnyInterpreter = Interpreter<any, any>;
+export type AnyActor = Actor<any, any>;
+/**
+ * @deprecated Use `AnyActor` instead.
+ */
+export type AnyInterpreter = AnyActor;
 export type Observer<T> = {
     next?: (value: T) => void;
     error?: (err: any) => void;
@@ -719,12 +735,15 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot = any> extends S
 }
 export type AnyActorRef = ActorRef<any, any>;
 export type ActorLogicFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<any, any, any, any, any> ? R : R extends Promise<infer U> ? PromiseActorLogic<U> : never : never;
-export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? ActorRef<TEvent, State<TContext, TEvent, TODO, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRefFrom<PromiseActorLogic<U>> : R extends ActorLogic<infer TEvent, infer TSnapshot, infer _, infer __, infer ___, infer ____, infer _____> ? ActorRef<TEvent, TSnapshot> : never : never;
-export type DevToolsAdapter = (service: AnyInterpreter) => void;
-export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TAction, infer TActor, infer TResolvedTypesMeta> ? Interpreter<ActorLogic<TEvent, State<TContext, TEvent, TActor, TResolvedTypesMeta>, State<TContext, TEvent, TActor, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TActor, TResolvedTypesMeta>>>> : never;
-export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TAction, infer TActor, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TAction, TActor, TResolvedTypesMeta, TRequireMissingImplementations> : never;
-export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
-export type EventOfMachine<TMachine extends AnyStateMachine> = TMachine extends StateMachine<any, infer E, any, any, any> ? E : never;
+export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, any, any, any, infer TResolvedTypesMeta> ? ActorRef<TEvent, State<TContext, TEvent, TODO, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRefFrom<PromiseActorLogic<U>> : R extends ActorLogic<infer TEvent, infer TSnapshot, infer _, infer __, infer ___, infer ____, infer _____> ? ActorRef<TEvent, TSnapshot> : never : never;
+export type DevToolsAdapter = (service: AnyActor) => void;
+/**
+ * @deprecated Use `Actor<T>` instead.
+ */
+export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer _TAction, infer TActor, infer TInput, infer TResolvedTypesMeta> ? Actor<ActorLogic<TEvent, State<TContext, TEvent, TActor, TResolvedTypesMeta>, State<TContext, TEvent, TActor, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TActor, TResolvedTypesMeta>>, ActorSystem<any>, TInput>> : never;
+export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TAction, infer TActor, infer _TInput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TAction, TActor, TResolvedTypesMeta, TRequireMissingImplementations> : never;
+export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, any, any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
+export type EventOfMachine<TMachine extends AnyStateMachine> = TMachine extends StateMachine<any, infer E, any, any, any, any> ? E : never;
 export interface ActorContext<TEvent extends EventObject, TSnapshot, TSystem extends ActorSystem<any> = ActorSystem<any>> {
     self: ActorRef<TEvent, TSnapshot>;
     id: string;
@@ -763,13 +782,13 @@ any, // persisted state
 any, // system
 any, // input
 any>;
-export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Interpreter<infer TLogic> ? SnapshotFrom<TLogic> : R extends StateMachine<infer _, infer __, infer ___, infer ____, infer _____> ? StateFrom<R> : R extends ActorLogic<infer _, infer TSnapshot, infer __, infer ___, infer ____> ? TSnapshot : R extends ActorContext<infer _, infer TSnapshot, infer __> ? TSnapshot : never : never;
+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 _, infer __, infer ___, infer ____, infer _____, infer ______> ? StateFrom<R> : R extends ActorLogic<infer _, infer TSnapshot, infer __, infer ___, infer ____> ? TSnapshot : R extends ActorContext<infer _, infer TSnapshot, infer __> ? TSnapshot : never : never;
 export type EventFromLogic<TLogic extends ActorLogic<any, any>> = TLogic extends ActorLogic<infer TEvent, infer _, infer __, infer ___, infer ____> ? TEvent : never;
 export type PersistedStateFrom<TLogic extends ActorLogic<any, any>> = TLogic extends ActorLogic<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer TPersisted> ? TPersisted : never;
 export type InternalStateFrom<TLogic extends ActorLogic<any, any>> = TLogic extends ActorLogic<infer _TEvent, infer _TSnapshot, infer TInternalState, infer _TPersisted> ? TInternalState : never;
-type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer TEvent, infer __, infer ___, infer ____> ? TEvent : R extends State<infer _TContext, infer TEvent, infer _TAction, infer _TActor> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
+type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer TEvent, infer __, infer ___, infer ____, infer _____> ? TEvent : R extends State<infer _TContext, infer TEvent, infer _TAction, infer _TActor> ? 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 _, infer __, infer ___, infer ____> ? TContext : R extends State<infer TContext, infer _TEvent, infer _TAction, infer _TActor> ? TContext : R extends Interpreter<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _> ? TContext : never : never : never;
+export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___, infer ____, infer _____> ? TContext : R extends State<infer TContext, infer _TEvent, infer _TAction, infer _TActor> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TActions, infer _TActors, infer _TInput, infer _TTypesMeta> ? TContext : never : never : never;
 export type InferEvent<E extends EventObject> = {
     [T in E['type']]: {
         type: T;
@@ -791,7 +810,7 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
 }
 export type AnyActorSystem = ActorSystem<any>;
-export type PersistedMachineState<TState extends AnyState> = Pick<TState, 'value' | 'output' | 'context' | 'done' | 'historyValue'> & {
+export type PersistedMachineState<TState extends AnyState> = Pick<TState, 'value' | 'output' | 'error' | 'context' | 'done' | 'historyValue'> & {
     children: {
         [K in keyof TState['children']]: {
             state: any;

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

@@ -1,6 +1,6 @@
 import { AnyActorLogic, AnyState } from "./index.js";
 import type { StateNode } from "./StateNode.js";
-import type { ActorLogic, AnyEventObject, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, PropertyMapper, ErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget, TODO } from "./types.js";
+import type { ActorLogic, AnyEventObject, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, ErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget, TODO, AnyActorRef } from "./types.js";
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue): boolean;
 export declare function toStatePath(stateId: string | string[]): string[];
@@ -26,7 +26,7 @@ export declare function toStatePaths(stateValue: StateValue | undefined): string
 export declare function flatten<T>(array: Array<T | T[]>): T[];
 export declare function toArrayStrict<T>(value: T[] | T): T[];
 export declare function toArray<T>(value: T[] | T | undefined): T[];
-export declare function mapContext<TContext extends MachineContext, TEvent extends EventObject>(mapper: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>, context: TContext, event: TEvent): any;
+export declare function mapContext<TContext extends MachineContext, TEvent extends EventObject>(mapper: Mapper<TContext, TEvent, any>, context: TContext, event: TEvent, self: AnyActorRef): any;
 export declare function isBuiltInEvent(eventType: EventType): boolean;
 export declare function isPromiseLike(value: any): value is PromiseLike<any>;
 export declare function isActorLogic(value: any): value is ActorLogic<any, any>;

package/dist/xstate.cjs.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var actors_dist_xstateActors = require('./actions-069d9805.cjs.js');
+var actors_dist_xstateActors = require('./actions-8f2e997e.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 const EMPTY_OBJECT = {};
@@ -365,6 +365,7 @@ class StateMachine {
     this.__TAction = void 0;
     this.__TActor = void 0;
     this.__TResolvedTypesMeta = void 0;
+    this.__TInput = void 0;
     this.id = config.id || '(machine)';
     this.implementations = {
       actors: implementations?.actors ?? {},
@@ -452,7 +453,9 @@ class StateMachine {
   transition(state, event, actorCtx) {
     // TODO: handle error events in a better way
     if (actors_dist_xstateActors.isErrorEvent(event) && !state.nextEvents.some(nextEvent => nextEvent === event.type)) {
-      throw event.data;
+      return actors_dist_xstateActors.cloneState(state, {
+        error: event.data
+      });
     }
     const {
       state: nextState
@@ -523,15 +526,10 @@ class StateMachine {
     } = actors_dist_xstateActors.macrostep(nextState, initEvent, actorCtx);
     return macroState;
   }
-  start(state, actorCtx) {
+  start(state) {
     Object.values(state.children).forEach(child => {
       if (child.status === 0) {
-        try {
-          child.start?.();
-        } catch (err) {
-          // TODO: unify error handling when child starts
-          actorCtx.self.send(actors_dist_xstateActors.error(child.id, err));
-        }
+        child.start?.();
       }
     });
   }
@@ -558,7 +556,10 @@ class StateMachine {
     return stateConfig instanceof actors_dist_xstateActors.State ? stateConfig : new actors_dist_xstateActors.State(stateConfig, this);
   }
   getStatus(state) {
-    return state.done ? {
+    return state.error ? {
+      status: 'error',
+      data: state.error
+    } : state.done ? {
       status: 'done',
       data: state.output
     } : {
@@ -576,7 +577,7 @@ class StateMachine {
         return;
       }
       const actorState = logic.restoreState?.(childState, _actorCtx);
-      const actorRef = actors_dist_xstateActors.interpret(logic, {
+      const actorRef = actors_dist_xstateActors.createActor(logic, {
         id: actorId,
         state: actorState
       });
@@ -600,7 +601,7 @@ class StateMachine {
           }
           const referenced = actors_dist_xstateActors.resolveReferencedActor(this.implementations.actors[src]);
           if (referenced) {
-            const actorRef = actors_dist_xstateActors.interpret(referenced.src, {
+            const actorRef = actors_dist_xstateActors.createActor(referenced.src, {
               id,
               parent: _actorCtx?.self,
               input: 'input' in invokeConfig ? invokeConfig.input : referenced.input
@@ -750,15 +751,17 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
+exports.Actor = actors_dist_xstateActors.Actor;
+exports.ActorStatus = actors_dist_xstateActors.ActorStatus;
 exports.ConstantPrefix = actors_dist_xstateActors.ConstantPrefix;
-exports.Interpreter = actors_dist_xstateActors.Interpreter;
-exports.InterpreterStatus = actors_dist_xstateActors.ActorStatus;
+exports.InterpreterStatus = actors_dist_xstateActors.InterpreterStatus;
 exports.SpecialTargets = actors_dist_xstateActors.SpecialTargets;
 exports.State = actors_dist_xstateActors.State;
 exports.and = actors_dist_xstateActors.and;
 exports.assign = actors_dist_xstateActors.assign;
 exports.cancel = actors_dist_xstateActors.cancel;
 exports.choose = actors_dist_xstateActors.choose;
+exports.createActor = actors_dist_xstateActors.createActor;
 exports.doneInvoke = actors_dist_xstateActors.doneInvoke;
 exports.forwardTo = actors_dist_xstateActors.forwardTo;
 exports.fromCallback = actors_dist_xstateActors.fromCallback;

package/dist/xstate.cjs.mjs

@@ -1,6 +1,7 @@
 export {
+  Actor,
+  ActorStatus,
   ConstantPrefix,
-  Interpreter,
   InterpreterStatus,
   SimulatedClock,
   SpecialTargets,
@@ -11,6 +12,7 @@ export {
   assign,
   cancel,
   choose,
+  createActor,
   createMachine,
   doneInvoke,
   forwardTo,