API Machine

Module

Machine

View source

Schema-first machine definitions.

Since v0.4.0 86 declarations ./Machine

Combinators

declare const plan: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, state: Machine.Snapshot<States>, event: Machine.EventInputOf<InputEvents>) => Effect.Effect<{
  readonly commands: ReadonlyArray<Command>;
  readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>;
  readonly event: Machine.EventOf<InputEvents>;
  readonly microsteps: ReadonlyArray<{
    readonly changed: boolean;
    readonly commands: ReadonlyArray<Command>;
    readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>;
    readonly entryPaths: ReadonlyArray<string>;
    readonly event: Machine.EventOf<Events> | InitialEvent;
    readonly exitPaths: ReadonlyArray<string>;
    readonly next: Machine.Snapshot<States>;
    readonly raisedEvents: ReadonlyArray<Machine.EventOf<Events>>;
    readonly transitions: ReadonlyArray<Machine.RetainedTransition<Machine.StateNodeIdentifier<States>, Machine.TagOf<Events[number]>, Machine.StateNodeIdentifier<States>>>;
  }>;
  readonly next: Machine.Snapshot<States>;
} & {
  readonly done: true;
  readonly output: Output;
} | {
  readonly done: false;
  readonly output: undefined;
}, E | InfiniteTransitionError | MachineSchemaDecodeError, never>

Returns an Effect that plans the next state snapshot without running command effects.

Details

Planning selects child transitions before conflicting ancestors, permits non-conflicting transitions in parallel regions, processes completion and eventless transitions, and drains raised events in FIFO order. Exit paths are deepest-first and entry paths are parent-first.

Gotchas

plan returns data; it does not implement the managed machine commit protocol. start executes child commands, publishes next, and then delivers emittedEvents. Events with no enabled transition are ignored and produce an unchanged plan.

Example typescript

import { Machine } from "@typeonce/effect-machine"
import { Effect, Schema } from "effect"
class Off extends Schema.TaggedClass<Off>("Off")("Off", {}) {
}
class On extends Schema.TaggedClass<On>("On")("On", {}) {
}
class Toggle extends Schema.TaggedClass<Toggle>("Toggle")("Toggle", {}) {
}
const States = Machine.state({ states: { Off, On } })
const machine = Machine.make({
  root: States,
  events: Machine.eventsFromSchemas(Toggle)
}).handle({
  initial: {
    target: "Off"
  },
  states: {
    Off: {
      on: {
        Toggle: { target: "On" }
      }
    },
    On: {}
  }
})
const nextState = Effect.gen(function*() {
  const initial = yield* Machine.planInitial(machine)
  return (yield* Machine.plan(machine, initial.state, new Toggle({}))).next
})

See also

planInitial for planning machine startup.
start for managed execution and lifecycle observation.

Since v0.4.0

declare const waitFor: {
  <State, Error, Output, Narrowed extends RuntimeSnapshot<State, Error, Output>>(predicate: (snapshot: RuntimeSnapshot<State, Error, Output>) => snapshot is Narrowed): <Event, Emitted>(ref: MachineRef<State, Event, Error, Output, Emitted>) => Effect<Narrowed, StoppedError | Error | NoSuchElementError>;
  <State, Error, Output>(predicate: (snapshot: RuntimeSnapshot<State, Error, Output>) => boolean): <Event, Emitted>(ref: MachineRef<State, Event, Error, Output, Emitted>) => Effect<RuntimeSnapshot<State, Error, Output>, StoppedError | Error | NoSuchElementError>;
  <State, Event, Error, Output, Emitted, Narrowed extends RuntimeSnapshot<State, Error, Output>>(ref: MachineRef<State, Event, Error, Output, Emitted>, predicate: (snapshot: RuntimeSnapshot<State, Error, Output>) => snapshot is Narrowed): Effect<Narrowed, StoppedError | Error | NoSuchElementError>;
  <State, Event, Error, Output, Emitted>(ref: MachineRef<State, Event, Error, Output, Emitted>, predicate: (snapshot: RuntimeSnapshot<State, Error, Output>) => boolean): Effect<RuntimeSnapshot<State, Error, Output>, StoppedError | Error | NoSuchElementError>;
}

Waits for the first current or subsequent published snapshot matching a predicate.

Use for external Effect coordination and tests. Prefer atom selectors for UI reads, invocation outcomes for workflow behavior, and ref.join for output. This observes state; it does not acknowledge or correlate a sent event.

The predicate runs before terminal classification, so explicitly matching a done, error, or stopped snapshot succeeds. Otherwise an error preserves its Cause, stopping fails with StoppedError, and completion without a match fails with Cause.NoSuchElementError. Predicate exceptions are defects.

Evaluation subscribes lazily. Interruption releases only the subscription, never the machine. There is no default timeout; compose Effect.timeout. Type predicates narrow the returned snapshot. Intermediate microsteps and historical snapshots are not observed.

Example typescript

const snapshot = yield* Machine.waitFor(ref, isReady).pipe(Effect.timeout("5 seconds"))

Since v0.37.0

declare const watch: <State, Event, Error = never, Output = never>(ref: MachineRef<State, Event, Error, Output>) => Stream.Stream<RuntimeOutcome<State, Error, Output>>

Returns a stream of terminal lifecycle outcomes for a running machine.

Since v0.4.0

Constructors

declare const child: <Id extends string, M extends Machine.Any>(id: Id, machine: M) => ChildMachine<Id, M>

Creates a typed descriptor for a complete child machine.

Descriptors identify a child by id and machine identity, so independently constructed descriptors for the same pair address the same invoked child.

Since v0.4.0

declare const childAddress: <Event = never>(id: string) => ChildAddress<Event>

Creates a typed parent-local address for lower-level child process logic.

The default event protocol is never; provide an event type before using the address with spawn, a state-owned logic invocation, or sendTo.

Since v0.4.0

declare const childFamily: <M extends Machine.Any>(machine: M) => ChildMachine.Family<M>

Binds one machine definition to an open family of runtime child ids.

Descriptors created by the returned function are interchangeable with child descriptors for the same id and machine definition.

Since v0.20.0

declare const emittedEvents: <Cases extends Readonly<Record<string, Schema.Struct.Fields>>>(cases: Cases & ValidateEventFields<NoInfer<Cases>> & ValidateEventProtocolBuilder<"emitted", EventFieldsSchemas<Cases>>) => Machine.EventProtocol<"emitted", EventFieldsSchemas<Cases>>

Defines the ephemeral notifications a machine may publish to external observers. Emitted events are separate from machine input and are never sent implicitly to a parent machine. Observe them through MachineRef.emissions or the AtomMachine emission stream adapters.

Example typescript

const Emitted = Machine.emittedEventsFromSchemas(
  Schema.TaggedUnion({
    Saved: { id: Schema.String }
  })
)
const machine = Machine.make({ emittedEvents: Emitted, ... })

Since v0.10.0

declare const emittedEventsFromSchemas: <Inputs extends readonly Array<EventProtocolInput<"emitted">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"emitted", Inputs, EventProtocolInputSchemasOf<"emitted", Inputs>, DuplicateEventTag<EventProtocolInputSchemasOf<"emitted", Inputs>, never>>) => EventProtocol<"emitted", EventProtocolInputSchemasOf<"emitted", Inputs>>

Imports existing schemas and protocols without rebuilding their contracts.

Since v0.32.0

