@akterjs/effect 0.0.0-stage → 0.1.0

package/src/contract/computer/computer.schema.ts

@@ -0,0 +1,159 @@
+import { Schema } from "effect";
+
+import { ComputerSecret } from "#src/contract/secret/secret.schema";
+
+const kib = 1024;
+const mib = kib * kib;
+const inputKib = 100;
+const outputMib = 4;
+const nameLength = 63;
+const smallest = 1;
+const nothing = 0;
+
+/**
+ * Archil's serverless exec limits, applied to every exec step so a step behaves the same in any engine: five
+ * minutes, 100 KiB of command and standard input together, and 4 MiB of each output stream returned. Longer work
+ * runs as a process in the computer; longer output belongs in files.
+ */
+const execLimits = { inputBytes: inputKib * kib, outputBytes: outputMib * mib, seconds: 300 } as const;
+
+const encoder = new globalThis.TextEncoder();
+
+/** One of an actor's computers. Lowercase letters, digits and hyphens, starting with a letter. */
+const ComputerName = Schema.String.check(
+  Schema.isPattern(new RegExp(`^[a-z][a-z0-9-]{0,${nameLength - smallest}}$`, "u")),
+)
+  .pipe(Schema.brand("ComputerName"))
+  .annotate({ description: "A computer's name, unique among its actor's computers." });
+
+type ComputerName = typeof ComputerName.Type;
+
+const Seconds = Schema.Int.check(Schema.isBetween({ maximum: execLimits.seconds, minimum: smallest }));
+
+const Positive = Schema.Int.check(Schema.isGreaterThanOrEqualTo(smallest));
+
+const ComputerSize = Schema.Struct({ memoryMib: Positive, vcpu: Positive });
+
+type ComputerSize = typeof ComputerSize.Type;
+
+/**
+ * A computer to keep: its image, its size and the hosts it may reach. `egress` lists hosts or rules, never
+ * credentials. `secrets` names the credentials the platform adds to an allowed host's requests on the way out, from
+ * the actor's declared secrets, so no value ever reaches the computer.
+ */
+const ComputerSpec = Schema.Struct({
+  egress: Schema.Array(Schema.String),
+  image: Schema.String,
+  name: ComputerName,
+  secrets: Schema.optionalKey(Schema.Array(ComputerSecret)),
+  size: ComputerSize,
+});
+
+type ComputerSpec = typeof ComputerSpec.Type;
+
+/**
+ * Where a computer is. `paused` keeps its memory, processes and files; `stopped` and `failed` keep only its files;
+ * `gone` means its disk no longer exists, so it is never recreated empty under the same name by accident.
+ */
+const ComputerState = Schema.Literals(["starting", "running", "paused", "stopped", "failed", "gone"]);
+
+type ComputerState = typeof ComputerState.Type;
+
+const Computer = Schema.Struct({ ...ComputerSpec.fields, state: ComputerState });
+
+type Computer = typeof Computer.Type;
+
+const withinInput = Schema.makeFilter(
+  (request: { readonly command: string; readonly stdin?: Uint8Array | undefined }) =>
+    encoder.encode(request.command).byteLength + (request.stdin?.byteLength ?? nothing) <= execLimits.inputBytes,
+  { expected: `a command and standard input of at most ${execLimits.inputBytes} bytes together` },
+);
+
+/**
+ * One exec step. `key` is the step's stable logical-operation key, such as `Activity.idempotencyKey(name)`: the
+ * computer records the outcome under it, so the same step sent again reads that outcome back instead of running.
+ */
+const ExecRequest = Schema.Struct({
+  command: Schema.String,
+  cwd: Schema.optionalKey(Schema.String),
+  key: Schema.String.check(Schema.isMinLength(smallest)),
+  stdin: Schema.optionalKey(Schema.Uint8Array),
+  timeoutSeconds: Schema.optionalKey(Seconds),
+}).check(withinInput);
+
+type ExecRequest = typeof ExecRequest.Type;
+
+/**
+ * The step ran to an end, or its recorded outcome was read back; the two look the same. `exitCode` is absent when
+ * the process was ended without one, such as at the time limit. Past 4 MiB a stream, output is not returned and
+ * `truncated` is set; the whole of each stream stays in the step's directory on the computer.
+ */
+const ExecRan = Schema.TaggedStruct("Ran", {
+  exitCode: Schema.optionalKey(Schema.Int),
+  stderr: Schema.String,
+  stdout: Schema.String,
+  truncated: Schema.Boolean,
+});
+
+/**
+ * The step started once but no outcome was recorded: the computer lost power, or the step is still running. It is
+ * not run again, because whatever it did outside the computer may already have happened. Reconcile with the
+ * outside system by the step's key.
+ */
+const ExecUnknown = Schema.TaggedStruct("Unknown", {});
+
+const ExecResult = Schema.Union([ExecRan, ExecUnknown]);
+
+type ExecResult = typeof ExecResult.Type;
+
+/** How much a log page returns at most, and when a request names no limit. */
+const logPageLines = 1000;
+
+/**
+ * One line of a computer's log, oldest first: what the platform did to it (made, paused, resumed, stopped, forked,
+ * deleted) and each exec step's key and outcome. `seq` rises by one per line of the computer, so a reader passes the
+ * last `seq` it saw as `after` to read on.
+ */
+const ComputerLogLine = Schema.Struct({
+  at: Schema.Int,
+  level: Schema.Literals(["info", "warn", "error"]),
+  message: Schema.String,
+  seq: Schema.Int,
+});
+
+type ComputerLogLine = typeof ComputerLogLine.Type;
+
+const LogLimit = Schema.Int.check(Schema.isBetween({ maximum: logPageLines, minimum: smallest }));
+
+/** A page of a computer's log: the lines after `after`, at most `limit` (1 to 1,000; 1,000 when absent). */
+const ComputerLogPage = Schema.Struct({
+  after: Schema.optionalKey(Schema.Int),
+  limit: Schema.optionalKey(LogLimit),
+});
+
+type ComputerLogPage = typeof ComputerLogPage.Type;
+
+export { ComputerSecret } from "#src/contract/secret/secret.schema";
+
+export {
+  ComputerCopy,
+  ComputerCopyResult,
+  ComputerFileRequest,
+  computerFileBytes,
+} from "./files/computer-files.schema.js";
+
+export {
+  Computer,
+  ComputerLogLine,
+  ComputerLogPage,
+  ComputerName,
+  ComputerSize,
+  ComputerSpec,
+  ComputerState,
+  ExecRan,
+  ExecRequest,
+  ExecResult,
+  ExecUnknown,
+  execLimits,
+  logPageLines,
+};

