@typeonce/effect-machine v0.4.0
GitHub
API Machine
Module

Machine

View source

Schema-first machine definitions.

Since v0.4.0 64 declarations ./Machine

Combinators

2
#

plan

variable
Source 
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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, state: Machine.Snapshot<States>, event: Machine.EventOf<InputEvents>) => Effect.Effect<{
  readonly commands: ReadonlyArray<Command>;
  readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
  readonly microsteps: ReadonlyArray<{
    readonly changed: boolean;
    readonly commands: ReadonlyArray<Command>;
    readonly emittedEvents: ReadonlyArray<Machine.EmitOf<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>

Plans the next state snapshot synchronously.

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 actor 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 { Effect, Schema } from "effect"
import { Machine } from "@typeonce/effect-machine"

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.defineStates({ Off, On })
const machine = Machine.make({
  states: States.states,
  events: [Toggle],
  initial: () => States.initial.Off.from()
}).handle({ Off: { on: { Toggle: () => States.initial.On.from() } }, 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
#

watch

variable
Source 
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

17
#

after

variable
Source 
declare const after: <Event extends {
  readonly _tag: PropertyKey;
}>(duration: Duration.Input, event: Event, options?: {
  readonly id?: InvokeLifecycleId;
}) => InvokeEffectResult<never, Event>

Creates a cancellable state-scoped delayed event.

The timer starts when its owning state is entered and is interrupted when that state exits. The delayed value should normally be declared in internalEvents.

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

class TimedOut extends Schema.TaggedClass<TimedOut>("TimedOut")("TimedOut", {}) {}

const timeout = Machine.after("5 seconds", new TimedOut({}))
Since v0.4.0
#

child

variable
Source 
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
#

childAddress

variable
Source 
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, invoke, or sendTo.

Since v0.4.0
#

defineStates

variable
Source 
declare const defineStates: DefineStates

Defines a state tree while preserving literal state paths.

When to use

Use when you want to pass a state tree to make and also get typed snapshot builders for initial states and tests.

Details

The returned states property is the same object passed to defineStates. The returned initial builder creates snapshots without user-authored path strings and enforces compound and parallel initial-state rules.

Atomic initial snapshot typescript 
import { Schema } from "effect"
import { Machine } from "@typeonce/effect-machine"

class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}

const States = Machine.defineStates({ idle: Idle })

Machine.make({
  states: States.states,
  events: [],
  initial: () => States.initial.idle.from()
})
Since v0.4.0
#

effect

variable
Source 
declare const effect: <Output, Error = never, Requirements = never>(effect: Effect.Effect<Output, Error, Requirements>) => Logic<void, never, Error, Requirements, Output>

Creates a one-shot child process from an Effect.

When to use

Use when you need side effects that produce one typed output or error.

Details

The Effect may run arbitrary side effects. Its success value is the process output, its typed error is preserved, and its services are inferred. When invoked, the output is sent to the owning machine as an event unless it is void.

Gotchas

This process has no incoming event protocol. Its Effect runs once. Use transition for a process that receives events over time and logic for direct machine-local communication or intermediate snapshots.

Recover a child failure as output typescript 
import { Effect, Schema } from "effect"
import { Machine } from "@typeonce/effect-machine"

class LoadFailed extends Schema.TaggedClass<LoadFailed>("LoadFailed")("LoadFailed", {
  reason: Schema.String
}) {}

const load = Machine.effect(
  Effect.fail("unavailable").pipe(
    Effect.catch((reason) => Effect.succeed(new LoadFailed({ reason })))
  )
)
See also
  • transition for event-driven state.
  • logic for direct control over intermediate snapshots.
Since v0.4.0
#

event

variable
Source 
declare const event: <M extends Machine.Any, EventSchema extends Machine.TaggedSchema>(machine: M, schema: EventSchema & [EventSchema["Type"]] extends [Machine.Event<M>] ? unknown : never, ...args: EventConstructorArgs<EventSchema>) => EventSchema["Type"]

Constructs an event from a schema owned by a machine's protocol.

Details

The schema constructor runs exactly once. The resulting decoded event is trusted by this machine and definitions derived from it with handle, so repeated delivery does not decode the same already-constructed value again. Events supplied through ordinary send and plan calls remain untrusted and continue through full runtime schema validation. Treat the returned event as immutable after construction.

The schema must be one of the machine's configured public or internal event schemas, or a case schema belonging to a configured Schema.TaggedUnion.

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

class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
class Increment extends Schema.TaggedClass<Increment>("Increment")("Increment", {
  by: Schema.Number
}) {}

const States = Machine.defineStates({ Idle })
const counter = Machine.make({
  states: States.states,
  events: [Increment],
  initial: () => States.initial.Idle.from()
}).handle({ Idle: { on: { Increment: () => States.initial.Idle.from() } } })

const increment = Machine.event(counter, Increment, { by: 1 })
Since v0.4.0
#

InitialEvent

variable
Source 
declare const InitialEvent: InitialEvent

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

Since v0.4.0
#

invoke

variable
Source 
declare const invoke: <ChildState, ChildEvent, ChildError = never, ChildRequirements = never, ChildOutput = never, ChildInitialError = never, Event = never, Address extends ChildAddress<never> | undefined = undefined>(config: {
  readonly id: InvokeLifecycleId;
  readonly snapshot?: (context: Machine.InvokeSnapshotContext<ChildState, ChildError, ChildOutput>) => Event | undefined;
  readonly src: () => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
} & [Address] extends [undefined] ? {
  readonly address?: never;
} : {
  readonly address: Exclude<Address, undefined>;
} & ChildAddress.Compatibility<Exclude<Address, undefined>, NoInfer<ChildEvent>>) => Machine.InvokeConfig<any, any, any, any, Event, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>

Creates an invoked child process configuration for an active state.

When to use

Use to run a child process while a machine remains in a state. Successful outputs are sent directly to the parent machine as events; void sends nothing. Unrecovered child failures fail the owning machine. Active snapshots can optionally be mapped to progress events.

Gotchas

Invoked child processes run while their owning state is active and are stopped before the state exits. An unrecovered child failure fails the owning machine; recover inside the child Effect when failure should become an event. The id is a state-local lifecycle key, not a communication address. To send events to the invocation, pass a typed childAddress as address. The src callback is intentionally independent from its parent state. When construction depends on the typed state, lifecycle event, or runtime, use the state config factory form invoke: (context) => Machine.invoke(...) and close over that context from src.

Effect output as a parent event typescript 
import { Effect, Schema } from "effect"
import { Machine } from "@typeonce/effect-machine"

class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
  value: Schema.String
}) {}

const load = Machine.invoke({
  id: "load",
  src: () => Machine.effect(Effect.succeed(new Loaded({ value: "ready" })))
})
See also
  • effect for one-shot child effects.
  • spawn for children whose lifetime is controlled by actions.
Since v0.4.0
#

invokeEffect

variable
Source 
declare const invokeEffect: <Fx extends Effect.Effect<any, any, any>, SuccessEvent, FailureEvent = never>(config: InvokeEffectConfig<Fx, SuccessEvent, FailureEvent>) => InvokeEffectResult<Effect.Services<Fx>, SuccessEvent | InvokeEffectIsInfallible<Fx> extends true ? never : FailureEvent>

Invokes one Effect and maps its typed outcome into machine-local events.

Details

This is the high-level one-shot counterpart to invoke. Success and typed failure values are mapped independently, so callers do not need to recover an Effect into a common event union by hand. Defects and interruption remain failures of the owning machine.

Declare mapped outcomes in internalEvents unless they are also legitimate public commands.

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

class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
  value: Schema.String
}) {}

