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

MachineTest

View source

Property-based scenario generation and planner trace utilities.

Since v0.4.0 202 declarations ./testing/MachineTest

Constructors

17
#

advanceCommand

function
Source 
declare function advanceCommand<Event = never>(duration: Input): RuntimeCommand<Event>

Constructs a command that advances Effect's TestClock.

Since v0.4.0
#

checkpointCommand

function
Source 
declare function checkpointCommand<Event = never>(label?: string): RuntimeCommand<Event>

Constructs a no-op command used to synchronize with work enqueued by earlier commands. Its behavior is selected by the reference-model step.

Since v0.4.0
#

compileModel

function
Source 
declare function compileModel(model: FiniteModel): Any

Compiles a finite model into a real machine using only public definition, construction, and handler APIs.

Hand-authored models are validated before compilation. This compiler is a testing adapter, not the independent reference interpreter used by later conformance stages.

Since v0.4.0
#

finiteModels

function
Source 
declare function finiteModels(options: FiniteModelOptions): FiniteModels

Generates bounded, structurally valid hierarchical statechart models.

Generation is composed from shrinkable topology, initial-state, event, and transition decisions. Paths and transition candidates are rebuilt after a topology shrink, so a shrink can never retain a dangling source or target. Generated automatic transitions are acyclic by construction: always transitions leave atomic sources and completion transitions leave compound or parallel sources. Separate focused witnesses cover cyclic stabilization.

Since v0.4.0
#

Invariant

variable
Source 
declare const Invariant: {
  readonly state: <M extends Any>(name: string, check: (context: StateInvariantContext<M>) => InvariantOutcome, options?: StateInvariantOptions<M>) => StateInvariant<M>;
  readonly step: <M extends Any>(name: string, check: (context: StepInvariantContext<M>) => InvariantOutcome, options?: InvariantOptions<StepInvariantContext<M>>) => StepInvariant<M>;
  readonly trace: <M extends Any>(name: string, check: (context: TraceInvariantContext<M>) => InvariantOutcome, options?: InvariantOptions<TraceInvariantContext<M>>) => TraceInvariant<M>;
}

Direct invariant constructors. Prefer invariants(machine) when contextual machine types should be inferred without an explicit type argument.

Since v0.4.0
#

invariants

variable
Source 
declare const invariants: <M extends AnyMachine>(machine: M) => InvariantBuilder<M>

Creates invariant constructors bound to a machine's exact state and event types. The machine is used only for inference; invariant evaluation remains pure and reusable across traces from that machine.

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

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 nonNegative = MachineTest.invariants(machine).state(
  "count is non-negative",
  ({ snapshot }) => snapshot.value.value >= 0
)
Since v0.4.0
#

run

variable
Source 
declare const run: <M extends AnyMachine>(machine: ReadyMachine<M>, scenario: Scenario<M>) => Effect.Effect<Trace<M>, RunFailure<RunError<M>, M>, RunServices<M>>

Executes a generated scenario exclusively through planInitial and plan.

Staged actions are retained in each plan but are never executed. Every event is planned, including events that occur after a terminal configuration. Typed planning errors retain the scenario and successfully completed prefix in a RunFailure.

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

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 trace = MachineTest.run(machine, { events: [] })
Since v0.4.0
#

runCausalCommands

function
Source 
declare function runCausalCommands<M extends Any, Error, Output, Model, Expected, Observed = never, ModelError = never, ModelServices = never, InspectionError = never, InspectionServices = never, AssertionError = never, AssertionServices = never>(probe: Probe<M, Error, Output>, commands: Iterable<RuntimeCommand<InputEvent<M>>>, options: CausalRuntimeModelOptions<M, Model, Expected, Error, Output, Observed, ModelError, ModelServices, InspectionError, InspectionServices, AssertionError, AssertionServices>): Effect<CausalRuntimeTranscript<M, Model, Expected, Error, Output, Observed>, CausalRuntimeCommandFailure<Error | ModelError | InspectionError | AssertionError | RuntimeObservationError, M, Model, Expected, Error, Output, Observed>, ModelServices | InspectionServices | AssertionServices>

Runs typed commands against a probe and checks them against an Effect-native reference model.

Every accepted Send completes its exact managed runtime macrostep before inspection, assertion, and the next command. Use probe.await.until only for later asynchronous work such as timer, invoke, or child delivery. Processing failures are attributed to the exact submitted command and retain the successfully checked prefix for FastCheck shrinking and replay.

Use runEnqueuedCommands instead when the behavior under test intentionally depends on burst enqueueing or outstanding mailbox work.

Since v0.4.0
#

runEnqueuedCommands

function
Source 
declare function runEnqueuedCommands<Model, Expected, State, Event, Error, Output, Observed = never, ModelError = never, ModelServices = never, InspectionError = never, InspectionServices = never, AssertionError = never, AssertionServices = never>(ref: MachineRef<State, Event, Error, Output>, commands: Iterable<RuntimeCommand<Event>>, options: RuntimeModelOptions<Model, Expected, State, Event, Error, Output, Observed, ModelError, ModelServices, InspectionError, InspectionServices, AssertionError, AssertionServices>): Effect<RuntimeTranscript<Model, Expected, State, Event, Error, Output, Observed>, RuntimeCommandFailure<RuntimeObservationError | ModelError | InspectionError | AssertionError, Model, Expected, State, Event, Error, Output, Observed>, ModelServices | InspectionServices | AssertionServices>

Runs typed commands against a live MachineRef and checks them against a supplied Effect-native reference model.

The runner observes only public MachineRef behavior. In particular, a successful send means enqueue acceptance, not completed processing. A model must request Next/Until only when it predicts a publication, or use an explicit checkpoint to drain previously enqueued work. Machine emissions can be captured by the runtime service used by the machine and returned from the optional inspect effect.

Typed failures and defects from model transitions, command execution, inspection, and assertions are retained as full Cause values. A cause containing only interruption is propagated as interruption so cancelling a property run cannot be mistaken for a machine counterexample.

Since v0.4.0
#

runRuntimeCommands

variable
Source 
declare const runRuntimeCommands: typeof runEnqueuedCommands

Compatibility alias for enqueue-oriented runtime command execution.

Since v0.4.0
#

runtimeCommands

function
Source 
declare function runtimeCommands<M extends Any>(machine: M, options: RuntimeCommandsOptions<M>): RuntimeCommands<M>

Derives a shrinkable command sequence from public event schemas and explicit clock/stop/checkpoint command choices.

This deliberately returns ordinary Effect FastCheck arbitraries instead of adapting the runner through asyncModelRun: the latter requires Promise callbacks and would erase Effect error and service channels.

Since v0.4.0
#

runtimeInvariants

variable
Source 
declare const runtimeInvariants: <M extends AnyMachine>(machine: M) => RuntimeInvariantBuilder<M>

Creates reusable semantic laws for causal runtime evidence.

Since v0.4.0
#

RuntimeSynchronization

variable
Source 
declare const RuntimeSynchronization: {
  readonly current: {
    readonly _tag: "Current";
  };
  readonly next: {
    readonly _tag: "Next";
  };
  readonly none: {
    readonly _tag: "None";
  };
  readonly until: <State, Error = never, Output = never>(predicate: (snapshot: RuntimeSnapshot<State, Error, Output>) => boolean) => RuntimeSynchronization<State, Error, Output>;
}

Constructors for runtime synchronization policies.

Since v0.4.0
#

scenarios

variable
Source 
declare const scenarios: <M extends AnyMachine>(machine: M, options?: ScenarioOptions<M>) => Scenarios<M>

Derives valid machine inputs and public events from their schemas.

Unsupported schema derivations fail immediately through Schema.toArbitrary. Non-fatal derivation warnings are returned instead of being hidden.

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

class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
class Reset extends Schema.TaggedClass<Reset>("Reset")("Reset", {}) {}
const States = Machine.defineStates({ Idle })
const machine = Machine.make({
  states: States.states,
  events: [Reset],
  initial: () => States.initial.Idle.from()
}).handle({ Idle: { on: { Reset: () => States.initial.Idle.from() } } })

const generated = MachineTest.scenarios(machine, { maxEvents: 5 })
Since v0.4.0
#

sendCommand

function
Source 
declare function sendCommand<Event>(event: Event): RuntimeCommand<Event>

Constructs a command that sends one public event.

Since v0.4.0
#

stopCommand

function
Source 
declare function stopCommand<Event = never>(): RuntimeCommand<Event>

Constructs an idempotent command that stops the machine.

Since v0.4.0
#

verifyCausalCommands

function
Source 
declare function verifyCausalCommands<M extends Any, Error, Output>(probe: Probe<M, Error, Output>, commands: Iterable<RuntimeCommand<InputEvent<M>>>, options: CausalVerificationOptions<M, Error, Output>): Effect<CausalVerificationTranscript<M, Error, Output>, CausalRuntimeCommandFailure<RuntimeObservationError | Error, M, undefined, undefined, Error, Output, never> | RuntimeInvariantError<M>>

Causally executes commands and checks reusable runtime invariants without requiring a dummy reference model. Use runCausalCommands when exact expected results come from an application model.

Since v0.4.0

Errors

11
#

CausalRuntimeCommandFailure

class
Source 
declare class CausalRuntimeCommandFailure<Failure = unknown, M extends AnyMachine = AnyMachine, Model = unknown, Expected = unknown, Error = unknown, Output = unknown, Observed = unknown> extends YieldableError<this> & {
  readonly _tag: "MachineTestCausalRuntimeCommandFailure";
} & Readonly<{
  readonly attempted: CausalRuntimeCommandAttempt<M, Model, Expected, Error, Output, Observed> | undefined;
  readonly cause: Cause<Failure>;
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly index: number;
  readonly phase: "model" | "execution" | "observation" | "inspection" | "assertion";
  readonly prefix: readonly Array<CausalRuntimeCommandRecord<M, Model, Expected, Error, Output, Observed>>;
}> {
  constructor<Failure = unknown, M extends Any = Any, Model = unknown, Expected = unknown, Error = unknown, Output = unknown, Observed = unknown>(args: {
    readonly attempted: CausalRuntimeCommandAttempt<M, Model, Expected, Error, Output, Observed> | undefined;
    readonly cause: Cause<Failure>;
    readonly command: RuntimeCommand<InputEvent<M>>;
    readonly index: number;
    readonly phase: "model" | "execution" | "observation" | "inspection" | "assertion";
    readonly prefix: readonly Array<CausalRuntimeCommandRecord<M, Model, Expected, Error, Output, Observed>>;
  });
  readonly _tag: "MachineTestCausalRuntimeCommandFailure";
  readonly ~effect/Effect: Variance<never, CausalRuntimeCommandFailure<Failure, M, Model, Expected, Error, Output, Observed>, 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 attempted: CausalRuntimeCommandAttempt<M, Model, Expected, Error, Output, Observed> | undefined;
  cause: Cause<Failure>;
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly index: number;
  message: string;
  name: string;
  readonly phase: "model" | "execution" | "observation" | "inspection" | "assertion";
  readonly prefix: readonly Array<CausalRuntimeCommandRecord<M, Model, Expected, Error, Output, Observed>>;
  stack?: string;
  [iterator](): EffectIterator<Effect<never, CausalRuntimeCommandFailure<Failure, M, Model, Expected, Error, Output, Observed>, 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;
}

A typed causal command-model failure retaining the successfully checked prefix and exact attempted command.

Since v0.4.0
#

InvariantError

class
Source 
declare class InvariantError<M extends AnyMachine = AnyMachine> extends YieldableError<this> & {
  readonly _tag: "MachineTestInvariantError";
} & Readonly<{
  readonly report: InvariantReport;
  readonly trace: Trace<M>;
  readonly violations: readonly Array<InvariantViolation<M>>;
}> {
  constructor<M extends Any = Any>(args: {
    readonly report: InvariantReport;
    readonly trace: Trace<M>;
    readonly violations: readonly Array<InvariantViolation<M>>;
  });
  readonly _tag: "MachineTestInvariantError";
  readonly ~effect/Effect: Variance<never, InvariantError<M>, 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 report: InvariantReport;
  stack?: string;
  readonly trace: Trace<M>;
  readonly violations: readonly Array<InvariantViolation<M>>;
  [iterator](): EffectIterator<Effect<never, InvariantError<M>, 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;
}

