@typeonce/effect-machine v0.4.0
GitHub
API unstable/reactivity/AtomMachine
Module

AtomMachine

View source

Atom bridge for running machines.

Since v0.4.0 13 declarations ./unstable/reactivity/AtomMachine

Combinators

4
#

matches

variable
Source 
declare const matches: <State extends Machine.Machine.AtomicSnapshot<string, unknown>, Event, Error, Output, StartError, Path extends SnapshotIdentifier<State>>(self: MachineAtom<State, Event, Error, Output, StartError>, path: Path) => Atom.Atom<AsyncResult.AsyncResult<boolean, StartError | Error>>

Returns whether a state path is active.

Valid paths are inferred from the bridge snapshot. The derived atom suppresses equal updates. Runtime failures remain in the typed failure channel.

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

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 machineAtom = AtomMachine.make(machine)

const isIdleAtom = AtomMachine.matches(machineAtom, "Idle")
Since v0.4.0
#

matchesChild

variable
Source 
declare const matchesChild: <Child extends Machine.ChildMachine.Any, StartError, Path extends SnapshotIdentifier<ChildState<Child>>>(self: ChildMachineAtom<Child, StartError>, path: Path) => Atom.Atom<AsyncResult.AsyncResult<boolean, StartError | RefError<Machine.ChildMachine.Ref<Child>>>>

Returns whether a state path is active in an invoked child.

Valid paths are inferred from the child bridge snapshot. An inactive child produces false. Keep the returned atom stable when constructing it inside a component.

Since v0.4.0
#

select

variable
Source 
declare const select: <State extends Machine.Machine.AtomicSnapshot<string, unknown>, Event, Error, Output, StartError, Path extends SnapshotIdentifier<State>>(self: MachineAtom<State, Event, Error, Output, StartError>, path: Path) => Atom.Atom<AsyncResult.AsyncResult<Option.Option<SnapshotValueByIdentifier<State, Path>>, StartError | Error>>

Selects the typed value for an active state path.

Valid paths and their selected value types are inferred from the bridge. The derived atom suppresses structurally equal updates. Keep the returned atom stable when constructing it inside a component.

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

class Count extends Schema.TaggedClass<Count>("Count")("Count", {
  value: Schema.Number
}) {}
const States = Machine.defineStates({ Count })
const machine = Machine.make({
  states: States.states,
  events: [],
  initial: () => States.initial.Count(new Count({ value: 0 }))
}).handle({ Count: {} })
const machineAtom = AtomMachine.make(machine)

const countAtom = AtomMachine.select(machineAtom, "Count")
Since v0.4.0
#

selectChild

variable
Source 
declare const selectChild: <Child extends Machine.ChildMachine.Any, StartError, Path extends SnapshotIdentifier<ChildState<Child>>>(self: ChildMachineAtom<Child, StartError>, path: Path) => Atom.Atom<AsyncResult.AsyncResult<Option.Option<SnapshotValueByIdentifier<ChildState<Child>, Path>>, StartError | RefError<Machine.ChildMachine.Ref<Child>>>>

Selects the typed value for an active state path in an invoked child.

Valid paths and their selected value types are inferred from the child bridge. An inactive child produces Option.none(). Keep the returned atom stable when constructing it inside a component.

Example typescript 
const editingAtom = AtomMachine.selectChild(editorAtom, "Editing")
// Atom<AsyncResult<Option<Editing>, StartError | ChildRuntimeError>>
Since v0.4.0

Constructors

3
#

bind

variable
Source 
declare const bind: <Services, RuntimeError>(runtime: Atom.AtomRuntime<Services, RuntimeError>) => Bound<Services, RuntimeError>

Creates an AtomMachine factory that owns a shared Effect runtime.

Use this when an application runs many machines from the same service layer. The returned factory keeps runtime provisioning at the composition boundary, while every call to make still creates an independent machine bridge.

Since v0.4.0
#

make

variable
Source 
declare const make: <States extends Readonly<Record<string, TaggedSchema | StateNodeConfig>>, Events extends readonly Array<TaggedSchema>, Emits extends readonly Array<TaggedSchema> = any, Input extends Top = Void, UnhandledStates extends string = StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends string = never, Output = never, OutputStates extends string = never, InputEvents extends readonly Array<TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureNoExternalRequirements<MachineRequirements<InitialR, R, EventOf<Events>, EmitOf<Emits>>> & EnsureOutputImplementations<States, OutputStates> & [HistoryIdentifier<States>] extends [never] ? unknown : [Extract<UnhandledStates, HistoryParentIdentifier<States> | RequiredHistoryInitializers<States>>] extends [never] ? unknown : {
  readonly ~effect/Machine/MissingHistoryImplementation: MissingHistoryImplementations<States, UnhandledStates>;
} & EnsureChoiceImplementations<States, UnhandledStates>, ...args: [...Array<InputArgs<Input>>]) => MachineAtom<Snapshot<States>, EventOf<InputEvents>, MachineRuntimeError<E, R>, Output, MachineStartError<InitialE, E, InitialR, R, never>>

Creates atoms backed by a running machine.