package/src/contract/computer/computers-unavailable.errors.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+
+/** This engine runs no computers, or their provider didn't answer. */
+export class ComputersUnavailableError extends Schema.TaggedError<
+  ComputersUnavailableError,
+  { readonly brand: unique symbol }
+>()("ComputersUnavailableError", {
+  message: Schema.String,
+}) {}

package/src/contract/computer/files/computer-files.schema.ts

@@ -0,0 +1,31 @@
+import { Schema } from "effect";
+
+/** One file per call, bounded before crossing the host/control link. Paths are relative to the computer's files directory. */
+const computerFileBytes = 1_048_576;
+
+const ComputerFileRequest = Schema.TaggedUnion({
+  Read: { path: Schema.String },
+  Write: { content: Schema.Uint8ArrayFromBase64, path: Schema.String },
+});
+
+type ComputerFileRequest = typeof ComputerFileRequest.Type;
+
+const ComputerCopy = Schema.Struct({
+  computer: Schema.String,
+  computerPath: Schema.String,
+  direction: Schema.Literals(["toComputer", "fromComputer"]),
+  key: Schema.String,
+  path: Schema.String,
+});
+
+type ComputerCopy = typeof ComputerCopy.Type;
+
+/** Copy-back returns an upload receipt; only an actor command can attach it to an actor path. */
+const ComputerCopyResult = Schema.Struct({
+  bytes: Schema.Int,
+  receipt: Schema.optionalKey(Schema.String),
+});
+
+type ComputerCopyResult = typeof ComputerCopyResult.Type;
+
+export { ComputerCopy, ComputerCopyResult, ComputerFileRequest, computerFileBytes };

package/src/contract/computer/rpc/computer-rpc.contract.ts