All semantic violations found in one trace, together with the complete counterexample and aggregate report.

Since v0.4.0
#

ModelVerificationError

class
Source 
declare class ModelVerificationError extends YieldableError<this> & {
  readonly _tag: "MachineTestModelVerificationError";
} & Readonly<{
  readonly mismatches: readonly Array<ModelVerificationMismatch>;
}> {
  constructor(args: {
    readonly mismatches: readonly Array<ModelVerificationMismatch>;
  });
  readonly _tag: "MachineTestModelVerificationError";
  readonly ~effect/Effect: Variance<never, ModelVerificationError, 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;
  readonly mismatches: readonly Array<ModelVerificationMismatch>;
  name: string;
  stack?: string;
  [iterator](): EffectIterator<Effect<never, ModelVerificationError, 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;
}

All semantic disagreements found for one finite-model trace.

Since v0.4.0
#

PlannerRuntimeAgreementError

class
Source 
declare class PlannerRuntimeAgreementError<M extends AnyMachine = AnyMachine> extends YieldableError<this> & {
  readonly _tag: "MachineTestPlannerRuntimeAgreementError";
} & Readonly<{
  readonly evidence: CausalRuntimeEvidence<M, unknown, unknown>;
  readonly violations: readonly Array<PlannerRuntimeAgreementViolation<M>>;
}> {
  constructor<M extends Any = Any>(args: {
    readonly evidence: CausalRuntimeEvidence<M, unknown, unknown>;
    readonly violations: readonly Array<PlannerRuntimeAgreementViolation<M>>;
  });
  readonly _tag: "MachineTestPlannerRuntimeAgreementError";
  readonly ~effect/Effect: Variance<never, PlannerRuntimeAgreementError<M>, 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 evidence: CausalRuntimeEvidence<M, unknown, unknown>;
  message: string;
  name: string;
  stack?: string;
  readonly violations: readonly Array<PlannerRuntimeAgreementViolation<M>>;
  [iterator](): EffectIterator<Effect<never, PlannerRuntimeAgreementError<M>, 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;
}

Raised when live causal evidence disagrees with a fresh pure plan.

Since v0.4.0
#

ProbeUnavailableError

class
Source 
declare class ProbeUnavailableError extends YieldableError<this> & {
  readonly _tag: "MachineTestProbeUnavailableError";
} & Readonly<{
  readonly message: string;
}> {
  constructor(args: {
    readonly message: string;
  });
  readonly _tag: "MachineTestProbeUnavailableError";
  readonly ~effect/Effect: Variance<never, ProbeUnavailableError, 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, ProbeUnavailableError, 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;
}

Raised when a reference was not created by the managed statechart runtime.

Since v0.4.0
#

ReachabilityError

class
Source 
declare class ReachabilityError<M extends AnyMachine = AnyMachine, Key extends ExplorationKey = ExplorationKey> extends YieldableError<this> & {
  readonly _tag: "MachineTestReachabilityError";
} & Readonly<{
  readonly completeness: ExplorationCompleteness<M, Key>;
  readonly expectation: "reachable" | "unreachable";
  readonly message: string;
  readonly name: string;
  readonly reason: ReachabilityFailure;
  readonly witness?: ExplorationNode<M, Key>;
}> {
  constructor<M extends Any = Any, Key extends PropertyKey = PropertyKey>(args: {
    readonly completeness: ExplorationCompleteness<M, Key>;
    readonly expectation: "reachable" | "unreachable";
    readonly message: string;
    readonly name: string;
    readonly reason: ReachabilityFailure;
    readonly witness?: ExplorationNode<M, Key>;
  });
  readonly _tag: "MachineTestReachabilityError";
  readonly ~effect/Effect: Variance<never, ReachabilityError<M, Key>, 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 completeness: ExplorationCompleteness<M, Key>;
  readonly expectation: "reachable" | "unreachable";
  message: string;
  name: string;
  readonly reason: ReachabilityFailure;
  stack?: string;
  readonly witness?: ExplorationNode<M, Key>;
  [iterator](): EffectIterator<Effect<never, ReachabilityError<M, Key>, 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;
}

A failed or inconclusive reachability assertion.

Since v0.4.0
#

RunError

type
Source 
type RunError<M extends AnyMachine> = Machine.Machine.InitialError<M> | Machine.Machine.Error<M> | Machine.InfiniteTransitionError | Machine.MachineSchemaDecodeError | Machine.StartupError

Errors that can be produced while planning a complete scenario.

Since v0.4.0
#

RuntimeCommandFailure

class
Source 
declare class RuntimeCommandFailure<Failure = unknown, Model = unknown, Expected = unknown, State = unknown, Event = unknown, Error = unknown, Output = unknown, Observed = unknown> extends YieldableError<this> & {
  readonly _tag: "MachineTestRuntimeCommandFailure";
} & Readonly<{
  readonly attempted: RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed> | undefined;
  readonly cause: Cause<Failure>;
  readonly command: RuntimeCommand<Event>;
  readonly index: number;
  readonly phase: "model" | "execution" | "observation" | "inspection" | "assertion";
  readonly prefix: readonly Array<RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed>>;
}> {
  constructor<Failure = unknown, Model = unknown, Expected = unknown, State = unknown, Event = unknown, Error = unknown, Output = unknown, Observed = unknown>(args: {
    readonly attempted: RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed> | undefined;
    readonly cause: Cause<Failure>;
    readonly command: RuntimeCommand<Event>;
    readonly index: number;
    readonly phase: "model" | "execution" | "observation" | "inspection" | "assertion";
    readonly prefix: readonly Array<RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed>>;
  });
  readonly _tag: "MachineTestRuntimeCommandFailure";
  readonly ~effect/Effect: Variance<never, RuntimeCommandFailure<Failure, Model, Expected, State, Event, Error, Output, Observed>, 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 attempted: RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed> | undefined;
  cause: Cause<Failure>;
  readonly command: RuntimeCommand<Event>;
  readonly index: number;
  message: string;
  name: string;
  readonly phase: "model" | "execution" | "observation" | "inspection" | "assertion";
  readonly prefix: readonly Array<RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed>>;
  stack?: string;
  [iterator](): EffectIterator<Effect<never, RuntimeCommandFailure<Failure, Model, Expected, State, Event, Error, Output, Observed>, 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;
}

A typed command-model failure retaining the successfully checked prefix.

Since v0.4.0
#

RuntimeInvariantError

class
Source 
declare class RuntimeInvariantError<M extends AnyMachine = AnyMachine> extends YieldableError<this> & {
  readonly _tag: "MachineTestRuntimeInvariantError";
} & Readonly<{
  readonly report: RuntimeInvariantReport;
  readonly transcript: RuntimeInvariantTranscript<M>;
  readonly violations: readonly Array<RuntimeInvariantViolation<M>>;
}> {
  constructor<M extends Any = Any>(args: {
    readonly report: RuntimeInvariantReport;
    readonly transcript: RuntimeInvariantTranscript<M>;
    readonly violations: readonly Array<RuntimeInvariantViolation<M>>;
  });
  readonly _tag: "MachineTestRuntimeInvariantError";
  readonly ~effect/Effect: Variance<never, RuntimeInvariantError<M>, 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 report: RuntimeInvariantReport;
  stack?: string;
  readonly transcript: RuntimeInvariantTranscript<M>;
  readonly violations: readonly Array<RuntimeInvariantViolation<M>>;
  [iterator](): EffectIterator<Effect<never, RuntimeInvariantError<M>, 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;
}

All violations found in one causal runtime transcript.

Since v0.4.0
#

RuntimeObservationError

class
Source 
declare class RuntimeObservationError extends YieldableError<this> & {
  readonly _tag: "MachineTestRuntimeObservationError";
} & Readonly<{
  readonly index: number;
  readonly message: string;
  readonly reason: "ended" | "timeout";
  readonly synchronization: "Until" | "Next";
}> {
  constructor(args: {
    readonly index: number;
    readonly message: string;
    readonly reason: "ended" | "timeout";
    readonly synchronization: "Until" | "Next";
  });
  readonly _tag: "MachineTestRuntimeObservationError";
  readonly ~effect/Effect: Variance<never, RuntimeObservationError, 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 index: number;
  message: string;
  name: string;
  readonly reason: "ended" | "timeout";
  stack?: string;
  readonly synchronization: "Until" | "Next";
  [iterator](): EffectIterator<Effect<never, RuntimeObservationError, 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;
}

Failure raised when an expected public change stream observation is absent.

Since v0.4.0
#

VerificationError

class
Source 
declare class VerificationError extends YieldableError<this> & {
  readonly _tag: "MachineTestVerificationError";
} & Readonly<{
  readonly violations: readonly Array<VerificationViolation>;
}> {
  constructor(args: {
    readonly violations: readonly Array<VerificationViolation>;
  });
  readonly _tag: "MachineTestVerificationError";
  readonly ~effect/Effect: Variance<never, VerificationError, 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;
  readonly violations: readonly Array<VerificationViolation>;
  [iterator](): EffectIterator<Effect<never, VerificationError, 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;
}

All violations found while checking one trace.

Since v0.4.0

Exploration

17
#

assertReachable

variable
Source 
declare const assertReachable: <M extends AnyMachine, Key extends ExplorationKey>(exploration: Exploration<M, Key>, name: string, predicate: ExplorationPredicate<M, Key>) => Effect.Effect<ExplorationNode<M, Key>, internal.ReachabilityError<M, Key>>

Requires a matching state and returns its shortest witness.

A truncated exploration without a witness fails as inconclusive rather than claiming the state is unreachable.

Since v0.4.0
#

assertUnreachable

variable
Source 
declare const assertUnreachable: <M extends AnyMachine, Key extends ExplorationKey>(exploration: Exploration<M, Key>, name: string, predicate: ExplorationPredicate<M, Key>) => Effect.Effect<void, internal.ReachabilityError<M, Key>>

Requires that no explored state matches a predicate.

This assertion succeeds only for a complete exploration. A truncated result without a witness fails as inconclusive.

Since v0.4.0
#

Exploration

interface
Source 
interface Exploration<M extends AnyMachine, Key extends ExplorationKey = ExplorationKey> {
  readonly completeness: ExplorationCompleteness<M, Key>;
  readonly graph: DirectedGraph<ExplorationNode<M, Key>, ExplorationEdge<M>>;
  readonly limits: ResolvedExplorationLimits;
  readonly nodes: readonly Array<ExplorationNode<M, Key>>;
  readonly nodesByKey: ReadonlyMap<Key, number>;
  readonly start: number;
  readonly stats: ExplorationStats;
}

A bounded logical state graph and its shortest-path evidence.

Since v0.4.0
#

ExplorationCompleteness

type
Source 
type ExplorationCompleteness<M extends AnyMachine, Key extends ExplorationKey = ExplorationKey> = {
  readonly _tag: "Complete";
} | {
  readonly _tag: "Truncated";
  readonly frontier: ReadonlyArray<ExplorationFrontier<M, Key>>;
  readonly reasons: ReadonlyArray<"depth" | "states" | "transitions">;
}

Honest completeness status for the supplied event representatives and state key abstraction.

Since v0.4.0
#

ExplorationEdge

interface
Source 
interface ExplorationEdge<M extends AnyMachine> {
  readonly discovered: boolean;
  readonly event: InputEvent<M>;
  readonly step: TraceStep<M>;
}

One concretely planned public event in the exploration graph.

Since v0.4.0
#

ExplorationFrontier

type
Source 
type ExplorationFrontier<M extends AnyMachine, Key extends ExplorationKey = ExplorationKey> = {
  readonly _tag: "DepthLimit";
  readonly event: Machine.Machine.InputEvent<M>;
  readonly source: Key;
  readonly trace: Trace<M>;
} | {
  readonly _tag: "StateLimit";
  readonly event: Machine.Machine.InputEvent<M>;
  readonly source: Key;
  readonly target: Key;
  readonly targetTrace: Trace<M>;
  readonly trace: Trace<M>;
} | {
  readonly _tag: "TransitionLimit";
  readonly event: Machine.Machine.InputEvent<M>;
  readonly source: Key;
  readonly trace: Trace<M>;
}

