@gjermundgaraba/clankerbox-sdk 0.16.0 → 0.18.0

package/dist/{client-DgDb-TR7.d.mts → client-8af586hb.d.mts}

@@ -7,6 +7,7 @@ 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 made: Schema.optionalKey<Schema.String>;
   readonly message: Schema.String;
   readonly file: Schema.optionalKey<Schema.String>;
 }>, import("effect/Cause").YieldableError>;
@@ -14,56 +15,134 @@ declare const Invalid_base: Schema.Class<Invalid, Schema.TaggedStruct<"Invalid",
  * 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 class Invalid extends Invalid_base {}
 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 made: 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 class NotFound extends NotFound_base {}
 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 made: 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", {
+declare class Conflict extends Conflict_base {}
+declare const NotOffered_base: Schema.Class<NotOffered, Schema.TaggedStruct<"NotOffered", {
   readonly host: Schema.optionalKey<Schema.String>;
   readonly action: Schema.optionalKey<Schema.String>;
   readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
   readonly message: Schema.String;
+  readonly base: 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;
-}
+/** No host offers `base`: the host a create names, or any in the client's list. */
+declare class NotOffered extends NotOffered_base {}
+declare const NotMade_base: Schema.Class<NotMade, Schema.TaggedStruct<"NotMade", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly machine: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `machine`'s create, fork or restore failed before it was made: it can only be deleted. */
+declare class NotMade extends NotMade_base {}
+declare const Missing_base: Schema.Class<Missing, Schema.TaggedStruct<"Missing", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly machine: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The runtime no longer has `machine`: it can only be deleted. */
+declare class Missing extends Missing_base {}
+declare const NotReady_base: Schema.Class<NotReady, Schema.TaggedStruct<"NotReady", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly checkpoint: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `checkpoint`'s capture failed, so nothing restores from it: it can only be deleted. */
+declare class NotReady extends NotReady_base {}
+declare const PinMismatch_base: Schema.Class<PinMismatch, Schema.TaggedStruct<"PinMismatch", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly checkpoint: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `checkpoint` holds RAM state saved under another runtime pin than the one the host runs. */
+declare class PinMismatch extends PinMismatch_base {}
+declare const WrongState_base: Schema.Class<WrongState, Schema.TaggedStruct<"WrongState", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly machine: Schema.String;
+  readonly state: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** `machine` is in `state`, which the action doesn't act from. */
+declare class WrongState extends WrongState_base {}
+declare const Unsizable_base: Schema.Class<Unsizable, Schema.TaggedStruct<"Unsizable", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The runtime can't give the requested sizes, such as a disk below the base's. */
+declare class Unsizable extends Unsizable_base {}
+declare const ScriptFailed_base: Schema.Class<ScriptFailed, Schema.TaggedStruct<"ScriptFailed", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+  readonly script: Schema.Literals<readonly ["setup", "preparation"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A guest script exited non-zero or ran past its timeout; the message says which, with its
+ * output's tail. A failed `setup` leaves the machine unmade, a failed `preparation` made.
+ */
+declare class ScriptFailed extends ScriptFailed_base {}
+declare const Refused_base: Schema.Class<Refused, Schema.TaggedStruct<"Refused", {
+  readonly host: Schema.optionalKey<Schema.String>;
+  readonly action: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.String>;
+  readonly made: Schema.optionalKey<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The provider under the runtime refused the call for good, such as for its plan or API key. */
+declare class Refused extends Refused_base {}
 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 made: 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 class Capacity extends Capacity_base {}
 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 made: Schema.optionalKey<Schema.String>;
   readonly message: Schema.String;
   readonly readOnly: Schema.Boolean;
 }>, import("effect/Cause").YieldableError>;
@@ -71,25 +150,32 @@ declare const Unavailable_base: Schema.Class<Unavailable, Schema.TaggedStruct<"U
  * 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 class Unavailable extends Unavailable_base {}
 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 made: Schema.optionalKey<Schema.String>;
   readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-declare class Internal extends Internal_base {
-  get retryable(): boolean;
-}
+declare class Internal extends Internal_base {}
 /** 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]>;
+declare const hostErrors: readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal];
+declare const HostError: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
+type HostError = typeof HostError.Type;
+/**
+ * Each carries, where known: `host` and `action`, which the client sets; `id`, the resource the
+ * error is about, which a host sets on `NotFound` and `Conflict` and the client sets to the call's
+ * subject otherwise; and `made`, the resource a create, fork, restore or capture makes, which a
+ * failure may leave behind.
+ */
+declare const ClankerboxError: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, 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;
+/**
+ * Whether the same call may succeed later: a busy resource or a full host may free up, and a read
+ * that got no reply may get one.
+ */
+declare const retryable: (error: ClankerboxError) => boolean;
 //#endregion
 //#region src/api.d.ts
 /** A host bounds its own reads of runtime state under it, so a list answers in time. */
@@ -106,15 +192,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -136,15 +219,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -175,15 +255,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -191,7 +268,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
     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 (typeof Invalid | typeof Conflict | typeof NotOffered | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"startMachine", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
@@ -205,15 +282,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -221,7 +295,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
     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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"stopMachine", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
@@ -235,15 +309,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -251,9 +322,9 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
     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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | 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<{
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"forkMachine", Schema.Struct<{
   readonly machine: Schema.String;
   readonly name: Schema.String;
 }>, Schema.Struct<{
@@ -268,15 +339,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -284,7 +352,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
     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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"restoreMachine", Schema.Struct<{
   readonly checkpoint: Schema.String;
   readonly name: Schema.String;
 }>, Schema.Struct<{
@@ -299,15 +367,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -315,7 +380,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
     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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotReady | typeof PinMismatch | typeof Unsizable | typeof ScriptFailed | typeof Refused | 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;
@@ -326,15 +391,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
 }>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"getCheckpoint", Schema.Struct<{
   readonly id: Schema.String;
@@ -349,15 +411,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
 }>, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"captureCheckpoint", Schema.Struct<{
   readonly machine: Schema.String;
@@ -373,31 +432,33 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"deleteCheckpoint", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Refused | 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<{
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | 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 (typeof Invalid)[], true, typeof Action.Anyone>, Action.Action<"getCapacity", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
   readonly host: Schema.String;
-  readonly resource: Schema.Literals<readonly ["ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
-  readonly limit: Schema.Int;
+  readonly resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
   readonly used: Schema.Int;
-}>>, readonly (typeof Invalid | typeof Precondition | typeof Internal)[], true, typeof Action.Anyone>], [], undefined>;
+}>, Schema.Struct<{
+  readonly host: Schema.String;
+  readonly resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
+  readonly unread: Schema.$Array<Schema.String>;
+}>]>>, readonly (typeof Invalid | typeof Refused | typeof Internal)[], true, typeof Action.Anyone>], [], undefined>;
 declare const actionsByName: {
   readonly captureCheckpoint: Action.Action<"captureCheckpoint", Schema.Struct<{
     readonly machine: Schema.String;
@@ -413,17 +474,14 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
   readonly createMachine: Action.Action<"createMachine", Schema.Struct<{
     readonly base: Schema.String;
     readonly cpu: Schema.Int;
@@ -447,15 +505,12 @@ declare const actionsByName: {
     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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -463,13 +518,13 @@ declare const actionsByName: {
       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 (typeof Invalid | typeof Conflict | typeof NotOffered | typeof Unsizable | typeof ScriptFailed | typeof Refused | 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>;
+  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | 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>;
+  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>;
   readonly forkMachine: Action.Action<"forkMachine", Schema.Struct<{
     readonly machine: Schema.String;
     readonly name: Schema.String;
@@ -485,15 +540,12 @@ declare const actionsByName: {
     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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -501,13 +553,18 @@ declare const actionsByName: {
       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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  readonly getCapacity: Action.Action<"getCapacity", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
     readonly host: Schema.String;
-    readonly resource: Schema.Literals<readonly ["ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
-    readonly limit: Schema.Int;
+    readonly resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
     readonly used: Schema.Int;
-  }>>, readonly (typeof Invalid | typeof Precondition | typeof Internal)[], true, typeof Action.Anyone>;
+  }>, Schema.Struct<{
+    readonly host: Schema.String;
+    readonly resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+    readonly unread: Schema.$Array<Schema.String>;
+  }>]>>, readonly (typeof Invalid | typeof Refused | typeof Internal)[], true, typeof Action.Anyone>;
   readonly getCheckpoint: Action.Action<"getCheckpoint", Schema.Struct<{
     readonly id: Schema.String;
   }>, Schema.Struct<{
@@ -521,15 +578,12 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
   }>, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], true, typeof Action.Anyone>;
   readonly getHost: Action.Action<"getHost", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
@@ -554,15 +608,12 @@ declare const actionsByName: {
     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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -582,15 +633,12 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
   }>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>;
   readonly listMachines: Action.Action<"listMachines", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
@@ -605,15 +653,12 @@ declare const actionsByName: {
     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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -637,15 +682,12 @@ declare const actionsByName: {
     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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -653,7 +695,7 @@ declare const actionsByName: {
       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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotReady | typeof PinMismatch | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
   readonly startMachine: Action.Action<"startMachine", Schema.Struct<{
     readonly id: Schema.String;
   }>, Schema.Struct<{
@@ -668,15 +710,12 @@ declare const actionsByName: {
     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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -684,7 +723,7 @@ declare const actionsByName: {
       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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
   readonly stopMachine: Action.Action<"stopMachine", Schema.Struct<{
     readonly id: Schema.String;
   }>, Schema.Struct<{
@@ -699,15 +738,12 @@ declare const actionsByName: {
     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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literals<readonly ["running", "done"]>;
     }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
       readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Struct<{
-        readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-        readonly message: Schema.String;
-      }>;
+      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
     }>]>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -715,45 +751,29 @@ declare const actionsByName: {
       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>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>;
 };
+/** What a host may answer action `N` with: the errors the contract declares for it. */
+type Declared<N extends keyof typeof actionsByName> = (typeof actionsByName)[N]["error"][number]["Type"];
 //#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"]>;
+/** The contract's mutations, which record themselves on a resource's `action`. */
+declare const ActionName: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
 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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
   readonly status: Schema.Literals<readonly ["running", "done"]>;
 }>, Schema.Struct<{
-  readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+  readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
   readonly status: Schema.Literal<"failed">;
-  readonly error: Schema.Struct<{
-    readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-    readonly message: Schema.String;
-  }>;
+  readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
 }>]>;
 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;
@@ -765,6 +785,12 @@ declare const SshLogin: Schema.Struct<{
   readonly user: Schema.String;
 }>;
 type SshLogin = typeof SshLogin.Type;
+/**
+ * `state` is `missing` when the runtime doesn't have the machine, and `unknown` when it couldn't
+ * be read. Until its create, fork or restore has `made` it, a machine can only be read, stopped or
+ * deleted. `ssh` is only on a running machine whose runtime gives it an endpoint, and `hostKey`,
+ * `<type> <base64>`, once preparation has recorded it.
+ */
 declare const Machine: Schema.Struct<{
   readonly id: Schema.String;
   readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
@@ -774,36 +800,31 @@ declare const Machine: Schema.Struct<{
   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 name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
-  /** 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;
+/** The state as people read it: `running`, or `stopped (unmade)` for one never made. */
+declare const stateLabel: ({ state, made }: Machine) => string;
+/** `kind` is `ram` (RAM and disks) on smolvm, and `disk` on Tart and boat. */
 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>;
@@ -811,44 +832,54 @@ declare const Checkpoint: Schema.Struct<{
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literals<readonly ["running", "done"]>;
   }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["capture", "delete"]>;
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
     readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>;
+    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
   }>]>;
 }>;
 type Checkpoint = typeof Checkpoint.Type;
+/** A checkpoint restores once its capture is done; it never changes after. */
+declare const isReady: (checkpoint: Pick<Checkpoint, "action">) => boolean;
+/**
+ * `runtimeVersion` is boat's API version on boat. `captureFrom` is the state a machine must be in
+ * to be captured: Tart's is `stopped`.
+ */
 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.
+ * A resource of a host and how much of it is in use, counted as a refusal counts it, so it
+ * needn't match the host's own machines. When a machine the sum counts couldn't be read, the
+ * sum would be a guess, so the row names those machines instead.
+ *
+ * `cpu` and `ramMib` are what the host's running machines were given, `runningVms` Apple's two
+ * VMs per Mac, and `activeSandboxes` and the `starts` of each rolling window the boat account's.
+ * `limit` is there only where the host refuses an action that would pass it.
  */
-declare const Limit: Schema.Struct<{
+declare const Usage: Schema.Union<readonly [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 resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
   readonly used: Schema.Int;
-}>;
-type Limit = typeof Limit.Type;
+}>, Schema.Struct<{
+  readonly host: Schema.String;
+  readonly resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
+  readonly unread: Schema.$Array<Schema.String>;
+}>]>;
+type Usage = typeof Usage.Type;
+type WithoutHost<Row> = Row extends unknown ? Omit<Row, "host"> : never;
+/** A `Usage` row as a runtime reads it, before the host names itself on it. */
+type Reading = WithoutHost<Usage>;
 /** Nothing logs the script: it can carry secrets. */
 declare const Setup: Schema.Struct<{
   readonly script: Schema.String;
@@ -883,7 +914,7 @@ declare const CreateRequest: Schema.Struct<{
 }>;
 type CreateRequest = typeof CreateRequest.Type;
 declare namespace client_d_exports {
-  export { Client, CreateOptions, ErrorOf, Gathered, HostAction, HostEntry, Interface, Options, Unreachable, layer, make };
+  export { Calls, Client, CreateOptions, Deleted, ErrorOf, Gathered, HostAction, HostEntry, Interface, Options, Routed, Unreachable, layer, make };
 }
 /** `id` is the host part of every ID the host holds. */
 declare const HostEntry: Schema.Struct<{
@@ -898,7 +929,9 @@ 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;
+type ErrorOf<N extends HostAction> = Declared<N> | Unavailable | Internal;
+type Success<N extends HostAction> = Actions[N]["success"]["Type"];
+type Input<N extends HostAction> = Actions[N]["input"]["Type"];
 interface Unreachable {
   readonly host: string;
   readonly error: ClankerboxError;
@@ -917,30 +950,46 @@ interface Options {
   /** The wait for a read's reply, `readTimeout` by default; a fan-out bounds each host's own. */
   readonly readTimeout?: Duration.Duration | undefined;
 }
+/** A delete of a resource that is already gone is `absent`: done either way. */
+type Deleted = "deleted" | "absent";
 interface CreateOptions {
   /** The host to create on, instead of the first that offers the base. */
   readonly host?: string | undefined;
 }
-interface Interface {
+/** The resource an input names, whose host the call goes to. */
+type Subject = {
+  readonly id: string;
+} | {
+  readonly machine: string;
+} | {
+  readonly checkpoint: string;
+};
+/** The actions on one resource, which the client sends to its host. */
+type Routed = { readonly [N in HostAction]: Input<N> extends Subject ? N : never; }[HostAction];
+/**
+ * One method per action on a resource, named and typed as in the contract, but for `create` and
+ * the deletes. A create, fork, restore or capture's errors carry `made`, the resource it makes, so
+ * a caller can find what a failure left behind.
+ */
+type Calls = { readonly [N in Exclude<Routed, "createMachine" | "deleteMachine" | "deleteCheckpoint">]: (input: Input<N>) => Effect.Effect<Success<N>, ErrorOf<N>>; };
+interface Interface extends Calls {
   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 capacity: Effect.Effect<Gathered<Usage>>;
+  /**
+   * The host a create of `base` goes to, read even when `options.host` names it: the first in
+   * list order that offers it. With none, it is `Unavailable` if a host gave no reply, and
+   * `NotOffered` otherwise.
+   */
+  readonly place: (base: string, options?: CreateOptions) => Effect.Effect<Host, ErrorOf<"getHost"> | NotOffered>;
+  /** `createMachine` on `options.host`, or else on the first host that offers the base. */
   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">>;
+  /** A delete of a resource that is already gone is `absent`: done either way. */
+  readonly deleteMachine: (input: Input<"deleteMachine">) => Effect.Effect<Deleted, Exclude<ErrorOf<"deleteMachine">, NotFound>>;
+  /** A delete of a checkpoint that is already gone is `absent`: done either way. */
+  readonly deleteCheckpoint: (input: Input<"deleteCheckpoint">) => Effect.Effect<Deleted, Exclude<ErrorOf<"deleteCheckpoint">, NotFound>>;
 }
 declare const Client_base: Context.ServiceClass<Client, "@gjermundgaraba/clankerbox-sdk/Client", Interface>;
 /**
@@ -955,4 +1004,4 @@ declare class Client extends Client_base {}
 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 };
+export { ConflictKind as A, Refused as B, Declared as C, Capacity as D, readTimeout as E, NotFound as F, hostErrors as G, Unavailable as H, NotMade as I, retryable as K, NotOffered as L, Internal as M, Invalid as N, ClankerboxError as O, Missing as P, NotReady as R, stateLabel as S, actionsByName as T, Unsizable as U, ScriptFailed as V, WrongState as W, Setup as _, Options as a, Usage as b, ActionRecord as c, CreateRequest as d, Host as f, Runtime as g, Reading as h, Interface as i, HostError as j, Conflict as k, ActionStatus as l, MachineSpec as m, CreateOptions as n, client_d_exports as o, Machine as p, HostEntry as r, ActionName as s, Client as t, Checkpoint as u, SshEndpoint as v, Http as w, isReady as x, SshLogin as y, PinMismatch as z };