@@ -0,0 +1,140 @@
+import { Schema } from "effect";
+import { Rpc } from "effect/rpc";
+
+import { HostedFailure } from "#src/contract/hosted/hosted-failure.schema";
+import { ComputerHeldError } from "#src/contract/computer/computer-held.errors";
+import { ComputerLostError } from "#src/contract/computer/computer-lost.errors";
+import { ComputerNotFoundError } from "#src/contract/computer/computer-not-found.errors";
+import { ComputersUnavailableError } from "#src/contract/computer/computers-unavailable.errors";
+import {
+  Computer,
+  ComputerLogLine,
+  ComputerLogPage,
+  ComputerCopy,
+  ComputerCopyResult,
+} from "#src/contract/computer/computer.schema";
+import { ComputerStep, StepPage } from "#src/contract/computer/step/computer-step.schema";
+import { StepNotFoundError } from "#src/contract/computer/step/step-not-found.errors";
+
+const ComputerRpcFailure = Schema.Union([
+  HostedFailure,
+  ComputerHeldError,
+  ComputerLostError,
+  ComputerNotFoundError,
+  ComputersUnavailableError,
+  StepNotFoundError,
+]);
+
+type ComputerRpcFailureSchema = typeof ComputerRpcFailure;
+
+type ComputerRpcFailureType = ComputerRpcFailureSchema["Type"];
+
+/** The actor's encoded key, as every actor RPC carries it. */
+const Keyed = { key: Schema.String };
+
+/** One computer of the actor, by name. */
+const Named = { computer: Schema.String, key: Schema.String };
+
+const Logs = { ...Named, ...ComputerLogPage.fields };
+
+/** A page of the actor's durable steps. */
+const Paged = { ...Keyed, ...StepPage.fields };
+
+/** One durable step of the actor, by its key. */
+const Stepped = { key: Schema.String, step: Schema.String };
+
+const Computers = Schema.Array(Computer);
+
+const Steps = Schema.Array(ComputerStep);
+
+const LogLines = Schema.Array(ComputerLogLine);
+
+/** Moves a computer to a state and answers it as it is then. */
+type ComputerMove = "pause" | "resume" | "stop";
+
+type ComputerRpcOperation = ComputerMove | "delete" | "files" | "get" | "list" | "logs" | "step" | "steps";
+
+type ComputerTag<
+  Operation extends ComputerRpcOperation = ComputerRpcOperation,
+  Actor extends string = string,
+> = `${Actor}/computer/${Operation}`;
+
+const computerTag = <Operation extends ComputerRpcOperation, Actor extends string>({
+  actor,
+  operation,
+}: {
+  readonly actor: Actor;
+  readonly operation: Operation;
+}): ComputerTag<Operation, Actor> => `${actor}/computer/${operation}`;
+
+type NamedRpc<Operation extends ComputerRpcOperation, Success extends Schema.Top, Actor extends string> = Rpc.Rpc<
+  ComputerTag<Operation, Actor>,
+  Schema.Struct<typeof Named>,
+  Success,
+  ComputerRpcFailureSchema
+>;
+
+/** One computer RPC of the actor named `Actor`, so a client of a known actor sends exact tags. */
+type ComputerRpc<Actor extends string = string> =
+  | Rpc.Rpc<ComputerTag<"files", Actor>, typeof ComputerCopy, typeof ComputerCopyResult, ComputerRpcFailureSchema>
+  | Rpc.Rpc<ComputerTag<"list", Actor>, Schema.Struct<typeof Keyed>, typeof Computers, ComputerRpcFailureSchema>
+  | Rpc.Rpc<ComputerTag<"logs", Actor>, Schema.Struct<typeof Logs>, typeof LogLines, ComputerRpcFailureSchema>
+  | Rpc.Rpc<ComputerTag<"steps", Actor>, Schema.Struct<typeof Paged>, typeof Steps, ComputerRpcFailureSchema>
+  | Rpc.Rpc<ComputerTag<"step", Actor>, Schema.Struct<typeof Stepped>, typeof ComputerStep, ComputerRpcFailureSchema>
+  | NamedRpc<"delete", typeof Schema.Void, Actor>
+  | NamedRpc<"get", typeof Computer, Actor>
+  | NamedRpc<"pause", typeof Computer, Actor>
+  | NamedRpc<"resume", typeof Computer, Actor>
+  | NamedRpc<"stop", typeof Computer, Actor>;
+
+const named = <Operation extends "get" | ComputerMove, Actor extends string>(
+  actor: Actor,
+  operation: Operation,
+): NamedRpc<Operation, typeof Computer, Actor> =>
+  Rpc.make(computerTag({ actor, operation }), { error: ComputerRpcFailure, payload: Named, success: Computer });
+
+/**
+ * An actor's computers as seen from outside the actor, under the tags docs/adr/0016 reserves:
+ * `<Actor>/computer/<operation>`. Every payload carries the actor's encoded key. `list` and `get` answer computers as
+ * they are; `pause`, `resume` and `stop` drive one there and answer it, and a `resume` of a computer a fork holds
+ * fails with `ComputerHeldError`; `delete` removes one with its disk and answers nothing, so a client confirms it
+ * first; `logs` reads a page of its log. There is no outside `exec` and no `ensure`: only the actor makes and runs
+ * its computers. `steps` reads a page of the actor's durable steps, newest first, and `step` one step by its key with its
+ * output (`StepNotFoundError` when the journal has none); both read the actor's own journal, not a computer.
+ */
+const computerRpcsOf = <Actor extends string>(actor: Actor): readonly ComputerRpc<Actor>[] => [
+  Rpc.make(computerTag({ actor, operation: "files" }), {
+    error: ComputerRpcFailure,
+    payload: ComputerCopy,
+    success: ComputerCopyResult,
+  }),
+  Rpc.make(computerTag({ actor, operation: "list" }), {
+    error: ComputerRpcFailure,
+    payload: Keyed,
+    success: Computers,
+  }),
+  named(actor, "get"),
+  named(actor, "pause"),
+  named(actor, "resume"),
+  named(actor, "stop"),
+  Rpc.make(computerTag({ actor, operation: "delete" }), {
+    error: ComputerRpcFailure,
+    payload: Named,
+    success: Schema.Void,
+  }),
+  Rpc.make(computerTag({ actor, operation: "logs" }), {
+    error: ComputerRpcFailure,
+    payload: Logs,
+    success: LogLines,
+  }),
+  Rpc.make(computerTag({ actor, operation: "steps" }), { error: ComputerRpcFailure, payload: Paged, success: Steps }),
+  Rpc.make(computerTag({ actor, operation: "step" }), {
+    error: ComputerRpcFailure,
+    payload: Stepped,
+    success: ComputerStep,
+  }),
+];
+
+export { computerRpcsOf, computerTag };
+
+export type { ComputerMove, ComputerRpc, ComputerRpcFailureType, ComputerRpcOperation, ComputerTag };