One boundary that could not be explored because a hard limit was reached.

Since v0.4.0
#

ExplorationKey

type
Source 
type ExplorationKey = PropertyKey

User-defined identity for a logical exploration state.

Equal keys deliberately collapse snapshots into one explored state. The key therefore defines both finiteness and the semantic precision of an exploration.

Since v0.4.0
#

ExplorationLimits

interface
Source 
interface ExplorationLimits {
  readonly maxDepth?: number;
  readonly maxStates?: number;
  readonly maxTransitions?: number;
}

Hard bounds for one exploration.

Defaults are 20 public events, 1,000 states, and 10,000 planned transitions. A limit never makes an incomplete result appear exhaustive.

Since v0.4.0
#

ExplorationNode

interface
Source 
interface ExplorationNode<M extends AnyMachine, Key extends ExplorationKey = ExplorationKey> extends ExplorationStateContext<M> {
  readonly configuration: readonly Array<StatePath<M>>;
  readonly depth: number;
  readonly key: Key;
  readonly machine: M;
  readonly snapshot: Snapshot<States<M>>;
  readonly trace: Trace<M>;
}

One logical state discovered by breadth-first exploration.

trace is the first, and therefore shortest, trace that reached key.

Since v0.4.0
#

ExplorationPredicate

type
Source 
type ExplorationPredicate<M extends AnyMachine, Key extends ExplorationKey = ExplorationKey> = (node: ExplorationNode<M, Key>) => boolean

A predicate over one explored logical state.

Since v0.4.0
#

ExplorationStateContext

interface
Source 
interface ExplorationStateContext<M extends AnyMachine> {
  readonly configuration: readonly Array<StatePath<M>>;
  readonly depth: number;
  readonly machine: M;
  readonly snapshot: Snapshot<States<M>>;
  readonly trace: Trace<M>;
}

Evidence available while assigning a state key.

Since v0.4.0
#

ExplorationStats

interface
Source 
interface ExplorationStats {
  readonly maxDepth: number;
  readonly plannedTransitions: number;
  readonly retainedEdges: number;
  readonly states: number;
}

Deterministic breadth-first exploration counts.

Since v0.4.0
#

explore

variable
Source 
declare const explore: <M extends AnyMachine, Key extends ExplorationKey>(machine: ReadyMachine<M>, options: ExploreOptions<M, Key>) => Effect.Effect<Exploration<M, Key>, RunFailure<RunError<M>, M> | internal.InvariantError<M>, RunServices<M>>

Explores the bounded logical state graph in breadth-first order.

Invariants are checked against startup and every concretely planned edge, so a failure retains a shortest discovered counterexample. Staged actions and runtime activities are not executed.

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

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

const explored = MachineTest.explore(machine, {
  events: ({ snapshot }) => snapshot.value.value < 2 ? [new Increment({})] : [],
  stateKey: ({ snapshot }) => snapshot.value.value
})
Since v0.4.0
#

ExploreOptions

type
Source 
type ExploreOptions<M extends AnyMachine, Key extends ExplorationKey = ExplorationKey> = ExploreOptionsBase<M, Key> & Machine.Machine.Input<M> extends typeof Schema.Void ? {
  readonly input?: never;
} : {
  readonly input: InputValue<M>;
}

Configuration for bounded planner exploration.

Event representatives may depend on the current state. Exploration is exhaustive only relative to those representatives and the equivalence relation defined by stateKey.

Since v0.4.0
#

findShortest

variable
Source 
declare const findShortest: <M extends AnyMachine, Key extends ExplorationKey>(exploration: Exploration<M, Key>, predicate: ExplorationPredicate<M, Key>) => ExplorationNode<M, Key> | undefined

Finds the first, and therefore shortest, explored state matching a predicate.

Since v0.4.0
#

ReachabilityFailure

type
Source 
type ReachabilityFailure = "NotFound" | "UnexpectedMatch" | "Inconclusive"

Why a reachability assertion failed.

Since v0.4.0
#

ResolvedExplorationLimits

interface
Source 
interface ResolvedExplorationLimits {
  readonly maxDepth: number;
  readonly maxStates: number;
  readonly maxTransitions: number;
}

Resolved bounds retained by an exploration result.

Since v0.4.0

Formatting

4
#

formatCausalTranscript

function
Source 
declare function formatCausalTranscript(value: CausalRuntimeTranscript<any, any, any, any, any, any> | CausalRuntimeCommandFailure<any, any, any, any, any, any, any>): string

Formats a causal runtime transcript or failure as replayable line-oriented evidence, including exact probe steps and explicit asynchronous observations.

Since v0.4.0
#

formatEnqueuedTranscript

function
Source 
declare function formatEnqueuedTranscript(value: RuntimeTranscript<any, any, any, any, any, any, any> | RuntimeCommandFailure<any, any, any, any, any, any, any, any>): string

Formats a runtime transcript or failure as replayable line-oriented evidence.

Since v0.4.0
#

formatRuntimeTranscript

variable
Source 
declare const formatRuntimeTranscript: typeof formatEnqueuedTranscript

Compatibility alias for enqueue-oriented transcript formatting.

Since v0.4.0
#

formatTrace

variable
Source 
declare const formatTrace: <M extends AnyMachine, Cause>(trace: Trace<M> | RunFailure<Cause, M>) => string

Formats a trace as deterministic, line-oriented counterexample evidence.

Object keys and map/set entries are canonicalized. Deferred effects are represented by counts so formatting never evaluates or inspects actions. Failures include their original cause and every available successful prefix.

Since v0.4.0

Invariants

25
#

Invariant

type
Source 
type Invariant<M extends AnyMachine> = StateInvariant<M> | StepInvariant<M> | TraceInvariant<M>

A user-defined semantic property over a planner trace.

Since v0.4.0
#

InvariantBuilder

interface
Source 
interface InvariantBuilder<M extends AnyMachine> {
  readonly state: (name: string, check: (context: StateInvariantContext<M>) => InvariantOutcome, options?: StateInvariantOptions<M>) => StateInvariant<M>;
  readonly step: (name: string, check: (context: StepInvariantContext<M>) => InvariantOutcome, options?: InvariantOptions<StepInvariantContext<M>>) => StepInvariant<M>;
  readonly trace: (name: string, check: (context: TraceInvariantContext<M>) => InvariantOutcome, options?: InvariantOptions<TraceInvariantContext<M>>) => TraceInvariant<M>;
}

Machine-bound invariant constructors with complete contextual inference.

Since v0.4.0
#

InvariantCheckResult

interface
Source 
interface InvariantCheckResult {
  readonly failures: number;
  readonly invariant: string;
  readonly observations: number;
  readonly scope: InvariantScope;
  readonly status: InvariantStatus;
}

Aggregate result for one invariant.

Since v0.4.0
#

InvariantOptions

interface
Source 
interface InvariantOptions<Context> {
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: Context) => boolean;
}

Controls conditional invariant evaluation and optional non-vacuity checks.

A condition that never matches is reported as untested. Set require.minObservations when that must fail the check instead.

Since v0.4.0
#

InvariantOutcome

type
Source 
type InvariantOutcome = boolean | string

The result of evaluating one semantic invariant.

true passes, false produces a default failure message, and a string fails with that string as its counterexample explanation.

Since v0.4.0
#

InvariantReport

interface
Source 
interface InvariantReport {
  readonly checks: readonly Array<InvariantCheckResult>;
}

Aggregate result for all checked invariants.

Since v0.4.0
#

InvariantScope

type
Source 
type InvariantScope = "state" | "step" | "trace"

The scope of a semantic invariant.

Since v0.4.0
#

InvariantStatus

type
Source 
type InvariantStatus = "passed" | "failed" | "untested" | "insufficient"

Result status for one invariant.

untested is non-failing unless the invariant declares a minimum number of observations, in which case it becomes insufficient.

Since v0.4.0
#

InvariantViolation

interface
Source 
interface InvariantViolation<M extends AnyMachine = AnyMachine> {
  readonly configuration?: readonly Array<StatePath<M>>;
  readonly event?: InitialEvent | Event<M>;
  readonly eventIndex: number | undefined;
  readonly invariant: string;
  readonly kind: "predicate" | "observations";
  readonly message: string;
  readonly microstepIndex?: number;
  readonly observationIndex?: number;
  readonly phase?: StateObservation;
  readonly scope: InvariantScope;
}

One semantic invariant violation with its precise trace location.

Since v0.4.0
#

RuntimeCommandInvariant

interface
Source 
interface RuntimeCommandInvariant<M extends AnyMachine> extends InvariantOptions<RuntimeCommandInvariantContext<M>> {
  readonly _tag: "RuntimeCommandInvariant";
  readonly check: (context: RuntimeCommandInvariantContext<M>) => InvariantOutcome;
  readonly name: string;
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: RuntimeCommandInvariantContext) => boolean;
}

A semantic property checked after every completed causal command.

Since v0.4.0
#

RuntimeInvariant

type
Source 
type RuntimeInvariant<M extends AnyMachine> = RuntimeSnapshotInvariant<M> | RuntimeCommandInvariant<M> | RuntimeTranscriptInvariant<M>

A user-defined semantic property over retained live runtime evidence.

Since v0.4.0
#

RuntimeInvariantScope

type
Source 
type RuntimeInvariantScope = "snapshot" | "command" | "transcript"

Scope of a runtime invariant.

Since v0.4.0
#

RuntimeSnapshotInvariant

interface
Source 
interface RuntimeSnapshotInvariant<M extends AnyMachine> extends InvariantOptions<RuntimeSnapshotInvariantContext<M>> {
  readonly _tag: "RuntimeSnapshotInvariant";
  readonly check: (context: RuntimeSnapshotInvariantContext<M>) => InvariantOutcome;
  readonly name: string;
  readonly observe: RuntimeSnapshotObservationMode;
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: RuntimeSnapshotInvariantContext) => boolean;
}

A semantic property checked against selected live runtime snapshots.

Since v0.4.0
#

RuntimeSnapshotObservation

type
Source 
type RuntimeSnapshotObservation = "initial" | "command" | "awaited" | "final"

The semantic location of one retained runtime snapshot.

Since v0.4.0
#

RuntimeSnapshotObservationMode

type
Source 
type RuntimeSnapshotObservationMode = "settled" | "awaited" | "all" | "final"

The runtime snapshots selected by one snapshot invariant.

Since v0.4.0
#

RuntimeTranscriptInvariant

interface
Source 
interface RuntimeTranscriptInvariant<M extends AnyMachine> extends InvariantOptions<RuntimeTranscriptInvariantContext<M>> {
  readonly _tag: "RuntimeTranscriptInvariant";
  readonly check: (context: RuntimeTranscriptInvariantContext<M>) => InvariantOutcome;
  readonly name: string;
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: RuntimeTranscriptInvariantContext) => boolean;
}

A semantic property checked once against a complete causal transcript.

Since v0.4.0
#

StateInvariant

interface
Source 
interface StateInvariant<M extends AnyMachine> extends InvariantOptions<StateInvariantContext<M>> {
  readonly _tag: "StateInvariant";
  readonly check: (context: StateInvariantContext<M>) => InvariantOutcome;
  readonly name: string;
  readonly observe: StateObservationMode;
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: StateInvariantContext) => boolean;
}

A semantic property checked against selected state observations.

Since v0.4.0
#

StateInvariantContext

interface
Source 
interface StateInvariantContext<M extends AnyMachine> {
  readonly configuration: readonly Array<StatePath<M>>;
  readonly event: InitialEvent | Event<M> | undefined;
  readonly eventIndex: number | undefined;
  readonly machine: M;
  readonly microstepIndex: number | undefined;
  readonly observationIndex: number;
  readonly phase: StateObservation;
  readonly snapshot: Snapshot<States<M>>;
  readonly trace: Trace<M>;
}

Evidence passed to a state invariant.

Since v0.4.0
#

StateInvariantOptions

interface
Source 
interface StateInvariantOptions<M extends AnyMachine> extends InvariantOptions<StateInvariantContext<M>> {
  readonly observe?: StateObservationMode;
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: StateInvariantContext) => boolean;
}

Options for a state invariant.

Since v0.4.0
#

StateObservation