const load = Machine.invokeEffect({
  id: "load",
  effect: Effect.succeed("ready"),
  onSuccess: (value) => new Loaded({ value })
})
See also
  • invoke for arbitrary child process logic.
  • after for a state-scoped delayed event.
Since v0.4.0
#

invokeMachine

variable
Source 
declare const invokeMachine: {
  <States extends Readonly<Record<string, TaggedSchema | StateNodeConfig>>, Events extends readonly Array<TaggedSchema>, Emits extends readonly Array<TaggedSchema> = readonly [], Input extends Top = Void, UnhandledStates extends string = StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends string = never, Output = never, SnapshotEvent = never, DoneEvent = never, Id extends string = string, OutputStates extends string = never, InputEvents extends readonly Array<TaggedSchema> = Events>(config: {
    readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>>;
    readonly onDone: (context: Machine.InvokeDoneContext<Output>) => DoneEvent | undefined;
    readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
  } & InvokeMachineInput<Input>): InvokeConfig<any, any, any, any, SnapshotEvent, Snapshot<States>, EventOf<InputEvents>, MachineSchemaDecodeError | StoppedError | InfiniteTransitionError | E | ActionError<R>, ExcludeCompatibleRuntime<Exclude<Exclude<Exclude<R, ActionRequirement<any, any>>, MachineRuntime>, MachineRuntime>, EventOf<Events>, EmitOf<Emits>> | ExcludeCompatibleRuntime<Exclude<Exclude<Exclude<InitialR, ActionRequirement<any, any>>, MachineRuntime>, MachineRuntime>, EventOf<Events>, EmitOf<Emits>> | ExcludeCompatibleRuntime<Exclude<Exclude<ActionServices<R>, MachineRuntime>, MachineRuntime>, EventOf<Events>, EmitOf<Emits>> | ExcludeCompatibleRuntime<Exclude<Exclude<ActionServices<InitialR>, MachineRuntime>, MachineRuntime>, EventOf<Events>, EmitOf<Emits>>, Output, MachineSchemaDecodeError | StoppedError | InfiniteTransitionError | E | InitialE | ActionError<R> | ActionError<InitialR> | StartupError, EmitOf<Emits>, DoneEvent>;
  <States extends Readonly<Record<string, TaggedSchema | StateNodeConfig>>, Events extends readonly Array<TaggedSchema>, Emits extends readonly Array<TaggedSchema> = readonly [], Input extends Top = Void, UnhandledStates extends string = StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends string = never, Output = never, SnapshotEvent = never, Id extends string = string, OutputStates extends string = never, InputEvents extends readonly Array<TaggedSchema> = Events>(config: {
    readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>>;
    readonly onDone?: never;
    readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
  } & InvokeMachineInput<Input>): InvokeConfig<any, any, any, any, SnapshotEvent, Snapshot<States>, EventOf<InputEvents>, MachineSchemaDecodeError | StoppedError | InfiniteTransitionError | E | ActionError<R>, ExcludeCompatibleRuntime<Exclude<Exclude<Exclude<R, ActionRequirement<any, any>>, MachineRuntime>, MachineRuntime>, EventOf<Events>, EmitOf<Emits>> | ExcludeCompatibleRuntime<Exclude<Exclude<Exclude<InitialR, ActionRequirement<any, any>>, MachineRuntime>, MachineRuntime>, EventOf<Events>, EmitOf<Emits>> | ExcludeCompatibleRuntime<Exclude<Exclude<ActionServices<R>, MachineRuntime>, MachineRuntime>, EventOf<Events>, EmitOf<Emits>> | ExcludeCompatibleRuntime<Exclude<Exclude<ActionServices<InitialR>, MachineRuntime>, MachineRuntime>, EventOf<Events>, EmitOf<Emits>>, Output, MachineSchemaDecodeError | StoppedError | InfiniteTransitionError | E | InitialE | StartupError | ActionError<R> | ActionError<InitialR>, EmitOf<Emits>>;
}