declare const events: <Cases extends Readonly<Record<string, Schema.Struct.Fields>>>(cases: Cases & ValidateEventFields<NoInfer<Cases>> & ValidateEventProtocolBuilder<"public", EventFieldsSchemas<Cases>>) => Machine.EventProtocol<"public", EventFieldsSchemas<Cases>>

Defines a public event protocol from tagged field records.

Constructors defer schema validation until delivery. Use eventsFromSchemas when importing existing tagged schemas or protocol descriptors.

Example typescript

const Events = Machine.events({ Increment: { by: Schema.Number }, Reset: {} })
const increment = Events.Increment({ by: 1 })

Since v0.32.0

declare const eventsFromSchemas: <Inputs extends readonly Array<EventProtocolInput<"public">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"public", Inputs, EventProtocolInputSchemasOf<"public", Inputs>, DuplicateEventTag<EventProtocolInputSchemasOf<"public", Inputs>, never>>) => EventProtocol<"public", EventProtocolInputSchemasOf<"public", Inputs>>

Imports existing schemas and protocols without rebuilding their contracts.

Since v0.32.0

declare const InitialEvent: InitialEvent

Synthetic event value used while the machine settles its initial state.

Since v0.4.0

declare const internalEvents: <Cases extends Readonly<Record<string, Schema.Struct.Fields>>>(cases: Cases & ValidateEventFields<NoInfer<Cases>> & ValidateEventProtocolBuilder<"internal", EventFieldsSchemas<Cases>>) => Machine.EventProtocol<"internal", EventFieldsSchemas<Cases>>

Defines an internal event protocol and returns deferred constructors for every statically finite configured event tag.

Use these constructors for raised events and other machine-local deliveries. Construction failures are reported through the owning machine's MachineSchemaDecodeError channel.

Example typescript

const Internal = Machine.internalEventsFromSchemas(
  Schema.TaggedUnion({
    Loaded: { value: Schema.String },
    Failed: { message: Schema.String }
  })
)
const machine = Machine.make({ internalEvents: Internal, ... })

// Inside a transition callback:
enqueue.raise(Internal.Loaded({ value }))

Since v0.10.0

declare const internalEventsFromSchemas: <Inputs extends readonly Array<EventProtocolInput<"internal">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"internal", Inputs, EventProtocolInputSchemasOf<"internal", Inputs>, DuplicateEventTag<EventProtocolInputSchemasOf<"internal", Inputs>, never>>) => EventProtocol<"internal", EventProtocolInputSchemasOf<"internal", Inputs>>

Imports existing schemas and protocols without rebuilding their contracts.

Since v0.32.0

declare const logic: <State, Event = never, Output = void, Error = never, Requirements = never, InitialError = never, InitialRequirements = never>(options: {
  readonly initial: State | (scope: Logic.Scope<Event>) => Effect.Effect<State, InitialError, InitialRequirements>;
  readonly run: (context: Logic.Context<State, Event>) => Effect.Effect<Output, Error, Requirements>;
}) => Logic<State, Event, Error, Requirements | InitialRequirements, Output, InitialError>

Creates advanced stateful process logic from explicit initialization and execution methods.

When to use

Use when you need a machine-scoped process to publish intermediate snapshots directly.

Details

Initialization produces the first state before run starts. The running context receives events, reads or updates state, manages child processes, and can communicate with its owning machine. Errors and service requirements from both phases remain in the returned Logic type.

Gotchas

This is the low-level process constructor. Parent messages sent directly through its scope are intentionally unknown because the logic does not know which machine will eventually own it. Prefer typed output, typed child addresses, or invocation lifecycle transitions when possible.

Use an inline invoke with an effect source for one-shot work.

See also

transition for event-driven state.

Since v0.4.0

declare const make: <Root extends StateNodeConfig, InputEvents extends readonly Array<TaggedSchema>, Emits extends readonly Array<TaggedSchema> = readonly [], Input extends Top = Void, InitialE = never, InitialR = never, InternalEvents extends readonly Array<TaggedSchema> = readonly [], ParentDeclaration extends Any | undefined = undefined, Effects extends Readonly<Record<string, Program<Effect<unknown, unknown, unknown>>>> = {}, Streams extends Readonly<Record<string, Program<Stream<unknown, unknown, unknown>>>> = {}, Timers extends Readonly<Record<string, Program<Input>>> = {}, Logics extends Readonly<Record<string, unknown>> = {}, Children extends Readonly<Record<string, Any>> = {}, Branches extends Readonly<Record<string, Readonly<Record<string, BranchDeclaration<NoInfer<Root>, RootSchemas<NoInfer<Root>>>>>>> = {}>(config: {
  readonly branches?: Branches & { [K in string | number | symbol]: ValidateTransitionBranchRecord<NoInfer<Branches[K]>> };
  readonly children?: Children;
  readonly effects?: Effects & ValidatePrograms<Effects>;
  readonly emittedEvents?: EventProtocol<"emitted", Emits>;
  readonly events: EventConstructors<InputEvents, "public"> & {
    readonly [EventProtocolTypeId]: {
      readonly kind: "public";
      readonly schemas: InputEvents;
    };
  } & ValidateInputEventProtocol<NoInfer<InputEvents>, DuplicateEventTag<NoInfer<InputEvents>, never>>;
  readonly id?: string;
  readonly input?: Input;
  readonly internalEvents?: EventConstructors<InternalEvents, "internal"> & {
    readonly [EventProtocolTypeId]: {
      readonly kind: "internal";
      readonly schemas: InternalEvents;
    };
  } & ValidateInternalEventProtocol<NoInfer<InputEvents>, NoInfer<InternalEvents>, DuplicateEventTag<NoInfer<InternalEvents>, never>, Extract<TagOf<NoInfer<InputEvents>[number]>, TagOf<NoInfer<InternalEvents>[number]>>>;
  readonly logic?: Logics & ValidatePrograms<Logics> & ValidateLogicSources<NoInfer<Logics>>;
  readonly parent?: ParentDeclaration;
  readonly root: {
    readonly ~effect/Machine/State: "~effect/Machine/State";
    readonly node: Root;
  } & ReservedRootName<NoInfer<Root>>;
  readonly streams?: Streams & ValidatePrograms<Streams>;
  readonly timers?: Timers & ValidatePrograms<Timers>;
} & UniqueSourceNames<NoInfer<Effects>, NoInfer<Streams>, NoInfer<Timers>, NoInfer<Logics>, NoInfer<Children>>) => MakeResult<Root, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration, Effects, Streams, Timers, Logics, Children, Branches>

Creates a schema-first machine definition.

Details

State and event schemas provide runtime boundary validation while their decoded types drive handler, state, event, target, error, and service inference. State-tree validation is applied whether states comes from states or is passed inline. Call handle on the returned definition to implement state behavior with ordinary TypeScript control flow.

initial is a target-first callback. Its outer selector runs once while the definition is captured; an attached .resolve(...) callback remains lazy until initial planning. Return a bare selected state when its schema supports default construction.

Machine.events defines the public input protocol. Machine.internalEvents adds raised events and other machine-local deliveries. Machine.emittedEvents defines outward ephemeral notifications. The parent configuration accepts Machine.parent(events) for a required owner or Machine.optionalParent(events) for a root-capable machine. All descriptors expose deferred constructors while retaining their schemas opaquely for runtime validation. Public and internal tags must be disjoint.