type
Source 
type StateObservation = "initial" | "event" | "microstep" | "final"

The semantic location of one state observation.

Since v0.4.0
#

StateObservationMode

type
Source 
type StateObservationMode = "settled" | "microsteps" | "all" | "final"

The portions of a trace that a state invariant may observe.

  • settled observes startup and the state after every public event.
  • microsteps observes every internal microstep.
  • all observes both settled states and microsteps.
  • final observes only the final state.
Since v0.4.0
#

StepInvariant

interface
Source 
interface StepInvariant<M extends AnyMachine> extends InvariantOptions<StepInvariantContext<M>> {
  readonly _tag: "StepInvariant";
  readonly check: (context: StepInvariantContext<M>) => InvariantOutcome;
  readonly name: string;
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: StepInvariantContext) => boolean;
}

A semantic property checked after every public event.

Since v0.4.0
#

StepInvariantContext

interface
Source 
interface StepInvariantContext<M extends AnyMachine> {
  readonly after: Snapshot<States<M>>;
  readonly afterConfiguration: readonly Array<StatePath<M>>;
  readonly before: Snapshot<States<M>>;
  readonly beforeConfiguration: readonly Array<StatePath<M>>;
  readonly event: InputEvent<M>;
  readonly index: number;
  readonly machine: M;
  readonly plan: EventPlan<M>;
  readonly step: TraceStep<M>;
  readonly trace: Trace<M>;
}

Evidence passed to an invariant for one public event step.

Since v0.4.0
#

TraceInvariant

interface
Source 
interface TraceInvariant<M extends AnyMachine> extends InvariantOptions<TraceInvariantContext<M>> {
  readonly _tag: "TraceInvariant";
  readonly check: (context: TraceInvariantContext<M>) => InvariantOutcome;
  readonly name: string;
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: TraceInvariantContext) => boolean;
}

A semantic property checked once against a complete trace.

Since v0.4.0
#

TraceInvariantContext

interface
Source 
interface TraceInvariantContext<M extends AnyMachine> {
  readonly machine: M;
  readonly trace: Trace<M>;
}

Evidence passed to a whole-trace invariant.

Since v0.4.0

Models

112
#

CausalRuntimeAssertionContext

interface
Source 
interface CausalRuntimeAssertionContext<M extends AnyMachine, Model, Expected, Error, Output, Observed> extends CausalRuntimeInspectionContext<M, Error, Output> {
  readonly actual: CausalRuntimeCommandActual<M, Error, Output, Observed>;
  readonly awaited: readonly Array<RuntimeSnapshot<Snapshot<States<M>>, Error, Output>>;
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly expected: Expected;
  readonly index: number;
  readonly model: Model;
  readonly probe: Probe<M, Error, Output>;
  readonly ref: MachineRef<Snapshot<States<M>>, InputEvent<M>, Error, Output>;
  readonly result: CausalRuntimeCommandResult<M>;
  readonly snapshot: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
}

Context supplied to a causal reference-model assertion.

Since v0.4.0
#

CausalRuntimeCommandActual

interface
Source 
interface CausalRuntimeCommandActual<M extends AnyMachine, Error, Output, Observed> {
  readonly awaited: readonly Array<RuntimeSnapshot<Snapshot<States<M>>, Error, Output>>;
  readonly inspected: Observed | undefined;
  readonly result: CausalRuntimeCommandResult<M>;
  readonly snapshot: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
}

Actual causal evidence made available to inspection and assertions.

Since v0.4.0
#

CausalRuntimeCommandRecord

interface
Source 
interface CausalRuntimeCommandRecord<M extends AnyMachine, Model, Expected, Error, Output, Observed> {
  readonly actual: CausalRuntimeCommandActual<M, Error, Output, Observed>;
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly expected: Expected;
  readonly index: number;
  readonly model: Model;
}

One successfully checked causal command.

Since v0.4.0
#

CausalRuntimeCommandResult

type
Source 
type CausalRuntimeCommandResult<M extends AnyMachine> = {
  readonly _tag: "SendProcessed";
  readonly step: ProbeStep<M>;
} | {
  readonly _tag: "SendRejected";
  readonly error: Machine.StoppedError;
} | {
  readonly _tag: "ClockAdvanced";
} | {
  readonly _tag: "Stopped";
} | {
  readonly _tag: "Checkpoint";
}

Exact execution result for one causal runtime command.

Since v0.4.0
#

CausalRuntimeEvidence

interface
Source 
interface CausalRuntimeEvidence<M extends AnyMachine, Error, Output> {
  readonly commands: readonly Array<RuntimeCommand<InputEvent<M>>>;
  readonly final: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
  readonly initial: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
  readonly records: readonly Array<CausalRuntimeEvidenceRecord<M, Error, Output>>;
}

The model-independent evidence shared by causal command transcripts.

Since v0.4.0
#

CausalRuntimeEvidenceRecord

interface
Source 
interface CausalRuntimeEvidenceRecord<M extends AnyMachine, Error, Output> {
  readonly actual: CausalRuntimeCommandActual<M, Error, Output, unknown>;
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly index: number;
}

A causal command record projected independently of a reference model.

Since v0.4.0
#

CausalRuntimeInspectionContext

interface
Source 
interface CausalRuntimeInspectionContext<M extends AnyMachine, Error, Output> {
  readonly awaited: readonly Array<RuntimeSnapshot<Snapshot<States<M>>, Error, Output>>;
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly index: number;
  readonly probe: Probe<M, Error, Output>;
  readonly ref: MachineRef<Snapshot<States<M>>, InputEvent<M>, Error, Output>;
  readonly result: CausalRuntimeCommandResult<M>;
  readonly snapshot: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
}

Context supplied to a custom causal runtime inspection effect.

Since v0.4.0
#

CausalRuntimeModelOptions

interface
Source 
interface CausalRuntimeModelOptions<M extends AnyMachine, Model, Expected, Error, Output, Observed = never, ModelError = never, ModelServices = never, InspectionError = never, InspectionServices = never, AssertionError = never, AssertionServices = never> {
  readonly assert: (context: CausalRuntimeAssertionContext<M, Model, Expected, Error, Output, Observed>) => Effect<void, AssertionError, AssertionServices>;
  readonly initialModel: Model;
  readonly inspect?: (context: CausalRuntimeInspectionContext<M, Error, Output>) => Effect<Observed, InspectionError, InspectionServices>;
  readonly observationTimeout?: Input;
  readonly transition: (model: Model, command: RuntimeCommand<InputEvent<M>>, index: number) => Effect<CausalRuntimeModelStep<Model, Expected, Snapshot<States<M>>, Error, Output>, ModelError, ModelServices>;
}

Configuration for causally checking runtime commands against a reference model.

Since v0.4.0
#

CausalRuntimeModelStep

interface
Source 
interface CausalRuntimeModelStep<Model, Expected, State, Error, Output> {
  readonly await?: RuntimeAwait<State, Error, Output>;
  readonly expected: Expected;
  readonly model: Model;
}

The pure/reference-model result for one causally executed command.

await is only for asynchronous behavior after the command boundary. A submitted Send always completes its exact managed macrostep first.

Since v0.4.0
#

CausalRuntimeTranscript

interface
Source 
interface CausalRuntimeTranscript<M extends AnyMachine, Model, Expected, Error, Output, Observed> {
  readonly commands: readonly Array<RuntimeCommand<InputEvent<M>>>;
  readonly final: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
  readonly finalModel: Model;
  readonly initial: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
  readonly records: readonly Array<CausalRuntimeCommandRecord<M, Model, Expected, Error, Output, Observed>>;
}

A complete causally executed command-model transcript.

Every accepted send in records completed its managed macrostep. This does not claim that later timer, invoke, or child work has completed unless the corresponding model step requested probe.await.until.

Since v0.4.0
#

CausalVerificationAwaitContext

interface
Source 
interface CausalVerificationAwaitContext<M extends AnyMachine, Error, Output> {
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly index: number;
  readonly probe: Probe<M, Error, Output>;
}

Context used to select additional asynchronous observation for a law-oriented command run.

Since v0.4.0
#

CausalVerificationOptions

interface
Source 
interface CausalVerificationOptions<M extends AnyMachine, Error, Output> {
  readonly await?: (context: CausalVerificationAwaitContext<M, Error, Output>) => RuntimeAwait<Snapshot<States<M>>, Error, Output>;
  readonly invariants: readonly Array<RuntimeInvariant<M>>;
  readonly observationTimeout?: Input;
}

Configuration for causal verification without a separate reference model.

Since v0.4.0
#

CausalVerificationTranscript

interface
Source 
interface CausalVerificationTranscript<M extends AnyMachine, Error, Output> extends CausalRuntimeEvidence<M, Error, Output> {
  readonly commands: readonly Array<RuntimeCommand<InputEvent<M>>>;
  readonly final: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
  readonly initial: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>;
  readonly records: readonly Array<CausalRuntimeEvidenceRecord<M, Error, Output>>;
}

A law-oriented causal transcript without dummy model or expected fields.

Since v0.4.0
#

CompletionCoverageEvidence

interface
Source 
interface CompletionCoverageEvidence<Path extends string = string> {
  readonly donePlans: number;
  readonly paths: readonly Array<Path>;
  readonly recordObservations: number;
}

Directly observed completion evidence.

Since v0.4.0
#

Coverage

interface
Source 
interface Coverage<M extends AnyMachine> {
  readonly completion: CompletionCoverageEvidence<StatePath<M>>;
  readonly events: EventCoverage<TagOf<InputEvents<M>[number]>>;
  readonly history: HistoryCoverageEvidence<StateNodePath<M>>;
  readonly logicalConfigurations: LogicalConfigurationCoverage;
  readonly microsteps: MicrostepCoverageEvidence;
  readonly scenarios: ScenarioCoverage;
  readonly startup: {
    readonly traces: number;
    readonly withMicrosteps: number;
  };
  readonly states: StateCoverage<StatePath<M>>;
  readonly transitions: CoverageSummary<TransitionCoverageItem<StateNodePath<M>, TagOf<Events<M>[number]>, StateNodePath<M>>>;
}

Coverage computed only from observable machine definitions and planner traces.

Since v0.4.0
#

CoverageSummary

interface
Source 
interface CoverageSummary<Item> {
  readonly hit: number;
  readonly hits: readonly Array<Item>;
  readonly misses: readonly Array<Item>;
  readonly missing: number;
  readonly total: number;
}

A deterministic hit/miss summary for a finite set declared by a machine.

Since v0.4.0
#

EnqueuedRuntimeAssertionContext

type
Source 
type EnqueuedRuntimeAssertionContext<Model, Expected, State, Event, Error, Output, Observed> = RuntimeAssertionContext<Model, Expected, State, Event, Error, Output, Observed>

Enqueue-oriented name for runtime assertion context.

Since v0.4.0
#

EnqueuedRuntimeCommandActual

type
Source 
type EnqueuedRuntimeCommandActual<State, Error, Output, Observed> = RuntimeCommandActual<State, Error, Output, Observed>

Enqueue-oriented name for actual runtime command evidence.

Since v0.4.0
#

EnqueuedRuntimeCommandRecord

type
Source 
type EnqueuedRuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed> = RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed>

Enqueue-oriented name for a checked runtime command record.

Since v0.4.0
#

EnqueuedRuntimeInspectionContext

type
Source 
type EnqueuedRuntimeInspectionContext<State, Event, Error, Output> = RuntimeInspectionContext<State, Event, Error, Output>

Enqueue-oriented name for runtime inspection context.

Since v0.4.0
#

EnqueuedRuntimeModelOptions

type
Source 
type EnqueuedRuntimeModelOptions<Model, Expected, State, Event, Error, Output, Observed = never, ModelError = never, ModelServices = never, InspectionError = never, InspectionServices = never, AssertionError = never, AssertionServices = never> = RuntimeModelOptions<Model, Expected, State, Event, Error, Output, Observed, ModelError, ModelServices, InspectionError, InspectionServices, AssertionError, AssertionServices>

Enqueue-oriented options for a runtime reference model.

Since v0.4.0
#

EnqueuedRuntimeModelStep

type
Source 
type EnqueuedRuntimeModelStep<Model, Expected, State, Error, Output> = RuntimeModelStep<Model, Expected, State, Error, Output>

Explicit name for the model step used by the enqueue-oriented command runner. The RuntimeModelStep name remains as a compatibility alias.

Since v0.4.0
#

EnqueuedRuntimeTranscript

type
Source 
type EnqueuedRuntimeTranscript<Model, Expected, State, Event, Error, Output, Observed> = RuntimeTranscript<Model, Expected, State, Event, Error, Output, Observed>

Enqueue-oriented name for a complete runtime transcript.

Since v0.4.0
#

EventCoverage

type
Source 
type EventCoverage<Tag extends PropertyKey = PropertyKey> = {
  readonly available: true;
  readonly diagnostics: readonly [];
  readonly hit: number;
  readonly hits: ReadonlyArray<EventCoverageItem<Tag>>;
  readonly misses: ReadonlyArray<EventCoverageItem<Tag>>;
  readonly missing: number;
  readonly observed: ReadonlyArray<EventCoverageItem<Tag>>;
  readonly total: number;
} | {
  readonly available: false;
  readonly diagnostics: ReadonlyArray<{
    readonly message: string;
    readonly schemaIndex: number;
  }>;
  readonly hit: undefined;
  readonly hits: undefined;
  readonly misses: undefined;
  readonly missing: undefined;
  readonly observed: ReadonlyArray<EventCoverageItem<Tag>>;
  readonly total: undefined;
}

Public event coverage, including events that no transition retained.

Since v0.4.0
#

EventCoverageItem

interface
Source 
interface EventCoverageItem<Tag extends PropertyKey = PropertyKey> {
  readonly count: number;
  readonly tag: Tag;
}

One public event tag declared by the machine.

Since v0.4.0
#

EventPlan

type
Source 
type EventPlan<M extends AnyMachine> = {
  readonly commands: ReadonlyArray<Machine.Command>;
  readonly emittedEvents: ReadonlyArray<Machine.Machine.Emit<M>>;
  readonly microsteps: ReadonlyArray<Microstep<M>>;
  readonly next: Machine.Machine.Snapshot<Machine.Machine.States<M>>;
} & PlanCompletion<M>

The complete data returned while planning one public event.

Since v0.4.0
#

FiniteAtomicState

interface
Source 
interface FiniteAtomicState {
  readonly _tag: "Atomic";
  readonly key: string;
  readonly value: number;
}

An atomic state in a finite generated model.

Since v0.4.0
#

FiniteAutomaticTransition

type
Source 
type FiniteAutomaticTransition = FiniteTransitionBase & {
  readonly trigger: Exclude<FiniteTransitionTrigger, {
    readonly type: "event";
  }>;
}

An always or completion transition. Automatic transitions deliberately omit the event-only reentry option.

Since v0.4.0
#

FiniteCompoundState

interface
Source 
interface FiniteCompoundState {
  readonly _tag: "Compound";
  readonly initial: string;
  readonly key: string;
  readonly states: readonly Array<FiniteState>;
  readonly value: number;
}

A compound state in a finite generated model.

Since v0.4.0
#

FiniteEventTransition

type
Source 
type FiniteEventTransition = FiniteTransitionBase & {
  readonly reenter: boolean;
  readonly trigger: Extract<FiniteTransitionTrigger, {
    readonly type: "event";
  }>;
}

A public event transition may explicitly request source reentry.

Since v0.4.0
#

FiniteFinalState

interface
Source 
interface FiniteFinalState {
  readonly _tag: "Final";
  readonly key: string;
  readonly output: string;
  readonly value: number;
}

A final state in a finite generated model.

Since v0.4.0
#

FiniteHistoryMutation

interface
Source 
interface FiniteHistoryMutation {
  readonly event: string;
  readonly source: string;
  readonly target: string;
  readonly value: number;
}

The exact generated transition that changes a value before history capture.

The source and target are the same active atomic state. value is distinct from that state's generated default value.

Since v0.4.0
#

FiniteHistoryScenario

interface
Source 
interface FiniteHistoryScenario {
  readonly events: readonly [string, string, string];
  readonly history: string;
  readonly historyType: "shallow" | "deep";
  readonly leave: FiniteHistoryTransfer;
  readonly mutation: FiniteHistoryMutation;
  readonly owner: string;
  readonly resume: FiniteHistoryTransfer;
}

A replayable value-mutation, capture, and restoration witness generated for one history pseudo-state.

events is exactly [mutation.event, leave.event, resume.event]. Replaying it changes a schema-valid atomic value, exits the history owner through its root, and restores the remembered non-default value through history.

Since v0.4.0
#

FiniteHistoryState

interface
Source 
interface FiniteHistoryState {
  readonly _tag: "History";
  readonly fallback: string;
  readonly history: "shallow" | "deep";
  readonly key: string;
}

A shallow or deep history pseudo-state in a finite generated model.

History states never carry values, become active, or act as transition sources. fallback is a concrete descendant of the direct compound or parallel owner and is used only before that history register is captured.

Since v0.4.0
#

FiniteHistoryTransfer

interface
Source 
interface FiniteHistoryTransfer {
  readonly event: string;
  readonly source: string;
  readonly target: string;
}

One exact transition in a generated history witness.

Since v0.4.0
#

FiniteModel

interface
Source 
interface FiniteModel {
  readonly events: readonly Array<string>;
  readonly historyScenarios?: readonly Array<FiniteHistoryScenario>;
  readonly initial: string;
  readonly roots: readonly Array<FiniteState>;
  readonly transitions: readonly Array<FiniteTransition>;
}

A small immutable statechart model suitable for generation and shrinking.

State paths use dot-separated state keys. Transitions are unique by source/event pair. A transition may target any state under its source root, or a different root as a complete configuration.

Since v0.4.0
#

FiniteModelDiagnostics

interface
Source 
interface FiniteModelDiagnostics {
  readonly guarantees: {
    readonly acyclicAutomaticTransitions: true;
    readonly choiceInitialWitnesses: true;
    readonly choiceStates: true;
    readonly compoundOnly: false;
    readonly eventlessTransitions: true;
    readonly historyLeaveResumeSequences: true;
    readonly historyStates: true;
    readonly historyValueScenarios: true;
    readonly parallelStates: true;
    readonly shrinkPreservesValidity: true;
    readonly structurallyValid: true;
  };
  readonly limits: {
    readonly maxChildren: number;
    readonly maxChoiceStates: number;
    readonly maxDepth: number;
    readonly maxEvents: number;
    readonly maxHistoryStates: number;
    readonly maxParallelRegions: 2 | 3;
    readonly maxRoots: 1 | 2 | 3;
    readonly maxTransitions: number;
  };
}

Resolved limits and structural guarantees for a finite model arbitrary.

Since v0.4.0
#

FiniteModelOptions

interface
Source 
interface FiniteModelOptions {
  readonly maxChildren?: number;
  readonly maxChoiceStates?: number;
  readonly maxDepth?: number;
  readonly maxEvents?: number;
  readonly maxHistoryStates?: number;
  readonly maxParallelRegions?: 3 | 2;
  readonly maxRoots?: 1 | 3 | 2;
  readonly maxTransitions?: number;
}

Limits controlling finite model generation.

Since v0.4.0
#

FiniteModels

interface
Source 
interface FiniteModels {
  readonly arbitrary: Arbitrary<FiniteModel>;
  readonly diagnostics: FiniteModelDiagnostics;
}

A finite model arbitrary and the exact limits used to construct it.

Since v0.4.0
#

FiniteParallelState

interface
Source 
interface FiniteParallelState {
  readonly _tag: "Parallel";
  readonly key: string;
  readonly output: string;
  readonly states: readonly Array<FiniteState>;
  readonly value: number;
}

A parallel state in a finite generated model.

Every direct child is an orthogonal region and is active whenever the parallel state is active. The output is deterministic so completion can be compared without sharing executable callbacks with the reference model.

Since v0.4.0
#

FiniteState

type
Source 
type FiniteState = FiniteAtomicState | FiniteFinalState | FiniteCompoundState | FiniteParallelState | FiniteHistoryState | FiniteChoiceState

A finite model state.

Since v0.4.0
#

FiniteTransition

type
Source 
type FiniteTransition = FiniteEventTransition | FiniteAutomaticTransition

One deterministic event or automatic transition in a finite model.

Since v0.4.0
#

FiniteTransitionTrigger

type
Source 
type FiniteTransitionTrigger = {
  readonly event: string;
  readonly type: "event";
} | {
  readonly type: "always";
} | {
  readonly type: "done";
}

The single trigger representation used by generated and hand-authored finite transitions. Event, always, and completion registrations therefore share the same validation, compilation, and reference interpretation path.

Since v0.4.0
#

HistoryCoverageEvidence

interface
Source 
interface HistoryCoverageEvidence<Path extends string = string> {
  readonly recorded: readonly Array<{
    readonly modes: readonly Array<"shallow" | "deep">;
    readonly path: Path;
  }>;
  readonly recordObservations: number;
  readonly resolvedTargets: number;
  readonly targets: number;
}

Directly observed history records and history-target transitions.

Since v0.4.0
#

InitialPlan

type
Source 
type InitialPlan<M extends AnyMachine> = {
  readonly commands: ReadonlyArray<Machine.Command>;
  readonly emittedEvents: ReadonlyArray<Machine.Machine.Emit<M>>;
  readonly initialEntryPaths: ReadonlyArray<StatePath<M>>;
  readonly microsteps: ReadonlyArray<Microstep<M, Machine.Machine.InitialServices<M> | Machine.Machine.Services<M>>>;
  readonly startingState: Machine.Machine.Snapshot<Machine.Machine.States<M>>;
  readonly state: Machine.Machine.Snapshot<Machine.Machine.States<M>>;
} & PlanCompletion<M>

The complete data returned while planning machine startup.

Since v0.4.0
#

InitialTrace

interface
Source 
interface InitialTrace<M extends AnyMachine> {
  readonly configuration: readonly Array<StatePath<M>>;
  readonly initialEntryPaths: readonly Array<StatePath<M>>;
  readonly plan: InitialPlan<M>;
  readonly startingConfiguration: readonly Array<StatePath<M>>;
  readonly startingState: Snapshot<States<M>>;
}

Startup portion of an executable planner trace.

Since v0.4.0
#

LogicalConfigurationCoverage

interface
Source 
interface LogicalConfigurationCoverage {
  readonly hit: number;
  readonly identities: readonly Array<string>;
  readonly observations: number;
}

Trace-derived logical configuration counts. There is no claimed exhaustive total.

Since v0.4.0
#

Microstep

interface
Source 
interface Microstep<M extends AnyMachine, Requirements = Machine.Machine.Services<M>> {
  readonly changed: boolean;
  readonly commands: readonly Array<Command>;
  readonly emittedEvents: readonly Array<Emit<M>>;
  readonly entryPaths: readonly Array<string>;
  readonly event: InitialEvent | Event<M>;
  readonly exitPaths: readonly Array<string>;
  readonly next: Snapshot<States<M>>;
  readonly raisedEvents: readonly Array<Event<M>>;
  readonly transitions: readonly Array<RetainedTransition<StatePath<M>, TagOf<Events<M>[number]>, StateNodePath<M>>>;
}

One public planned microstep, including retained post-conflict transitions.

Since v0.4.0
#

MicrostepCoverageEvidence

interface
Source 
interface MicrostepCoverageEvidence {
  readonly alwaysTriggered: number;
  readonly changed: number;
  readonly choiceTriggered: number;
  readonly doneTriggered: number;
  readonly emitted: number;
  readonly eventTriggered: number;
  readonly raised: number;
  readonly targetless: number;
  readonly total: number;
}

Directly observed startup and microstep evidence.

Since v0.4.0
#

ModelVerificationField

type
Source 
type ModelVerificationField = `${ModelStateField}.${"activePaths" | "values" | "completions" | "history"}` | "event.tag" | "initial.startingConfiguration" | "initial.initialEntryPaths" | "initial.plan.initialEntryPaths" | "initial.configuration" | "initial.plan.microsteps" | "initial.plan.done" | "initial.plan.output" | "trace.steps.length" | "step.index" | "step.event" | "step.beforeConfiguration" | "step.plan.microsteps.length" | "microstep.event" | "microstep.transitions" | "microstep.exitPaths" | "microstep.entryPaths" | "microstep.changed" | "step.afterConfiguration" | "step.plan.done" | "step.plan.output" | "trace.finalConfiguration"

