xstate 5.32.1 → 6.0.0-alpha.2

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

@@ -1,144 +1,260 @@
+import { StandardSchemaV1 } from "./schema.types.js";
 import { StateMachine } from "./StateMachine.js";
-import { assign } from "./actions/assign.js";
-import { cancel } from "./actions/cancel.js";
-import { emit } from "./actions/emit.js";
-import { enqueueActions } from "./actions/enqueueActions.js";
-import { log } from "./actions/log.js";
-import { raise } from "./actions/raise.js";
-import { sendTo } from "./actions/send.js";
-import { spawnChild } from "./actions/spawnChild.js";
-import { stopChild } from "./actions/stopChild.js";
-import { GuardPredicate } from "./guards.js";
-import { ActionFunction, AnyActorRef, AnyEventObject, Cast, DelayConfig, EventObject, Invert, IsNever, MachineConfig, MachineContext, MetaObject, NonReducibleUnknown, ParameterizedObject, RoutableStateId, SetupTypes, StateNodeConfig, StateSchema, ToChildren, ToStateValue, UnknownActorLogic, Values } from "./types.js";
-type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
-    [K in keyof TParameterizedMap as K & string]: {
-        type: K & string;
-        params: TParameterizedMap[K];
+import { AnyActorRef, EventObject, AnyEventObject, EventDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, ToChildren, MetaObject, Cast } from "./types.js";
+import { DelayMapFromNames, Implementations, InferOutput, InferEvents, Next_MachineConfig, Next_StateNodeConfig, ValidateDelayReferences, WithDefault } from "./types.v6.js";
+type SetupStateSchemas = {
+    context?: StandardSchemaV1;
+    input?: StandardSchemaV1;
+};
+type SetupSchemas = {
+    context?: StandardSchemaV1;
+    events?: Record<string, StandardSchemaV1>;
+    emitted?: Record<string, StandardSchemaV1>;
+    input?: StandardSchemaV1;
+    output?: StandardSchemaV1;
+    meta?: StandardSchemaV1;
+    tags?: StandardSchemaV1;
+};
+/** State schema with optional schemas.input and nested states */
+interface SetupStateSchema {
+    schemas?: SetupStateSchemas;
+    states?: Record<string, SetupStateSchema>;
+}
+type SetupSchema<TSchemas, TKey extends keyof SetupSchemas> = TKey extends keyof TSchemas ? TSchemas[TKey] extends StandardSchemaV1 ? TSchemas[TKey] : never : never;
+type SetupSchemaMap<TSchemas, TKey extends 'events' | 'emitted'> = TKey extends keyof TSchemas ? TSchemas[TKey] extends Record<string, StandardSchemaV1> ? TSchemas[TKey] : never : never;
+type SetupOrConfigSchema<TSchemas, TKey extends Exclude<keyof SetupSchemas, 'events' | 'emitted'>, TConfigSchema extends StandardSchemaV1> = [SetupSchema<TSchemas, TKey>] extends [never] ? TConfigSchema : SetupSchema<TSchemas, TKey>;
+type SetupOrConfigSchemaMap<TSchemas, TKey extends 'events' | 'emitted', TConfigSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, TKey>] extends [never] ? TConfigSchemaMap : SetupSchemaMap<TSchemas, TKey>;
+type SetupStateKeys<TStateSchemas extends Record<string, SetupStateSchema>> = keyof TStateSchemas & string;
+type SetupStateKey<TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? string : [SetupStateKeys<TStateSchemas>] extends [never] ? string : SetupStateKeys<TStateSchemas>;
+type SetupStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? string : [SetupStateKeys<TStateSchemas>] extends [never] ? string : SetupStateKeys<TStateSchemas> | `.${string}` | `#${string}`;
+type InvalidSetupStateKeys<TConfig, TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? never : [SetupStateKeys<TStateSchemas>] extends [never] ? never : TConfig extends {
+    states: infer TStates;
+} ? Exclude<keyof TStates & string, SetupStateKeys<TStateSchemas>> : never;
+type ValidateSetupStateKeys<TConfig, TStateSchemas extends Record<string, SetupStateSchema>> = [InvalidSetupStateKeys<TConfig, TStateSchemas>] extends [never] ? unknown : {
+    states: {
+        [K in InvalidSetupStateKeys<TConfig, TStateSchemas>]: never;
     };
-}>;
-type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<string, UnknownActorLogic>> = Values<{
-    [K in keyof TActors as K & string]: {
-        src: K & string;
-        logic: TActors[K];
-        id: IsNever<TChildrenMap> extends true ? string | undefined : K extends keyof Invert<TChildrenMap> ? Invert<TChildrenMap>[K] & string : string | undefined;
+};
+type ValidateNestedSetupStateKeys<TConfig, TStateSchemas extends Record<string, SetupStateSchema>> = TConfig extends {
+    states: infer TConfigStates;
+} ? TConfigStates extends Record<string, unknown> ? {
+    states: {
+        [K in keyof TConfigStates & keyof TStateSchemas & string]: TStateSchemas[K] extends {
+            states: infer TChildStateSchemas;
+        } ? TChildStateSchemas extends Record<string, SetupStateSchema> ? TConfigStates[K] & ValidateSetupStateKeys<TConfigStates[K], TChildStateSchemas> & ValidateNestedSetupStateKeys<TConfigStates[K], TChildStateSchemas> : TConfigStates[K] : TConfigStates[K];
     };
-}>;
-type ToStateSchema<TSchema extends StateSchema> = {
-    -readonly [K in keyof TSchema as K & ('id' | 'states')]: K extends 'states' ? {
-        [SK in keyof TSchema['states']]: ToStateSchema<NonNullable<TSchema['states'][SK]>>;
-    } : TSchema[K];
+} : unknown : unknown;
+type SetupContext<TSchemas, TContextSchema extends StandardSchemaV1> = [
+    SetupSchema<TSchemas, 'context'>
+] extends [never] ? unknown extends StandardSchemaV1.InferOutput<TContextSchema> ? MachineContext : StandardSchemaV1.InferOutput<TContextSchema> & MachineContext : StandardSchemaV1.InferOutput<SetupSchema<TSchemas, 'context'>> & MachineContext;
+type SetupContextRequired<TSchemas, TContextSchema extends StandardSchemaV1> = [
+    SetupSchema<TSchemas, 'context'>
+] extends [never] ? unknown extends StandardSchemaV1.InferOutput<TContextSchema> ? false : true : true;
+type SetupEvents<TSchemas, TEventSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, 'events'>] extends [never] ? InferEvents<TEventSchemaMap> : InferEvents<SetupSchemaMap<TSchemas, 'events'>>;
+type SetupTags<TSchemas, TTagSchema extends StandardSchemaV1> = [
+    SetupSchema<TSchemas, 'tags'>
+] extends [never] ? StandardSchemaV1.InferOutput<TTagSchema> & string : StandardSchemaV1.InferOutput<SetupSchema<TSchemas, 'tags'>> & string;
+type SetupInput<TSchemas, TInputSchema extends StandardSchemaV1> = [
+    SetupSchema<TSchemas, 'input'>
+] extends [never] ? InferOutput<TInputSchema, unknown> : InferOutput<SetupSchema<TSchemas, 'input'>, unknown>;
+type SetupOutput<TSchemas, TOutputSchema extends StandardSchemaV1> = [
+    SetupSchema<TSchemas, 'output'>
+] extends [never] ? InferOutput<TOutputSchema, unknown> : InferOutput<SetupSchema<TSchemas, 'output'>, unknown>;
+type SetupEmitted<TSchemas, TEmittedSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, 'emitted'>] extends [never] ? WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject> : WithDefault<InferEvents<SetupSchemaMap<TSchemas, 'emitted'>>, AnyEventObject>;
+type SetupMeta<TSchemas, TMetaSchema extends StandardSchemaV1> = [
+    SetupSchema<TSchemas, 'meta'>
+] extends [never] ? InferOutput<TMetaSchema, MetaObject> : InferOutput<SetupSchema<TSchemas, 'meta'>, MetaObject>;
+/** Extracts input type from a state schema */
+type StateInput<TStateSchema extends SetupStateSchema> = TStateSchema['schemas'] extends {
+    input: infer TInputSchema;
+} ? TInputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInputSchema> : undefined : undefined;
+type StateContext<TStateSchema extends SetupStateSchema, TFallbackContext extends MachineContext> = TStateSchema['schemas'] extends {
+    context: infer TContextSchema;
+} ? TContextSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TContextSchema> & MachineContext : TFallbackContext : TFallbackContext;
+type WithNestedStates<TConfig, TNestedStates> = TConfig extends {
+    type: 'choice';
+} ? TConfig : Omit<TConfig, 'states'> & {
+    states?: TNestedStates;
 };
