@gjermundgaraba/clankerbox-sdk 0.20.1 → 0.22.0

package/dist/{client-DwbRw_dg.mjs → client-CW42FiN2.mjs}

@@ -88,11 +88,6 @@ var ScriptFailed = class extends Schema.TaggedError()("ScriptFailed", {
 	...located,
 	script: Schema.String
 }, { httpApiStatus: 422 }) {};
-/** The provider under the runtime refused the call for good, such as for its plan or API key. */
-var Refused = class extends Schema.TaggedError()("Refused", {
-	message: Schema.String,
-	...located
-}, { httpApiStatus: 403 }) {};
 /** The host has no room now; room can free up, so a later call may succeed. */
 var Capacity = class extends Schema.TaggedError()("Capacity", {
 	message: Schema.String,
@@ -124,7 +119,6 @@ const hostErrors = [
 	WrongState,
 	Unsizable,
 	ScriptFailed,
-	Refused,
 	Capacity,
 	Internal
 ];
@@ -154,7 +148,6 @@ const retryable = (error) => Match.value(error).pipe(Match.tagsExhaustive({
 	WrongState: () => false,
 	Unsizable: () => false,
 	ScriptFailed: () => false,
-	Refused: () => false,
 	Capacity: () => true,
 	Unavailable: ({ readOnly }) => readOnly,
 	Internal: () => false
@@ -198,11 +191,14 @@ const formatId = (host, name) => {
 };
 //#endregion
 //#region src/resources.ts
-const Runtime = Schema.Literals([
-	"smolvm",
-	"tart",
-	"boat"
-]);
+/** What a host's machines are: `linux` guests on smolvm, or `mac` guests on Tart. */
+const Kind = Schema.Literals(["linux", "mac"]);
+const CheckpointKind = Schema.Literals(["ram", "disk"]);
+/**
+* The user a machine is logged in as, on either kind: the user a setup, run as root, leaves in the
+* guest, for whom the host installs the operator's keys. Tart's bases ship it; never root.
+*/
+const loginUser = "admin";
 const Size = Schema.Int.check(Schema.isGreaterThan(0));
 /** What the operator asked a machine to be; the host keeps moving the machine toward it. */
 const Desired = Schema.Literals([
@@ -268,7 +264,7 @@ const TailnetStatus = Schema.Union([
 */
 const Machine = Schema.Struct({
 	id: Id,
-	runtime: Runtime,
+	kind: Kind,
 	createdAt: Schema.DateTimeUtcFromString,
 	base: Schema.String,
 	profile: Schema.optionalKey(Schema.String),
@@ -294,30 +290,27 @@ const Machine = Schema.Struct({
 */
 const stateLabel = ({ state, desired, phase }) => phase === "settled" ? state : state === desired ? `${state} (${phase})` : `${state}, wants ${desired} (${phase})`;
 /**
-* `kind` is `ram` (RAM and disks) on smolvm, and `disk` on Tart and boat. A checkpoint exists only
-* once its capture is done, and never changes after.
+* `kind` follows its host's: `ram` (RAM and disks) on linux, captured from a running machine, and
+* `disk` on mac, from a stopped one. A checkpoint exists only once its capture is done, and never
+* changes after.
 */
 const Checkpoint = Schema.Struct({
 	id: Id,
 	createdAt: Schema.DateTimeUtcFromString,
 	machine: Id,
-	kind: Schema.Literals(["ram", "disk"]),
+	kind: CheckpointKind,
 	base: Schema.String,
 	profile: Schema.optionalKey(Schema.String),
 	cpu: Size,
 	ramMib: Size,
 	diskGib: Size
 }).annotate({ identifier: "Checkpoint" });
-/**
-* `runtimeVersion` is boat's API version on boat. `captureFrom` is the state a machine must be in
-* to be captured: Tart's is `stopped`.
-*/
+/** `runtimeVersion` is the version of smolvm on linux, and of Tart on mac. */
 const Host = Schema.Struct({
 	id: HostId,
-	runtime: Runtime,
+	kind: Kind,
 	version: Schema.String,
 	runtimeVersion: Schema.String,
-	captureFrom: Schema.Literals(["running", "stopped"]),
 	bases: Schema.Array(Schema.String)
 }).annotate({ identifier: "Host" });
 const usageFields = {
@@ -325,11 +318,7 @@ const usageFields = {
 	resource: Schema.Literals([
 		"cpu",
 		"ramMib",
-		"runningVms",
-		"activeSandboxes",
-		"startsPerMinute",
-		"startsPerHour",
-		"startsPerDay"
+		"runningVms"
 	]),
 	limit: Schema.optionalKey(Schema.Int)
 };
@@ -338,8 +327,8 @@ const usageFields = {
 * 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.
+* `cpu` and `ramMib` are what the host's running machines were given, and `runningVms`, on mac,
+* Apple's two VMs per Mac.
 * `limit` is there only where the host refuses an action that would pass it.
 */
 const Usage = Schema.Union([Schema.Struct({
@@ -418,12 +407,6 @@ const reading = [
 	NotFound,
 	Internal
 ];
-const removing = [
-	Invalid,
-	NotFound,
-	Refused,
-	Internal
-];
 const converging = [
 	Invalid,
 	NotFound,
@@ -433,7 +416,6 @@ const converging = [
 	PinMismatch,
 	Unsizable,
 	ScriptFailed,
-	Refused,
 	Capacity,
 	Superseded,
 	Internal
@@ -520,17 +502,16 @@ const Http = ActionHttp.make([
 			NotMade,
 			Missing,
 			WrongState,
-			Refused,
 			Capacity,
 			Internal
 		],
-		description: "Capture a checkpoint of a machine. Its kind follows the runtime: ram on smolvm, which captures only a running machine, and disk on Tart and boat.",
+		description: "Capture a checkpoint of a machine. Its kind follows the host's: ram on linux, which captures only a running machine, and disk on mac, which captures only a stopped one.",
 		input: FromMachine,
 		success: Checkpoint
 	}),
 	Action.make("deleteCheckpoint", {
 		...write,
-		error: removing,
+		error: reading,
 		description: "Delete a checkpoint, once the restores that read it are done.",
 		input: ById
 	}),
@@ -544,16 +525,12 @@ const Http = ActionHttp.make([
 	Action.make("getHost", {
 		...read,
 		error: [Invalid],
-		description: "Read the host: its runtime, versions and bases.",
+		description: "Read the host: its kind, versions and bases.",
 		success: Host
 	}),
 	Action.make("getCapacity", {
 		...read,
-		error: [
-			Invalid,
-			Refused,
-			Internal
-		],
+		error: listing,
 		description: "Read the host's resources, how much of each is in use, and their limits. A machine whose state can't be read leaves the rows that count it unread; it fails when the runtime can't be read at all.",
 		success: Schema.Array(Usage)
 	})
@@ -562,7 +539,7 @@ const actionsByName = Action.byName(Http.actions);
 //#endregion
 //#region src/release.ts
 /** Also the version of the clankerbox CLI released with it. */
-const version = "0.20.1";
+const version = "0.22.0";
 /** major.minor: releases that share it speak the same API. */
 const release = (of) => of.split(".").slice(0, 2).join(".");
 /** A host refuses a request whose `release` differs from its own, or that has none. */
@@ -770,4 +747,4 @@ const make = (hosts, options) => Effect.gen(function* () {
 });
 const layer = (hosts, options) => Layer.effect(Client, make(hosts, options));
 //#endregion
-export { Name as A, Missing as B, SshEndpoint as C, stateLabel as D, Usage as E, ClankerboxError as F, Refused as G, NotMade as H, Conflict as I, Unavailable as J, ScriptFailed as K, HostError as L, parseId as M, parseName as N, HostId as O, Capacity as P, retryable as Q, Internal as R, Setup as S, TailnetStatus as T, NotOffered as U, NotFound as V, PinMismatch as W, WrongState as X, Unsizable as Y, hostErrors as Z, Phase as _, release as a, PublicKeys as b, Http as c, Checkpoint as d, CreateRequest as f, MachineSpec as g, Machine as h, describeIssues as i, formatId as j, Id as k, actionsByName as l, Host as m, layer as n, version as o, Desired as p, Superseded as q, describeFileError as r, versionHeader as s, client_exports as t, readTimeout as u, PrebuildRequest as v, SshLogin as w, Runtime as x, Prebuilt as y, Invalid as z };
+export { Id as A, Invalid as B, SshEndpoint as C, loginUser as D, Usage as E, Capacity as F, PinMismatch as G, NotFound as H, ClankerboxError as I, Unavailable as J, ScriptFailed as K, Conflict as L, formatId as M, parseId as N, stateLabel as O, parseName as P, retryable as Q, HostError as R, Setup as S, TailnetStatus as T, NotMade as U, Missing as V, NotOffered as W, WrongState as X, Unsizable as Y, hostErrors as Z, MachineSpec as _, release as a, Prebuilt as b, Http as c, Checkpoint as d, CreateRequest as f, Machine as g, Kind as h, describeIssues as i, Name as j, HostId as k, actionsByName as l, Host as m, layer as n, version as o, Desired as p, Superseded as q, describeFileError as r, versionHeader as s, client_exports as t, readTimeout as u, Phase as v, SshLogin as w, PublicKeys as x, PrebuildRequest as y, Internal as z };

package/dist/{client-Dr3PcuCP.d.mts → client-D6pHB56g.d.mts}

@@ -121,15 +121,6 @@ declare const ScriptFailed_base: Schema.Class<ScriptFailed, Schema.TaggedStruct<
  * `preparation` runs again on the next start.
  */
 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>;
@@ -161,8 +152,8 @@ declare const Internal_base: Schema.Class<Internal, Schema.TaggedStruct<"Interna
 }>, 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 Superseded, typeof NotOffered, typeof NotMade, typeof Missing, 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 Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
+declare const hostErrors: readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal];
+declare const HostError: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>;
 type HostError = typeof HostError.Type;
 /**
  * Each carries, where known: `host` and `action`, which the client sets; `id`, the resource the
@@ -172,7 +163,7 @@ type HostError = typeof HostError.Type;
  * keeps one whose preparation fails; a call whose answer was lost, `Unavailable`, may leave
  * `made` behind unmade.
  */
-declare const ClankerboxError: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal, typeof Unavailable]>;
+declare const ClankerboxError: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal, typeof Unavailable]>;
 type ClankerboxError = typeof ClankerboxError.Type;
 /**
  * Whether the same call may succeed later: a full host may free up, and a read that got no reply
@@ -185,7 +176,7 @@ declare const retryable: (error: ClankerboxError) => boolean;
 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly base: Schema.String;
   readonly profile: Schema.optionalKey<Schema.String>;
@@ -195,7 +186,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
   readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
   readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
@@ -215,7 +206,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly kind: Schema.Literals<readonly ["linux", "mac"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly base: Schema.String;
   readonly profile: Schema.optionalKey<Schema.String>;
@@ -225,7 +216,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
   readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
   readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
@@ -255,7 +246,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly kind: Schema.Literals<readonly ["linux", "mac"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly base: Schema.String;
   readonly profile: Schema.optionalKey<Schema.String>;
@@ -265,7 +256,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
   readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
   readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
@@ -281,11 +272,11 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   }>, Schema.Struct<{
     readonly state: Schema.Literal<"missing">;
   }>]>>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotOffered | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"startMachine", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotOffered | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly base: Schema.String;
   readonly profile: Schema.optionalKey<Schema.String>;
@@ -295,7 +286,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
   readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
   readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
@@ -311,11 +302,11 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   }>, Schema.Struct<{
     readonly state: Schema.Literal<"missing">;
   }>]>>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"stopMachine", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly base: Schema.String;
   readonly profile: Schema.optionalKey<Schema.String>;
@@ -325,7 +316,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
   readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
   readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
@@ -341,14 +332,14 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   }>, Schema.Struct<{
     readonly state: Schema.Literal<"missing">;
   }>]>>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"deleteMachine", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"deleteMachine", Schema.Struct<{
   readonly id: Schema.String;
-}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"forkMachine", Schema.Struct<{
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Capacity | 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly base: Schema.String;
   readonly profile: Schema.optionalKey<Schema.String>;
@@ -358,7 +349,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
   readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
   readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
@@ -374,12 +365,12 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   }>, Schema.Struct<{
     readonly state: Schema.Literal<"missing">;
   }>]>>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"restoreMachine", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly base: Schema.String;
   readonly profile: Schema.optionalKey<Schema.String>;
@@ -389,7 +380,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
   readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
   readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
@@ -405,7 +396,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   }>, Schema.Struct<{
     readonly state: Schema.Literal<"missing">;
   }>]>>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | 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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | 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;
@@ -440,9 +431,9 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-}>, 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 (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | 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 Refused | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"prebuildCheckpoint", Schema.Struct<{
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"prebuildCheckpoint", Schema.Struct<{
   readonly base: Schema.String;
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
@@ -467,24 +458,23 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
     readonly diskGib: Schema.Int;
   }>;
   readonly built: Schema.Boolean;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotOffered | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"getHost", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotOffered | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Capacity | 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
   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 resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms"]>;
   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 resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms"]>;
   readonly limit: Schema.optionalKey<Schema.Int>;
   readonly unread: Schema.$Array<Schema.String>;
-}>]>>, readonly (typeof Invalid | typeof Refused | typeof Internal)[], true, typeof Action.Anyone>], [], undefined>;
+}>]>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>], [], undefined>;
 declare const actionsByName: {
   readonly captureCheckpoint: Action.Action<"captureCheckpoint", Schema.Struct<{
     readonly machine: Schema.String;
@@ -499,7 +489,7 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
   readonly createMachine: Action.Action<"createMachine", Schema.Struct<{
     readonly base: Schema.String;
     readonly cpu: Schema.Int;
@@ -514,7 +504,7 @@ declare const actionsByName: {
     readonly id: Schema.String;
   }>, Schema.Struct<{
     readonly id: Schema.String;
-    readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+    readonly kind: Schema.Literals<readonly ["linux", "mac"]>;
     readonly createdAt: Schema.DateTimeUtcFromString;
     readonly base: Schema.String;
     readonly profile: Schema.optionalKey<Schema.String>;
@@ -524,7 +514,7 @@ declare const actionsByName: {
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
     readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
     readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
@@ -540,19 +530,19 @@ declare const actionsByName: {
     }>, Schema.Struct<{
       readonly state: Schema.Literal<"missing">;
     }>]>>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotOffered | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotOffered | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | 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 Refused | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | 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 Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Capacity | 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
     readonly createdAt: Schema.DateTimeUtcFromString;
     readonly base: Schema.String;
     readonly profile: Schema.optionalKey<Schema.String>;
@@ -562,7 +552,7 @@ declare const actionsByName: {
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
     readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
     readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
@@ -578,18 +568,18 @@ declare const actionsByName: {
     }>, Schema.Struct<{
       readonly state: Schema.Literal<"missing">;
     }>]>>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | 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 resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms"]>;
     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 resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms"]>;
     readonly limit: Schema.optionalKey<Schema.Int>;
     readonly unread: Schema.$Array<Schema.String>;
-  }>]>>, readonly (typeof Invalid | typeof Refused | typeof Internal)[], true, typeof Action.Anyone>;
+  }>]>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>;
   readonly getCheckpoint: Action.Action<"getCheckpoint", Schema.Struct<{
     readonly id: Schema.String;
   }>, Schema.Struct<{
@@ -605,17 +595,16 @@ declare const actionsByName: {
   }>, 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
     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 kind: Schema.Literals<readonly ["linux", "mac"]>;
     readonly createdAt: Schema.DateTimeUtcFromString;
     readonly base: Schema.String;
     readonly profile: Schema.optionalKey<Schema.String>;
@@ -625,7 +614,7 @@ declare const actionsByName: {
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
     readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
     readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
@@ -655,7 +644,7 @@ declare const actionsByName: {
   }>>, 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
     readonly createdAt: Schema.DateTimeUtcFromString;
     readonly base: Schema.String;
     readonly profile: Schema.optionalKey<Schema.String>;
@@ -665,7 +654,7 @@ declare const actionsByName: {
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
     readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
     readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
@@ -707,13 +696,13 @@ declare const actionsByName: {
       readonly diskGib: Schema.Int;
     }>;
     readonly built: Schema.Boolean;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotOffered | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotOffered | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Capacity | typeof Internal)[], false, 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
     readonly createdAt: Schema.DateTimeUtcFromString;
     readonly base: Schema.String;
     readonly profile: Schema.optionalKey<Schema.String>;
@@ -723,7 +712,7 @@ declare const actionsByName: {
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
     readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
     readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
@@ -739,12 +728,12 @@ declare const actionsByName: {
     }>, Schema.Struct<{
       readonly state: Schema.Literal<"missing">;
     }>]>>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
     readonly createdAt: Schema.DateTimeUtcFromString;
     readonly base: Schema.String;
     readonly profile: Schema.optionalKey<Schema.String>;
@@ -754,7 +743,7 @@ declare const actionsByName: {
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
     readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
     readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
@@ -770,12 +759,12 @@ declare const actionsByName: {
     }>, Schema.Struct<{
       readonly state: Schema.Literal<"missing">;
     }>]>>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | 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 kind: Schema.Literals<readonly ["linux", "mac"]>;
     readonly createdAt: Schema.DateTimeUtcFromString;
     readonly base: Schema.String;
     readonly profile: Schema.optionalKey<Schema.String>;
@@ -785,7 +774,7 @@ declare const actionsByName: {
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
     readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
     readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
@@ -801,14 +790,20 @@ declare const actionsByName: {
     }>, Schema.Struct<{
       readonly state: Schema.Literal<"missing">;
     }>]>>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, readonly (typeof Invalid | typeof NotFound | typeof Superseded | typeof NotMade | typeof Missing | typeof PinMismatch | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Capacity | 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;
+/** What a host's machines are: `linux` guests on smolvm, or `mac` guests on Tart. */
+declare const Kind: Schema.Literals<readonly ["linux", "mac"]>;
+type Kind = typeof Kind.Type;
+/**
+ * The user a machine is logged in as, on either kind: the user a setup, run as root, leaves in the
+ * guest, for whom the host installs the operator's keys. Tart's bases ship it; never root.
+ */
+declare const loginUser = "admin";
 /** What the operator asked a machine to be; the host keeps moving the machine toward it. */
 declare const Desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
 type Desired = typeof Desired.Type;
@@ -860,7 +855,7 @@ type TailnetStatus = typeof TailnetStatus.Type;
  */
 declare const Machine: Schema.Struct<{
   readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly kind: Schema.Literals<readonly ["linux", "mac"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly base: Schema.String;
   readonly profile: Schema.optionalKey<Schema.String>;
@@ -870,7 +865,7 @@ declare const Machine: Schema.Struct<{
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
   readonly desired: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
   readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
-  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>>;
+  readonly error: Schema.optionalKey<Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Superseded, typeof NotOffered, typeof NotMade, typeof Missing, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
@@ -894,8 +889,9 @@ type Machine = typeof Machine.Type;
  */
 declare const stateLabel: ({ state, desired, phase }: Machine) => string;
 /**
- * `kind` is `ram` (RAM and disks) on smolvm, and `disk` on Tart and boat. A checkpoint exists only
- * once its capture is done, and never changes after.
+ * `kind` follows its host's: `ram` (RAM and disks) on linux, captured from a running machine, and
+ * `disk` on mac, from a stopped one. A checkpoint exists only once its capture is done, and never
+ * changes after.
  */
 declare const Checkpoint: Schema.Struct<{
   readonly id: Schema.String;
@@ -909,16 +905,12 @@ declare const Checkpoint: Schema.Struct<{
   readonly diskGib: Schema.Int;
 }>;
 type Checkpoint = typeof Checkpoint.Type;
-/**
- * `runtimeVersion` is boat's API version on boat. `captureFrom` is the state a machine must be in
- * to be captured: Tart's is `stopped`.
- */
+/** `runtimeVersion` is the version of smolvm on linux, and of Tart on mac. */
 declare const Host: Schema.Struct<{
   readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
+  readonly kind: Schema.Literals<readonly ["linux", "mac"]>;
   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;
@@ -927,18 +919,18 @@ type Host = typeof Host.Type;
  * 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.
+ * `cpu` and `ramMib` are what the host's running machines were given, and `runningVms`, on mac,
+ * Apple's two VMs per Mac.
  * `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 resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms"]>;
   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 resource: Schema.Literals<readonly ["cpu", "ramMib", "runningVms"]>;
   readonly limit: Schema.optionalKey<Schema.Int>;
   readonly unread: Schema.$Array<Schema.String>;
 }>]>;
@@ -1113,4 +1105,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 { ClankerboxError as A, Refused as B, Usage as C, actionsByName as D, Http as E, Missing as F, WrongState as G, Superseded as H, NotFound as I, hostErrors as K, NotMade as L, HostError as M, Internal as N, readTimeout as O, Invalid as P, NotOffered as R, TailnetStatus as S, Declared as T, Unavailable as U, ScriptFailed as V, Unsizable as W, Reading as _, Options as a, SshEndpoint as b, CreateRequest as c, Machine as d, MachineSpec as f, PublicKeys as g, Prebuilt as h, Interface as i, Conflict as j, Capacity as k, Desired as l, PrebuildRequest as m, CreateOptions as n, client_d_exports as o, Phase as p, retryable as q, HostEntry as r, Checkpoint as s, Client as t, Host as u, Runtime as v, stateLabel as w, SshLogin as x, Setup as y, PinMismatch as z };
+export { Capacity as A, PinMismatch as B, Usage as C, Http as D, Declared as E, Invalid as F, WrongState as G, Superseded as H, Missing as I, hostErrors as K, NotFound as L, Conflict as M, HostError as N, actionsByName as O, Internal as P, NotMade as R, TailnetStatus as S, stateLabel as T, Unavailable as U, ScriptFailed as V, Unsizable as W, PublicKeys as _, Options as a, SshEndpoint as b, CreateRequest as c, Kind as d, Machine as f, Prebuilt as g, PrebuildRequest as h, Interface as i, ClankerboxError as j, readTimeout as k, Desired as l, Phase as m, CreateOptions as n, client_d_exports as o, MachineSpec as p, retryable as q, HostEntry as r, Checkpoint as s, Client as t, Host as u, Reading as v, loginUser as w, SshLogin as x, Setup as y, NotOffered as z };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { A as ClankerboxError, B as Refused, C as Usage, D as actionsByName, E as Http, F as Missing, G as WrongState, H as Superseded, I as NotFound, K as hostErrors, L as NotMade, M as HostError, N as Internal, O as readTimeout, P as Invalid, R as NotOffered, S as TailnetStatus, T as Declared, U as Unavailable, V as ScriptFailed, W as Unsizable, _ as Reading, b as SshEndpoint, c as CreateRequest, d as Machine, f as MachineSpec, g as PublicKeys, h as Prebuilt, i as Interface, j as Conflict, k as Capacity, l as Desired, m as PrebuildRequest, n as CreateOptions$1, o as client_d_exports, p as Phase, q as retryable, s as Checkpoint, u as Host, v as Runtime, w as stateLabel, x as SshLogin, y as Setup, z as PinMismatch } from "./client-Dr3PcuCP.mjs";
+import { A as Capacity, B as PinMismatch, C as Usage, D as Http, E as Declared, F as Invalid, G as WrongState, H as Superseded, I as Missing, K as hostErrors, L as NotFound, M as Conflict, N as HostError, O as actionsByName, P as Internal, R as NotMade, S as TailnetStatus, T as stateLabel, U as Unavailable, V as ScriptFailed, W as Unsizable, _ as PublicKeys, b as SshEndpoint, c as CreateRequest, d as Kind, f as Machine, g as Prebuilt, h as PrebuildRequest, i as Interface, j as ClankerboxError, k as readTimeout, l as Desired, m as Phase, n as CreateOptions$1, o as client_d_exports, p as MachineSpec, q as retryable, s as Checkpoint, u as Host, v as Reading, w as loginUser, x as SshLogin, y as Setup, z as NotOffered } from "./client-D6pHB56g.mjs";
 import { Effect, FileSystem, Path, PlatformError, Schema, Scope } from "effect";
 //#region src/ids.d.ts
 export declare const HostId: Schema.String;
@@ -131,8 +131,8 @@ export declare const knownHostsLine: (name: string, hostKey: string) => string;
 /**
  * ssh's arguments to the target's address, pinned to its host key through a known-hosts file that
  * lasts as long as the scope, which must outlast the ssh. The destination is the address, not the
- * ID, so no ssh_config block for the ID applies. Ports change on fork, restore, and every boat
- * start, so read the target anew for each ssh.
+ * ID, so no ssh_config block for the ID applies. Ports change on fork and restore, so read the
+ * target anew for each ssh.
  */
 export declare const pinnedSsh: (target: SshTarget, user: string, extra: ReadonlyArray<string>) => Effect.Effect<Array<string>, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path | Scope.Scope>;
 //#endregion
@@ -152,4 +152,4 @@ export declare const formatMib: (mib: number) => string;
 /** As a size flag takes it: `60G`. */
 export declare const formatGib: (gib: number) => string;
 //#endregion
-export { Capacity, Checkpoint, ClankerboxError, client_d_exports as Client, Conflict, CreateRequest, Declared, Desired, Host, HostError, Http, Internal, Invalid, Machine, MachineSpec, Missing, NotFound, NotMade, NotOffered, Phase, PinMismatch, prebuild_d_exports as Prebuild, PrebuildRequest, Prebuilt, PublicKeys, Reading, Refused, Runtime, ScriptFailed, Setup, SshEndpoint, SshLogin, Superseded, TailnetStatus, Unavailable, Unsizable, Usage, WrongState, actionsByName, hostErrors, readTimeout, retryable, stateLabel };
+export { Capacity, Checkpoint, ClankerboxError, client_d_exports as Client, Conflict, CreateRequest, Declared, Desired, Host, HostError, Http, Internal, Invalid, Kind, Machine, MachineSpec, Missing, NotFound, NotMade, NotOffered, Phase, PinMismatch, prebuild_d_exports as Prebuild, PrebuildRequest, Prebuilt, PublicKeys, Reading, ScriptFailed, Setup, SshEndpoint, SshLogin, Superseded, TailnetStatus, Unavailable, Unsizable, Usage, WrongState, actionsByName, hostErrors, loginUser, readTimeout, retryable, stateLabel };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { A as Name, B as Missing, C as SshEndpoint, D as stateLabel, E as Usage, F as ClankerboxError, G as Refused, H as NotMade, I as Conflict, J as Unavailable, K as ScriptFailed, L as HostError, M as parseId, N as parseName, O as HostId, P as Capacity, Q as retryable, R as Internal, S as Setup, T as TailnetStatus, U as NotOffered, V as NotFound, W as PinMismatch, X as WrongState, Y as Unsizable, Z as hostErrors, _ as Phase, a as release, b as PublicKeys, c as Http, d as Checkpoint, f as CreateRequest, g as MachineSpec, h as Machine, i as describeIssues, j as formatId, k as Id, l as actionsByName, m as Host, o as version, p as Desired, q as Superseded, r as describeFileError, s as versionHeader, t as client_exports, u as readTimeout, v as PrebuildRequest, w as SshLogin, x as Runtime, y as Prebuilt, z as Invalid } from "./client-DwbRw_dg.mjs";
+import { A as Id, B as Invalid, C as SshEndpoint, D as loginUser, E as Usage, F as Capacity, G as PinMismatch, H as NotFound, I as ClankerboxError, J as Unavailable, K as ScriptFailed, L as Conflict, M as formatId, N as parseId, O as stateLabel, P as parseName, Q as retryable, R as HostError, S as Setup, T as TailnetStatus, U as NotMade, V as Missing, W as NotOffered, X as WrongState, Y as Unsizable, Z as hostErrors, _ as MachineSpec, a as release, b as Prebuilt, c as Http, d as Checkpoint, f as CreateRequest, g as Machine, h as Kind, i as describeIssues, j as Name, k as HostId, l as actionsByName, m as Host, o as version, p as Desired, q as Superseded, r as describeFileError, s as versionHeader, t as client_exports, u as readTimeout, v as Phase, w as SshLogin, x as PublicKeys, y as PrebuildRequest, z as Internal } from "./client-CW42FiN2.mjs";
 import { Effect, FileSystem, Option, Path, Predicate, Record, Schema } from "effect";
 import { Base64, Hex } from "effect/encoding";
 //#region src/prebuild.ts
@@ -273,8 +273,8 @@ const sshArguments = (target, user, knownHosts, extra) => [
 /**
 * ssh's arguments to the target's address, pinned to its host key through a known-hosts file that
 * lasts as long as the scope, which must outlast the ssh. The destination is the address, not the
-* ID, so no ssh_config block for the ID applies. Ports change on fork, restore, and every boat
-* start, so read the target anew for each ssh.
+* ID, so no ssh_config block for the ID applies. Ports change on fork and restore, so read the
+* target anew for each ssh.
 */
 const pinnedSsh = (target, user, extra) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
@@ -292,4 +292,4 @@ const formatMib = (mib) => mib >= 1024 && mib % 512 === 0 ? `${mib / mibPerGib}G
 /** As a size flag takes it: `60G`. */
 const formatGib = (gib) => `${gib}G`;
 //#endregion
-export { Capacity, Checkpoint, ClankerboxError, client_exports as Client, Conflict, CreateRequest, Desired, Host, HostError, HostId, Http, Id, Internal, Invalid, Machine, MachineSpec, Missing, Name, NotFound, NotMade, NotOffered, Phase, PinMismatch, prebuild_exports as Prebuild, PrebuildRequest, Prebuilt, Profile, PublicKeys, Refused, Runtime, ScriptFailed, Setup, SshEndpoint, SshLogin, Superseded, TailnetStatus, Unavailable, Unsizable, Usage, WrongState, actionsByName, describeFileError, describeIssues, formatGib, formatId, formatMib, hostErrors, knownHostsLine, loadProfile, mibPerGib, packRecipe, parseId, parseName, pinnedSsh, readAuthorizedKeys, readSetup, readTimeout, release, retryable, specRequest, sshTarget, stateLabel, version, versionHeader };
+export { Capacity, Checkpoint, ClankerboxError, client_exports as Client, Conflict, CreateRequest, Desired, Host, HostError, HostId, Http, Id, Internal, Invalid, Kind, Machine, MachineSpec, Missing, Name, NotFound, NotMade, NotOffered, Phase, PinMismatch, prebuild_exports as Prebuild, PrebuildRequest, Prebuilt, Profile, PublicKeys, ScriptFailed, Setup, SshEndpoint, SshLogin, Superseded, TailnetStatus, Unavailable, Unsizable, Usage, WrongState, actionsByName, describeFileError, describeIssues, formatGib, formatId, formatMib, hostErrors, knownHostsLine, loadProfile, loginUser, mibPerGib, packRecipe, parseId, parseName, pinnedSsh, readAuthorizedKeys, readSetup, readTimeout, release, retryable, specRequest, sshTarget, stateLabel, version, versionHeader };

package/dist/node.d.mts

@@ -1,4 +1,4 @@
-import { P as Invalid, a as Options, r as HostEntry, t as Client } from "./client-Dr3PcuCP.mjs";
+import { F as Invalid, a as Options, r as HostEntry, t as Client } from "./client-D6pHB56g.mjs";
 import { Layer } from "effect";
 //#region src/node.d.ts
 /**

package/dist/node.mjs

@@ -1,4 +1,4 @@
-import { n as layer$1 } from "./client-DwbRw_dg.mjs";
+import { n as layer$1 } from "./client-CW42FiN2.mjs";
 import { Layer } from "effect";
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 //#region src/node.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjermundgaraba/clankerbox-sdk",
-  "version": "0.20.1",
+  "version": "0.22.0",
   "description": "clankerbox's API contract and client library, for Effect",
   "license": "MIT",
   "repository": {