Use bind(runtime).make(machine) when the machine requires external services.

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

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 machineAtom = AtomMachine.make(machine)
Since v0.4.0
#

resume

variable
Source 
declare const resume: <M extends Any>(machine: M & EnsureNoExternalRequirements<MachineResumeRequirementsOf<NoInfer<M>>> & EnsureMachineExecutable<NoInfer<M>>, snapshot: Snapshot<States<M>>) => ResumedMachineAtomOf<M, never>

Creates a lazy atom bridge from a decoded logical snapshot.

The bridge owns one freshly resumed runtime per AtomRegistry, with the same lazy start and disposal semantics as make. The machine initial function and its input, errors, and services are not involved.

Since v0.4.0

Errors

2
#

ChildNotActiveError

class
Source 
declare class ChildNotActiveError extends YieldableError<this> & {
  readonly _tag: "ChildNotActiveError";
} & Readonly<{
  readonly id: string;
}> {
  constructor(args: {
    readonly id: string;
  });
  readonly _tag: "ChildNotActiveError";
  readonly ~effect/Effect: Variance<never, ChildNotActiveError, 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, ChildNotActiveError, 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 command targets a child machine that is not active.

Since v0.4.0
#

NotReadyError

class
Source 
declare class NotReadyError extends YieldableError<this> & {
  readonly _tag: "NotReadyError";
} & Readonly<{}> {
  constructor(args: void);
  readonly _tag: "NotReadyError";
  readonly ~effect/Effect: Variance<never, NotReadyError, 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, NotReadyError, 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 command is issued before startup completes.

Since v0.4.0

Models

3
#

Bound

interface
Source 
interface Bound<Services, RuntimeError = never> {
  readonly make: <M extends Any>(machine: M & EnsureBoundRequirements<Services, NoInfer<M>> & EnsureMachineExecutable<NoInfer<M>>, ...args: [...Array<InputArgs<Input<M>>>]) => MachineAtomOf<M, RuntimeError>;
  readonly resume: <M extends Any>(machine: M & EnsureBoundResumeRequirements<Services, NoInfer<M>> & EnsureMachineExecutable<NoInfer<M>>, snapshot: Snapshot<States<M>>) => ResumedMachineAtomOf<M, RuntimeError>;
}

An AtomMachine factory with one owned Effect runtime.

Since v0.4.0
#

ChildMachineAtom

interface
Source 
interface ChildMachineAtom<Child extends Machine.ChildMachine.Any, StartError = unknown> {
  readonly child: <Nested extends Any>(child: Nested) => ChildMachineAtom<Nested, StartError>;
  readonly ref: Atom<AsyncResult<Option<Ref<Child>>, StartError>>;
  readonly result: Atom<AsyncResult<Option<RefState<Ref<Child>>>, StartError | RefError<Ref<Child>>>>;
  readonly send: Writable<AsyncResult<void, StoppedError | NotReadyError | StartError | ChildNotActiveError>, Event<Child>>;
  readonly snapshot: Atom<AsyncResult<Option<RuntimeSnapshot<RefState<Ref<Child>>, RefError<Ref<Child>>, RefOutput<Ref<Child>>>>, StartError>>;
  readonly state: Atom<AsyncResult<Option<RefState<Ref<Child>>>, StartError>>;
  readonly stop: Writable<AsyncResult<void, NotReadyError | StartError | ChildNotActiveError>, void>;
}

Reactive access to one invoked child machine selected by its descriptor.

Details

Each atom contains Option.none() while the state that owns the invocation is inactive or while the child is starting. It contains Option.some(...) for the current child instance and follows replacements after re-entry.

Gotchas

Lookup is direct-child scoped. Use child again on this bridge to reach a machine invoked by the selected child.

Since v0.4.0
#

MachineAtom

interface
Source 
interface MachineAtom<State, Event, Error = never, Output = never, StartError = never> {
  readonly child: <Child extends Any>(child: Child) => ChildMachineAtom<Child, StartError>;
  readonly ref: Atom<AsyncResult<MachineRef<State, Event, Error, Output>, StartError>>;
  readonly result: Atom<AsyncResult<State, Error | StartError>>;
  readonly send: Writable<AsyncResult<void, StoppedError | StartError | NotReadyError>, Event>;
  readonly snapshot: Atom<AsyncResult<RuntimeSnapshot<State, Error, Output>, StartError>>;
  readonly state: Atom<AsyncResult<State, StartError>>;
  readonly stop: Writable<AsyncResult<void, StartError | NotReadyError>, void>;
}

Atoms backed by one running machine instance in an AtomRegistry.

Details

The machine starts when one of the returned atoms is mounted or read in a registry, and it is stopped when the registry disposes the ref atom. The same atom values share one running machine per registry.

Since v0.4.0

Utility Types

1
#

ChildOf

type
Source 
type ChildOf<Parent extends MachineAtom<any, any, any, any, any> | ChildMachineAtom<any, any>, Child extends Machine.ChildMachine.Any> = ChildMachineAtom<Child, BridgeStartError<Parent>>

Derives the exact child bridge type from a parent bridge and child descriptor.

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