xstate 5.18.2 → 5.19.1

package/dev/dist/xstate-dev.development.esm.js

@@ -18,7 +18,7 @@ function getGlobal() {
 }
 function getDevTools() {
   const w = getGlobal();
-  if (!!w.__xstate__) {
+  if (w.__xstate__) {
     return w.__xstate__;
   }
   return undefined;

package/dev/dist/xstate-dev.esm.js

@@ -15,7 +15,7 @@ function getGlobal() {
 }
 function getDevTools() {
   const w = getGlobal();
-  if (!!w.__xstate__) {
+  if (w.__xstate__) {
     return w.__xstate__;
   }
   return undefined;

package/dev/dist/xstate-dev.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"xstate-dev.umd.min.js","sources":["../../src/dev/index.ts"],"sourcesContent":["import isDevelopment from '#is-development';\nimport { AnyActor, DevToolsAdapter } from '../types.ts';\n\ninterface DevInterface {\n  services: Set<AnyActor>;\n  register(service: AnyActor): void;\n  onRegister(listener: ServiceListener): void;\n}\ntype ServiceListener = (service: AnyActor) => void;\n\nexport interface XStateDevInterface {\n  register: (service: AnyActor) => void;\n  unregister: (service: AnyActor) => void;\n  onRegister: (listener: ServiceListener) => {\n    unsubscribe: () => void;\n  };\n  services: Set<AnyActor>;\n}\n\n// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis\nexport function getGlobal(): typeof globalThis | undefined {\n  if (typeof globalThis !== 'undefined') {\n    return globalThis;\n  }\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  if (isDevelopment) {\n    console.warn(\n      'XState could not find a global object in this environment. Please let the maintainers know and raise an issue here: https://github.com/statelyai/xstate/issues'\n    );\n  }\n}\n\nfunction getDevTools(): DevInterface | undefined {\n  const w = getGlobal();\n  if (!!(w as any).__xstate__) {\n    return (w as any).__xstate__;\n  }\n\n  return undefined;\n}\n\nexport function registerService(service: AnyActor) {\n  if (typeof window === 'undefined') {\n    return;\n  }\n\n  const devTools = getDevTools();\n\n  if (devTools) {\n    devTools.register(service);\n  }\n}\n\nexport const devToolsAdapter: DevToolsAdapter = (service) => {\n  if (typeof window === 'undefined') {\n    return;\n  }\n\n  const devTools = getDevTools();\n\n  if (devTools) {\n    devTools.register(service);\n  }\n};\n"],"names":["getGlobal","globalThis","self","window","getDevTools","w","__xstate__","service","devTools","register"],"mappings":"iPAoBO,SAASA,IACd,MAA0B,oBAAfC,WACFA,WAEW,oBAATC,KACFA,KAGAC,MAUX,CAEA,SAASC,IACP,MAAMC,EAAIL,IACV,GAAOK,EAAUC,WACf,OAAQD,EAAUC,UAItB,mBAciDC,IAK/C,MAAMC,EAAWJ,IAEbI,GACFA,EAASC,SAASF,EACpB,kCArBK,SAAyBA,GAK9B,MAAMC,EAAWJ,IAEbI,GACFA,EAASC,SAASF,EAEtB"}
+{"version":3,"file":"xstate-dev.umd.min.js","sources":["../../src/dev/index.ts"],"sourcesContent":["import isDevelopment from '#is-development';\nimport { AnyActor, DevToolsAdapter } from '../types.ts';\n\ninterface DevInterface {\n  services: Set<AnyActor>;\n  register(service: AnyActor): void;\n  onRegister(listener: ServiceListener): void;\n}\ntype ServiceListener = (service: AnyActor) => void;\n\nexport interface XStateDevInterface {\n  register: (service: AnyActor) => void;\n  unregister: (service: AnyActor) => void;\n  onRegister: (listener: ServiceListener) => {\n    unsubscribe: () => void;\n  };\n  services: Set<AnyActor>;\n}\n\n// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis\nexport function getGlobal(): typeof globalThis | undefined {\n  if (typeof globalThis !== 'undefined') {\n    return globalThis;\n  }\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  if (isDevelopment) {\n    console.warn(\n      'XState could not find a global object in this environment. Please let the maintainers know and raise an issue here: https://github.com/statelyai/xstate/issues'\n    );\n  }\n}\n\nfunction getDevTools(): DevInterface | undefined {\n  const w = getGlobal();\n  if ((w as any).__xstate__) {\n    return (w as any).__xstate__;\n  }\n\n  return undefined;\n}\n\nexport function registerService(service: AnyActor) {\n  if (typeof window === 'undefined') {\n    return;\n  }\n\n  const devTools = getDevTools();\n\n  if (devTools) {\n    devTools.register(service);\n  }\n}\n\nexport const devToolsAdapter: DevToolsAdapter = (service) => {\n  if (typeof window === 'undefined') {\n    return;\n  }\n\n  const devTools = getDevTools();\n\n  if (devTools) {\n    devTools.register(service);\n  }\n};\n"],"names":["getGlobal","globalThis","self","window","getDevTools","w","__xstate__","service","devTools","register"],"mappings":"iPAoBO,SAASA,IACd,MAA0B,oBAAfC,WACFA,WAEW,oBAATC,KACFA,KAGAC,MAUX,CAEA,SAASC,IACP,MAAMC,EAAIL,IACV,GAAKK,EAAUC,WACb,OAAQD,EAAUC,UAItB,mBAciDC,IAK/C,MAAMC,EAAWJ,IAEbI,GACFA,EAASC,SAASF,EACpB,kCArBK,SAAyBA,GAK9B,MAAMC,EAAWJ,IAEbI,GACFA,EAASC,SAASF,EAEtB"}

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

@@ -4,7 +4,7 @@ import type { ProvidedActor, AnyMachineSnapshot, AnyStateMachine, EventObject, H
 type ToTestStateValue<TStateValue extends StateValue> = TStateValue extends string ? TStateValue : IsNever<keyof TStateValue> extends true ? never : keyof TStateValue | {
     [K in keyof TStateValue]?: ToTestStateValue<NonNullable<TStateValue[K]>>;
 };
-export declare function isMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject>(value: unknown): value is AnyMachineSnapshot;
+export declare function isMachineSnapshot(value: unknown): value is AnyMachineSnapshot;
 interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta, TStateSchema extends StateSchema = StateSchema> {
     /** The state machine that produced this state snapshot. */
     machine: StateMachine<TContext, TEvent, TChildren, ProvidedActor, ParameterizedObject, ParameterizedObject, string, TStateValue, TTag, unknown, TOutput, EventObject, // TEmitted

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

@@ -1,4 +1,4 @@
-import { ActionArgs, ActionFunction, DoNotInfer, EventObject, MachineContext, ParameterizedObject, RaiseActionOptions, SendExpr } from "../types.js";
+import { ActionArgs, ActionFunction, DoNotInfer, EventObject, ExecutableActionObject, MachineContext, ParameterizedObject, RaiseActionOptions, SendExpr } from "../types.js";
 export interface RaiseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
     (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
     _out_TEvent?: TEvent;
@@ -11,3 +11,11 @@ export interface RaiseAction<TContext extends MachineContext, TExpressionEvent e
  * @param eventType The event to raise.
  */
 export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TDelay extends string = never, TUsedDelay extends TDelay = never>(eventOrExpr: DoNotInfer<TEvent> | SendExpr<TContext, TExpressionEvent, TParams, DoNotInfer<TEvent>, TEvent>, options?: RaiseActionOptions<TContext, TExpressionEvent, TParams, DoNotInfer<TEvent>, TUsedDelay>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, TDelay, never>;
+export interface ExecutableRaiseAction extends ExecutableActionObject {
+    type: 'xstate.raise';
+    params: {
+        event: EventObject;
+        id: string | undefined;
+        delay: number | undefined;
+    };
+}

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

@@ -1,4 +1,4 @@
-import { ActionArgs, ActionFunction, AnyActorRef, AnyEventObject, Cast, DoNotInfer, EventFrom, EventObject, InferEvent, MachineContext, ParameterizedObject, SendExpr, SendToActionOptions } from "../types.js";
+import { ActionArgs, ActionFunction, AnyActorRef, AnyEventObject, Cast, DoNotInfer, EventFrom, EventObject, ExecutableActionObject, InferEvent, MachineContext, ParameterizedObject, SendExpr, SendToActionOptions } from "../types.js";
 export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
     (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
     _out_TDelay?: TDelay;
@@ -30,4 +30,13 @@ type Target<TContext extends MachineContext, TExpressionEvent extends EventObjec
  * @param options Options to pass into the send action creator.
  */
 export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string = never, TUsedDelay extends TDelay = never>(target: Target<TContext, TExpressionEvent, TParams, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TUsedDelay>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, never, never, never, TDelay, never>;
+export interface ExecutableSendToAction extends ExecutableActionObject {
+    type: 'xstate.sendTo';
+    params: {
+        event: EventObject;
+        id: string | undefined;
+        delay: number | undefined;
+        to: AnyActorRef;
+    };
+}
 export {};

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

@@ -1,5 +1,6 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AnyActorSystem, Clock } from "./system.js";
+export declare let executingCustomAction: boolean;
 import type { AnyActorLogic, AnyActorRef, ConditionalRequired, EmittedFrom, EventFromLogic, InputFrom, IsNotNever, Snapshot, SnapshotFrom } from "./types.js";
 import { ActorOptions, ActorRef, InteropSubscribable, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
@@ -111,7 +112,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
      */
     subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
     subscribe(nextListener?: (snapshot: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
-    on<TType extends EmittedFrom<TLogic>['type'] | '*'>(type: TType, handler: (emitted: EmittedFrom<TLogic> & (TType extends '*' ? {} : {
+    on<TType extends EmittedFrom<TLogic>['type'] | '*'>(type: TType, handler: (emitted: EmittedFrom<TLogic> & (TType extends '*' ? unknown : {
         type: TType;
     })) => void): Subscription;
     /** Starts the Actor from the initial state */

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

@@ -1,4 +1,5 @@
 import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom } from "./types.js";
+/** @deprecated Use `initialTransition(…)` instead. */
 export declare function getInitialSnapshot<T extends AnyActorLogic>(actorLogic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): SnapshotFrom<T>;
 /**
  * Determines the next snapshot for the given `actorLogic` based on the given
@@ -7,6 +8,7 @@ export declare function getInitialSnapshot<T extends AnyActorLogic>(actorLogic:
  * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
  * used.
  *
+ * @deprecated Use `transition(…)` instead.
  * @example
  *
  * ```ts

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

@@ -17,6 +17,7 @@ export type { ActorSystem } from "./system.js";
 export { toPromise } from "./toPromise.js";
 export * from "./types.js";
 export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, pathToStateValue, toObserver } from "./utils.js";
+export { transition, initialTransition } from "./transition.js";
 export { waitFor } from "./waitFor.js";
 declare global {
     interface SymbolConstructor {

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

@@ -26,7 +26,7 @@ export interface InspectedActionEvent extends BaseInspectionEventProperties {
     type: '@xstate.action';
     action: {
         type: string;
-        params: Record<string, unknown>;
+        params: unknown;
     };
 }
 export interface InspectedEventEvent extends BaseInspectionEventProperties {

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

@@ -1,4 +1,4 @@
-import { ActorRefFromLogic, AnyActorLogic, AnyActorRef, AnyActorScope, AnyEventObject, AnyMachineSnapshot, ConditionalRequired, GetConcreteByKey, InputFrom, IsLiteralString, IsNotNever, ProvidedActor, RequiredActorOptions } from "./types.js";
+import { ActorRefFromLogic, AnyActorLogic, AnyActorRef, AnyActorScope, AnyEventObject, AnyMachineSnapshot, ConditionalRequired, GetConcreteByKey, InputFrom, IsLiteralString, IsNotNever, ProvidedActor, RequiredActorOptions, type RequiredLogicInput } from "./types.js";
 type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
     src: TSrc;
 } ? ConditionalRequired<[
@@ -13,17 +13,25 @@ type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TA
 ], 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>): ActorRefFromLogic<GetConcreteByKey<TActor, 'src', TSrc>['logic']>;
-    <TLogic extends AnyActorLogic>(src: TLogic, options?: {
-        id?: never;
+    <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[
+        options?: {
+            id?: never;
+            systemId?: string;
+            input?: InputFrom<TLogic>;
+            syncSnapshot?: boolean;
+        } & {
+            [K in RequiredLogicInput<TLogic>]: unknown;
+        }
+    ], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+} : <TLogic extends AnyActorLogic | string>(src: TLogic, ...[options]: ConditionalRequired<[
+    options?: {
+        id?: string;
         systemId?: string;
-        input?: InputFrom<TLogic>;
+        input?: TLogic extends string ? unknown : InputFrom<TLogic>;
         syncSnapshot?: boolean;
-    }): ActorRefFromLogic<TLogic>;
-} : <TLogic extends AnyActorLogic | string>(src: TLogic, options?: {
-    id?: string;
-    systemId?: string;
-    input?: TLogic extends string ? unknown : InputFrom<TLogic>;
-    syncSnapshot?: boolean;
-}) => TLogic extends AnyActorLogic ? ActorRefFromLogic<TLogic> : AnyActorRef;
+    } & (TLogic extends AnyActorLogic ? {
+        [K in RequiredLogicInput<TLogic>]: unknown;
+    } : {})
+], IsNotNever<TLogic extends AnyActorLogic ? RequiredLogicInput<TLogic> : never>>) => TLogic extends AnyActorLogic ? ActorRefFromLogic<TLogic> : AnyActorRef;
 export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyMachineSnapshot, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;
 export {};

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

@@ -1,6 +1,6 @@
 import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { AnyEventObject, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, TransitionDefinition, TODO, UnknownAction, ActionFunction, AnyTransitionConfig, AnyActorScope } from "./types.js";
+import { ActionArgs, AnyEventObject, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, TransitionDefinition, TODO, UnknownAction, ParameterizedObject, AnyTransitionConfig, AnyActorScope } from "./types.js";
 type StateNodeIterable<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyStateNodeIterable = StateNodeIterable<any, any>;
 export declare function getAllStateNodes(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
@@ -10,7 +10,7 @@ export declare const isStateId: (str: string) => boolean;
 export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type']): Array<TransitionDefinition<any, TEvent>>;
 /** All delayed transitions from the config. */
 export declare function getDelayedTransitions(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<MachineContext, EventObject>>;
-export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, descriptor: string, transitionConfig: AnyTransitionConfig): AnyTransitionDefinition;
+export declare function formatTransition(stateNode: AnyStateNode, descriptor: string, transitionConfig: AnyTransitionConfig): AnyTransitionDefinition;
 export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Map<string, TransitionDefinition<TContext, TEvent>[]>;
 export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, _target: string | undefined | InitialTransitionConfig<TContext, TEvent, TODO, TODO, TODO, TODO>): InitialTransitionDefinition<TContext, TEvent>;
 export declare function getInitialStateNodes(stateNode: AnyStateNode): Set<AnyStateNode>;
@@ -25,13 +25,23 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
  *
  * @param stateValue The state value or State instance
  */
-export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue): Array<AnyStateNode>;
+export declare function getStateNodes(stateNode: AnyStateNode, stateValue: StateValue): Array<AnyStateNode>;
 export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentSnapshot: AnyMachineSnapshot, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyMachineSnapshot;
-export declare let executingCustomAction: ActionFunction<any, any, any, any, any, any, any, any, any> | false;
-export declare function resolveActionsAndContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyMachineSnapshot;
-export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue?: AnyEventObject[]): {
+export declare function microstep(transitions: Array<AnyTransitionDefinition>, currentSnapshot: AnyMachineSnapshot, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyMachineSnapshot;
+export interface BuiltinAction {
+    (): void;
+    type: `xstate.${string}`;
+    resolve: (actorScope: AnyActorScope, snapshot: AnyMachineSnapshot, actionArgs: ActionArgs<any, any, any>, actionParams: ParameterizedObject['params'] | undefined, action: unknown, extra: unknown) => [
+        newState: AnyMachineSnapshot,
+        params: unknown,
+        actions?: UnknownAction[]
+    ];
+    retryResolve: (actorScope: AnyActorScope, snapshot: AnyMachineSnapshot, params: unknown) => void;
+    execute: (actorScope: AnyActorScope, params: unknown) => void;
+}
+export declare function resolveActionsAndContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds: string[] | undefined): AnyMachineSnapshot;
+export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue: AnyEventObject[]): {
     snapshot: typeof snapshot;
     microstates: Array<typeof snapshot>;
 };

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

@@ -0,0 +1,16 @@
+import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom, ExecutableActionsFrom } from "./types.js";
+/**
+ * Given actor `logic`, a `snapshot`, and an `event`, returns a tuple of the
+ * `nextSnapshot` and `actions` to execute.
+ *
+ * This is a pure function that does not execute `actions`.
+ */
+export declare function transition<T extends AnyActorLogic>(logic: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): [nextSnapshot: SnapshotFrom<T>, actions: ExecutableActionsFrom<T>[]];
+/**
+ * Given actor `logic` and optional `input`, returns a tuple of the
+ * `nextSnapshot` and `actions` to execute from the initial transition (no
+ * previous state).
+ *
+ * This is a pure function that does not execute `actions`.
+ */
+export declare function initialTransition<T extends AnyActorLogic>(logic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): [SnapshotFrom<T>, ExecutableActionsFrom<T>[]];

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

@@ -2,12 +2,14 @@ import type { MachineSnapshot } from "./State.js";
 import type { StateMachine } from "./StateMachine.js";
 import type { StateNode } from "./StateNode.js";
 import { AssignArgs } from "./actions/assign.js";
+import { ExecutableRaiseAction } from "./actions/raise.js";
+import { ExecutableSendToAction } from "./actions/send.js";
 import { PromiseActorLogic } from "./actors/promise.js";
-import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
 import type { Actor } from "./createActor.js";
+import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
+import { InspectionEvent } from "./inspection.js";
 import { Spawner } from "./spawn.js";
 import { AnyActorSystem, Clock } from './system.js';
-import { InspectionEvent } from "./inspection.js";
 export type Identity<T> = {
     [K in keyof T]: T[K];
 };
@@ -42,7 +44,7 @@ export type AnyFunction = (...args: any[]) => any;
 type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export type IsNever<T> = [T] extends [never] ? true : false;
 export type IsNotNever<T> = [T] extends [never] ? false : true;
-export type Compute<A extends any> = {
+export type Compute<A> = {
     [K in keyof A]: A[K];
 } & unknown;
 export type Prop<T, K> = K extends keyof T ? T[K] : never;
@@ -55,13 +57,13 @@ export type IndexByProp<T extends Record<P, string>, P extends keyof T> = {
 export type IndexByType<T extends {
     type: string;
 }> = IndexByProp<T, 'type'>;
-export type Equals<A1 extends any, A2 extends any> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
+export type Equals<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
 export type IsAny<T> = Equals<T, any>;
 export type Cast<A, B> = A extends B ? A : B;
 export type DoNotInfer<T> = [T][T extends any ? 0 : any];
 /** @deprecated Use the built-in `NoInfer` type instead */
 export type NoInfer<T> = DoNotInfer<T>;
-export type LowInfer<T> = T & {};
+export type LowInfer<T> = T & NonNullable<unknown>;
 export type MetaObject = Record<string, any>;
 export type Lazy<T> = () => T;
 export type MaybeLazy<T> = T | Lazy<T>;
@@ -175,7 +177,7 @@ export type DelayedTransitions<TContext extends MachineContext, TEvent extends E
     [K in Delay<TDelay>]?: string | SingleOrArray<TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay, TODO, // TEmitted
     TODO>>;
 };
-export type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | string;
+export type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | ({} & string);
 export type SingleOrArray<T> = readonly T[] | T;
 export type StateNodesConfig<TContext extends MachineContext, TEvent extends EventObject> = {
     [K in string]: StateNode<TContext, TEvent>;
@@ -253,7 +255,7 @@ export type InvokeConfig<TContext extends MachineContext, TEvent extends EventOb
     onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
 };
 export type AnyInvokeConfig = InvokeConfig<any, any, any, any, any, any, any, any>;
-export interface StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TOutput, TEmitted extends EventObject, TMeta extends MetaObject> {
+export interface StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, _TOutput, TEmitted extends EventObject, TMeta extends MetaObject> {
     /** The initial state transition. */
     initial?: InitialTransitionConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay> | string | undefined;
     /**
@@ -755,11 +757,12 @@ export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends Ev
     _parent?: AnyActorRef;
     system: AnyActorSystem;
     src: string | AnyActorLogic;
-    on: <TType extends TEmitted['type'] | '*'>(type: TType, handler: (emitted: TEmitted & (TType extends '*' ? {} : {
+    on: <TType extends TEmitted['type'] | '*'>(type: TType, handler: (emitted: TEmitted & (TType extends '*' ? unknown : {
         type: TType;
     })) => void) => Subscription;
 }
-export type AnyActorRef = ActorRef<any, any, any>;
+export type AnyActorRef = ActorRef<any, any, // TODO: shouldn't this be AnyEventObject?
+any>;
 export type ActorRefLike = Pick<AnyActorRef, 'sessionId' | 'send' | 'getSnapshot'>;
 export type UnknownActorRef = ActorRef<Snapshot<unknown>, EventObject>;
 export type ActorLogicFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<any, any, any, any, any, any, any, any, any, any, any, any, any, // TMeta
@@ -779,6 +782,7 @@ export interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends
     emit: (event: TEmitted) => void;
     system: TSystem;
     stopChild: (child: AnyActorRef) => void;
+    actionExecutor: ActionExecutor;
 }
 export type AnyActorScope = ActorScope<any, // TSnapshot
 any, // TEvent
@@ -815,15 +819,15 @@ in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem
     /** 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.
+     * Transition function that processes the current state and an incoming event
+     * to produce a new state.
      *
      * @param snapshot - The current state.
-     * @param message - The incoming message.
+     * @param event - The incoming event.
      * @param actorScope - The actor scope.
      * @returns The new state.
      */
-    transition: (snapshot: TSnapshot, message: TEvent, actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => TSnapshot;
+    transition: (snapshot: TSnapshot, event: TEvent, actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => TSnapshot;
     /**
      * Called to provide the initial state of the actor.
      *
@@ -887,6 +891,7 @@ export interface ActorSystemInfo {
     actors: Record<string, AnyActorRef>;
 }
 export type RequiredActorOptions<TActor extends ProvidedActor> = (undefined extends TActor['id'] ? never : 'id') | (undefined extends InputFrom<TActor['logic']> ? never : 'input');
+export type RequiredLogicInput<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? never : 'input';
 type ExtractLiteralString<T extends string | undefined> = T extends string ? string extends T ? never : T : never;
 type ToConcreteChildren<TActor extends ProvidedActor> = {
     [A in TActor as ExtractLiteralString<A['id']>]?: ActorRefFromLogic<A['logic']>;
@@ -895,7 +900,7 @@ export type ToChildren<TActor extends ProvidedActor> = string extends TActor['sr
     include: {
         [id: string]: TActor extends any ? ActorRefFromLogic<TActor['logic']> | undefined : never;
     };
-    exclude: {};
+    exclude: unknown;
 }[undefined extends TActor['id'] ? 'include' : string extends TActor['id'] ? 'include' : 'exclude']>;
 export type StateSchema = {
     id?: string;
@@ -960,4 +965,33 @@ export type ToStateValue<T extends StateSchema> = T extends {
         [StateKey in K]: ToStateValue<T['states'][K]>;
     };
 }>> : never) : {};
+export interface ExecutableActionObject {
+    type: string;
+    info: ActionArgs<MachineContext, EventObject, EventObject>;
+    params: NonReducibleUnknown;
+    exec: ((info: ActionArgs<any, any, any>, params: unknown) => void) | undefined;
+}
+export interface ToExecutableAction<T extends ParameterizedObject> extends ExecutableActionObject {
+    type: T['type'];
+    params: T['params'];
+    exec: undefined;
+}
+export interface ExecutableSpawnAction extends ExecutableActionObject {
+    type: 'xstate.spawnChild';
+    info: ActionArgs<MachineContext, EventObject, EventObject>;
+    params: {
+        id: string;
+        actorRef: AnyActorRef | undefined;
+        src: string | AnyActorLogic;
+    };
+}
+export type SpecialExecutableAction = ExecutableSpawnAction | ExecutableRaiseAction | ExecutableSendToAction;
+export type ExecutableActionsFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig> ? SpecialExecutableAction | (string extends TAction['type'] ? never : ToExecutableAction<TAction>) : never;
+export type ActionExecutor = (actionToExecute: ExecutableActionObject) => void;
+export type BuiltinActionResolution = [
+    AnyMachineSnapshot,
+    NonReducibleUnknown,
+    // params
+    UnknownAction[] | undefined
+];
 export {};

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

@@ -9,7 +9,7 @@ export declare function mapValues<P, O extends Record<string, unknown>>(collecti
 export declare function toArray<T>(value: readonly T[] | T | undefined): readonly T[];
 export declare function resolveOutput<TContext extends MachineContext, TExpressionEvent extends EventObject>(mapper: Mapper<TContext, TExpressionEvent, unknown, EventObject> | NonReducibleUnknown, context: TContext, event: TExpressionEvent, self: AnyActorRef): unknown;
 export declare function isErrorActorEvent(event: AnyEventObject): event is ErrorActorEvent;
-export declare function toTransitionConfigArray<TContext extends MachineContext, TEvent extends EventObject>(configLike: SingleOrArray<AnyTransitionConfig | TransitionConfigTarget>): Array<AnyTransitionConfig>;
+export declare function toTransitionConfigArray(configLike: SingleOrArray<AnyTransitionConfig | TransitionConfigTarget>): Array<AnyTransitionConfig>;
 export declare function normalizeTarget<TContext extends MachineContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, TEvent>> | undefined): ReadonlyArray<string | StateNode<TContext, TEvent>> | undefined;
 export declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;

package/dist/{log-38475d87.development.esm.js → log-0acd9069.development.esm.js}

@@ -1,41 +1,37 @@
-import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as executingCustomAction, W as XSTATE_ERROR, Y as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-5ea71f04.development.esm.js';
+import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as executingCustomAction, W as XSTATE_ERROR, Y as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-1db27a82.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
   context
 }, event, spawnedChildren) {
-  const spawn = (src, options = {}) => {
-    const {
-      systemId,
-      input
-    } = options;
+  const spawn = (src, options) => {
     if (typeof src === 'string') {
       const logic = resolveReferencedActor(machine, src);
       if (!logic) {
         throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
       }
       const actorRef = createActor(logic, {
-        id: options.id,
+        id: options?.id,
         parent: actorScope.self,
-        syncSnapshot: options.syncSnapshot,
-        input: typeof input === 'function' ? input({
+        syncSnapshot: options?.syncSnapshot,
+        input: typeof options?.input === 'function' ? options.input({
           context,
           event,
           self: actorScope.self
-        }) : input,
+        }) : options?.input,
         src,
-        systemId
+        systemId: options?.systemId
       });
       spawnedChildren[actorRef.id] = actorRef;
       return actorRef;
     } else {
       const actorRef = createActor(src, {
-        id: options.id,
+        id: options?.id,
         parent: actorScope.self,
-        syncSnapshot: options.syncSnapshot,
-        input: options.input,
+        syncSnapshot: options?.syncSnapshot,
+        input: options?.input,
         src,
-        systemId
+        systemId: options?.systemId
       });
       return actorRef;
     }
@@ -83,7 +79,7 @@ function resolveAssign(actorScope, snapshot, actionArgs, actionParams, {
       ...snapshot.children,
       ...spawnedChildren
     } : snapshot.children
-  })];
+  }), undefined, undefined];
 }
 /**
  * Updates the current context of the machine.
@@ -123,7 +119,7 @@ function assign(assignment) {
   if (executingCustomAction) {
     console.warn('Custom actions should not call `assign()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
   }
-  function assign(args, params) {
+  function assign(_args, _params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -137,13 +133,10 @@ function assign(assignment) {
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr
 }) {
-  if (typeof eventOrExpr === 'string') {
-    throw new Error(`Only event objects may be used with emit; use emit({ type: "${eventOrExpr}" }) instead`);
-  }
   const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args, actionParams) : eventOrExpr;
   return [snapshot, {
     event: resolvedEvent
-  }];
+  }, undefined];
 }
 function executeEmit(actorScope, {
   event
@@ -191,7 +184,7 @@ eventOrExpr) {
   if (executingCustomAction) {
     console.warn('Custom actions should not call `emit()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
   }
-  function emit(args, params) {
+  function emit(_args, _params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -239,8 +232,6 @@ eventOrExpr) {
  *   "someChildState" }`.
  */
 
-// TODO: remove once TS fixes this type-widening issue
-
 /** @deprecated Use `AnyMachineSnapshot` instead */
 
 // TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
@@ -271,6 +262,8 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
 
 /** @deprecated */
 
+// TODO: cover all that can be actually returned
+
 function resolveSendTo(actorScope, snapshot, args, actionParams, {
   to,
   event: eventOrExpr,
@@ -279,7 +272,9 @@ function resolveSendTo(actorScope, snapshot, args, actionParams, {
 }, extra) {
   const delaysMap = snapshot.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
-    throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
+    throw new Error(
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    `Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
   }
   const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args, actionParams) : eventOrExpr;
   let resolvedDelay;
@@ -292,9 +287,12 @@ function resolveSendTo(actorScope, snapshot, args, actionParams, {
   const resolvedTarget = typeof to === 'function' ? to(args, actionParams) : to;
   let targetActorRef;
   if (typeof resolvedTarget === 'string') {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
     if (resolvedTarget === SpecialTargets.Parent) {
       targetActorRef = actorScope.self._parent;
-    } else if (resolvedTarget === SpecialTargets.Internal) {
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+    else if (resolvedTarget === SpecialTargets.Internal) {
       targetActorRef = actorScope.self;
     } else if (resolvedTarget.startsWith('#_')) {
       // SCXML compatibility: https://www.w3.org/TR/scxml/#SCXMLEventProcessor
@@ -311,10 +309,11 @@ function resolveSendTo(actorScope, snapshot, args, actionParams, {
   }
   return [snapshot, {
     to: targetActorRef,
+    targetId: typeof resolvedTarget === 'string' ? resolvedTarget : undefined,
     event: resolvedEvent,
     id,
     delay: resolvedDelay
-  }];
+  }, undefined];
 }
 function retryResolveSendTo(_, snapshot, params) {
   if (typeof params.to === 'string') {
@@ -354,14 +353,14 @@ function executeSendTo(actorScope, params) {
  */
 function sendTo(to, eventOrExpr, options) {
   if (executingCustomAction) {
-    console.warn('Custom actions should not call `raise()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
+    console.warn('Custom actions should not call `sendTo()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
   }
-  function sendTo(args, params) {
+  function sendTo(_args, _params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
   }
-  sendTo.type = 'xsnapshot.sendTo';
+  sendTo.type = 'xstate.sendTo';
   sendTo.to = to;
   sendTo.event = eventOrExpr;
   sendTo.id = options?.id;
@@ -471,7 +470,7 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, {
  * ```
  */
 function enqueueActions(collect) {
-  function enqueueActions(args, params) {
+  function enqueueActions(_args, _params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -489,7 +488,7 @@ function resolveLog(_, snapshot, actionArgs, actionParams, {
   return [snapshot, {
     value: typeof value === 'function' ? value(actionArgs, actionParams) : value,
     label
-  }];
+  }, undefined];
 }
 function executeLog({
   logger
@@ -519,7 +518,7 @@ function log(value = ({
   context,
   event
 }), label) {
-  function log(args, params) {
+  function log(_args, _params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }