@gjermundgaraba/clankerbox-sdk 0.15.6 → 0.16.0

package/dist/client-DgDb-TR7.d.mts

@@ -0,0 +1,958 @@
+import * as Action from "@gjermundgaraba/effect-actions/Action";
+import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
+import { Context, Duration, Effect, Layer, Schema } from "effect";
+import { HttpClient } from "effect/http";
+//#region src/errors.d.ts
+declare const Invalid_base: Schema.Class<Invalid, Schema.TaggedStruct<"Invalid", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly file: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The request is malformed, or the host list is one a client can't route by, or a config,
+ * profile or setup file couldn't be read or doesn't hold what it should: then `file` names it.
+ */
+declare class Invalid extends Invalid_base {
+  get retryable(): boolean;
+}
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The machine or checkpoint doesn't exist. A `delete` that meets it is done. */
+declare class NotFound extends NotFound_base {
+  get retryable(): boolean;
+}
+declare const ConflictKind: Schema.Literals<readonly ["exists", "busy"]>;
+type ConflictKind = typeof ConflictKind.Type;
+declare const Conflict_base: Schema.Class<Conflict, Schema.TaggedStruct<"Conflict", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly kind: Schema.Literals<readonly ["exists", "busy"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The name is taken (`exists`), or another action holds the resource (`busy`). */
+declare class Conflict extends Conflict_base {
+  get retryable(): boolean;
+}
+declare const Precondition_base: Schema.Class<Precondition, Schema.TaggedStruct<"Precondition", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The resource's state doesn't allow the action, or no host offers the requested base. */
+declare class Precondition extends Precondition_base {
+  get retryable(): boolean;
+}
+declare const Capacity_base: Schema.Class<Capacity, Schema.TaggedStruct<"Capacity", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The host has no room now; room can free up, so a later call may succeed. */
+declare class Capacity extends Capacity_base {
+  get retryable(): boolean;
+}
+declare const Unavailable_base: Schema.Class<Unavailable, Schema.TaggedStruct<"Unavailable", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly readOnly: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No reply: only the client library makes it. A mutation's request may have reached the host
+ * and run, so it is retryable only when `readOnly`.
+ */
+declare class Unavailable extends Unavailable_base {
+  get retryable(): boolean;
+}
+declare const Internal_base: Schema.Class<Internal, Schema.TaggedStruct<"Internal", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class Internal extends Internal_base {
+  get retryable(): boolean;
+}
+/** What a host may answer with; each action declares its own share. */
+declare const hostErrors: readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal];
+type HostError = InstanceType<(typeof hostErrors)[number]>;
+declare const ClankerboxError: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal, typeof Unavailable]>;
+type ClankerboxError = typeof ClankerboxError.Type;
+declare const HostErrorTag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+type HostErrorTag = typeof HostErrorTag.Type;
+//#endregion
+//#region src/api.d.ts
+/** A host bounds its own reads of runtime state under it, so a list answers in time. */
+declare const readTimeout: Duration.Duration;
+declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+  readonly made: Schema.Boolean;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+  readonly ssh: Schema.optionalKey<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"getMachine", Schema.Struct<{
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+  readonly made: Schema.Boolean;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+  readonly ssh: Schema.optionalKey<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"createMachine", Schema.Struct<{
+  readonly base: Schema.String;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly setup: Schema.optionalKey<Schema.Struct<{
+    readonly script: Schema.String;
+    readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+  }>>;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+  readonly made: Schema.Boolean;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+  readonly ssh: Schema.optionalKey<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"startMachine", Schema.Struct<{
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+  readonly made: Schema.Boolean;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+  readonly ssh: Schema.optionalKey<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"stopMachine", Schema.Struct<{
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+  readonly made: Schema.Boolean;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+  readonly ssh: Schema.optionalKey<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"deleteMachine", Schema.Struct<{
+  readonly id: Schema.String;
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"forkMachine", Schema.Struct<{
+  readonly machine: Schema.String;
+  readonly name: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+  readonly made: Schema.Boolean;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+  readonly ssh: Schema.optionalKey<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"restoreMachine", Schema.Struct<{
+  readonly checkpoint: Schema.String;
+  readonly name: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+  readonly made: Schema.Boolean;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+  readonly ssh: Schema.optionalKey<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"listCheckpoints", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+  readonly id: Schema.String;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly machine: Schema.String;
+  readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+}>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"getCheckpoint", Schema.Struct<{
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly machine: Schema.String;
+  readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"captureCheckpoint", Schema.Struct<{
+  readonly machine: Schema.String;
+  readonly name: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly machine: Schema.String;
+  readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"deleteCheckpoint", Schema.Struct<{
+  readonly id: Schema.String;
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"getHost", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly version: Schema.String;
+  readonly runtimeVersion: Schema.String;
+  readonly captureFrom: Schema.Literals<readonly ["running", "stopped"]>;
+  readonly bases: Schema.$Array<Schema.String>;
+}>, readonly (typeof Invalid)[], true, typeof Action.Anyone>, Action.Action<"getCapacity", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+  readonly host: Schema.String;
+  readonly resource: Schema.Literals<readonly ["ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+  readonly limit: Schema.Int;
+  readonly used: Schema.Int;
+}>>, readonly (typeof Invalid | typeof Precondition | typeof Internal)[], true, typeof Action.Anyone>], [], undefined>;
+declare const actionsByName: {
+  readonly captureCheckpoint: Action.Action<"captureCheckpoint", Schema.Struct<{
+    readonly machine: Schema.String;
+    readonly name: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly machine: Schema.String;
+    readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  readonly createMachine: Action.Action<"createMachine", Schema.Struct<{
+    readonly base: Schema.String;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly setup: Schema.optionalKey<Schema.Struct<{
+      readonly script: Schema.String;
+      readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+    }>>;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly id: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+    readonly made: Schema.Boolean;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+    readonly ssh: Schema.optionalKey<Schema.Struct<{
+      readonly host: Schema.String;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  readonly deleteCheckpoint: Action.Action<"deleteCheckpoint", Schema.Struct<{
+    readonly id: Schema.String;
+  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Internal)[], false, typeof Action.Anyone>;
+  readonly deleteMachine: Action.Action<"deleteMachine", Schema.Struct<{
+    readonly id: Schema.String;
+  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Internal)[], false, typeof Action.Anyone>;
+  readonly forkMachine: Action.Action<"forkMachine", Schema.Struct<{
+    readonly machine: Schema.String;
+    readonly name: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+    readonly made: Schema.Boolean;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+    readonly ssh: Schema.optionalKey<Schema.Struct<{
+      readonly host: Schema.String;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  readonly getCapacity: Action.Action<"getCapacity", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly resource: Schema.Literals<readonly ["ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+    readonly limit: Schema.Int;
+    readonly used: Schema.Int;
+  }>>, readonly (typeof Invalid | typeof Precondition | typeof Internal)[], true, typeof Action.Anyone>;
+  readonly getCheckpoint: Action.Action<"getCheckpoint", Schema.Struct<{
+    readonly id: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly machine: Schema.String;
+    readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], true, typeof Action.Anyone>;
+  readonly getHost: Action.Action<"getHost", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly version: Schema.String;
+    readonly runtimeVersion: Schema.String;
+    readonly captureFrom: Schema.Literals<readonly ["running", "stopped"]>;
+    readonly bases: Schema.$Array<Schema.String>;
+  }>, readonly (typeof Invalid)[], true, typeof Action.Anyone>;
+  readonly getMachine: Action.Action<"getMachine", Schema.Struct<{
+    readonly id: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+    readonly made: Schema.Boolean;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+    readonly ssh: Schema.optionalKey<Schema.Struct<{
+      readonly host: Schema.String;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], true, typeof Action.Anyone>;
+  readonly listCheckpoints: Action.Action<"listCheckpoints", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly machine: Schema.String;
+    readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+  }>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>;
+  readonly listMachines: Action.Action<"listMachines", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+    readonly made: Schema.Boolean;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+    readonly ssh: Schema.optionalKey<Schema.Struct<{
+      readonly host: Schema.String;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>;
+  readonly restoreMachine: Action.Action<"restoreMachine", Schema.Struct<{
+    readonly checkpoint: Schema.String;
+    readonly name: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+    readonly made: Schema.Boolean;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+    readonly ssh: Schema.optionalKey<Schema.Struct<{
+      readonly host: Schema.String;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  readonly startMachine: Action.Action<"startMachine", Schema.Struct<{
+    readonly id: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+    readonly made: Schema.Boolean;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+    readonly ssh: Schema.optionalKey<Schema.Struct<{
+      readonly host: Schema.String;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  readonly stopMachine: Action.Action<"stopMachine", Schema.Struct<{
+    readonly id: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+    readonly made: Schema.Boolean;
+    readonly action: Schema.Union<readonly [Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly status: Schema.Literal<"failed">;
+      readonly error: Schema.Struct<{
+        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+        readonly message: Schema.String;
+      }>;
+    }>]>;
+    readonly ssh: Schema.optionalKey<Schema.Struct<{
+      readonly host: Schema.String;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Internal)[], false, typeof Action.Anyone>;
+};
+//#endregion
+//#region src/resources.d.ts
+declare const Runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+type Runtime = typeof Runtime.Type;
+/** The mutations that record themselves on a resource's `action`. */
+declare const ActionName: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+type ActionName = typeof ActionName.Type;
+declare const ActionStatus: Schema.Literals<readonly ["running", "failed", "done"]>;
+type ActionStatus = typeof ActionStatus.Type;
+/** A resource's last action; the next action replaces it. */
+declare const ActionRecord: Schema.Union<readonly [Schema.Struct<{
+  readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+  readonly status: Schema.Literals<readonly ["running", "done"]>;
+}>, Schema.Struct<{
+  readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+  readonly status: Schema.Literal<"failed">;
+  readonly error: Schema.Struct<{
+    readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+    readonly message: Schema.String;
+  }>;
+}>]>;
+type ActionRecord = typeof ActionRecord.Type;
+/** A checkpoint is only ever captured or deleted. */
+declare const CheckpointActionName: Schema.Literals<readonly ["capture", "delete"]>;
+type CheckpointActionName = typeof CheckpointActionName.Type;
+declare const CheckpointActionRecord: Schema.Union<readonly [Schema.Struct<{
+  readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+  readonly status: Schema.Literals<readonly ["running", "done"]>;
+}>, Schema.Struct<{
+  readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+  readonly status: Schema.Literal<"failed">;
+  readonly error: Schema.Struct<{
+    readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+    readonly message: Schema.String;
+  }>;
+}>]>;
+type CheckpointActionRecord = typeof CheckpointActionRecord.Type;
+declare const SshEndpoint: Schema.Struct<{
+  readonly host: Schema.String;
+  readonly port: Schema.Int;
+}>;
+type SshEndpoint = typeof SshEndpoint.Type;
+declare const SshLogin: Schema.Struct<{
+  readonly host: Schema.String;
+  readonly port: Schema.Int;
+  readonly user: Schema.String;
+}>;
+type SshLogin = typeof SshLogin.Type;
+declare const Machine: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  /** `missing`: the runtime doesn't have it; `unknown`: it couldn't be read. */
+  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
+  /** Until its create, fork or restore has made it, it can only be read, stopped or deleted. */
+  readonly made: Schema.Boolean;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+  /** Only on a running machine whose runtime gives it an endpoint. */
+  readonly ssh: Schema.optionalKey<Schema.Struct<{
+    readonly host: Schema.String;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  /** `<type> <base64>`, once preparation has recorded it. */
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>;
+type Machine = typeof Machine.Type;
+declare const Checkpoint: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly machine: Schema.String;
+  /** `ram` (RAM and disks) on smolvm, `disk` on Tart and boat. */
+  readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+  readonly base: Schema.String;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly action: Schema.Union<readonly [Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly status: Schema.Literal<"failed">;
+    readonly error: Schema.Struct<{
+      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
+      readonly message: Schema.String;
+    }>;
+  }>]>;
+}>;
+type Checkpoint = typeof Checkpoint.Type;
+declare const Host: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly version: Schema.String;
+  /** For boat, its API version. */
+  readonly runtimeVersion: Schema.String;
+  /** The state a machine must be in to be captured: Tart's is `stopped`. */
+  readonly captureFrom: Schema.Literals<readonly ["running", "stopped"]>;
+  readonly bases: Schema.$Array<Schema.String>;
+}>;
+type Host = typeof Host.Type;
+/**
+ * `used` is counted as a `Capacity` refusal counts it, so it needn't match the host's own
+ * machines.
+ */
+declare const Limit: Schema.Struct<{
+  readonly host: Schema.String;
+  /**
+   * `ramMib`: smolvm's RAM budget. `runningVms`: Tart's, Apple's two VMs per Mac.
+   * `activeSandboxes` and the `starts` of each rolling window: the boat account's.
+   */
+  readonly resource: Schema.Literals<readonly ["ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+  readonly limit: Schema.Int;
+  readonly used: Schema.Int;
+}>;
+type Limit = typeof Limit.Type;
+/** Nothing logs the script: it can carry secrets. */
+declare const Setup: Schema.Struct<{
+  readonly script: Schema.String;
+  readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+}>;
+type Setup = typeof Setup.Type;
+/** A profile file fills these in; the host sees only the `profile` label. */
+declare const MachineSpec: Schema.Struct<{
+  base: Schema.String;
+  cpu: Schema.Int;
+  ramMib: Schema.Int;
+  diskGib: Schema.Int;
+  setup: Schema.optionalKey<Schema.Struct<{
+    readonly script: Schema.String;
+    readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+  }>>;
+  profile: Schema.optionalKey<Schema.String>;
+}>;
+type MachineSpec = typeof MachineSpec.Type;
+/** The host checks that `id` names it, so a create never lands under another host's ID. */
+declare const CreateRequest: Schema.Struct<{
+  readonly base: Schema.String;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly setup: Schema.optionalKey<Schema.Struct<{
+    readonly script: Schema.String;
+    readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+  }>>;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.String;
+}>;
+type CreateRequest = typeof CreateRequest.Type;
+declare namespace client_d_exports {
+  export { Client, CreateOptions, ErrorOf, Gathered, HostAction, HostEntry, Interface, Options, Unreachable, layer, make };
+}
+/** `id` is the host part of every ID the host holds. */
+declare const HostEntry: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly url: Schema.String;
+}>;
+type HostEntry = typeof HostEntry.Type;
+type Actions = typeof actionsByName;
+/** An action of the host API, by name. */
+type HostAction = keyof Actions;
+/**
+ * What a call of `N` fails with: an error the action declares, which always includes `Invalid`,
+ * or no reply, or a reply the client couldn't use.
+ */
+type ErrorOf<N extends HostAction> = Actions[N]["error"][number]["Type"] | Unavailable | Internal;
+interface Unreachable {
+  readonly host: string;
+  readonly error: ClankerboxError;
+}
+/** A fan-out's result: a host that fails is named, and fails nothing else. */
+interface Gathered<A> {
+  readonly answers: ReadonlyArray<A>;
+  readonly unreachable: ReadonlyArray<Unreachable>;
+}
+interface Options {
+  /**
+   * The wait for a mutation's reply, unbounded by default, as a create's setup can take hours.
+   * It ends only the wait: a mutation that outlasts it fails like a lost reply.
+   */
+  readonly timeout?: Duration.Duration | undefined;
+  /** The wait for a read's reply, `readTimeout` by default; a fan-out bounds each host's own. */
+  readonly readTimeout?: Duration.Duration | undefined;
+}
+interface CreateOptions {
+  /** The host to create on, instead of the first that offers the base. */
+  readonly host?: string | undefined;
+}
+interface Interface {
+  readonly hosts: Effect.Effect<Gathered<Host>>;
+  readonly machines: Effect.Effect<Gathered<Machine>>;
+  readonly checkpoints: Effect.Effect<Gathered<Checkpoint>>;
+  /** A host whose runtime couldn't be read is among the unreachable. */
+  readonly capacity: Effect.Effect<Gathered<Limit>>;
+  readonly machine: (id: string) => Effect.Effect<Machine, ErrorOf<"getMachine">>;
+  readonly checkpoint: (id: string) => Effect.Effect<Checkpoint, ErrorOf<"getCheckpoint">>;
+  /** The host a create of `base` goes to, read even when `options.host` names it. */
+  readonly place: (base: string, options?: CreateOptions) => Effect.Effect<Host, ErrorOf<"getHost"> | Precondition>;
+  readonly create: (name: string, spec: MachineSpec, options?: CreateOptions) => Effect.Effect<Machine, ErrorOf<"createMachine">>;
+  readonly start: (id: string) => Effect.Effect<Machine, ErrorOf<"startMachine">>;
+  readonly stop: (id: string) => Effect.Effect<Machine, ErrorOf<"stopMachine">>;
+  readonly delete: (id: string) => Effect.Effect<void, ErrorOf<"deleteMachine">>;
+  /** Copies a machine to a new name on its host. */
+  readonly fork: (machine: string, name: string) => Effect.Effect<Machine, ErrorOf<"forkMachine">>;
+  /** Creates a machine named `name` from a checkpoint, on the checkpoint's host. */
+  readonly restore: (checkpoint: string, name: string) => Effect.Effect<Machine, ErrorOf<"restoreMachine">>;
+  readonly capture: (machine: string, name: string) => Effect.Effect<Checkpoint, ErrorOf<"captureCheckpoint">>;
+  readonly deleteCheckpoint: (id: string) => Effect.Effect<void, ErrorOf<"deleteCheckpoint">>;
+}
+declare const Client_base: Context.ServiceClass<Client, "@gjermundgaraba/clankerbox-sdk/Client", Interface>;
+/**
+ * Nothing retries: a mutation whose reply is lost or times out is `Unavailable`, and the caller
+ * reads the resource to see what happened.
+ */
+declare class Client extends Client_base {}
+/**
+ * A client over `hosts`, in placement order. It sends nothing until called. An empty list, a
+ * malformed entry or a host ID that appears twice is Invalid.
+ */
+declare const make: (hosts: ReadonlyArray<HostEntry>, options?: Options) => Effect.Effect<Interface, Invalid, HttpClient.HttpClient>;
+declare const layer: (hosts: ReadonlyArray<HostEntry>, options?: Options) => Layer.Layer<Client, Invalid, HttpClient.HttpClient>;
+//#endregion
+export { HostErrorTag as A, actionsByName as C, Conflict as D, ClankerboxError as E, Unavailable as F, hostErrors as I, Invalid as M, NotFound as N, ConflictKind as O, Precondition as P, Http as S, Capacity as T, MachineSpec as _, Options as a, SshEndpoint as b, ActionRecord as c, CheckpointActionName as d, CheckpointActionRecord as f, Machine as g, Limit as h, Interface as i, Internal as j, HostError as k, ActionStatus as l, Host as m, CreateOptions as n, client_d_exports as o, CreateRequest as p, HostEntry as r, ActionName as s, Client as t, Checkpoint as u, Runtime as v, readTimeout as w, SshLogin as x, Setup as y };