package/src/contract/computer/step/computer-step.contract.ts

@@ -0,0 +1,126 @@
+import { Clock, Duration, Effect, Schedule, Schema, Struct } from "effect";
+import { Activity } from "effect/workflow";
+import type { WorkflowEngine } from "effect/workflow";
+
+import { ActorUnavailableError } from "#src/contract/client/actor-unavailable.errors";
+import type { ComputerClient, ComputerClientFailure } from "#src/contract/computer/computer-client.contract";
+import { ComputersUnavailableError } from "#src/contract/computer/computers-unavailable.errors";
+import { ExecRan, ExecUnknown, execLimits } from "#src/contract/computer/computer.schema";
+import type { ExecResult } from "#src/contract/computer/computer.schema";
+import { StepEnd, StepStart } from "./computer-step.schema.js";
+import type { StepRequest } from "./computer-step.schema.js";
+import { StepFailure } from "./step-failure.schema.js";
+
+/**
+ * How long past its own time limit a step keeps asking for its outcome, measured from when it was first journaled: the
+ * time between journaling and the computer starting the command, which a lost reply or a restart can stretch.
+ */
+const graceSeconds = 10;
+
+/** How often a step asks again while its computer is unreachable or its command has no outcome yet. */
+const askEverySeconds = 2;
+
+const millis = 1000;
+
+const none = 0;
+
+/** The step was sent before and its command has no recorded outcome yet: it may still be running. */
+class NoOutcomeYetError extends Schema.TaggedError<NoOutcomeYetError, { readonly brand: unique symbol }>()(
+  "NoOutcomeYetError",
+  {},
+) {}
+
+/** Failures that say nothing about the step: the engine or control plane between the job and the computer is away. */
+const isPassing = Schema.is(Schema.Union([ActorUnavailableError, ComputersUnavailableError, NoOutcomeYetError]));
+
+const isRan = Schema.is(ExecRan);
+
+const sentOnce = (
+  client: ComputerClient,
+  request: StepRequest,
+  start: StepStart,
+): Effect.Effect<ExecResult, ComputerClientFailure | NoOutcomeYetError> => {
+  const sent = client.exec(start.computer, {
+    ...Struct.omit(request, ["name"]),
+    key: start.key,
+    timeoutSeconds: start.timeoutSeconds,
+  });
+
+  return Effect.filterOrFail(sent, isRan, () => NoOutcomeYetError.make({}));
+};
+
+/**
+ * Sends the step under its key until it has an outcome, asking again while its computer is unreachable or its command
+ * runs on past a lost reply, until its time limit and the grace have passed since it was first journaled. The key
+ * makes every send after the first read the command's outcome back instead of running it again. Past the deadline with
+ * no outcome the step is `Unknown`: it may have done its work, and it never runs again.
+ */
+const settled = (
+  client: ComputerClient,
+  request: StepRequest,
+  start: StepStart,
+): Effect.Effect<StepEnd, ComputerClientFailure> =>
+  Effect.gen(function* settledStep() {
+    const now = yield* Clock.currentTimeMillis;
+    const deadline = start.startedAt + (start.timeoutSeconds + graceSeconds) * millis;
+    const remaining = Duration.millis(Math.max(none, deadline - now));
+    const asking = Schedule.spaced(Duration.seconds(askEverySeconds)).pipe(Schedule.upTo({ duration: remaining }));
+
+    const outcome = yield* sentOnce(client, request, start).pipe(
+      Effect.retry({ schedule: asking, while: isPassing }),
+      Effect.catchIf(isPassing, (): Effect.Effect<ExecResult> => Effect.succeed(ExecUnknown.make({}))),
+    );
+
+    const endedAt = yield* Clock.currentTimeMillis;
+
+    return { endedAt, outcome };
+  });
+
+const started = (
+  computer: string,
+  request: StepRequest,
+): Effect.Effect<StepStart, never, WorkflowEngine.WorkflowInstance> =>
+  Effect.gen(function* startedStep() {
+    const key = yield* Activity.idempotencyKey(`step/${request.name}`);
+    const startedAt = yield* Clock.currentTimeMillis;
+    const timeoutSeconds = request.timeoutSeconds ?? execLimits.seconds;
+
+    return { command: request.command, computer, key, startedAt, timeoutSeconds };
+  });
+
+/**
+ * Runs one command in one of the actor's computers as a durable step of the job that calls it, and answers its
+ * outcome. The step journals where it runs, its key and when it started before it sends anything, then its outcome,
+ * so `akter steps` reads it from the actor. A job replayed after a host or control plane restart reads both back: a
+ * settled step answers its journaled outcome without reaching the computer, and a step cut off mid-flight sends the
+ * same key again, which reads the command's own recorded outcome back and never runs it a second time. A command whose
+ * outcome no send could read before its deadline answers `Unknown`; reconcile it with the outside system by its key.
+ * Call it from a job, never from inside an activity, and give each step of a job its own name.
+ */
+const step = ({
+  client,
+  computer,
+  request,
+}: {
+  readonly client: ComputerClient;
+  readonly computer: string;
+  readonly request: StepRequest;
+}): Effect.Effect<ExecResult, ComputerClientFailure, WorkflowEngine.WorkflowEngine | WorkflowEngine.WorkflowInstance> =>
+  Effect.gen(function* durableStep() {
+    const start = yield* Activity.make({
+      execute: started(computer, request),
+      name: `step-start/${request.name}`,
+      success: StepStart,
+    });
+
+    const end = yield* Activity.make({
+      error: StepFailure,
+      execute: settled(client, request, start),
+      name: `step/${request.name}`,
+      success: StepEnd,
+    });
+
+    return end.outcome;
+  });
+
+export { step };