Typed counter machine typescript

import { Machine } from "@typeonce/effect-machine"
import { Schema } from "effect"
class Count extends Schema.TaggedClass<Count>("Count")("Count", {
  value: Schema.Number
}) {
}
class Increment extends Schema.TaggedClass<Increment>("Increment")("Increment", {
  by: Schema.Number
}) {
}
const States = Machine.state({ states: { Count } })
const Events = Machine.eventsFromSchemas(Increment)
const counter = Machine.make({
  root: States,
  events: Events
}).handle({
  initial: {
    target: "Count",
    decoded: true,
    data: new Count({ value: 0 })
  },
  states: {
    Count: {
      on: {
        Increment: {
          update: "Count",
          decoded: true,
          data: ({ event, state }) => new Count({ value: state.value + event.by })
        }
      }
    }
  }
})

See also

state for typed state-tree helpers.

Since v0.4.0

declare const optionalParent: <Events extends ReadonlyArray<Machine.TaggedSchema>>(events: Machine.EventProtocol<"public", Events>) => Parent<"optional", Events>

Declares public events a machine may send to its owner while preserving the ability to run that machine as a root.

Optional-parent machines expose parent as a possibly absent target.

Since v0.17.0

declare const parent: <Events extends ReadonlyArray<Machine.TaggedSchema>>(events: Machine.EventProtocol<"public", Events>) => Parent<"required", Events>

Requires the machine to run as an owned child whose parent accepts the supplied public event protocol.

Required-parent machines expose a non-optional parent target in behavior contexts and are rejected by root execution APIs.

Since v0.17.0

declare const planInitial: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
  readonly commands: ReadonlyArray<Command>;
  readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>;
  readonly initialEntryPaths: ReadonlyArray<Machine.StateIdentifier<States>>;
  readonly microsteps: ReadonlyArray<{
    readonly changed: boolean;
    readonly commands: ReadonlyArray<Command>;
    readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>;
    readonly entryPaths: ReadonlyArray<string>;
    readonly event: Machine.EventOf<Events> | InitialEvent;
    readonly exitPaths: ReadonlyArray<string>;
    readonly next: Machine.Snapshot<States>;
    readonly raisedEvents: ReadonlyArray<Machine.EventOf<Events>>;
    readonly transitions: ReadonlyArray<Machine.RetainedTransition<Machine.StateNodeIdentifier<States>, Machine.TagOf<Events[number]>, Machine.StateNodeIdentifier<States>>>;
  }>;
  readonly startingState: Machine.Snapshot<States>;
  readonly state: Machine.Snapshot<States>;
} & {
  readonly done: true;
  readonly output: Output;
} | {
  readonly done: false;
  readonly output: undefined;
}, InitialE | E | InfiniteTransitionError | MachineSchemaDecodeError | StartupError, never>

Plans the initial state for a machine without executing machine commands.

Details

The returned plan contains the settled initial snapshot, machine commands, emitted events, optional final output, and every startup microstep. Planning may evaluate transition logic and follow completion, eventless, and raised-event steps. Transition callbacks are evaluated synchronously. startingState and initialEntryPaths describe the normalized configuration before entry callbacks and settlement begin.

Gotchas

start executes the closed command list as part of the managed machine commit protocol. Manual planners may inspect commands but need running machine targets to execute child-addressed operations.

Example typescript

import { Machine } from "@typeonce/effect-machine"
import { Effect, Schema } from "effect"
class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {
}
const States = Machine.state({ states: { Idle } })
const machine = Machine.make({
  root: States,
  events: Machine.eventsFromSchemas()
}).handle({
  initial: {
    target: "Idle"
  },
  states: {
    Idle: {}
  }
})
const initialState = Effect.map(Machine.planInitial(machine), (plan) => plan.state)

See also

plan for planning a received event.
start for the managed runtime protocol.

Since v0.4.0

declare const prepare: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<Prepared<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>>>>

Prepares a fresh machine without initializing it.

Use this constructor when observation must be composed before initial-entry actions run. Subscribe to prepared.emissions, then evaluate prepared.start. Ordinary callers can continue to use start, which starts directly and does not allocate the prepared lifecycle boundary.

Example typescript

const prepared = yield* Machine.prepare(machine)

yield* prepared.emissions.pipe(
  Stream.runForEach(handleEmission),
  Effect.forkScoped({ startImmediately: true })
)

const ref = yield* prepared.start

Since v0.11.0

declare const resume: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>>>

Starts a fresh managed runtime from a decoded logical snapshot.

Details

resume validates and normalizes the supplied snapshot before publishing it as the first state. It does not call the machine's initial function, replay entry or transition actions, re-deliver raised or emitted events, or re-evaluate historical completion and eventless transitions. Active-state invokes start once in ancestor and document order with InitialEvent; timer invocations restart their complete duration and child-machine invocations start from their own initial state.

Only logical state, completion, and history metadata are resumed. Queues, scopes, subscriptions, fibers, spawned children, invoke progress, and prior runtime status are process-local and are not restored. A final snapshot immediately produces a completed ref with its current-machine output.

Decode encoded data explicitly with decodeSnapshot before calling this function. Stable snapshots are hosted as supplied; newly enabled eventless or completion transitions in a changed machine definition are not evaluated merely because the runtime was resumed; only ordinary subsequent transition planning can enter and stabilize states.

Example typescript

import { Machine } from "@typeonce/effect-machine"
import { Effect, Schema } from "effect"
class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {
}
const States = Machine.state({ states: { Idle } })
const machine = Machine.make({
  root: States,
  events: Machine.eventsFromSchemas()
}).handle({
  initial: {
    target: "Idle"
  },
  states: {
    Idle: {}
  }
})
const resumed = Effect.gen(function*() {
  const initial = yield* Machine.planInitial(machine)
  const encoded = yield* Machine.encodeSnapshot(machine, initial.state)
  const snapshot = yield* Machine.decodeSnapshot(machine, encoded)
  return yield* Machine.resume(machine, snapshot)
})

See also

decodeSnapshot for the schema and transport boundary.
start for ordinary initial startup.

Since v0.4.0

declare const start: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>>>

Starts a machine.

When to use

Use when you want asynchronous event delivery, lifecycle snapshots, join, and machine-owned spawned or invoked children.

Details

For each accepted event the runtime plans the complete synchronous macrostep, executes closed machine commands, stops invokes for exited states, publishes the new state, delivers emitted events, and then starts invokes for entered states.

Gotchas

The returned handle's send operation only enqueues events. Transition failures are reported through the runtime snapshot, changes, and join rather than being returned by send. Sending after the machine reaches any terminal state fails immediately with StoppedError.

Example typescript

import { Machine } from "@typeonce/effect-machine"
import { Effect, Schema } from "effect"
class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {
}
const States = Machine.state({ states: { Idle } })
const machine = Machine.make({
  root: States,
  events: Machine.eventsFromSchemas()
}).handle({
  initial: {
    target: "Idle"
  },
  states: {
    Idle: {}
  }
})
const state = Effect.gen(function*() {
  const ref = yield* Machine.start(machine)
  return yield* ref.state
})

See also

plan for inspecting the same transition plan without executing it.
watch for classified terminal outcomes.

Since v0.4.0

declare const state: StateConstructor

Defines root or nested state schemas while preserving the exact child topology.

Pass the root descriptor to make. Nested states can be declared inline or reused by mounting a descriptor in multiple places. Initial edges and value constructors belong in the handler tree.