Stable semantic observation compared by the finite-model oracle.

Since v0.4.0
#

ModelVerificationLocation

interface
Source 
interface ModelVerificationLocation {
  readonly eventIndex?: number;
  readonly microstepIndex?: number;
  readonly phase: "final" | "event" | "initial";
}

Location of one planner/reference disagreement.

Since v0.4.0
#

ModelVerificationMismatch

interface
Source 
interface ModelVerificationMismatch {
  readonly actual: unknown;
  readonly expected: unknown;
  readonly field: ModelVerificationField;
  readonly location: ModelVerificationLocation;
  readonly message: string;
}

One structured semantic disagreement with the independent interpreter.

Since v0.4.0
#

ObservedGraph

interface
Source 
interface ObservedGraph<M extends AnyMachine> {
  readonly graph: DirectedGraph<ObservedGraphNode<M>, ObservedGraphEdge<M>>;
  readonly nodesById: ReadonlyMap<string, number>;
  readonly starts: readonly Array<number>;
  readonly startupSources: readonly Array<number>;
}

An Effect directed graph plus stable indexes useful to graph algorithms.

Since v0.4.0
#

ObservedGraphEdge

type
Source 
type ObservedGraphEdge<M extends AnyMachine> = {
  readonly _tag: "Startup";
  readonly completion: PlanCompletion<M>;
  readonly microsteps: ReadonlyArray<ObservedGraphMicrostep<M>>;
  readonly traceIndex: number;
} | {
  readonly _tag: "Event";
  readonly completion: PlanCompletion<M>;
  readonly event: Machine.Machine.InputEvent<M>;
  readonly eventIndex: number;
  readonly microsteps: ReadonlyArray<ObservedGraphMicrostep<M>>;
  readonly traceIndex: number;
}

A startup or public-event macrostep retained by the observed graph.

Since v0.4.0
#

ObservedGraphMicrostep

interface
Source 
interface ObservedGraphMicrostep<M extends AnyMachine> {
  readonly changed: boolean;
  readonly emittedEvents: readonly Array<Emit<M>>;
  readonly entryPaths: readonly Array<StatePath<M>>;
  readonly event: InitialEvent | Event<M>;
  readonly exitPaths: readonly Array<StatePath<M>>;
  readonly next: string;
  readonly raisedEvents: readonly Array<Event<M>>;
  readonly transitions: readonly Array<RetainedTransition<StatePath<M>, TagOf<Events<M>[number]>, StateNodePath<M>>>;
}

Retained evidence for one microstep inside an observed graph edge.

Since v0.4.0
#

ObservedGraphNode

interface
Source 
interface ObservedGraphNode<M extends AnyMachine> {
  readonly configuration: readonly Array<StatePath<M>>;
  readonly encoded: EncodedSnapshot;
  readonly id: string;
  readonly observations: ObservedGraphNodeObservations;
  readonly snapshot: Snapshot<States<M>>;
}

One full encoded logical snapshot stored in the observed Effect graph.

Since v0.4.0
#

ObservedGraphNodeObservations

interface
Source 
interface ObservedGraphNodeObservations {
  readonly event: number;
  readonly microstep: number;
  readonly startup: number;
  readonly total: number;
}

The observation roles summarized for one logical graph node.

Since v0.4.0
#

PlanCompletion

type
Source 
type PlanCompletion<M extends AnyMachine> = {
  readonly done: true;
  readonly output: Machine.Machine.Output<M>;
} | {
  readonly done: false;
  readonly output: undefined;
}

Completion information retained by an initial or event plan.

Since v0.4.0
#

PlannerRuntimeAgreementViolation

interface
Source 
interface PlannerRuntimeAgreementViolation<M extends AnyMachine = AnyMachine> {
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly commandIndex: number;
  readonly field: "commands" | "emittedEvents" | "planning" | "handled" | "configurationChanged" | "planNext" | "after" | "completion" | "microsteps";
  readonly message: string;
}

One disagreement between pure planning and a causally processed send.

Since v0.4.0
#

ReferenceCompletion

interface
Source 
interface ReferenceCompletion {
  readonly output: string;
  readonly path: string;
}

One output retained for an actively completed state.

Since v0.4.0
#

ReferenceHistoryRecord

interface
Source 
interface ReferenceHistoryRecord {
  readonly active: readonly Array<string>;
  readonly mode: "shallow" | "deep";
  readonly values: Readonly<Record<string, ReferenceStateValue>>;
}

One independently captured shallow or deep history register.

Since v0.4.0
#

ReferenceInitialStep

interface
Source 
interface ReferenceInitialStep {
  readonly done: boolean;
  readonly initialEntryPaths: readonly Array<string>;
  readonly microsteps: readonly Array<ReferenceMicrostep>;
  readonly output: string | undefined;
  readonly startingState: ReferenceState;
  readonly state: ReferenceState;
}

Startup semantics calculated without executing the real machine.

Since v0.4.0
#

ReferenceMicrostep

interface
Source 
interface ReferenceMicrostep {
  readonly changed: boolean;
  readonly entryPaths: readonly Array<string>;
  readonly event: string;
  readonly exitPaths: readonly Array<string>;
  readonly next: ReferenceState;
  readonly transitions: readonly Array<ReferenceTransition>;
}

The independently calculated planner microstep for one selected event.

Since v0.4.0
#

ReferenceState

interface
Source 
interface ReferenceState {
  readonly activePaths: readonly Array<string>;
  readonly completions: readonly Array<ReferenceCompletion>;
  readonly history: Readonly<Record<string, ReferenceHistoryRecord>>;
  readonly output: string | undefined;
  readonly status: "active" | "done";
  readonly values: Readonly<Record<string, ReferenceStateValue>>;
}

An independently interpreted finite-model configuration.

Since v0.4.0
#

ReferenceStateValue

interface
Source 
interface ReferenceStateValue {
  readonly _tag: string;
  readonly value: number;
}

The deterministic value assigned to one active finite-model state.

Since v0.4.0
#

ReferenceStep

interface
Source 
interface ReferenceStep {
  readonly after: ReferenceState;
  readonly before: ReferenceState;
  readonly done: boolean;
  readonly event: string;
  readonly index: number;
  readonly microsteps: readonly Array<ReferenceMicrostep>;
  readonly output: string | undefined;
}

One public event interpreted against a reference configuration.

Since v0.4.0
#

ReferenceTrace

interface
Source 
interface ReferenceTrace {
  readonly events: readonly Array<string>;
  readonly final: ReferenceState;
  readonly initial: ReferenceInitialStep;
  readonly steps: readonly Array<ReferenceStep>;
}

A complete, pure interpretation of a finite model and event sequence.

Since v0.4.0
#

ReferenceTransition

interface
Source 
interface ReferenceTransition {
  readonly reenter: boolean;
  readonly resolvedTarget: string | undefined;
  readonly source: string;
  readonly target: string | undefined;
  readonly trigger: {
    readonly event: string;
    readonly type: "event";
  } | {
    readonly type: "always";
  } | {
    readonly type: "done";
  } | {
    readonly type: "choice";
  };
}

One transition retained by the independent reference step.

Since v0.4.0
#

RunFailure

type
Source 
type RunFailure<Cause, M extends AnyMachine = AnyMachine> = {
  readonly _tag: "MachineTestRunFailure";
  readonly cause: Cause;
  readonly event: undefined;
  readonly eventIndex: undefined;
  readonly initial: undefined;
  readonly phase: "initial";
  readonly scenario: Scenario<M>;
  readonly steps: readonly [];
} | {
  readonly _tag: "MachineTestRunFailure";
  readonly cause: Cause;
  readonly event: Machine.Machine.InputEvent<M>;
  readonly eventIndex: number;
  readonly initial: InitialTrace<M>;
  readonly phase: "event";
  readonly scenario: Scenario<M>;
  readonly steps: ReadonlyArray<TraceStep<M>>;
}

A typed planning failure together with every successfully completed trace segment preceding it.

Since v0.4.0
#

RunServices

type
Source 
type RunServices<M extends AnyMachine> = IsAny<Machine.PlanningServices<Machine.Machine.InitialServices<M> | Machine.Machine.Services<M>>> extends true ? Machine.PlanningServices<Machine.Machine.InitialServices<M> | Machine.Machine.Services<M>> : never

Services required while planning a complete scenario.

Scenario execution delegates exclusively to the service-free planInitial and plan APIs. Invoke services and managed runtime capabilities belong to later execution, not synchronous planning.

Since v0.4.0
#

RuntimeAssertionContext

interface
Source 
interface RuntimeAssertionContext<Model, Expected, State, Event, Error, Output, Observed> extends RuntimeInspectionContext<State, Event, Error, Output> {
  readonly actual: RuntimeCommandActual<State, Error, Output, Observed>;
  readonly command: RuntimeCommand<Event>;
  readonly expected: Expected;
  readonly index: number;
  readonly model: Model;
  readonly published: readonly Array<RuntimeSnapshot<State, Error, Output>>;
  readonly ref: MachineRef<State, Event, Error, Output>;
  readonly result: RuntimeCommandResult;
  readonly snapshot: RuntimeSnapshot<State, Error, Output> | undefined;
}

Context supplied to the reference-model assertion.

Since v0.4.0
#

RuntimeAwait

type
Source 
type RuntimeAwait<State, Error, Output> = {
  readonly _tag: "None";
} | {
  readonly _tag: "Until";
  readonly predicate: (snapshot: Machine.RuntimeSnapshot<State, Error, Output>) => boolean;
}

Additional asynchronous observation requested after a causal command has completed. None never guesses that later invoke, timer, or child work is finished. Until observes the current runtime snapshot and subsequent publications until its predicate matches.

Since v0.4.0
#

RuntimeCommand

type
Source 
type RuntimeCommand<Event> = {
  readonly _tag: "Send";
  readonly event: Event;
} | {
  readonly _tag: "Advance";
  readonly duration: Duration.Input;
} | {
  readonly _tag: "Stop";
} | {
  readonly _tag: "Checkpoint";
  readonly label: string | undefined;
}

A command applied to a running machine during model-based testing.

Since v0.4.0
#

RuntimeCommandActual

interface
Source 
interface RuntimeCommandActual<State, Error, Output, Observed> {
  readonly inspected: Observed | undefined;
  readonly published: readonly Array<RuntimeSnapshot<State, Error, Output>>;
  readonly result: RuntimeCommandResult;
  readonly snapshot: RuntimeSnapshot<State, Error, Output> | undefined;
}

Actual evidence made available to a runtime command assertion.

Since v0.4.0
#

RuntimeCommandInvariantContext

interface
Source 
interface RuntimeCommandInvariantContext<M extends AnyMachine> {
  readonly awaited: readonly Array<RuntimeSnapshot<Snapshot<States<M>>, RuntimeInvariantErrorChannel<M>, Output<M>>>;
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly index: number;
  readonly machine: M;
  readonly previous: RuntimeInvariantRecord<M> | undefined;
  readonly record: RuntimeInvariantRecord<M>;
  readonly result: CausalRuntimeCommandResult<M>;
  readonly snapshot: RuntimeSnapshot<Snapshot<States<M>>, RuntimeInvariantErrorChannel<M>, Output<M>>;
  readonly transcript: RuntimeInvariantTranscript<M>;
}

Evidence passed to an invariant for one completed causal command.

Since v0.4.0
#

RuntimeCommandRecord

interface
Source 
interface RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed> {
  readonly actual: RuntimeCommandActual<State, Error, Output, Observed>;
  readonly command: RuntimeCommand<Event>;
  readonly expected: Expected;
  readonly index: number;
  readonly model: Model;
}

One successfully checked command in a replayable runtime transcript.

Since v0.4.0
#

RuntimeCommandResult

type
Source 
type RuntimeCommandResult = {
  readonly _tag: "SendAccepted";
} | {
  readonly _tag: "SendRejected";
  readonly error: Machine.StoppedError;
} | {
  readonly _tag: "ClockAdvanced";
} | {
  readonly _tag: "Stopped";
} | {
  readonly _tag: "Checkpoint";
}

