Machine

Machine: object

Defined in: Core/Machine.ts:180

Type Declaration

interpret

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

Starts an actor that stores state and runs its entry and exit effects.

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.
• Propagates synchronous callback errors after completing the active transition or cleanup.

Type Parameters

States

States extends WithKind<string> & object

Events

Events extends Record<string, unknown>

BusEvents

BusEvents extends Record<string, unknown> = Events

Parameters

machine

Machine<States, Events>

options

MachineInterpretOptions<States, Events, BusEvents> & CompatibleBus<Events, BusEvents>

Returns

MachineActor<States, Events>

See

Machine.transition for pure stateless transitions.

Example

const actor = Machine.interpret(authMachine, { initial: Machine.state("loggedOut") });

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>(states) => Machine<States, Events>

Creates a state machine definition from state configurations and event handlers.

Type Parameters

States

States extends WithKind<string> & object

Events

Events extends Record<string, unknown>

Parameters

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>({
  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; <States, Cases>(state, cases): HandlerReturn<Cases[keyof Cases]>; } = matchMachine

Exhaustive pattern matcher across all state variants of a machine.

The data-first form infers state payloads and the union of branch return values. The curried form remains available for pipe, but requires explicit state and return type arguments.

Call Signature

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

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

Call Signature

<States, Cases>(state, cases): HandlerReturn<Cases[keyof Cases]>

Type Parameters

States

States extends WithKind<string> & object

Cases

Cases extends MachineMatchCases<States>

Parameters

state

States

cases

Cases

Returns

HandlerReturn<Cases[keyof Cases]>

Example

const title = Machine.match(actor.getState(), {
  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.

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),
  Machine.state("cart"),
);

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. State kinds and event kinds must be declared machine members; external data must be validated before it enters a machine (garbage-in-garbage-out — a prototype-named kind through a contract violation is treated as an inherited property, not a member).

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" } }),
);