package/src/contract/computer/step/computer-step.schema.ts

@@ -0,0 +1,80 @@
+import { Schema } from "effect";
+
+import { ExecRequest, ExecResult } from "#src/contract/computer/computer.schema";
+
+const nameLength = 63;
+const smallest = 1;
+const stepPage = 100;
+const largestPage = 1000;
+
+/** A step's name, unique among its job's steps: lowercase letters, digits, dots, underscores and hyphens. */
+const StepName = Schema.String.check(
+  Schema.isPattern(new RegExp(`^[a-z0-9][a-z0-9._-]{0,${nameLength - smallest}}$`, "u")),
+).annotate({ description: "A step's name, unique among its job's steps." });
+
+const { command, cwd, stdin, timeoutSeconds } = ExecRequest.fields;
+
+/**
+ * One durable step of a job (`step` on an actor's computers): the exec request without its key, which the step derives from its job and
+ * name, so the same step in a replayed job sends the same key.
+ */
+const StepRequest = Schema.Struct({ command, cwd, name: StepName, stdin, timeoutSeconds });
+
+type StepRequest = typeof StepRequest.Type;
+
+/** What a step journals before it sends anything: where it runs, its key, and when it first started. */
+const StepStart = Schema.Struct({
+  command: Schema.String,
+  computer: Schema.String,
+  key: Schema.String,
+  startedAt: Schema.Int,
+  timeoutSeconds: Schema.Int,
+});
+
+type StepStart = typeof StepStart.Type;
+
+/** What a step journals once it settles: its outcome, and when it settled. */
+const StepEnd = Schema.Struct({ endedAt: Schema.Int, outcome: ExecResult });
+
+type StepEnd = typeof StepEnd.Type;
+
+/**
+ * Where a step is. `running` has no outcome yet; `ran` ended with its exit code and output; `unknown` started and has no
+ * recorded outcome, so it may or may not have done its work, and is never run again; `failed` could not run, such as on
+ * a lost computer.
+ */
+const StepState = Schema.Literals(["running", "ran", "unknown", "failed"]);
+
+type StepState = typeof StepState.Type;
+
+/**
+ * One step as the actor's journal holds it. `step` is its key, the id a reader asks for it by and the key an outside
+ * system reconciles an `unknown` step with. Output is only in a single step's read.
+ */
+const ComputerStep = Schema.Struct({
+  command: Schema.String,
+  computer: Schema.String,
+  endedAt: Schema.optionalKey(Schema.Int),
+  exitCode: Schema.optionalKey(Schema.Int),
+  failure: Schema.optionalKey(Schema.String),
+  job: Schema.String,
+  name: Schema.String,
+  startedAt: Schema.Int,
+  state: StepState,
+  stderr: Schema.optionalKey(Schema.String),
+  stdout: Schema.optionalKey(Schema.String),
+  step: Schema.String,
+  timeoutSeconds: Schema.Int,
+  truncated: Schema.optionalKey(Schema.Boolean),
+});
+
+type ComputerStep = typeof ComputerStep.Type;
+
+const StepLimit = Schema.Int.check(Schema.isBetween({ maximum: largestPage, minimum: smallest }));
+
+/** A page of an actor's steps, newest first: at most `limit` (1 to 1,000; 100 when absent). */
+const StepPage = Schema.Struct({ limit: Schema.optionalKey(StepLimit) });
+
+type StepPage = typeof StepPage.Type;
+
+export { ComputerStep, StepEnd, StepPage, StepRequest, StepStart, StepState, largestPage, stepPage };

