@typeonce/effect-machine v0.4.0
GitHub
API unstable/cluster/ClusterMachine
Module

ClusterMachine

View source

Runs Effect machines as persisted Cluster entities.

Since v0.4.0 15 declarations ./unstable/cluster/ClusterMachine

Constructors

2
#

make

variable
Source 
declare const make: <Type extends string, States extends Machine.Machine.StateSchemas, Events extends ReadonlyArray<Machine.Machine.TaggedSchema>, Input extends Schema.Top, UnhandledStates extends Machine.Machine.StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends Machine.Machine.StateIdentifier<States>, Output, Emits extends ReadonlyArray<Machine.Machine.TaggedSchema>, OutputStates extends Machine.Machine.StateIdentifier<States>, InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = Events>(type: Type, machine: Machine.Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, options: {
  readonly version: string;
}, ...input: [...Machine.Machine.InputArgs<Input>]) => ClusterMachine<Type, Machine.Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, ExcludeCompatibleRuntime<Machine.ExecutionServices<R | InitialR>, Machine.Machine.EventOf<Events>, Machine.Machine.EmitOf<Emits>> | Machine.Machine.SnapshotDecodingServices<States> | Machine.Machine.SnapshotEncodingServices<States>>

Creates a persisted Cluster entity adapter for a machine.

When to use

Use when each Cluster entity id should own one durable machine snapshot and accept schema-validated machine events through a persisted send RPC.

Details

A missing checkpoint runs initial planning before the first event. Existing checkpoints are identity-checked, version-checked, decoded, and resumed without rerunning initial entry behavior. Final checkpoints accept later requests as no-ops. The stable bridge identity is machine.id when present, otherwise the Cluster entity type.

Gotchas

Invoked processes, spawned children, action-time runtime.raise, timers, subscriptions, and other process-local state are not durable and are rejected. Planning-time raised events remain part of the current macrostep. Arbitrary action effects may run again after a crash before checkpoint commit, so the bridge does not provide exactly-once external effects.

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

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 adapter = ClusterMachine.make("IdleMachine", machine, { version: "1" })
Since v0.4.0
#

makeMemory

variable
Source 
declare const makeMemory: Effect.Effect<Storage["Service"]>

Creates an in-memory Cluster machine checkpoint store.

When to use

Use when you test or run a local process that does not require checkpoints to survive a restart.

Gotchas

This store is not durable and does not provide rollback with the in-memory MessageStorage transaction marker.

Since v0.4.0

Layers

1
#

layerMemory

variable
Source 
declare const layerMemory: Layer.Layer<Storage>

Layer providing the in-memory Cluster machine checkpoint store.

Since v0.4.0

Models

10
#

Accepted