Repeated compound state typescript

import { Machine } from "@typeonce/effect-machine"
import { Schema } from "effect"

const TradingState = Schema.TaggedUnion({
  InSession: {},
  Applying: {}
})
const TradingSlot = Machine.state({
  states: {
    Idle: {},
    InSession: TradingState.cases.InSession,
    Applying: TradingState.cases.Applying
  }
})

const States = Machine.state({
  states: {
    slot1: TradingSlot,
    slot2: TradingSlot
  }
})

Since v0.15.0

Decoding

declare const decodeSnapshot: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>

Decodes a normalized data representation into a validated machine snapshot.

When to use

Use when you need to resume planning from a snapshot loaded from storage or received over a transport boundary.

Details

Decoding resolves every path against the supplied machine, decodes values with their state and output schemas, validates compound and parallel state relationships, and rebuilds the recursive in-memory snapshot.

Gotchas

Decoding restores logical statechart data only. It does not restart invoked processes, recreate spawned children, or restore a previous MachineRef.

Example typescript

import { Machine } from "@typeonce/effect-machine"
import { Effect, Schema } from "effect"
class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {
}
const States = Machine.state({ states: { Idle } })
const machine = Machine.make({
  root: States,
  events: Machine.eventsFromSchemas()
}).handle({
  initial: {
    target: "Idle"
  },
  states: {
    Idle: {}
  }
})
const roundTrip = Effect.gen(function*() {
  const initial = yield* Machine.planInitial(machine)
  const encoded = yield* Machine.encodeSnapshot(machine, initial.state)
  return yield* Machine.decodeSnapshot(machine, encoded)
})

See also

encodeSnapshot for creating the normalized representation.

Since v0.4.0

Encoding

declare const encodeSnapshot: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, snapshot: Machine.Snapshot<States>) => Effect.Effect<Machine.EncodedSnapshot, MachineSchemaEncodeError, Machine.SnapshotEncodingServices<States>>

Encodes a decoded machine snapshot into a normalized data representation.

When to use

Use when you need to store or transport a statechart snapshot independently of its local machine runtime.

Details

Each active state value and completed output is encoded with the canonical JSON codec derived from the schema declared for its state path. Success guarantees that every state, output, and history value is Schema.Json. Non-JSON values, including cyclic process-local capabilities, fail with MachineSchemaEncodeError at their declared boundary.

Gotchas

The encoded snapshot does not contain the machine definition, machine version, running children, invoked process state, services, or subscriptions. Store machine identity and migration metadata alongside the result when the snapshot crosses deployment versions. Opaque declarations without a JSON codec can encode only when their current value is already JSON-compatible. Define an explicit JSON codec or keep process-local capabilities outside the logical snapshot.

Example typescript

import { Machine } from "@typeonce/effect-machine"
import { Effect, Schema } from "effect"
class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {
}
const States = Machine.state({ states: { Idle } })
const machine = Machine.make({
  root: States,
  events: Machine.eventsFromSchemas()
}).handle({
  initial: {
    target: "Idle"
  },
  states: {
    Idle: {}
  }
})
const encoded = Effect.gen(function*() {
  const initial = yield* Machine.planInitial(machine)
  return yield* Machine.encodeSnapshot(machine, initial.state)
})

See also

decodeSnapshot for restoring an encoded snapshot.

Since v0.4.0

Errors

declare class ChildAlreadyExistsError extends YieldableError<this> & {
  readonly _tag: "ChildAlreadyExistsError";
} & Readonly<{
  readonly id: string;
}> {
  constructor(args: {
    readonly id: string;
  });
  readonly _tag: "ChildAlreadyExistsError";
  readonly ~effect/Effect: Variance<never, ChildAlreadyExistsError, never>;
  readonly ~effect/ErrorReporter/attributes?: ReadonlyRecord<string, unknown>;
  readonly ~effect/ErrorReporter/ignore?: boolean;
  readonly ~effect/ErrorReporter/severity?: Severity;
  cause?: unknown;
  readonly id: string;
  message: string;
  name: string;
  stack?: string;
  [iterator](): EffectIterator<Effect<never, ChildAlreadyExistsError, never>>;
  [NodeInspectSymbol](): unknown;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  toJSON(): unknown;
  toString(): string;
}

Error returned by spawn when a child process with the same id already exists for the current machine.

Since v0.4.0

declare class InfiniteTransitionError extends YieldableError<this> & {
  readonly _tag: "InfiniteTransitionError";
} & Readonly<{
  readonly machineId: string | undefined;
  readonly maxIterations: number;
  readonly state: string;
}> {
  constructor(args: {
    readonly machineId: string | undefined;
    readonly maxIterations: number;
    readonly state: string;
  });
  readonly _tag: "InfiniteTransitionError";
  readonly ~effect/Effect: Variance<never, InfiniteTransitionError, never>;
  readonly ~effect/ErrorReporter/attributes?: ReadonlyRecord<string, unknown>;
  readonly ~effect/ErrorReporter/ignore?: boolean;
  readonly ~effect/ErrorReporter/severity?: Severity;
  cause?: unknown;
  readonly machineId: string | undefined;
  readonly maxIterations: number;
  message: string;
  name: string;
  stack?: string;
  readonly state: string;
  [iterator](): EffectIterator<Effect<never, InfiniteTransitionError, never>>;
  [NodeInspectSymbol](): unknown;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  toJSON(): unknown;
  toString(): string;
}

Error returned when a machine does not stabilize within the maximum number of macrostep iterations.

Since v0.4.0

declare class MachineSchemaDecodeError extends YieldableError<this> & {
  readonly _tag: "MachineSchemaDecodeError";
} & Readonly<{
  readonly boundary: "input" | "history" | "event" | "state" | "output" | "emission" | "configuration";
  readonly cause: Cause<unknown> | SchemaError;
  readonly event?: string;
  readonly machineId: string | undefined;
  readonly state?: string;
}> {
  constructor(args: {
    readonly boundary: "input" | "history" | "event" | "state" | "output" | "emission" | "configuration";
    readonly cause: Cause<unknown> | SchemaError;
    readonly event?: string;
    readonly machineId: string | undefined;
    readonly state?: string;
  });
  readonly _tag: "MachineSchemaDecodeError";
  readonly ~effect/Effect: Variance<never, MachineSchemaDecodeError, never>;
  readonly ~effect/ErrorReporter/attributes?: ReadonlyRecord<string, unknown>;
  readonly ~effect/ErrorReporter/ignore?: boolean;
  readonly ~effect/ErrorReporter/severity?: Severity;
  readonly boundary: "input" | "history" | "event" | "state" | "output" | "emission" | "configuration";
  cause: Cause<unknown> | SchemaError;
  readonly event?: string;
  readonly machineId: string | undefined;
  message: string;
  name: string;
  stack?: string;
  readonly state?: string;
  [iterator](): EffectIterator<Effect<never, MachineSchemaDecodeError, never>>;
  [NodeInspectSymbol](): unknown;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  toJSON(): unknown;
  toString(): string;
}

Error returned when a machine contract value does not match the schema or structural configuration declared for a machine boundary.

Since v0.4.0