package/src/contract/computer/step/step-failure.schema.ts

@@ -0,0 +1,26 @@
+import { Schema } from "effect";
+
+import { CallerNotAllowedError } from "#src/contract/caller/caller-not-allowed.errors";
+import { UnauthenticatedError } from "#src/contract/caller/unauthenticated.errors";
+import { ActorUnavailableError } from "#src/contract/client/actor-unavailable.errors";
+import { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
+import { ComputerHeldError } from "#src/contract/computer/computer-held.errors";
+import { ComputerLimitError } from "#src/contract/computer/computer-limit.errors";
+import { ComputerLostError } from "#src/contract/computer/computer-lost.errors";
+import { ComputerNotFoundError } from "#src/contract/computer/computer-not-found.errors";
+import { ComputersUnavailableError } from "#src/contract/computer/computers-unavailable.errors";
+
+/** Every failure a computer client can answer, as a schema, so a step journals the one it settled with. */
+const StepFailure = Schema.Union([
+  ActorUnavailableError,
+  CallerNotAllowedError,
+  ComputerHeldError,
+  ComputerLimitError,
+  ComputerLostError,
+  ComputerNotFoundError,
+  ComputersUnavailableError,
+  InvalidRequestError,
+  UnauthenticatedError,
+]);
+
+export { StepFailure };

package/src/contract/computer/step/step-not-found.errors.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+
+/** The actor's journal holds no durable step with that key. */
+export class StepNotFoundError extends Schema.TaggedError<StepNotFoundError, { readonly brand: unique symbol }>()(
+  "StepNotFoundError",
+  { step: Schema.String },
+) {}