The result of executing one runtime command.

Since v0.4.0
#

RuntimeCommands

interface
Source 
interface RuntimeCommands<M extends AnyMachine> {
  readonly arbitrary: Arbitrary<readonly Array<RuntimeCommand<InputEvent<M>>>>;
  readonly diagnostics: RuntimeCommandsDiagnostics;
}

A shrinkable runtime command arbitrary and its derivation diagnostics.

Since v0.4.0
#

RuntimeCommandsDiagnostics

interface
Source 
interface RuntimeCommandsDiagnostics {
  readonly events: "none" | "schema" | "override";
  readonly includesAdvance: boolean;
  readonly includesCheckpoint: boolean;
  readonly includesStop: boolean;
  readonly schemaReports: readonly Array<SchemaArbitraryReport>;
}

Diagnostics describing a schema-derived runtime command arbitrary.

Since v0.4.0
#

RuntimeCommandsOptions

interface
Source 
interface RuntimeCommandsOptions<M extends AnyMachine> {
  readonly additionalCommands?: readonly Array<Arbitrary<RuntimeCommand<InputEvent<M>>>>;
  readonly advanceArbitrary?: Arbitrary<Input>;
  readonly eventArbitrary?: Arbitrary<InputEvent<M>>;
  readonly includeAdvance?: boolean;
  readonly includeCheckpoint?: boolean;
  readonly includeStop?: boolean;
  readonly maxCommands?: number;
  readonly minCommands?: number;
}

Options controlling schema-derived runtime command generation.

Since v0.4.0
#

RuntimeInspectionContext

interface
Source 
interface RuntimeInspectionContext<State, Event, Error, Output> {
  readonly command: RuntimeCommand<Event>;
  readonly index: number;
  readonly published: readonly Array<RuntimeSnapshot<State, Error, Output>>;
  readonly ref: MachineRef<State, Event, Error, Output>;
  readonly result: RuntimeCommandResult;
  readonly snapshot: RuntimeSnapshot<State, Error, Output> | undefined;
}

Context supplied to a custom runtime inspection effect.

Since v0.4.0
#

RuntimeInvariantBuilder

interface
Source 
interface RuntimeInvariantBuilder<M extends AnyMachine> {
  readonly command: (name: string, check: (context: RuntimeCommandInvariantContext<M>) => InvariantOutcome, options?: InvariantOptions<RuntimeCommandInvariantContext<M>>) => RuntimeCommandInvariant<M>;
  readonly snapshot: (name: string, check: (context: RuntimeSnapshotInvariantContext<M>) => InvariantOutcome, options?: RuntimeSnapshotInvariantOptions<M>) => RuntimeSnapshotInvariant<M>;
  readonly transcript: (name: string, check: (context: RuntimeTranscriptInvariantContext<M>) => InvariantOutcome, options?: InvariantOptions<RuntimeTranscriptInvariantContext<M>>) => RuntimeTranscriptInvariant<M>;
}

Machine-bound runtime invariant constructors with exact event inference.

Since v0.4.0
#

RuntimeInvariantCheckResult

interface
Source 
interface RuntimeInvariantCheckResult {
  readonly failures: number;
  readonly invariant: string;
  readonly observations: number;
  readonly scope: RuntimeInvariantScope;
  readonly status: InvariantStatus;
}

Aggregate result for one runtime invariant.

Since v0.4.0
#

RuntimeInvariantRecord

interface
Source 
interface RuntimeInvariantRecord<M extends AnyMachine> {
  readonly awaited: readonly Array<RuntimeSnapshot<Snapshot<States<M>>, RuntimeInvariantErrorChannel<M>, Output<M>>>;
  readonly command: RuntimeCommand<InputEvent<M>>;
  readonly index: number;
  readonly result: CausalRuntimeCommandResult<M>;
  readonly snapshot: RuntimeSnapshot<Snapshot<States<M>>, RuntimeInvariantErrorChannel<M>, Output<M>>;
}

A model-independent command record supplied to runtime laws.

Since v0.4.0
#

RuntimeInvariantReport

interface
Source 
interface RuntimeInvariantReport {
  readonly checks: readonly Array<RuntimeInvariantCheckResult>;
}

Aggregate result for all checked runtime invariants.

Since v0.4.0
#

RuntimeInvariantTranscript

interface
Source 
interface RuntimeInvariantTranscript<M extends AnyMachine> {
  readonly commands: readonly Array<RuntimeCommand<InputEvent<M>>>;
  readonly final: RuntimeSnapshot<Snapshot<States<M>>, RuntimeInvariantErrorChannel<M>, Output<M>>;
  readonly initial: RuntimeSnapshot<Snapshot<States<M>>, RuntimeInvariantErrorChannel<M>, Output<M>>;
  readonly records: readonly Array<RuntimeInvariantRecord<M>>;
}

A model-independent causal transcript supplied to runtime laws.

Since v0.4.0
#

RuntimeInvariantViolation

interface
Source 
interface RuntimeInvariantViolation<M extends AnyMachine = AnyMachine> {
  readonly awaitedIndex?: number;
  readonly command?: RuntimeCommand<InputEvent<M>>;
  readonly commandIndex: number | undefined;
  readonly invariant: string;
  readonly kind: "predicate" | "observations";
  readonly message: string;
  readonly observationIndex?: number;
  readonly phase?: RuntimeSnapshotObservation;
  readonly scope: RuntimeInvariantScope;
}

One runtime invariant violation and its exact retained location.

Since v0.4.0
#

RuntimeModelOptions

interface
Source 
interface RuntimeModelOptions<Model, Expected, State, Event, Error, Output, Observed = never, ModelError = never, ModelServices = never, InspectionError = never, InspectionServices = never, AssertionError = never, AssertionServices = never> {
  readonly assert: (context: RuntimeAssertionContext<Model, Expected, State, Event, Error, Output, Observed>) => Effect<void, AssertionError, AssertionServices>;
  readonly initialModel: Model;
  readonly inspect?: (context: RuntimeInspectionContext<State, Event, Error, Output>) => Effect<Observed, InspectionError, InspectionServices>;
  readonly observationTimeout?: Input;
  readonly transition: (model: Model, command: RuntimeCommand<Event>, index: number) => Effect<RuntimeModelStep<Model, Expected, State, Error, Output>, ModelError, ModelServices>;
}

Configuration for an Effect-native runtime command-model run.

Since v0.4.0
#

RuntimeModelStep

interface
Source 
interface RuntimeModelStep<Model, Expected, State, Error, Output> {
  readonly expected: Expected;
  readonly model: Model;
  readonly synchronize: RuntimeSynchronization<State, Error, Output>;
}

The pure/reference-model result for one runtime command.

Since v0.4.0
#

RuntimeSnapshotInvariantContext

interface
Source 
interface RuntimeSnapshotInvariantContext<M extends AnyMachine> {
  readonly awaitedIndex: number | undefined;
  readonly command: RuntimeCommand<InputEvent<M>> | undefined;
  readonly commandIndex: number | undefined;
  readonly machine: M;
  readonly observationIndex: number;
  readonly phase: RuntimeSnapshotObservation;
  readonly result: CausalRuntimeCommandResult<M> | undefined;
  readonly snapshot: RuntimeSnapshot<Snapshot<States<M>>, RuntimeInvariantErrorChannel<M>, Output<M>>;
  readonly transcript: RuntimeInvariantTranscript<M>;
}

Evidence passed to a runtime snapshot invariant.

Since v0.4.0
#

RuntimeSnapshotInvariantOptions

interface
Source 
interface RuntimeSnapshotInvariantOptions<M extends AnyMachine> extends InvariantOptions<RuntimeSnapshotInvariantContext<M>> {
  readonly observe?: RuntimeSnapshotObservationMode;
  readonly require?: {
    readonly minObservations: number;
  };
  readonly when?: (context: RuntimeSnapshotInvariantContext) => boolean;
}

Options for a runtime snapshot invariant.

Since v0.4.0
#

RuntimeSynchronization

type
Source 
type RuntimeSynchronization<State, Error, Output> = {
  readonly _tag: "None";
} | {
  readonly _tag: "Current";
} | {
  readonly _tag: "Next";
} | {
  readonly _tag: "Until";
  readonly predicate: (snapshot: Machine.RuntimeSnapshot<State, Error, Output>) => boolean;
}

Defines how a model step synchronizes with public machine observations.

None is appropriate when a send is intentionally only enqueued. Next consumes the next snapshot published after the previously consumed one. Until also consumes intermediate snapshots and is useful for a checkpoint after several queued sends. Current is only a sample; it should be used when the model already knows there is no outstanding asynchronous work.

Since v0.4.0
#

RuntimeTranscript

interface
Source 
interface RuntimeTranscript<Model, Expected, State, Event, Error, Output, Observed> {
  readonly commands: readonly Array<RuntimeCommand<Event>>;
  readonly final: RuntimeSnapshot<State, Error, Output>;
  readonly finalModel: Model;
  readonly initial: RuntimeSnapshot<State, Error, Output>;
  readonly records: readonly Array<RuntimeCommandRecord<Model, Expected, State, Event, Error, Output, Observed>>;
  readonly synchronized: boolean;
}

A complete command-model execution transcript.

Since v0.4.0
#

RuntimeTranscriptInvariantContext

interface
Source 
interface RuntimeTranscriptInvariantContext<M extends AnyMachine> {
  readonly machine: M;
  readonly transcript: RuntimeInvariantTranscript<M>;
}

Evidence passed to a whole-runtime-transcript invariant.

Since v0.4.0
#

Scenario

type
Source 
type Scenario<M extends AnyMachine> = Machine.Machine.Input<M> extends typeof Schema.Void ? {
  readonly events: ReadonlyArray<Machine.Machine.InputEvent<M>>;
} : {
  readonly events: ReadonlyArray<Machine.Machine.InputEvent<M>>;
  readonly input: InputValue<M>;
}

A generated public-input scenario for a machine.

Machines without an input schema omit input; machines with one retain its exact decoded type. Events use only the public input protocol.

Since v0.4.0
#

ScenarioCoverage

interface
Source 
interface ScenarioCoverage {
  readonly empty: number;
  readonly events: number;
  readonly traces: number;
}

Trace-derived scenario counts. There is no finite declared scenario space.

Since v0.4.0
#

ScenarioDiagnostics

interface
Source 
interface ScenarioDiagnostics {
  readonly events: "schema" | "override" | "empty";
  readonly input: "none" | "schema" | "override";
  readonly schemas: readonly Array<SchemaArbitraryDiagnostic>;
}

Diagnostics describing how a scenario arbitrary was assembled.

Since v0.4.0
#

ScenarioOptions

type
Source 
type ScenarioOptions<M extends AnyMachine> = {
  readonly eventsArbitrary?: FastCheck.Arbitrary<ReadonlyArray<Machine.Machine.InputEvent<M>>>;
  readonly maxEvents?: number;
  readonly minEvents?: number;
} & Machine.Machine.Input<M> extends typeof Schema.Void ? {
  readonly inputArbitrary?: never;
} : {
  readonly inputArbitrary?: FastCheck.Arbitrary<InputValue<M>>;
}

Options for schema-derived scenario generation.

inputArbitrary and eventsArbitrary replace their complete generated value. An events override therefore owns its own length distribution.

Since v0.4.0
#

Scenarios

interface
Source 
interface Scenarios<M extends AnyMachine> {
  readonly arbitrary: Arbitrary<Scenario<M>>;
  readonly diagnostics: ScenarioDiagnostics;
}

A scenario arbitrary together with schema-derivation diagnostics.

Since v0.4.0
#

SchemaArbitraryDiagnostic

interface
Source 
interface SchemaArbitraryDiagnostic {
  readonly boundary: "event" | "input";
  readonly index: number | undefined;
  readonly report: SchemaArbitraryReport;
}

Diagnostics for one schema-derived arbitrary.

Since v0.4.0
#

SchemaArbitraryOpaqueFilterWarning

interface
Source 
interface SchemaArbitraryOpaqueFilterWarning {
  readonly _tag: "OpaqueFilter";
  readonly description?: string;
  readonly path: readonly Array<PropertyKey>;
}

Warning emitted when schema arbitrary generation must enforce an opaque filter through rejection sampling.