declare class MachineSchemaEncodeError extends YieldableError<this> & {
  readonly _tag: "MachineSchemaEncodeError";
} & Readonly<{
  readonly boundary: "history" | "state" | "output" | "configuration";
  readonly cause: Cause<unknown> | SchemaError;
  readonly machineId: string | undefined;
  readonly state?: string;
}> {
  constructor(args: {
    readonly boundary: "history" | "state" | "output" | "configuration";
    readonly cause: Cause<unknown> | SchemaError;
    readonly machineId: string | undefined;
    readonly state?: string;
  });
  readonly _tag: "MachineSchemaEncodeError";
  readonly ~effect/Effect: Variance<never, MachineSchemaEncodeError, never>;
  readonly ~effect/ErrorReporter/attributes?: ReadonlyRecord<string, unknown>;
  readonly ~effect/ErrorReporter/ignore?: boolean;
  readonly ~effect/ErrorReporter/severity?: Severity;
  readonly boundary: "history" | "state" | "output" | "configuration";
  cause: Cause<unknown> | SchemaError;
  readonly machineId: string | undefined;
  message: string;
  name: string;
  stack?: string;
  readonly state?: string;
  [iterator](): EffectIterator<Effect<never, MachineSchemaEncodeError, never>>;
  [NodeInspectSymbol](): unknown;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  toJSON(): unknown;
  toString(): string;
}

Error returned when a decoded machine snapshot cannot be encoded through its declared state or output schemas.

Since v0.4.0

declare class ProcessLocalError extends YieldableError<this> & {
  readonly _tag: "ProcessLocalError";
} & Readonly<{
  readonly operation: string;
}> {
  constructor(args: {
    readonly operation: string;
  });
  readonly _tag: "ProcessLocalError";
  readonly ~effect/Effect: Variance<never, ProcessLocalError, never>;
  readonly ~effect/ErrorReporter/attributes?: ReadonlyRecord<string, unknown>;
  readonly ~effect/ErrorReporter/ignore?: boolean;
  readonly ~effect/ErrorReporter/severity?: Severity;
  cause?: unknown;
  message: string;
  name: string;
  readonly operation: string;
  stack?: string;
  [iterator](): EffectIterator<Effect<never, ProcessLocalError, never>>;
  [NodeInspectSymbol](): unknown;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  toJSON(): unknown;
  toString(): string;
}

Error returned when standalone action execution attempts an operation that requires a managed machine process.

Since v0.4.0

declare class StartupError extends YieldableError<this> & {
  readonly _tag: "StartupError";
} & Readonly<{
  readonly cause: Cause<unknown>;
}> {
  constructor(args: {
    readonly cause: Cause<unknown>;
  });
  readonly _tag: "StartupError";
  readonly ~effect/Effect: Variance<never, StartupError, never>;
  readonly ~effect/ErrorReporter/attributes?: ReadonlyRecord<string, unknown>;
  readonly ~effect/ErrorReporter/ignore?: boolean;
  readonly ~effect/ErrorReporter/severity?: Severity;
  cause: Cause<unknown>;
  message: string;
  name: string;
  stack?: string;
  [iterator](): EffectIterator<Effect<never, StartupError, never>>;
  [NodeInspectSymbol](): unknown;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  toJSON(): unknown;
  toString(): string;
}

Error returned when a machine fails while running startup lifecycle logic after the initial state has been computed.

Since v0.4.0

declare class StoppedError extends YieldableError<this> & {
  readonly _tag: "StoppedError";
} & Readonly<{}> {
  constructor(args: void);
  readonly _tag: "StoppedError";
  readonly ~effect/Effect: Variance<never, StoppedError, never>;
  readonly ~effect/ErrorReporter/attributes?: ReadonlyRecord<string, unknown>;
  readonly ~effect/ErrorReporter/ignore?: boolean;
  readonly ~effect/ErrorReporter/severity?: Severity;
  cause?: unknown;
  message: string;
  name: string;
  stack?: string;
  [iterator](): EffectIterator<Effect<never, StoppedError, never>>;
  [NodeInspectSymbol](): unknown;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  toJSON(): unknown;
  toString(): string;
}

Error returned by join when a running machine is stopped before producing an output.

Since v0.4.0

Getters

declare const activityDefinitions: <M extends Machine.Any>(machine: M) => ReadonlyArray<Machine.ActivityDefinition<Machine.StateIdentifier<Machine.States<M>>>>

Returns serializable descriptions of every state-owned activity.

Details

Static inline invocation definitions expose stable ownership and lifecycle metadata without serializing runtime values. Function-valued sources are represented as dynamic and are never evaluated during inspection.

Since v0.4.0

declare const can: {
  <States extends Readonly<Record<string, TaggedSchema | StateNodeConfig>>, Events extends readonly Array<TaggedSchema>, Emits extends readonly Array<TaggedSchema>, Input extends Top = Void, UnhandledStates extends string = StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends string = never, Output = never, OutputStates extends string = never, InputEvents extends readonly Array<TaggedSchema> = Events, ParentEvents extends readonly Array<TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureOutputImplementations<States, OutputStates> & EnsureHistoryImplementations<States, UnhandledStates> & EnsureInitialImplementations<States, UnhandledStates> & RootCompatible<ParentEvents>): (state: Snapshot<States>, event: EventInputOf<Events>) => Effect<boolean, MachineSchemaDecodeError>;
  <States extends Readonly<Record<string, TaggedSchema | StateNodeConfig>>, Events extends readonly Array<TaggedSchema>, Emits extends readonly Array<TaggedSchema>, Input extends Top = Void, UnhandledStates extends string = StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends string = never, Output = never, OutputStates extends string = never, InputEvents extends readonly Array<TaggedSchema> = Events, ParentEvents extends readonly Array<TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureOutputImplementations<States, OutputStates> & EnsureHistoryImplementations<States, UnhandledStates> & EnsureInitialImplementations<States, UnhandledStates> & RootCompatible<ParentEvents>, state: Snapshot<States>, event: EventInputOf<Events>): Effect<boolean, MachineSchemaDecodeError>;
}

Tests whether a concrete event would select at least one transition from a decoded snapshot.

Details

Required handlers are accepted from their structural eligibility. Declinable handlers run their resolver only far enough to decide whether they accept the event. Any commands, emissions, or raised events collected during that check are discarded.

Event input is decoded through the machine's public and internal event protocols. Invalid input fails with MachineSchemaDecodeError. Final snapshots and valid events with no accepting handler return false.

Gotchas

This query does not execute transitions or stabilize the resulting machine. It does not run entry, exit, always, completion, child lifecycle, or command effects. A true result therefore describes event acceptance only, for this snapshot. It does not guarantee acceptance after the machine advances.

This Effect can also be used by machine effects to query internal events. Synchronous transition resolvers cannot execute it. Querying an internal event does not make that event available to MachineRef.send.

Example typescript

import { Machine } from "@typeonce/effect-machine"
import { Effect, Schema } from "effect"

const internalEvents = Machine.internalEventsFromSchemas(Schema.TaggedStruct("Loaded", {}))
const Root = Machine.state({ states: { Idle: {} } })
const machine = Machine.make({
  root: Root,
  events: Machine.eventsFromSchemas(),
  internalEvents
}).handle({
  initial: { target: "Idle" },
  states: { Idle: { on: { Loaded: { none: true } } } }
})

export const canLoad = Effect.gen(function*() {
  const initial = yield* Machine.planInitial(machine)
  return yield* Machine.can(machine, initial.state, internalEvents.Loaded())
})

Since v0.30.0