-type RequiredSetupKeys<TChildrenMap> = IsNever<keyof TChildrenMap> extends true ? never : 'actors';
-type ExtractInvokeEntry<T> = T extends {
-    id: infer TId extends string;
-    src: infer TSrc extends string;
-} ? {
-    [K in TId]: TSrc;
-} : {};
-type ExtractInvokeChildren<T> = T extends readonly (infer E)[] ? UnionToIntersection<ExtractInvokeEntry<E>> : ExtractInvokeEntry<T>;
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-type ExtractConfigChildren<TConfig> = TConfig extends {
-    invoke: infer TInvoke;
-} ? ExtractInvokeChildren<TInvoke> : {};
-type MergeChildrenMap<TExplicit extends Record<string, string>, TInferred extends Record<string, string>> = IsNever<keyof TExplicit> extends true ? TInferred : TExplicit;
-export type SetupReturn<TContext extends MachineContext, TEvent extends AnyEventObject, TActors extends Record<string, UnknownActorLogic>, TChildrenMap extends Record<string, string>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TEmitted extends EventObject, TMeta extends MetaObject> = {
-    extend: <TExtendActions extends Record<string, ParameterizedObject['params'] | undefined> = {}, TExtendGuards extends Record<string, ParameterizedObject['params'] | undefined> = {}, TExtendDelays extends string = never>({ actions, guards, delays }: {
-        actions?: {
-            [K in keyof TExtendActions]: ActionFunction<TContext, TEvent, TEvent, TExtendActions[K], ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions & TExtendActions>, ToParameterizedObject<TGuards & TExtendGuards>, TDelay | TExtendDelays, TEmitted>;
-        };
-        guards?: {
-            [K in keyof TExtendGuards]: GuardPredicate<TContext, TEvent, TExtendGuards[K], ToParameterizedObject<TGuards & TExtendGuards>>;
-        };
-        delays?: {
-            [K in TExtendDelays]: DelayConfig<TContext, TEvent, ToParameterizedObject<TActions & TExtendActions>['params'], TEvent>;
-        };
-    }) => SetupReturn<TContext, TEvent, TActors, TChildrenMap, TActions & TExtendActions, TGuards & TExtendGuards, TDelay | TExtendDelays, TTag, TInput, TOutput, TEmitted, TMeta>;
-    /**
-     * Creates a state config that is strongly typed. This state config can be
-     * used to create a machine.
-     *
-     * @example
-     *
-     * ```ts
-     * const lightMachineSetup = setup({
-     *   // ...
-     * });
-     *
-     * const green = lightMachineSetup.createStateConfig({
-     *   on: {
-     *     timer: {
-     *       actions: 'doSomething'
-     *     }
-     *   }
-     * });
-     *
-     * const machine = lightMachineSetup.createMachine({
-     *   initial: 'green',
-     *   states: {
-     *     green,
-     *     yellow,
-     *     red
-     *   }
-     * });
-     * ```
-     */
-    createStateConfig: <TStateConfig extends StateNodeConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, unknown, TEmitted, TMeta>>(config: TStateConfig) => TStateConfig;
-    /**
-     * Creates a type-safe action.
-     *
-     * @example
-     *
-     * ```ts
-     * const machineSetup = setup({
-     *   // ...
-     * });
-     *
-     * const action = machineSetup.createAction(({ context, event }) => {
-     *   console.log(context.count, event.value);
-     * });
-     *
-     * const incrementAction = machineSetup.createAction(
-     *   assign({ count: ({ context }) => context.count + 1 })
-     * );
-     *
-     * const machine = machineSetup.createMachine({
-     *   context: { count: 0 },
-     *   entry: [action, incrementAction]
-     * });
-     * ```
-     */
-    createAction: (action: ActionFunction<TContext, TEvent, TEvent, unknown, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TEmitted>) => typeof action;
-    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>, TResolvedChildren extends Record<string, string> = MergeChildrenMap<TChildrenMap, Cast<ExtractConfigChildren<TConfig>, Record<string, string>>>>(config: TConfig) => StateMachine<TContext, TEvent | ([RoutableStateId<TConfig>] extends [never] ? never : {
-        type: 'xstate.route';
-        to: RoutableStateId<TConfig>;
-    }), Cast<ToChildren<ToProvidedActor<TResolvedChildren, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TResolvedChildren, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, TEmitted, TMeta, ToStateSchema<TConfig>>;
-    assign: typeof assign<TContext, TEvent, undefined, TEvent, ToProvidedActor<TChildrenMap, TActors>>;
-    sendTo: <TTargetActor extends AnyActorRef>(...args: Parameters<typeof sendTo<TContext, TEvent, undefined, TTargetActor, TEvent, TDelay, TDelay>>) => ReturnType<typeof sendTo<TContext, TEvent, undefined, TTargetActor, TEvent, TDelay, TDelay>>;
-    raise: typeof raise<TContext, TEvent, TEvent, undefined, TDelay, TDelay>;
-    log: typeof log<TContext, TEvent, undefined, TEvent>;
-    cancel: typeof cancel<TContext, TEvent, undefined, TEvent>;
-    stopChild: typeof stopChild<TContext, TEvent, undefined, TEvent>;
-    enqueueActions: typeof enqueueActions<TContext, TEvent, undefined, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TEmitted>;
-    emit: typeof emit<TContext, TEvent, undefined, TEvent, TEmitted>;
-    spawnChild: typeof spawnChild<TContext, TEvent, undefined, TEvent, ToProvidedActor<TChildrenMap, TActors>>;
+/**
+ * Converts SetupStateSchema to StateSchema with input types included. This
+ * allows getInputs() to be strongly typed.
+ */
+type SetupStateSchemaToStateSchema<TSetupSchema extends SetupStateSchema> = {
+    input: StateInput<TSetupSchema>;
+    contextSchema: TSetupSchema['schemas'] extends {
+        context: infer TContextSchema;
+    } ? TContextSchema extends StandardSchemaV1 ? TContextSchema : undefined : undefined;
+    states: TSetupSchema['states'] extends Record<string, SetupStateSchema> ? {
+        [K in keyof TSetupSchema['states'] & string]: SetupStateSchemaToStateSchema<TSetupSchema['states'][K]>;
+    } : undefined;
 };
-export declare function setup<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
-TActors extends Record<string, UnknownActorLogic> = {}, TChildrenMap extends Record<string, string> = {}, TActions extends Record<string, ParameterizedObject['params'] | undefined> = {}, TGuards extends Record<string, ParameterizedObject['params'] | undefined> = {}, TDelay extends string = never, TTag extends string = string, TInput = NonReducibleUnknown, TOutput extends NonReducibleUnknown = NonReducibleUnknown, TEmitted extends EventObject = EventObject, TMeta extends MetaObject = MetaObject>({ schemas, actors, actions, guards, delays }: {
-    schemas?: unknown;
-    types?: SetupTypes<TContext, TEvent, TChildrenMap, TTag, TInput, TOutput, TEmitted, TMeta>;
-    actors?: {
-        [K in keyof TActors | Values<TChildrenMap>]: K extends keyof TActors ? TActors[K] : never;
-    };
-    actions?: {
-        [K in keyof TActions]: ActionFunction<TContext, TEvent, TEvent, TActions[K], ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TEmitted>;
+/** Converts the root setup states config to a StateSchema. */
+type SetupStatesToStateSchema<TStates extends Record<string, SetupStateSchema>> = {
+    states: {
+        [K in keyof TStates & string]: SetupStateSchemaToStateSchema<TStates[K]>;
     };
-    guards?: {
-        [K in keyof TGuards]: GuardPredicate<TContext, TEvent, TGuards[K], ToParameterizedObject<TGuards>>;
+};
+type EmptyStateSchema = {
+    input: undefined;
+    states: undefined;
+};
+type StateSchemaInput<TConfig extends StateSchema, TSetup extends StateSchema> = TSetup extends {
+    input: infer TInput;
+} ? TInput : TConfig extends {
+    input: infer TInput;
+} ? TInput : undefined;
+type StateSchemaContextSchema<TConfig extends StateSchema, TSetup extends StateSchema> = TSetup extends {
+    contextSchema: infer TContextSchema;
+} ? TContextSchema extends StandardSchemaV1 ? TContextSchema : undefined : TConfig extends {
+    contextSchema: infer TContextSchema;
+} ? TContextSchema extends StandardSchemaV1 ? TContextSchema : undefined : undefined;
+type StateSchemaChild<TSetup extends StateSchema, K extends string> = TSetup extends {
+    states: infer TStates;
+} ? K extends keyof TStates ? Cast<TStates[K], StateSchema> : EmptyStateSchema : EmptyStateSchema;
+type MergeStateSchema<TConfig extends StateSchema, TSetup extends StateSchema> = Omit<TConfig, 'contextSchema' | 'input' | 'states'> & {
+    contextSchema: StateSchemaContextSchema<TConfig, TSetup>;
+    input: StateSchemaInput<TConfig, TSetup>;
+    states: TConfig extends {
+        states: infer TStates;
+    } ? TStates extends Record<string, StateSchema> ? {
+        [K in keyof TStates & string]: MergeStateSchema<TStates[K], StateSchemaChild<TSetup, K>>;
+    } : undefined : undefined;
+};
+/** Machine config with typed state input */
+type SetupMachineConfig<TStateSchemas extends Record<string, SetupStateSchema>, TSchemas extends SetupSchemas, TContextSchema extends StandardSchemaV1, TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TContextRequired extends boolean> = Omit<Next_MachineConfig<SetupOrConfigSchema<TSchemas, 'context', TContextSchema>, SetupOrConfigSchemaMap<TSchemas, 'events', TEventSchemaMap>, SetupOrConfigSchemaMap<TSchemas, 'emitted', TEmittedSchemaMap>, SetupOrConfigSchema<TSchemas, 'input', TInputSchema>, SetupOrConfigSchema<TSchemas, 'output', TOutputSchema>, SetupOrConfigSchema<TSchemas, 'meta', TMetaSchema>, SetupOrConfigSchema<TSchemas, 'tags', TTagSchema>, TContext, TEvent, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap, TContextRequired>, 'states' | 'initial'> & {
+    initial?: SetupStateKey<TStateSchemas> | InitialTransitionWithInput<TStateSchemas, TContext, TEvent> | undefined;
+    states?: StatesWithInput<TStateSchemas, TStateSchemas, TContext, TEvent, TDelays, TTag, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>;
+};
+/** States config type that provides typed input for known states */
+type StatesWithInput<TRootStateSchemas extends Record<string, SetupStateSchema>, TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> = {
+    [K in keyof TStateSchemas & string]?: StateNodeConfigWithNestedInput<TRootStateSchemas, TStateSchemas[K], TContext, TEvent, TDelays, TTag, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>;
+};
+/** State node config that recursively applies typed input for nested states */
+type StateNodeConfigWithNestedInput<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> = WithNestedStates<Omit<Next_StateNodeConfig<StateContext<TStateSchema, TContext>, TEvent, TDelays, TTag, any, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, StateInput<TStateSchema>>, 'on' | 'always' | 'initial'> & {
+    initial?: TStateSchema['states'] extends Record<string, SetupStateSchema> ? SetupStateKey<TStateSchema['states']> | InitialTransitionWithInput<TStateSchema['states'], StateContext<TStateSchema, TContext>, TEvent> : string | {
+        target: string;
+        input?: Record<string, unknown>;
+    } | undefined;
+    on?: StateTransitions<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, TEvent, TEmitted, TMeta>;
+    always?: StateTransitionConfigOrTarget<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, TEvent, TEvent, TEmitted, TMeta>;
+}, TStateSchema['states'] extends Record<string, SetupStateSchema> ? StatesWithInput<TStateSchema['states'], TStateSchema['states'], TContext, TEvent, TDelays, TTag, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> : {
+    [K in string]?: Next_StateNodeConfig<TContext, TEvent, TDelays, TTag, any, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, undefined>;
+}>;
+type StateTransitions<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject> = {
+    [K in EventDescriptor<TEvent>]?: StateTransitionConfigOrTarget<TStateSchemas, TContext, ExtractEvent<TEvent, K>, TEvent, TEmitted, TMeta>;
+};
+type StateTransitionConfigOrTarget<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject> = SetupStateTarget<TStateSchemas> | undefined | {
+    target?: SetupStateTarget<TStateSchemas> | SetupStateTarget<TStateSchemas>[];
+    description?: string;
+    reenter?: boolean;
+    meta?: TMeta;
+    input?: Record<string, unknown> | ((args: {
+        context: TContext;
+        event: TExpressionEvent;
+    }) => Record<string, unknown>);
+} | StateTransitionFunction<TStateSchemas, TContext, TExpressionEvent, TEvent, TEmitted, TMeta>;
+type StateTransitionFunction<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TExpressionEvent extends EventObject, _TEvent extends EventObject, _TEmitted extends EventObject, TMeta extends MetaObject> = (args: {
+    context: TContext;
+    event: TExpressionEvent;
+    self: AnyActorRef;
+    parent: AnyActorRef | undefined;
+    value: StateValue;
+    children: Record<string, AnyActorRef>;
+    actions: Implementations['actions'];
+    actors: Implementations['actors'];
+    guards: Implementations['guards'];
+    delays: Implementations['delays'];
+}, enq: any) => StateTransitionResult<TStateSchemas, TContext, TMeta> | void;
+type StateTransitionResult<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TMeta extends MetaObject> = {
+    target?: never;
+    context?: TContext;
+    reenter?: boolean;
+    meta?: TMeta;
+} | {
+    [K in keyof TStateSchemas & string]: {
+        target: K;
+        context: StateContext<TStateSchemas[K], TContext>;
+        reenter?: boolean;
+        meta?: TMeta;
+        input?: StateInput<TStateSchemas[K]> | ((args: {
+            context: TContext;
+            event: EventObject;
+        }) => StateInput<TStateSchemas[K]>);
     };
-    delays?: {
-        [K in TDelay]: DelayConfig<TContext, TEvent, ToParameterizedObject<TActions>['params'], TEvent>;
+}[keyof TStateSchemas & string];
+/** Initial transition with typed input based on target state */
+type InitialTransitionWithInput<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TEvent extends EventObject> = {
+    [K in keyof TStateSchemas & string]: {
+        target: K;
+        input?: StateInput<TStateSchemas[K]> | ((args: {
+            context: TContext;
+            event: TEvent;
+        }) => StateInput<TStateSchemas[K]>);
     };
-} & {
-    [K in RequiredSetupKeys<TChildrenMap>]: unknown;
-}): SetupReturn<TContext, TEvent, TActors, TChildrenMap, TActions, TGuards, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>;
+}[keyof TStateSchemas & string];
+/** Return type of setup() */
+interface SetupReturn<TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TSchemas extends SetupSchemas = {}> {
+    /** Creates a state machine with the setup configuration */
+    createMachine<TContextSchema extends StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, _TEvent extends EventObject, TActor extends ProvidedActor, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TDelays extends string, TTag extends SetupTags<TSchemas, TTagSchema>, TInput, TConfig extends SetupMachineConfig<TStates, TSchemas, TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap>, TDelays, TTag, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, TActionMap, TActorMap, TGuardMap, TDelayMap, SetupContextRequired<TSchemas, TContextSchema>>>(config: TConfig & ValidateSetupStateKeys<TConfig, TStates> & ValidateNestedSetupStateKeys<TConfig, TStates> & ValidateDelayReferences<TConfig> & {
+        schemas?: {
+            events?: TEventSchemaMap;
+            context?: TContextSchema;
+            emitted?: TEmittedSchemaMap;
+            input?: TInputSchema;
+            output?: TOutputSchema;
+            meta?: TMetaSchema;
+            tags?: TTagSchema;
+        };
+    }): StateMachine<SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap> | ([RoutableStateId<Cast<TConfig, StateSchema>>] extends [never] ? never : {
+        type: 'xstate.route';
+        to: RoutableStateId<Cast<TConfig, StateSchema>>;
+    }), Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, [
+        SetupSchema<TSchemas, 'input'>
+    ] extends [never] ? TInput : SetupInput<TSchemas, TInputSchema>, SetupOutput<TSchemas, TOutputSchema>, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, MergeStateSchema<Cast<TConfig, StateSchema>, SetupStatesToStateSchema<TStates>>, TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>>;
+    /** Creates a state node config with the setup configuration */
+    createStateConfig<const TConfig extends StateNodeConfigWithNestedInput<TStates, SetupStateSchema, SetupContext<TSchemas, StandardSchemaV1>, SetupEvents<TSchemas, Record<string, StandardSchemaV1>>, string, SetupTags<TSchemas, StandardSchemaV1>, SetupEmitted<TSchemas, Record<string, StandardSchemaV1>>, SetupMeta<TSchemas, StandardSchemaV1>, Implementations['actions'], Implementations['actors'], Implementations['guards'], Implementations['delays']>>(config: TConfig): TConfig;
+    /** State input schemas from setup config */
+    states: TStates;
+}
+/**
+ * Sets up a state machine with state input schemas and other configuration.
+ *
+ * @example
+ *
+ * ```ts
+ * import { setup } from 'xstate';
+ * import z from 'zod';
+ *
+ * const s = setup({
+ *   states: {
+ *     loading: {
+ *       schemas: {
+ *         input: z.object({
+ *           userId: z.string()
+ *         })
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const machine = s.createMachine({
+ *   initial: {
+ *     target: 'loading',
+ *     input: { userId: '123' }
+ *   },
+ *   states: {
+ *     loading: {
+ *       entry: ({ input }) => {
+ *         console.log(input.userId);
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export declare function setup<const TSchemas extends SetupSchemas = {}, const TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>>(config?: {
+    schemas?: TSchemas;
+    states?: TStates;
+}): SetupReturn<TStates, TSchemas>;
 export {};

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

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

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

@@ -1,9 +1,8 @@
 import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { ActionArgs, AnyEventObject, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, ExecutableActionObject, 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 isAtomicStateNode(stateNode: StateNode<any, any>): boolean;
+import { AnyEventObject, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, ExecutableActionObject, MachineContext, StateValue, TransitionDefinition, AnyAction, AnyTransitionConfig, AnyActor, AnyActorScope } from "./types.js";
+type AnyStateNodeIterable = Iterable<AnyStateNode>;
+export declare function isAtomicStateNode(stateNode: AnyStateNode): boolean;
 export declare function getProperAncestors(stateNode: AnyStateNode, toStateNode: AnyStateNode | undefined): Array<typeof stateNode>;
 export declare function getAllStateNodes(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
 export declare function getStateValue(rootNode: AnyStateNode, stateNodes: AnyStateNodeIterable): StateValue;
@@ -13,13 +12,11 @@ export declare function getCandidates<TEvent extends EventObject>(stateNode: Sta
 /** All delayed transitions from the config. */
 export declare function getDelayedTransitions(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<MachineContext, EventObject>>;
 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>[]>;
 /**
  * Collects route transitions from all descendants with explicit IDs. Called
  * once on the root node to avoid O(N²) repeated traversals.
  */
 export declare function formatRouteTransitions(rootStateNode: AnyStateNode): void;
-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>;
 /**
  * Returns the relative state node from the given `statePath`, or throws.
  *
@@ -32,21 +29,24 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
  * @param stateValue The state value or State instance
  */
 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;
+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, self: AnyActor): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 type Microstep = readonly [AnyMachineSnapshot, ExecutableActionObject[]];
 export declare function initialMicrostep(root: AnyStateNode, preInitialState: AnyMachineSnapshot, actorScope: AnyActorScope, initEvent: AnyEventObject, internalQueue: AnyEventObject[]): Microstep;
-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;
+/**
+ * Gets the transition result for a given transition without executing the
+ * transition.
+ */
+export declare function getTransitionResult(transition: Pick<AnyTransitionDefinition, 'target' | 'to' | 'source'> & {
+    reenter?: AnyTransitionDefinition['reenter'];
+    input?: AnyTransitionDefinition['input'];
+}, snapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope): {
+    targets: Readonly<AnyStateNode[]> | undefined;
+    context: MachineContext | undefined;
+    actions: AnyAction[] | undefined;
+    reenter?: boolean;
+    internalEvents: EventObject[] | undefined;
+    input: Record<string, unknown> | undefined;
+};
 export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue: AnyEventObject[]): {
     snapshot: typeof snapshot;
     microsteps: Microstep[];
@@ -58,4 +58,6 @@ export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObje
  * @param stateValue The partial state value to resolve.
  */
 export declare function resolveStateValue(rootNode: AnyStateNode, stateValue: StateValue): StateValue;
+export declare function hasEffect(transition: AnyTransitionDefinition, context: MachineContext, event: EventObject, snapshot: AnyMachineSnapshot, self: AnyActor): boolean;
+export declare function evaluateCandidate(candidate: AnyTransitionDefinition, event: EventObject, snapshot: AnyMachineSnapshot, stateNode: AnyStateNode, self: AnyActor): boolean;
 export {};

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

@@ -1,21 +1,21 @@
 import { InspectionEvent } from "./inspection.js";
-import { ActorSystemInfo, AnyActorRef, Observer, EventObject, Subscription } from "./types.js";
+import { ActorSystemInfo, AnyActor, Observer, EventObject, Subscription, TimersRestoreStrategy } from "./types.js";
 interface ScheduledEvent {
     id: string;
     event: EventObject;
     startedAt: number;
     delay: number;
-    source: AnyActorRef;
-    target: AnyActorRef;
+    source: AnyActor;
+    target: AnyActor;
 }
 export interface Clock {
     setTimeout(fn: (...args: any[]) => void, timeout: number): any;
     clearTimeout(id: any): void;
 }
 interface Scheduler {
-    schedule(source: AnyActorRef, target: AnyActorRef, event: EventObject, delay: number, id: string | undefined): void;
-    cancel(source: AnyActorRef, id: string): void;
-    cancelAll(actorRef: AnyActorRef): void;
+    schedule(source: AnyActor, target: AnyActor, event: EventObject, delay: number, id: string | undefined): void;
+    cancel(source: AnyActor, id: string): void;
+    cancelAll(actor: AnyActor): void;
 }
 export interface ActorSystem<T extends ActorSystemInfo> {
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
@@ -30,9 +30,10 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     _logger: (...args: any[]) => void;
 }
 export type AnyActorSystem = ActorSystem<any>;
-export declare function createSystem<T extends ActorSystemInfo>(rootActor: AnyActorRef, options: {
+export declare function createSystem<T extends ActorSystemInfo>(rootActor: AnyActor, options: {
     clock: Clock;
     logger: (...args: any[]) => void;
     snapshot?: unknown;
+    timers?: TimersRestoreStrategy;
 }): ActorSystem<T>;
 export {};

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

@@ -1,11 +1,11 @@
-import { AnyActorLogic, AnyStateMachine, EventFromLogic, InputFrom, SnapshotFrom, ExecutableActionsFrom, AnyTransitionDefinition, AnyMachineSnapshot } from "./types.js";
+import { AnyActorLogic, AnyStateMachine, EventFromLogic, InputFrom, SnapshotFrom, ExecutableActionObject, AnyTransitionDefinition, AnyMachineSnapshot } 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>[]];
+export declare function transition<T extends AnyActorLogic>(logic: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): [nextSnapshot: SnapshotFrom<T>, actions: ExecutableActionObject[]];
 /**
  * Given actor `logic` and optional `input`, returns a tuple of the
  * `nextSnapshot` and `actions` to execute from the initial transition (no
@@ -13,14 +13,14 @@ export declare function transition<T extends AnyActorLogic>(logic: T, snapshot:
  *
  * 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>[]];
+export declare function initialTransition<T extends AnyActorLogic>(logic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): [SnapshotFrom<T>, ExecutableActionObject[]];
 /**
  * Given a state `machine`, a `snapshot`, and an `event`, returns an array of
  * microsteps, where each microstep is a tuple of `[snapshot, actions]`.
  *
  * This is a pure function that does not execute `actions`.
  */
-export declare function getMicrosteps<T extends AnyStateMachine>(machine: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): Array<[SnapshotFrom<T>, ExecutableActionsFrom<T>[]]>;
+export declare function getMicrosteps<T extends AnyStateMachine>(machine: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): Array<[SnapshotFrom<T>, ExecutableActionObject[]]>;
 /**
  * Given a state `machine` and optional `input`, returns an array of microsteps
  * from the initial transition, where each microstep is a tuple of `[snapshot,
@@ -28,7 +28,7 @@ export declare function getMicrosteps<T extends AnyStateMachine>(machine: T, sna
  *
  * This is a pure function that does not execute `actions`.
  */
-export declare function getInitialMicrosteps<T extends AnyStateMachine>(machine: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): Array<[SnapshotFrom<T>, ExecutableActionsFrom<T>[]]>;
+export declare function getInitialMicrosteps<T extends AnyStateMachine>(machine: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): Array<[SnapshotFrom<T>, ExecutableActionObject[]]>;
 /**
  * Gets all potential next transitions from the current state.
  *