@gjermundgaraba/clankerbox-sdk 0.15.6 → 0.18.0

package/dist/client-8af586hb.d.mts

@@ -0,0 +1,1007 @@
+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 made: 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 {}
+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 {}
+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 {}
+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>;
+/** 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 {}
+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>;
+/**
+ * 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 {}
+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 {}
+/** What a host may answer with; each action declares its own share. */
+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;
+/**
+ * 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. */
+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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, 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;
+  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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, 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;
+  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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, 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 Refused | 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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, 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<{
+  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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  readonly hostKey: Schema.optionalKey<Schema.String>;
+}>, 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;
+  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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+}>, 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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+  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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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 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 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.Union<readonly [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 used: Schema.Int;
+}>, 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;
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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 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;
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, 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 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 Refused | 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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, 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 ["cpu", "ramMib", "runningVms", "activeSandboxes", "startsPerMinute", "startsPerHour", "startsPerDay"]>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+    readonly used: Schema.Int;
+  }>, 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<{
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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<{
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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;
+      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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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<{
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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;
+      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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, 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<{
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, 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<{
+    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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literals<readonly ["running", "done"]>;
+    }>, Schema.Struct<{
+      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+      readonly status: Schema.Literal<"failed">;
+      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;
+      readonly port: Schema.Int;
+      readonly user: Schema.String;
+    }>>;
+    readonly hostKey: Schema.optionalKey<Schema.String>;
+  }>, 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 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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+  readonly status: Schema.Literals<readonly ["running", "done"]>;
+}>, Schema.Struct<{
+  readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+  readonly status: Schema.Literal<"failed">;
+  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;
+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;
+/**
+ * `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"]>;
+  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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+    readonly port: Schema.Int;
+    readonly user: Schema.String;
+  }>>;
+  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;
+  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 ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literals<readonly ["running", "done"]>;
+  }>, Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
+    readonly status: Schema.Literal<"failed">;
+    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;
+  readonly runtimeVersion: Schema.String;
+  readonly captureFrom: Schema.Literals<readonly ["running", "stopped"]>;
+  readonly bases: Schema.$Array<Schema.String>;
+}>;
+type Host = typeof Host.Type;
+/**
+ * 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 Usage: Schema.Union<readonly [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 used: Schema.Int;
+}>, 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;
+  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 { 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<{
+  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> = 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;
+}
+/** 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;
+}
+/** 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;
+}
+/** 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<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">>;
+  /** 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>;
+/**
+ * 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 { 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 };