Machine

Machine: object

Defined in: Core/Machine.ts:181

Type Declaration

interpret

interpret: <States, Events>(machine, options?) => MachineActor<States, Events>

Spawns an execution actor for a machine.

Manages active state lifecycles:

• Runs entry effects on state entry, providing an AbortSignal and guarded send.
• Automatically aborts active controllers and executes cleanup disposers when exiting a state.
• Suppresses stale async dispatches from previously active states.
• Queues re-entrant send calls to preserve sequential transition semantics.
• Optionally synchronizes with an EventBus.

Type Parameters

States

States extends WithKind<string> & object

Events

Events extends Record<string, unknown>

Parameters

machine

Machine<States, Events>

options?

MachineInterpretOptions<States, Events>

Returns

MachineActor<States, Events>

See

Machine.transition for pure stateless transitions.

Example

const actor = Machine.interpret(authMachine);

const unsubscribe = actor.subscribe((state) => {
  console.log("Current state:", state.kind);
});

actor.send({ kind: "SUBMIT", value: { email: "dev@example.com" } });

is

is: <K>(kind) => <S>(state) => state is Extract<S, { kind: K }>

Curried type guard that refines a state to a specific variant kind.

Type Parameters

K

K extends string

Parameters

kind

K

Returns

<S>(state) => state is Extract<S, { kind: K }>

Example

if (Machine.is("authenticating")(state)) {
  console.log(state.value.email);
}

make

make: <States, Events>(config) => Machine<States, Events>

Creates a validated, immutable state machine definition.

Type Parameters

States

States extends WithKind<string> & object

Events

Events extends Record<string, unknown>

Parameters

config

id?

string

initial

States

states

MachineTransitionTable<States, Events>

Returns

Machine<States, Events>

Example

type AuthState =
  | Machine.State<"loggedOut", void, "authenticating">
  | Machine.State<"authenticating", { readonly email: string }, "authenticated" | "failed">
  | Machine.State<"authenticated", { readonly token: string }, "loggedOut">
  | Machine.State<"failed", { readonly error: string }, "authenticating" | "loggedOut">;

type AuthEvents = {
  SUBMIT: { readonly email: string };
  RESOLVE: { readonly token: string };
  REJECT: { readonly error: string };
  LOGOUT: void;
};

const authMachine = Machine.make<AuthState, AuthEvents>({
  id: "auth",
  initial: Machine.state("loggedOut"),
  states: {
    loggedOut: {
      on: {
        SUBMIT: (_state, { email }) => Machine.state("authenticating", { email }),
      },
    },
    authenticating: {
      on: {
        RESOLVE: (_state, { token }) => Machine.state("authenticated", { token }),
        REJECT: (_state, { error }) => Machine.state("failed", { error }),
      },
    },
    authenticated: {
      on: {
        LOGOUT: () => Machine.state("loggedOut"),
      },
    },
    failed: {
      on: {
        SUBMIT: (_state, { email }) => Machine.state("authenticating", { email }),
        LOGOUT: () => Machine.state("loggedOut"),
      },
    },
  },
});

match

match: <States, R>(cases) => (state) => R

Curried exhaustive pattern matcher across all state variants of a machine.

Type Parameters

States

States extends WithKind<string> & object

R

R

Parameters

cases

{ readonly [K in string]: (state: Extract<States, { kind: K }>) => R }

Returns

(state) => R

Example

const title = pipe(
  actor.getState(),
  Machine.match<AuthState, string>({
    loggedOut: () => "Please Sign In",
    authenticating: ({ value }) => `Verifying ${value.email}...`,
    authenticated: ({ value }) => `Logged in with token ${value.token}`,
    failed: ({ value }) => `Error: ${value.error}`,
  }),
);

state

state: {<Kind>(kind): WithKind<Kind> & object; <Kind, Data>(kind, value): MachineState<Kind, Data, string>; } = makeState

Constructs a state variant without requiring manual type assertions.

Call Signature

<Kind>(kind): WithKind<Kind> & object

Type Parameters

Kind

Kind extends string

Parameters

kind

Kind

Returns

WithKind<Kind> & object

Call Signature

<Kind, Data>(kind, value): MachineState<Kind, Data, string>

Type Parameters

Kind

Kind extends string

Data

Data

Parameters

kind

Kind

value

Data

Returns

MachineState<Kind, Data, string>

Example

const idle = Machine.state("idle");
const active = Machine.state("active", { count: 1 });

to

to: object

Converters to standard external runtime structures.

to.reducer

reducer: <States, Events>(machine) => (state, event) => States

Converts a state machine into an uncurried reducer function (state, event) => nextState directly compatible with React useReducer and Redux.

If state is undefined (such as during Redux store initialization), defaults to machine.initial.

Type Parameters

States

States extends WithKind<string> & object

Events

Events extends Record<string, unknown>

Parameters

machine

Machine<States, Events>

Returns

(state, event) => States

See

Machine.transition for pure, curried data-last pipeline transitions.

Example

// In React:
const [state, dispatch] = useReducer(
  Machine.to.reducer(checkoutMachine),
  checkoutMachine.initial,
);

// In Redux:
const store = createStore(Machine.to.reducer(checkoutMachine));

transition

transition: <States, Events>(machine, event) => (state) => States

Pure, data-last transition function. Evaluates a transition on the provided state and returns the next state without executing lifecycle side effects.

If the state does not handle the event, the current state is returned unchanged.

Type Parameters

States

States extends WithKind<string> & object

Events

Events extends Record<string, unknown>

Parameters

machine

Machine<States, Events>

event

MachineEventMessage<Events>

Returns

(state) => States

See

Machine.interpret to run a stateful actor with async lifecycle effects.

Example

const nextState = pipe(
  currentState,
  Machine.transition(authMachine, { kind: "SUBMIT", value: { email: "dev@example.com" } }),
);