Since v0.4.0
#

SchemaArbitraryReport

interface
Source 
interface SchemaArbitraryReport {
  readonly warnings: readonly Array<SchemaArbitraryOpaqueFilterWarning>;
}

Diagnostics collected while deriving a schema arbitrary.

Since v0.4.0
#

SchemaArbitraryWarning

type
Source 
type SchemaArbitraryWarning = SchemaArbitraryOpaqueFilterWarning

Non-fatal diagnostic emitted while deriving a schema arbitrary.

Since v0.4.0
#

StateCoverage

interface
Source 
interface StateCoverage<Path extends string = string> {
  readonly activation: CoverageSummary<StateCoverageItem<Path>>;
  readonly entry: CoverageSummary<StateCoverageItem<Path>>;
  readonly exit: CoverageSummary<StateCoverageItem<Path>>;
}

State activation and lifecycle coverage.

Since v0.4.0
#

StateCoverageItem

interface
Source 
interface StateCoverageItem<Path extends string = string> {
  readonly path: Path;
  readonly type: "final" | "parallel" | "choice" | "atomic" | "compound";
}

One active (non-history) state node in a state coverage summary.

Since v0.4.0
#

Trace

interface
Source 
interface Trace<M extends AnyMachine> {
  readonly final: Snapshot<States<M>>;
  readonly finalConfiguration: readonly Array<StatePath<M>>;
  readonly initial: InitialTrace<M>;
  readonly scenario: Scenario<M>;
  readonly steps: readonly Array<TraceStep<M>>;
}

A scenario and every plan produced by executing it without running actions.

Since v0.4.0
#

TraceStep

interface
Source 
interface TraceStep<M extends AnyMachine> {
  readonly after: Snapshot<States<M>>;
  readonly afterConfiguration: readonly Array<StatePath<M>>;
  readonly before: Snapshot<States<M>>;
  readonly beforeConfiguration: readonly Array<StatePath<M>>;
  readonly event: InputEvent<M>;
  readonly index: number;
  readonly plan: EventPlan<M>;
}

One event portion of an executable planner trace.

Since v0.4.0
#

TransitionCoverageItem

interface
Source 
interface TransitionCoverageItem<SourcePath extends string = string, EventTag extends PropertyKey = PropertyKey, TargetPath extends string = SourcePath> {
  readonly id: string;
  readonly index: number;
  readonly reenter: boolean;
  readonly source: SourcePath;
  readonly targets: TransitionTargets<TargetPath>;
  readonly trigger: TransitionTrigger<EventTag>;
}

One stable transition-definition identity in definition order.

Since v0.4.0
#

VerificationLaw

type
Source 
type VerificationLaw = "configuration.shape" | "configuration.path" | "configuration.schema" | "configuration.hierarchy" | "configuration.compound" | "configuration.parallel" | "configuration.duplicate" | "configuration.trace" | "microsteps.unique" | "microsteps.order" | "microsteps.activeBefore" | "microsteps.activeAfter" | "microsteps.changed" | "microsteps.continuity" | "microsteps.reentry" | "completion.record" | "completion.output" | "completion.done" | "history.record" | "history.mode" | "history.path" | "history.value" | "history.shallow" | "history.deep" | "targetBounds.definition" | "targetBounds.target"

Stable identifiers for individual planner laws.

Since v0.4.0
#

VerificationLawGroup

type
Source 
type VerificationLawGroup = "configuration" | "microsteps" | "completion" | "history" | "targetBounds"

Independently checked families of planner laws.

Since v0.4.0
#

VerificationViolation

interface
Source 
interface VerificationViolation {
  readonly eventIndex: number | undefined;
  readonly law: VerificationLaw;
  readonly message: string;
  readonly microstepIndex?: number;
  readonly path?: string;
}

One independently observed violation in a planner trace.

Since v0.4.0
#

VerifyOptions

interface
Source 
interface VerifyOptions {
  readonly laws?: readonly Array<VerificationLawGroup>;
}

Selects law families for the single canonical verifier. All run by default.

Since v0.4.0

Runtime Testing

5
#

probe

variable
Source 
declare const probe: <M extends AnyMachine, Error, Output>(machine: ReadyMachine<M>, ref: Machine.MachineRef<Machine.Machine.Snapshot<Machine.Machine.States<M>>, Machine.Machine.InputEvent<M>, Error, Output>) => Effect.Effect<Probe<M, Error, Output>, internal.ProbeUnavailableError>

Attaches testing-only causal event delivery to a running statechart.

The returned probe exposes sendAndAwait; ordinary production sends remain available exclusively through MachineRef.send and retain their asynchronous enqueue-only semantics.

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

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 program = Effect.gen(function*() {
  const ref = yield* Machine.start(machine)
  return yield* MachineTest.probe(machine, ref)
})
Since v0.4.0
#

Probe

interface
Source 
interface Probe<M extends AnyMachine, Error = never, Output = never> {
  readonly await: {
    readonly none: RuntimeAwait<Snapshot<States<M>>, Error, Output>;
    readonly until: (predicate: (snapshot: RuntimeSnapshot<Snapshot<States<M>>, Error, Output>) => boolean) => RuntimeAwait<Snapshot<States<M>>, Error, Output>;
  };
  readonly machine: M;
  readonly ref: MachineRef<Snapshot<States<M>>, InputEvent<M>, Error, Output>;
  readonly sendAndAwait: (event: InputEvent<M>) => Effect<ProbeStep<M>, StoppedError | Error>;
}

Testing-only causal access to a managed statechart reference.

A probe does not change ordinary machine scheduling. sendAndAwait uses an acknowledged mailbox delivery so an ignored event can be proven processed without waiting for a snapshot that will never be published.

Since v0.4.0
#

ProbeMicrostep

type
Source 
type ProbeMicrostep<M extends AnyMachine> = Omit<Microstep<M>, "transitions">

One runtime microstep retained by the execution strategy used by a probe.

Transition-definition metadata is intentionally not reconstructed here: optimized runtimes retain execution evidence, while run and plan remain the APIs for complete diagnostic transition metadata.

Since v0.4.0
#

ProbePlan

type
Source 
type ProbePlan<M extends AnyMachine> = {
  readonly commands: ReadonlyArray<Machine.Command>;
  readonly emittedEvents: ReadonlyArray<Machine.Machine.Emit<M>>;
  readonly microsteps: ReadonlyArray<ProbeMicrostep<M>>;
  readonly next: Machine.Machine.Snapshot<Machine.Machine.States<M>>;
} & PlanCompletion<M>

Runtime plan evidence associated with one acknowledged public event.

Since v0.4.0
#

ProbeStep

interface
Source 
interface ProbeStep<M extends AnyMachine> {
  readonly after: Snapshot<States<M>>;
  readonly before: Snapshot<States<M>>;
  readonly configurationChanged: boolean;
  readonly event: InputEvent<M>;
  readonly handled: boolean;
  readonly plan: ProbePlan<M>;
}

Causal evidence produced after one event has completed its managed runtime macrostep.

handled distinguishes an ignored event from a retained transition that deliberately leaves the logical state unchanged. configurationChanged reports whether any microstep changed or reentered the active statechart configuration; compare before and after for state-value assertions.

Since v0.4.0

Utility Types

1
#

RuntimeInvariantErrorChannel

type
Source 
type RuntimeInvariantErrorChannel<M extends AnyMachine> = Machine.Machine.Error<M> | Machine.ActionError<Machine.Machine.Services<M>> | Machine.InfiniteTransitionError | Machine.MachineSchemaDecodeError | Machine.StoppedError

The runtime error channel exposed by a managed reference for a machine.

Since v0.4.0

Verification

10
#

assertInvariants

variable
Source 
declare const assertInvariants: <M extends AnyMachine>(machine: M, trace: Trace<M>, invariants: ReadonlyArray<Invariant<M>>) => Effect.Effect<void, internal.InvariantError<M>>

Asserts user-defined semantic invariants and discards the success report.

This is the property-test-oriented form of checkInvariants: its void success works directly with it.effect.prop, while failures retain the same complete report and trace evidence.

Since v0.4.0
#

assertPlannerRuntimeAgreement

variable
Source 
declare const assertPlannerRuntimeAgreement: <M extends AnyMachine, Error, Output>(machine: ReadyMachine<M>, transcript: CausalRuntimeEvidence<M, Error, Output>) => Effect.Effect<void, internal.PlannerRuntimeAgreementError<M>, RunServices<M>>

Checks that every processed public send agrees with a fresh pure plan.

Since v0.4.0
#

assertRuntimeInvariants

variable
Source 
declare const assertRuntimeInvariants: <M extends AnyMachine, Error, Output>(machine: M, transcript: CausalRuntimeEvidence<M, Error, Output>, invariants: ReadonlyArray<RuntimeInvariant<M>>) => Effect.Effect<void, internal.RuntimeInvariantError<M>>

Asserts runtime invariants against an existing causal transcript.

Since v0.4.0
#

checkInvariants

variable
Source 
declare const checkInvariants: <M extends AnyMachine>(machine: M, trace: Trace<M>, invariants: ReadonlyArray<Invariant<M>>) => Effect.Effect<InvariantReport, internal.InvariantError<M>>

Checks user-defined semantic invariants against an existing planner trace.

Every invariant and matching observation is evaluated so one failure contains all relevant evidence. Combine this with scenarios and run in an Effect property test to retain FastCheck shrinking.

Since v0.4.0
#

checkRuntimeInvariants

variable
Source 
declare const checkRuntimeInvariants: <M extends AnyMachine, Error, Output>(machine: M, transcript: CausalRuntimeEvidence<M, Error, Output>, invariants: ReadonlyArray<RuntimeInvariant<M>>) => Effect.Effect<RuntimeInvariantReport, internal.RuntimeInvariantError<M>>

Checks runtime invariants and returns their complete non-vacuity report.

Since v0.4.0
#

coverage

variable
Source 
declare const coverage: <M extends AnyMachine>(machine: M, traceOrTraces: Trace<M> | ReadonlyArray<Trace<M>>) => Coverage<M>

Computes deterministic, definition-aware coverage from completed planner traces. Finite declared sets report hits and misses; scenarios and logical configurations report observations only because their complete spaces are generally infinite.

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

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 report = Effect.map(
  MachineTest.run(machine, { events: [] }),
  (trace) => MachineTest.coverage(machine, trace)
)
Since v0.4.0
#

interpretModel

variable
Source 
declare const interpretModel: (model: FiniteModel, events: ReadonlyArray<string>) => ReferenceModel.ReferenceTrace

Purely interprets a finite hierarchical model without compiling a machine.

Since v0.4.0
#

observedGraph

variable
Source 
declare const observedGraph: <M extends AnyMachine>(machine: M, traceOrTraces: Trace<M> | ReadonlyArray<Trace<M>>) => Effect.Effect<ObservedGraph<M>, Machine.MachineSchemaEncodeError, Machine.Machine.SnapshotEncodingServices<Machine.Machine.States<M>>>

Converts concrete planner traces into an observed logical-state graph. Nodes are deduplicated by the public snapshot encoding and every edge is a concrete startup or public-event macrostep. This intentionally does not claim to be a static or exhaustive graph of the machine.

Since v0.4.0
#

verify

variable
Source 
declare const verify: <M extends AnyMachine>(machine: M, trace: Trace<M>, options?: VerifyOptions) => Effect.Effect<void, VerificationError>

Verifies an executed trace using only public machine inspection and raw snapshot data. The verifier deliberately does not reuse planner normalization, encoding, finality, or other internal helpers.

Every selected law is evaluated and returned in one structured error so a shrunk property-test counterexample retains all relevant evidence.

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

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 checked = Effect.gen(function*() {
  const trace = yield* MachineTest.run(machine, { events: [] })
  yield* MachineTest.verify(machine, trace)
})
Since v0.4.0
#

verifyModel

variable
Source 
declare const verifyModel: <M extends AnyMachine>(model: FiniteModel, actualTrace: Trace<M>) => Effect.Effect<void, ReferenceModel.ModelVerificationError>

Checks a real planner trace against the independent finite statechart model interpreter.

The oracle does not import the machine compiler, planner, snapshot helpers, or target builders. It compares semantic projections of the public trace and accumulates every disagreement in one structured error.

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