Creates an invoked child process from a complete statechart machine.

When to use

Use when a state should own another statechart machine and communicate with it through typed child events, emissions, snapshots, or terminal output.

Details

Child emissions are delivered directly to the parent as events. Active snapshots and terminal output can be mapped to parent events. The owning state controls the child lifetime.

Gotchas

Active invoked machines must have unique child addresses. A machine starts after its owning state's entry actions, so those actions cannot send events to a newly entered child. Unrecovered child failures fail the parent.

See also
  • invoke for invoking lower-level process logic.
  • sendTo for sending events to the invoked machine.
Since v0.4.0
#

logic

variable
Source 
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 invoke snapshot mapping when possible.

See also
  • effect for one-shot work.
  • transition for event-driven state.
Since v0.4.0
#

make

variable
Source 
declare const make: Make

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 defineStates or is passed inline. Call handle on the returned definition to implement state behavior with ordinary TypeScript control flow.

Schemas in events define the public input protocol. Schemas in internalEvents are added to the complete handler protocol for invoke results, child emissions, and other machine-local deliveries. Their tags must be disjoint.

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

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.defineStates({ Count })

const counter = Machine.make({
  states: States.states,
  events: [Increment],
  initial: () => States.initial.Count(new Count({ value: 0 }))
}).handle({
  Count: {
    on: {
      Increment: ({ event, state }) =>
        States.initial.Count(new Count({ value: state.value + event.by }))
    }
  }
})
See also
  • defineStates for typed initial snapshot builders.