class
Source 
declare class Accepted extends {
  readonly _tag: "Accepted";
} {
  constructor(...args: [props?: {
    readonly _tag?: "Accepted";
  }, options?: MakeOptions]);
  readonly _tag: "Accepted";
  readonly ~effect/Schema/Schema: "~effect/Schema/Schema";
  readonly ~encoded.mutability: "readonly";
  readonly ~encoded.optionality: "required";
  readonly ~type.constructor.default: "no-default";
  readonly ~type.make: Accepted;
  readonly ~type.make.in: void | {
    readonly _tag?: "Accepted";
  };
  readonly ~type.mutability: "readonly";
  readonly ~type.optionality: "required";
  readonly ~type.parameters: readonly [TaggedStruct<"Accepted", {}>];
  readonly ast: Declaration;
  readonly DecodingServices: never;
  readonly Encoded: {
    readonly _tag: "Accepted";
  };
  readonly EncodingServices: never;
  readonly fields: {
    readonly _tag: tag<"Accepted">;
  };
  readonly identifier: string;
  readonly Iso: {
    readonly _tag: "Accepted";
  };
  Rebuild: decodeTo<declareConstructor<Accepted, {
    readonly _tag: "Accepted";
  }, readonly [TaggedStruct<"Accepted", {}>], {
    readonly _tag: "Accepted";
  }>, TaggedStruct<"Accepted", {}>, never, never>;
  readonly Type: Accepted;
  annotate(annotations: Bottom<Accepted, readonly [TaggedStruct<"Accepted", {}>]>): decodeTo<declareConstructor<Accepted, {
    readonly _tag: "Accepted";
  }, readonly [TaggedStruct<"Accepted", {}>], {
    readonly _tag: "Accepted";
  }>, TaggedStruct<"Accepted", {}>, never, never>;
  annotateKey(annotations: Key<Accepted>): decodeTo<declareConstructor<Accepted, {
    readonly _tag: "Accepted";
  }, readonly [TaggedStruct<"Accepted", {}>], {
    readonly _tag: "Accepted";
  }>, TaggedStruct<"Accepted", {}>, never, never>;
  check(...checks: readonly [Check<Accepted>, Check<Accepted>]): decodeTo<declareConstructor<Accepted, {
    readonly _tag: "Accepted";
  }, readonly [TaggedStruct<"Accepted", {}>], {
    readonly _tag: "Accepted";
  }>, TaggedStruct<"Accepted", {}>, never, never>;
  extend<Extended = never, Static = {}, Brand = {}>(identifier: string): {
    <NewFields extends Fields>(fields: NewFields, annotations?: Declaration<Extended, readonly [Struct<{ [K in string | number | symbol]: { [K in string | number | symbol]: ... & ... extends never ? ... & ... : ... & ...[K] }[K] }>]>): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : InheritStaticMembers<Class<Extended, Struct<{ [K in string | number | symbol]: { [K in string | number | symbol]: ... & ... extends never ? ... & ... : ... & ...[K] }[K] }>, Accepted & Brand>, Static>;
    <Extension extends Struct<Fields>>(schema: Extension, annotations?: Declaration<Extended, readonly [Struct<{ [K in string | number | symbol]: { [K in string | number | symbol]: ... & ... extends never ? ... & ... : ... & ...[K] }[K] }>]>): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : InheritStaticMembers<Class<Extended, Struct<{ [K in string | number | symbol]: { [K in string | number | symbol]: ... & ... extends never ? ... & ... : ... & ...[K] }[K] }>, Accepted & Brand>, Static>;
  };
  make(input: void | {
    readonly _tag?: "Accepted";
  }, options?: MakeOptions): Accepted;
  makeEffect(input: void | {
    readonly _tag?: "Accepted";
  }, options?: MakeOptions): Effect<Accepted, Issue>;
  makeOption(input: void | {
    readonly _tag?: "Accepted";
  }, options?: MakeOptions): Option<Accepted>;
  mapFields<To extends Fields>(f: (fields: {
    readonly _tag: tag<"Accepted">;
  }) => To, options?: {
    readonly unsafePreserveChecks?: boolean;
  }): Struct<{ [K in string | number | symbol]: Readonly<To>[K] }>;
  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;
  rebuild(ast: Declaration): decodeTo<declareConstructor<Accepted, {
    readonly _tag: "Accepted";
  }, readonly [TaggedStruct<"Accepted", {}>], {
    readonly _tag: "Accepted";
  }>, TaggedStruct<"Accepted", {}>, never, never>;
}

Successful result returned after a Cluster machine request is committed or recognized as a redelivery.

Since v0.4.0
#

Checkpoint

interface
Source 
interface Checkpoint {
  readonly machineId: string;
  readonly requestId: Snowflake;
  readonly snapshot: EncodedSnapshot;
  readonly version: string;
}

Persisted machine checkpoint owned by the Cluster bridge.

Details

Machine identity and deployment version are stored around the generic encoded snapshot. The request id records the request that produced the checkpoint.

Since v0.4.0
#

ClusterMachine

interface
Source 
interface ClusterMachine<in out Type extends string, in out M extends Machine.Machine.Any, out Services = MachineServices<M>> {
  readonly entity: Entity<Type, SendRpc<MachineEvents<M>>>;
  readonly machine: M;
  readonly toLayer: <R = never>(options?: {
    readonly enqueue?: (event: EmitOf<MachineEmits<M>>) => Effect<void, unknown, R>;
  }) => Layer<never, never, Services | R | Storage | MessageStorage | Sharding>;
}