declare const configuration: <M extends Machine.Any>(machine: M, state: Machine.Snapshot<Machine.States<M>>) => ReadonlyArray<Machine.ActiveStateNode<Machine.StateIdentifier<Machine.States<M>>, Machine.ChoiceIdentifier<Machine.States<M>>>>

Returns every state node active in a decoded snapshot, in definition order.

Details

Active compound ancestors and parallel regions are included together with their active descendants. History and choice pseudo-states are never active and are not returned.

Since v0.4.0

declare const enabled: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, state: Machine.Snapshot<States>) => ReadonlyArray<Machine.TagOf<Events[number]>>

Returns event tags with at least one structurally eligible handler in the current state snapshot.

A declinable handler may still reject a concrete event at planning time, so this is a static candidate query rather than a guarantee that every value with the returned tag will be handled.

Since v0.4.0

declare const initialDefinition: <M extends Machine.Any>(machine: M) => Machine.InitialDefinition<Machine.RootStateIdentifier<Machine.StateIdentifier<Machine.States<M>>>>

Returns the statically selected root entry used during machine startup.

This function does not execute the initial resolver or require machine input. kind: "initial" means that the selected root enters its declared initial configuration.

Since v0.14.0

declare const inputEventSchemas: <M extends Machine.Any>(machine: M) => Machine.InputEvents<M>

Returns the schemas accepted by the machine's public event protocol.

Details

The returned tuple retains the schemas supplied to events, including grouped tagged unions. Internal and emitted event schemas are excluded. This getter is intended for tooling that needs to describe or construct valid external inputs without reaching into the opaque event protocol.

Since v0.24.0

declare const stateNodes: <M extends Machine.Any>(machine: M) => ReadonlyArray<Machine.StateNode<Machine.StateIdentifier<Machine.States<M>>, Machine.HistoryIdentifier<Machine.States<M>>, Machine.ChoiceIdentifier<Machine.States<M>>>>

Returns every compiled state node in definition order.

Details

The result includes atomic, compound, parallel, final, history, and choice nodes together with their resolved descriptive annotations. Use each node's parent property to reconstruct the complete hierarchy. Pseudo-states are intentionally omitted from children because they can never appear in an active configuration.

Since v0.4.0

declare const transitionDefinitions: <M extends Machine.Any>(machine: M) => ReadonlyArray<Machine.TransitionDefinition<Machine.StateNodeIdentifier<Machine.States<M>>, Machine.TagOf<Machine.Events<M>[number]>, Machine.StateNodeIdentifier<Machine.States<M>>>>

Returns every registered transition handler in state definition order.

Details

Event handlers retain their handler-key order within each source state and are followed by eventless and completion handlers. This function does not execute resolvers. Every branch exposes its static selection. State updates retain the updated owner in selection.path while leaving target undefined because they do not change topology. acceptance reports whether the resolver may decline the transition.

Since v0.4.0

Guards

declare const isFinal: <States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents>, state: Machine.Snapshot<States>) => state is Machine.SnapshotContainingFinal<States, FinalStates>

Returns true if a state snapshot is final for a machine.

Since v0.4.0

declare function isInitialEvent(u: unknown): u is InitialEvent

Returns true if a value is the synthetic machine initial event.

Since v0.4.0

declare const isMachine: (u: unknown) => u is Machine.Any

Returns true if a value is a Machine.

Since v0.4.0

Models

Namespace containing type-level members associated with ChildAddress.

Since v0.4.0

type ChildAddress<Event> = string & ChildAddress.Variance<Event>

Parent-local address for a child process that can receive events.

Since v0.4.0

interface ChildMachine<Id extends string, M extends Machine.Any> {
  readonly ~effect/Machine/ChildMachine: "~effect/Machine/ChildMachine";
  readonly id: Id;
  readonly machine: M;
}

Typed descriptor for a complete machine invoked as a child.

Details

The descriptor carries the child's address and complete machine type. Pass a descriptor for the same id and machine to inline invoke, sendTo, and child lookup APIs so state, event, error, and output types are inferred without separate annotations.

Since v0.4.0

Namespace containing type-level members associated with ChildMachine.

Since v0.4.0

interface ChildOwner<OwnerEvent> {
  readonly sendTo: <Child extends Any>(child: Child, event: Event<Child>) => Effect<void, StoppedError>;
  readonly spawn: <Child extends Any>(child: Child & Executable<Child> & ParentCompatibility<Child, OwnerEvent>, ...options: SpawnArgs<Child>) => Effect<Ref<Child>, ChildAlreadyExistsError | StartError<Child>, StartRequirements<Child>>;
  readonly stop: <Child extends Any>(child: Child) => Effect<void>;
}

Effectful operations for child machines owned directly by the current machine process.

Since v0.20.0

type Command = {
  readonly _tag: "SendTo";
  readonly event: unknown;
  readonly target: MachineTarget<unknown> | ChildMachine.Any | ChildAddress<never>;
} | {
  readonly _tag: "Stop";
  readonly child: ChildMachine.Any | ChildAddress<never>;
}

A closed machine command recorded by a synchronous transition.

Since v0.4.0

interface Definition<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], Registrations extends Machine.Registrations = {}> extends Omit<Machine<States, Events, Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, FinalStates, Output, Emits, never, InputEvents, ParentEvents>, TypeId | "stateNodes" | "handlers" | "initial" | "initialDefinition"> {
  readonly emittedEvents: EventProtocol<"emitted", Emits>;
  readonly events: EventProtocol<"public", InputEvents>;
  readonly handle: Handler<States, Events, Emits, Input, InitialE, InitialR, FinalStates, Output, InputEvents, ParentEvents, Registrations>;
  readonly id: string | undefined;
  readonly input: Input | undefined;
  readonly internalEvents: EventProtocol<"internal", InternalEventSchemas<Events, InputEvents>>;
  readonly parent: ParentDeclarationOf<ParentEvents>;
  readonly root: State<Extract<Omit<States[""], "~effect/Machine/ExplicitInitial">, StateNodeConfig>>;
  readonly states: States;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
}

A schema-first machine definition that can produce independent implementations.

Details

Call handle once for each implementation. The returned Machine does not expose handle, so handler configuration cannot be accumulated or replaced through chained calls. Calling handle multiple times on the same definition remains supported and creates independent machines.

Example typescript

const counter = definition.handle({ states: {
  Count: {
    on: {
      Increment: {
        update: "Count",
        decoded: ({ event, state }) => new Count({ value: state.value + event.by })
      }
    }
  }
} })

Since v0.15.0

Namespace containing type-level members associated with Definition.

Since v0.15.0

interface Enqueue<in Events, in Emits> {
  readonly emit: (event: EmittedEventInput<Emits>) => void;
  readonly raise: (event: EventInput<Events>) => void;
  readonly sendTo: {
    <Event>(target: MachineTarget<Event>, event: Event): void;
    <Child extends Any>(child: Child, event: Event<Child>): void;
    <Address extends ChildAddress<never>>(child: Address, event: Event<Address>): void;
  };
  readonly stop: {
    <Child extends Any>(child: Child): void;
    <Event>(child: ChildAddress<Event>): void;
  };
}

Synchronous commands available while a machine transition is being selected.

Enqueuing records statechart and machine operations for the selected transition. It never executes an Effect while the transition is evaluated.

Since v0.4.0

interface InitialEvent {
  readonly _tag: typeof InitialEventTypeId;
}