Since v0.4.0
#

planInitial

variable
Source 
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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
  readonly commands: ReadonlyArray<Command>;
  readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
  readonly initialEntryPaths: ReadonlyArray<Machine.StateIdentifier<States>>;
  readonly microsteps: ReadonlyArray<{
    readonly changed: boolean;
    readonly commands: ReadonlyArray<Command>;
    readonly emittedEvents: ReadonlyArray<Machine.EmitOf<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 actor commands.

Details

The returned plan contains the settled initial snapshot, actor 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 actor commit protocol. Manual planners may inspect commands but need a running actor scope to execute child-addressed operations.

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

class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
const States = Machine.defineStates({ Idle })
const machine = Machine.make({
  states: States.states,
  events: [],
  initial: () => States.initial.Idle.from()
}).handle({ 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
#

resume

variable
Source 
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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmitOf<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; delayed invokes restart their complete duration and invoked machines 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 { Effect, Schema } from "effect"
import { Machine } from "@typeonce/effect-machine"

class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
const States = Machine.defineStates({ Idle })
const machine = Machine.make({
  states: States.states,
  events: [],
  initial: () => States.initial.Idle.from()
}).handle({ 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
#

retag

variable
Source 
declare const retag: <Target extends Machine.TaggedSchema, Source extends {
  readonly _tag: PropertyKey;
}>(target: Target & RetagTargetCompatibility<Target>, source: Source, ...args: RetagArgs<Target, Source>) => Target["Type"]

Constructs another tagged case from compatible source fields.

The target must be one tagged struct or tagged class whose discriminator is supplied by its constructor. Union wrappers are rejected because their make operation cannot select a member after the source discriminator has been discarded. Missing or incompatible required target fields must be supplied by the patch, and the target schema's normal make validation remains authoritative at runtime.

Since v0.4.0
#

start

variable
Source 
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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<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 actor 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 { Effect, Schema } from "effect"
import { Machine } from "@typeonce/effect-machine"

class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
const States = Machine.defineStates({ Idle })
const machine = Machine.make({
  states: States.states,
  events: [],
  initial: () => States.initial.Idle.from()
}).handle({ 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
#

transition

variable
Source 
declare const transition: <State, Event, Error = never, Requirements = never>(initial: State, transition: (state: State, event: Event) => Effect.Effect<State, Error, Requirements>) => Logic<State, Event, Error, Requirements, never>

Creates child process logic from an initial state and a transition function.

When to use

Use when a child process only needs sequential event-driven state updates and does not need direct control over intermediate snapshots or child ownership.

Details

Each received event runs the transition Effect against the latest state. The resulting state is published before the next queued event is processed.

Example typescript 
import { Effect } from "effect"
import { Machine } from "@typeonce/effect-machine"

const counter = Machine.transition(
  0,
  (count, event: { readonly by: number }) => Effect.succeed(count + event.by)
)
See also
  • effect for one-shot work.
  • logic for direct process lifecycle control.
Since v0.4.0

Decoding

1
#

decodeSnapshot

variable
Source 
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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, 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 { Effect, Schema } from "effect"
import { Machine } from "@typeonce/effect-machine"

class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
const States = Machine.defineStates({ Idle })
const machine = Machine.make({
  states: States.states,
  events: [],
  initial: () => States.initial.Idle.from()
}).handle({ 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

1
#

encodeSnapshot

variable
Source 
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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, 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 schema declared for its state path. The result contains no process-local runtime state.

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. Schema encoding does not by itself guarantee JSON-compatible values; schemas used with JSON-backed storage must have JSON-compatible encoded representations.

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

class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
const States = Machine.defineStates({ Idle })
const machine = Machine.make({
  states: States.states,
  events: [],
  initial: () => States.initial.Idle.from()
}).handle({ 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

7
#

ChildAlreadyExistsError

class
Source 
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;
  readonly ~effect/Runtime/errorExitCode?: number;
  readonly ~effect/Runtime/errorReported?: boolean;
  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
#

InfiniteTransitionError

class
Source 
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;
  readonly ~effect/Runtime/errorExitCode?: number;
  readonly ~effect/Runtime/errorReported?: boolean;
  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
#

MachineSchemaDecodeError

class
Source 
declare class MachineSchemaDecodeError extends YieldableError<this> & {
  readonly _tag: "MachineSchemaDecodeError";
} & Readonly<{
  readonly boundary: "history" | "event" | "output" | "state" | "input" | "emit" | "configuration";
  readonly cause: SchemaError | Cause<unknown>;
  readonly event?: string;
  readonly machineId: string | undefined;
  readonly state?: string;
}> {
  constructor(args: {
    readonly boundary: "history" | "event" | "output" | "state" | "input" | "emit" | "configuration";
    readonly cause: SchemaError | Cause<unknown>;
    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 ~effect/Runtime/errorExitCode?: number;
  readonly ~effect/Runtime/errorReported?: boolean;
  readonly boundary: "history" | "event" | "output" | "state" | "input" | "emit" | "configuration";
  cause: SchemaError | Cause<unknown>;
  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
#

MachineSchemaEncodeError

class
Source 
declare class MachineSchemaEncodeError extends YieldableError<this> & {
  readonly _tag: "MachineSchemaEncodeError";
} & Readonly<{
  readonly boundary: "history" | "output" | "state" | "configuration";
  readonly cause: SchemaError | Cause<unknown>;
  readonly machineId: string | undefined;
  readonly state?: string;
}> {
  constructor(args: {
    readonly boundary: "history" | "output" | "state" | "configuration";
    readonly cause: SchemaError | Cause<unknown>;
    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 ~effect/Runtime/errorExitCode?: number;
  readonly ~effect/Runtime/errorReported?: boolean;
  readonly boundary: "history" | "output" | "state" | "configuration";
  cause: SchemaError | Cause<unknown>;
  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
#

ProcessLocalError

class
Source 
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;
  readonly ~effect/Runtime/errorExitCode?: number;
  readonly ~effect/Runtime/errorReported?: boolean;
  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
#

StartupError

class
Source 
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;
  readonly ~effect/Runtime/errorExitCode?: number;
  readonly ~effect/Runtime/errorReported?: boolean;
  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
#

StoppedError

class
Source 
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;
  readonly ~effect/Runtime/errorExitCode?: number;
  readonly ~effect/Runtime/errorReported?: boolean;
  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

5
#

activityDefinitions

variable
Source 
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 invoke, invokeEffect, after, and invokeMachine descriptors expose stable ownership and lifecycle metadata without serializing runtime values. Function-valued invoke factories are represented as dynamic and are never evaluated during inspection.

Since v0.4.0
#

configuration

variable
Source 
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
#

enabled

variable
Source 
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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, state: Machine.Snapshot<States>) => ReadonlyArray<Machine.TagOf<Events[number]>>

Returns the event tags handled by the current state snapshot.

Since v0.4.0
#

stateNodes

variable
Source 
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
#

transitionDefinitions

variable
Source 
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 handlers. Object-form event, eventless, and completion handlers with a targets declaration expose those possible paths; handlers without one remain dynamic.

Since v0.4.0

Guards

3
#

isFinal

variable
Source 
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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, 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
#

isInitialEvent

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

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

Since v0.4.0
#

isMachine

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

Returns true if a value is a Machine.

Since v0.4.0

Models

18
#

ChildAddress

namespace
Source

Namespace containing type-level members associated with ChildAddress.

Since v0.4.0
#

ChildAddress

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

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

Since v0.4.0
#

ChildMachine

interface
Source 
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 the same value to invokeMachine, sendTo, and child lookup APIs so state, event, error, and output types are inferred without separate annotations.

Since v0.4.0
#

ChildMachine

namespace
Source

Namespace containing type-level members associated with ChildMachine.

Since v0.4.0
#

Command

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

A closed actor command recorded by a synchronous machine transition.

Since v0.4.0
#

Enqueue

interface
Source 
interface Enqueue<in Events, in Emits> {
  readonly emit: (event: Emits) => void;
  readonly raise: (event: Events) => void;
  readonly sendTo: {
    <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 only records statechart and actor operations; it never executes an Effect.

Since v0.4.0
#

InitialEvent

interface
Source 
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
#

Logic

interface
Source 
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 invoke.

Since v0.4.0
#

Logic

namespace
Source

Public types used by advanced machine process logic.

Since v0.4.0
#

Machine

interface
Source 
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> extends Pipeable {
  readonly ~effect/Machine: "~effect/Machine";
  readonly emits: Emits;
  readonly events: InputEvents;
  readonly handle: Handler<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents>;
  readonly id: string | undefined;
  readonly input: Input | undefined;
  readonly internalEvents: readonly Array<TaggedSchema>;
  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.

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

Declarative first-class guards are not part of the current API. Conditional behavior can be expressed in typed handlers with ordinary TypeScript control flow. Use after for cancellable state-scoped delayed events.

Since v0.4.0
#

Machine

namespace
Source

Namespace containing type-level members associated with Machine.

Since v0.4.0
#

MachineRef

interface
Source 
interface MachineRef<out State, in Event, out Error = never, out Output = never> {
  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 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
#

Runtime

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

Managed runtime capability used to deliver raised and emitted events.

Since v0.4.0
#

Runtime

namespace
Source

Namespace containing type-level members associated with Runtime.

Since v0.4.0
#

RuntimeOutcome

type
Source 
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
#

RuntimeSnapshot

type
Source 
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
#

SpawnIdOptions

interface
Source 
interface SpawnIdOptions extends SpawnOptions {
  readonly id: string;
}

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

Since v0.4.0
#

SpawnOptions

interface
Source 
interface SpawnOptions {
  readonly id?: string;
}

Options for spawning child processes.

Since v0.4.0

Runtime

3
#

sendTo

variable
Source 
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
#

spawn

variable
Source 
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.

See also
  • invoke for children that start and stop with a state.
  • sendTo for sending events to named children.
Since v0.4.0
#

stopChild

variable
Source 
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

1
#

ActionRequirement

interface
Source 
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

2
#

TypeId

type
Source 
type TypeId = "~effect/Machine"

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

Since v0.4.0
#

TypeId

variable
Source 
declare const TypeId: "~effect/Machine"

Runtime type identifier attached to Machine values.

Since v0.4.0

Utility Types

4
#

ActionError

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

Extracts the typed error channel of staged machine actions.

Since v0.4.0
#

ActionServices

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

Extracts the service requirements of staged machine actions.

Since v0.4.0
#

ExecutionServices

type
Source 
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
#

PlanningServices

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

Removes staged action requirements from machine planning services.

Since v0.4.0
Type at least two characters to search.