Cluster adapter for one machine definition and entity type.

Details

The adapter exposes one persisted send RPC. Entity requests are serialized by the normal Cluster entity concurrency and every accepted request advances the checkpoint at most once.

Since v0.4.0
#

CommitResult

namespace
Source

Types for Cluster machine commit results.

Since v0.4.0
#

CommitResult

type
Source 
type CommitResult = CommitResult.Committed | CommitResult.Duplicate

Result of atomically committing a Cluster machine request.

Since v0.4.0
#

CommitResult

variable
Source 
declare const CommitResult: {
  Committed: () => Committed;
  Duplicate: () => Duplicate;
}

Constructors and types for Cluster machine commit results.

Since v0.4.0
#

LoadResult

interface
Source 
interface LoadResult {
  readonly checkpoint: Option<Checkpoint>;
  readonly processed: boolean;
}

Result of loading a checkpoint for a Cluster machine request.

Details

processed reports whether the exact Cluster request id was already committed. Storage implementations must retain enough request ids to detect redelivery even after later requests have advanced the checkpoint.

Since v0.4.0
#

Rejected

class
Source 
declare class Rejected extends {
  readonly _tag: "Rejected";
  readonly message: string;
  readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
} {
  constructor(...args: [props: {
    readonly _tag?: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, options?: MakeOptions]);
  readonly _tag: "Rejected";
  readonly message: string;
  readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  readonly ~effect/Schema/Schema: "~effect/Schema/Schema";
  readonly ~encoded.mutability: "readonly";
  readonly ~encoded.optionality: "required";
  readonly ~type.constructor.default: "no-default";
  readonly ~type.make: Rejected;
  readonly ~type.make.in: {
    readonly _tag?: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  };
  readonly ~type.mutability: "readonly";
  readonly ~type.optionality: "required";
  readonly ~type.parameters: readonly [TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>];
  readonly ast: Declaration;
  readonly DecodingServices: never;
  readonly Encoded: {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  };
  readonly EncodingServices: never;
  readonly fields: {
    readonly _tag: tag<"Rejected">;
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  };
  readonly identifier: string;
  readonly Iso: {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  };
  Rebuild: decodeTo<declareConstructor<Rejected, {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, readonly [TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>], {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }>, TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>, never, never>;
  readonly Type: Rejected;
  annotate(annotations: Bottom<Rejected, readonly [TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>]>): decodeTo<declareConstructor<Rejected, {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, readonly [TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>], {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }>, TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>, never, never>;
  annotateKey(annotations: Key<Rejected>): decodeTo<declareConstructor<Rejected, {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, readonly [TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>], {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }>, TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>, never, never>;
  check(...checks: readonly [Check<Rejected>, Check<Rejected>]): decodeTo<declareConstructor<Rejected, {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, readonly [TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>], {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }>, TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>, never, never>;
  extend<Extended = never, Static = {}, Brand = {}>(identifier: string): {
    <NewFields extends Fields>(fields: NewFields, annotations?: Declaration<Extended, readonly [Struct<{ [K in string | number | symbol]: { [K in string | number | symbol]: ... & ... extends never ? ... & ... : ... & ...[K] }[K] }>]>): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : InheritStaticMembers<Class<Extended, Struct<{ [K in string | number | symbol]: { [K in string | number | symbol]: ... & ... extends never ? ... & ... : ... & ...[K] }[K] }>, Rejected & Brand>, Static>;
    <Extension extends Struct<Fields>>(schema: Extension, annotations?: Declaration<Extended, readonly [Struct<{ [K in string | number | symbol]: { [K in string | number | symbol]: ... & ... extends never ? ... & ... : ... & ...[K] }[K] }>]>): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" : InheritStaticMembers<Class<Extended, Struct<{ [K in string | number | symbol]: { [K in string | number | symbol]: ... & ... extends never ? ... & ... : ... & ...[K] }[K] }>, Rejected & Brand>, Static>;
  };
  make(input: {
    readonly _tag?: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, options?: MakeOptions): Rejected;
  makeEffect(input: {
    readonly _tag?: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, options?: MakeOptions): Effect<Rejected, Issue>;
  makeOption(input: {
    readonly _tag?: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, options?: MakeOptions): Option<Rejected>;
  mapFields<To extends Fields>(f: (fields: {
    readonly _tag: tag<"Rejected">;
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }) => To, options?: {
    readonly unsafePreserveChecks?: boolean;
  }): Struct<{ [K in string | number | symbol]: Readonly<To>[K] }>;
  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;
  rebuild(ast: Declaration): decodeTo<declareConstructor<Rejected, {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }, readonly [TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>], {
    readonly _tag: "Rejected";
    readonly message: string;
    readonly reason: "MachineIdMismatch" | "VersionMismatch" | "InvalidCheckpoint" | "UnsupportedProcessLocal" | "TransitionFailure" | "PersistenceFailure" | "EmissionFailure";
  }>, TaggedStruct<"Rejected", {
    readonly message: String;
    readonly reason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>;
  }>, never, never>;
}

Rejected Cluster machine request. Transaction-participating durable storage leaves the previous checkpoint in place and suppresses emitted events.

Since v0.4.0
#

RejectionReason

type
Source 
type RejectionReason = typeof RejectionReason.Type

Type of RejectionReason.

Since v0.4.0
#

RejectionReason

variable
Source 
declare const RejectionReason: Literals<readonly ["MachineIdMismatch", "VersionMismatch", "InvalidCheckpoint", "UnsupportedProcessLocal", "TransitionFailure", "PersistenceFailure", "EmissionFailure"]>

Schema for reasons a Cluster machine request can be rejected without advancing its checkpoint.

Since v0.4.0

Schemas

1
#

SendResult

variable
Source 
declare const SendResult: Union<readonly [typeof Accepted, typeof Rejected]>

Schema for Cluster machine request outcomes.

Since v0.4.0

Services

1
#

Storage

class
Source 
declare class Storage extends Shape<"effect/cluster/ClusterMachine/Storage", {
  readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
  readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
}, this> {
  constructor(_: never);
  readonly ~effect/Context/Service: "~effect/Context/Service";
  readonly key: "effect/cluster/ClusterMachine/Storage";
  Service: {
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  };
  [ignoreSymbol]?: {};
  [typeSymbol]?: unknown;
  [unifySymbol]?: EffectUnify<ServiceClass<Storage, "effect/cluster/ClusterMachine/Storage", {
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  }>>;
  readonly ~effect/Context/Service: "~effect/Context/Service";
  readonly ~effect/Effect: Variance<{
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  }, never, Storage>;
  Identifier: Storage;
  readonly key: "effect/cluster/ClusterMachine/Storage";
  readonly Service: {
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  };
  [iterator](): EffectIterator<Effect<{
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  }, never, Storage>>;
  [NodeInspectSymbol](): unknown;
  context(self: {
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  }): Context<Storage>;
  of(this: void, self: {
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  }): {
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  };
  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;
  use<A, E, R>(f: (service: {
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  }) => Effect<A, E, R>): Effect<A, E, Storage | R>;
  useSync<A>(f: (service: {
    readonly commit: (address: EntityAddress, checkpoint: Checkpoint) => Effect<CommitResult, PersistenceError>;
    readonly load: (address: EntityAddress, requestId: Snowflake) => Effect<LoadResult, PersistenceError>;
  }) => A): Effect<A, never, Storage>;
}

Checkpoint persistence service used by Cluster machines.

When to use

Use to connect ClusterMachine to a durable checkpoint store that can atomically deduplicate request ids and replace the current checkpoint.

Gotchas

For checkpoint and emitted-message persistence to commit atomically, this service must join the transaction opened through the configured MessageStorage. The reply is persisted after that transaction; storing the request id with the checkpoint makes a redelivery recover that reply without applying the transition again. A separate transaction or database cannot provide checkpoint-and-emission atomicity.

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