Synthetic event passed to entry, exit, always, invoke, and output callbacks that run while the machine is settling its initial state.

Since v0.4.0

Live, root-scoped records describing one prepared machine tree.

Inspection records deliberately erase machine-specific values to unknown: one stream may contain unrelated root, child-machine, and Logic protocols. The record structure remains a closed discriminated union, while typed application observation continues through changes and emissions. Records retain decoded local events and snapshots and are not themselves a stable JSON export format. Telemetry exporters must project process-local values into an explicit portable representation.

Since v0.13.0

interface Logic<State, Event, out Error = never, out Requirements = never, out Output = never, out InitialError = never> {
  initial(scope: Scope<Event>): Effect<State, InitialError, Requirements>;
  run(context: Context<State, Event>): Effect<Output, Error, Requirements>;
}

Machine-specific process logic used by spawn and state-owned invocations.

Since v0.4.0

Public types used by advanced machine process logic.

Since v0.4.0

interface Machine<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []> extends Pipeable {
  readonly ~effect/Machine: "~effect/Machine";
  readonly emittedEvents: EventProtocol<"emitted", Emits>;
  readonly events: EventProtocol<"public", InputEvents>;
  readonly id: string | undefined;
  readonly input: Input | undefined;
  readonly internalEvents: EventProtocol<"internal", InternalEventSchemas<Events, InputEvents>>;
  readonly parent: ParentDeclarationOf<ParentEvents>;
  readonly root: State<Extract<Omit<States[""], "~effect/Machine/ExplicitInitial">, StateNodeConfig>>;
  readonly states: States;
  pipe<A>(this: A): A;
  pipe<A, B = never>(this: A, ab: (_: A) => B): B;
  pipe<A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C;
  pipe<A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D;
  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E): E;
  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F): F;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G): G;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H): H;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I): I;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J): J;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K): K;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L): L;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M): M;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N): N;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O): O;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P): P;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q): Q;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R): R;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S): S;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T): T;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D, de: (_: D) => E, ef: (_: E) => F, fg: (_: F) => G, gh: (_: G) => H, hi: (_: H) => I, ij: (_: I) => J, jk: (_: J) => K, kl: (_: K) => L, lm: (_: L) => M, mn: (_: M) => N, no: (_: N) => O, op: (_: O) => P, pq: (_: P) => Q, qr: (_: Q) => R, rs: (_: R) => S, st: (_: S) => T, tu: (_: T) => U): U;
}

A schema-first machine implementation.

Details

Machines support atomic, compound, parallel, and final states together with completion transitions, eventless transitions, raised events, actions, spawned children, and state-scoped invokes. Schemas validate machine boundaries while preserving decoded state, event, output, error, and service types throughout planning and execution.

Gotchas

Use guard to decline a transition before constructing its next state. Use declinable: true when a named branch resolver may return decline(). Register cancellable state-scoped delays in make({ timers }).

Example typescript

import { Machine } from "@typeonce/effect-machine"
import { Schema } from "effect"
const events = Machine.events({ Add: { by: Schema.Number } })
const Root = Machine.state({ fields: { count: Schema.Number } })
export const counter = Machine.make({
  root: Root,
  events
}).handle({
  root: () => ({ count: 0 }),
  on: {
    Add: {
      update: "root",
      guard: ({ event }) => event.by > 0,
      data: ({ root, event }) => ({ count: root.count + event.by })
    }
  }
})

Since v0.4.0

Namespace containing type-level members associated with Machine.

Since v0.4.0

interface MachineRef<out State, in Event, out Error = never, out Output = never, out Emitted = never> extends MachineTarget<Event> {
  readonly changes: Stream<RuntimeSnapshot<State, Error, Output>>;
  readonly child: <Child extends Any>(child: Child) => Effect<Option<Ref<Child>>>;
  readonly childChanges: <Child extends Any>(child: Child) => Stream<Option<Ref<Child>>>;
  readonly emissions: Stream<Emitted>;
  readonly id: string;
  readonly join: Effect<Output, StoppedError | Error>;
  readonly send: (event: Event) => Effect<void, StoppedError>;
  readonly sessionId: string;
  readonly snapshot: Effect<RuntimeSnapshot<State, Error, Output>>;
  readonly state: Effect<State>;
  readonly stop: Effect<void>;
}

Provides access to a running machine's state, lifecycle, event input, and termination operations.

Gotchas

send reports whether an event was accepted for delivery. Errors that occur while asynchronously processing an accepted event are observed through snapshot, changes, or join. Sending after termination fails with StoppedError.

Since v0.4.0

type MachineReferences<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> = {
  readonly self: MachineTarget<Machine.EventInputOf<InputEvents>>;
} & Machine.ParentModeOf<ParentEvents> extends "required" ? {
  readonly parent: MachineTarget<Machine.EventInputOf<ParentEvents>>;
} : Machine.ParentModeOf<ParentEvents> extends "optional" ? {
  readonly parent: MachineTarget<Machine.EventInputOf<ParentEvents>> | undefined;
} : {}

Machine targets available while evaluating machine behavior.

Since v0.12.0

interface MachineTarget<in Event> {
  readonly id: string;
  readonly send: (event: Event) => Effect<void, StoppedError>;
  readonly sessionId: string;
}

Minimal typed target accepted by inter-machine send commands.

Since v0.12.0

interface Parent<Mode extends ParentMode, Events extends ReadonlyArray<Machine.TaggedSchema>> {
  readonly ~effect/Machine/Parent: "~effect/Machine/Parent";
  readonly events: EventProtocol<"public", Events>;
  readonly mode: Mode;
}

Owning-machine protocol declared by parent or optionalParent.

Since v0.17.0

Namespace containing type-level members associated with Parent.

Since v0.17.0

type ParentMode = "required" | "optional"

Availability declared for an owning-machine target.

Since v0.17.0

interface Prepared<out State, in Event, out Error, out Output, out Emitted, out StartError, StartRequirements> {
  readonly changes: Stream<RuntimeSnapshot<State, Error, Output>, StartError>;
  readonly emissions: Stream<Emitted>;
  readonly id: string;
  readonly inspection: Stream<Event>;
  readonly sessionId: string;
  readonly start: Effect<MachineRef<State, Event, Error, Output, Emitted>, StartError, StartRequirements>;
}

A fresh machine whose observable streams exist before initialization.

Subscribe to emissions before evaluating start when initial-entry emissions must be observed. start is one-shot: concurrent and repeated evaluations share the same initialization and running reference.

Since v0.11.0

interface Runtime<in Events, in Emits> {
  readonly emit: (event: EmittedEventInput<Emits>) => Effect<void, MachineSchemaDecodeError | StoppedError>;
  readonly raise: (event: EventInput<Events>) => Effect<void, MachineSchemaDecodeError | StoppedError>;
}

Managed runtime capability used to deliver raised events and publish emitted notifications.

Since v0.4.0

Namespace containing type-level members associated with Runtime.

Since v0.4.0

type RuntimeOutcome<State, Error = never, Output = never> = {
  readonly _tag: "Done";
  readonly output: Output;
  readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
    readonly status: "done";
  }>;
} | {
  readonly _tag: "Failure";
  readonly cause: Cause.Cause<Error>;
  readonly error: Error;
  readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
    readonly status: "error";
  }>;
} | {
  readonly _tag: "Defect";
  readonly cause: Cause.Cause<Error>;
  readonly defect: unknown;
  readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
    readonly status: "error";
  }>;
} | {
  readonly _tag: "Interrupted";
  readonly cause: Cause.Cause<Error>;
  readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
    readonly status: "error";
  }>;
} | {
  readonly _tag: "Cause";
  readonly cause: Cause.Cause<Error>;
  readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
    readonly status: "error";
  }>;
} | {
  readonly _tag: "Stopped";
  readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, {
    readonly status: "stopped";
  }>;
}

Represents a classified terminal outcome derived from a runtime snapshot.

Since v0.4.0

type RuntimeSnapshot<State, Error = never, Output = never> = {
  readonly state: State;
  readonly status: "active";
} | {
  readonly output: Output;
  readonly state: State;
  readonly status: "done";
} | {
  readonly cause: Cause.Cause<Error>;
  readonly state: State;
  readonly status: "error";
} | {
  readonly state: State;
  readonly status: "stopped";
}

Represents the active or terminal lifecycle state of a running machine.

Details

Failures retain the last successfully published machine state and expose the complete Cause. Stopped machines are distinct from machines that complete with output or fail while processing an event.

Since v0.4.0

interface SpawnIdOptions extends SpawnOptions {
  readonly id: string;
}

Options for spawning child processes with a parent-local id.

Since v0.4.0

interface SpawnOptions {
  readonly id?: string;
}

Options for spawning child processes.

Since v0.4.0

interface State<Node extends Machine.StateNodeConfig> extends StateAccessors<{
  readonly : Node;
}> {
  readonly ~effect/Machine/State: "~effect/Machine/State";
  readonly get: {
    <Path extends "">(snapshot: Snapshot<{
      readonly : Node;
    }>, path: Path): Option<StateByIdentifier<{
      readonly : Node;
    }, Path>>;
    <From extends "", Path extends "">(snapshot: SnapshotByIdentifier<{
      readonly : Node;
    }, From>, path: Path & Path extends NoInfer<From> | NoInfer<From> extends "" ? string : `${NoInfer<From>}.${string}` ? unknown : never): Option<StateByIdentifier<{
      readonly : Node;
    }, Path>>;
  };
  readonly getSnapshot: {
    <Path extends "">(snapshot: Snapshot<{
      readonly : Node;
    }>, path: Path): Option<SnapshotByIdentifier<{
      readonly : Node;
    }, Path>>;
    <From extends "", Path extends "">(snapshot: SnapshotByIdentifier<{
      readonly : Node;
    }, From>, path: Path & Path extends NoInfer<From> | NoInfer<From> extends "" ? string : `${NoInfer<From>}.${string}` ? unknown : never): Option<SnapshotByIdentifier<{
      readonly : Node;
    }, Path>>;
  };
  readonly getWithParents: <Path extends "">(snapshot: Snapshot<{
    readonly : Node;
  }>, path: Path) => Option<StateWithParents<{
    readonly : Node;
  }, Path>>;
  readonly matches: {
    <Path extends "">(snapshot: Snapshot<{
      readonly : Node;
    }>, path: Path): boolean;
    <From extends "", Path extends "">(snapshot: SnapshotByIdentifier<{
      readonly : Node;
    }, From>, path: Path & Path extends NoInfer<From> | NoInfer<From> extends "" ? string : `${NoInfer<From>}.${string}` ? unknown : never): boolean;
  };
  readonly node: Node;
  readonly path: <Path extends "">(path: Path) => Path;
}

An immutable state descriptor, usable as a root or a nested state.

Since v0.32.0

Runtime

declare const sendTo: {
  <Child extends Any>(child: Child, event: Event<Child>): Effect<void, StoppedError, MachineRuntime>;
  <Address extends ChildAddress<never>>(id: Address, event: Event<Address>): Effect<void, StoppedError, MachineRuntime>;
}

Sends an event to a named child process of the running machine.

Since v0.4.0

declare const spawn: {
  <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(logic: Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>): SpawnResult<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, never, ChildInitialError>;
  <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, Options extends SpawnOptions, ChildInitialError = never>(logic: Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, options: Options & OptionsCompatibility<Options, ChildEvent>): SpawnResult<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, SpawnIdError<Options>, ChildInitialError>;
}

Spawns a child process owned by the currently running machine.

When to use

Use from lower-level process logic to create children that should be addressed or stopped by the owning process instead of tied to a single state's invoke lifecycle.

Gotchas

This Effect requires a managed process runtime. A named child id must be unique for the current parent until that child stops.

Register logic in make({ logic }) and use invoke: { src, id, address, ...outcomes } for children that start and stop with that state.

See also

sendTo for sending events to named children.

Since v0.4.0

declare const stopChild: {
  <Event>(child: ChildAddress<Event>): Effect<void, never, MachineRuntime>;
  <Child extends Any>(child: Child): Effect<void, never, MachineRuntime>;
}

Stops a named child process of the running machine.

Since v0.4.0

Services

interface ActionRequirement<Error, Requirements> {
  readonly ~effect/Machine/ActionRequirement: {
    readonly error: Covariant<Error>;
    readonly requirements: Covariant<Requirements>;
  };
}

Opaque marker used to keep staged action errors and services separate from the Effect that plans a machine step.

Since v0.4.0

Type IDs

type TypeId = "~effect/Machine"

String literal type used as the runtime type identifier for Machine values.

Since v0.4.0

declare const TypeId: "~effect/Machine"

Runtime type identifier attached to Machine values.

Since v0.4.0

Utility Types

type ActionError<Requirements> = Requirements extends ActionRequirement<infer Error, any> ? Error : never

Extracts the typed error channel of staged machine actions.

Since v0.4.0

type ActionServices<Requirements> = Requirements extends ActionRequirement<any, infer Services> ? Services : never

Extracts the service requirements of staged machine actions.

Since v0.4.0

type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventOf<Machine.EventProtocolSchemas<Protocol>>

Extracts the decoded event union carried by an event protocol descriptor.

Since v0.10.0

type ExecutionServices<Requirements> = Exclude<PlanningServices<Requirements>, MachineRuntimeRequirement> | Exclude<ActionServices<Requirements>, MachineRuntimeRequirement>

Resolves all services needed to execute a machine at runtime.

Since v0.4.0

type PlanningServices<Requirements> = Exclude<Requirements, ActionRequirement<any, any>>

Removes staged action requirements from machine planning services.

Since v0.4.0

Typed traversal of root and child logical snapshots.

Since v0.32.0

type Snapshot<Source extends StateSource> = Machine.Snapshot<StateSchemasOf<Source>>

Extracts the complete logical snapshot represented by a state definition or machine.

Since v0.15.0

type SnapshotAt<Source extends StateSource, Path extends Machine.StateIdentifier<StateSchemasOf<Source>>> = Machine.SnapshotByIdentifier<StateSchemasOf<Source>, Path>

Extracts the logical snapshot rooted at a state path.

The source may be the object returned by states or a machine definition. This is the type-level counterpart of State.getSnapshot.

Since v0.18.0

type Value<Source extends StateSource, Path extends Machine.ValuedStateIdentifier<StateSchemasOf<Source>>> = Machine.StateByIdentifier<StateSchemasOf<Source>, Path>

Extracts the decoded value owned by a schema-backed state path.

The source may be the object returned by states or a machine definition. Control-only state paths are intentionally excluded.

Since v0.18.0