@gjermundgaraba/clankerbox-sdk 0.23.0 → 0.24.0

package/dist/{client-CM0M6Czt.mjs → client-BFhJ4z-h.mjs}

@@ -30,17 +30,25 @@ var Conflict = class extends Schema.TaggedError()("Conflict", {
 	...located
 }, { httpApiStatus: 409 }) {};
 /**
+* What the operator asked a machine to be; the host keeps moving the machine toward it. `paused`
+* keeps its RAM, processes and disks, saved by the runtime with the VM stopped, and a start
+* resumes it; a machine that is stopped when a pause comes stays stopped, and one the runtime
+* can't save, such as a VM an older runtime booted, is stopped instead.
+*/
+const Desired = Schema.Literals([
+	"running",
+	"stopped",
+	"paused",
+	"deleted"
+]);
+/**
 * A later request on the machine replaced this one before the host got there: `by` is what that
 * request asked for. The machine's own state says where it is now.
 */
 var Superseded = class extends Schema.TaggedError()("Superseded", {
 	message: Schema.String,
 	...located,
-	by: Schema.Literals([
-		"running",
-		"stopped",
-		"deleted"
-	])
+	by: Desired
 }, { httpApiStatus: 409 }) {};
 /** No host offers `base`: the host a create names, or any in the client's list. */
 var NotOffered = class extends Schema.TaggedError()("NotOffered", {
@@ -60,11 +68,13 @@ var Missing = class extends Schema.TaggedError()("Missing", {
 	...located,
 	machine: Schema.String
 }, { httpApiStatus: 412 }) {};
-/** `checkpoint` holds RAM state saved under another runtime pin than the one the host runs. */
+/**
+* The checkpoint or paused machine `id` holds RAM state saved under another runtime pin than the
+* one the host runs, and restores or resumes only under that one.
+*/
 var PinMismatch = class extends Schema.TaggedError()("PinMismatch", {
 	message: Schema.String,
-	...located,
-	checkpoint: Schema.String
+	...located
 }, { httpApiStatus: 412 }) {};
 /** `machine` is in `state`, which the action doesn't act from. */
 var WrongState = class extends Schema.TaggedError()("WrongState", {
@@ -200,19 +210,13 @@ const CheckpointKind = Schema.Literals(["ram", "disk"]);
 */
 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([
-	"running",
-	"stopped",
-	"deleted"
-]);
 /**
 * What the host is doing about a machine. A request waits for a rest: `settled`, at rest with what
 * was asked; `failed`, after a step failed, until the next request; `lost`, one the runtime no
 * longer has, which can only be deleted; and `waiting`, one the runtime can't read, which fails the
 * request and is read again at the host's next recheck. `creating` copies the machine and runs its
 * setup, and a machine whose create or setup fails is deleted. `starting` starts the machine, also
-* when it runs already, and prepares it.
+* when it runs already, resumes a paused one, and prepares it.
 */
 const Phase = Schema.Literals([
 	"observing",
@@ -220,6 +224,7 @@ const Phase = Schema.Literals([
 	"creating",
 	"starting",
 	"stopping",
+	"pausing",
 	"deleting",
 	"settled",
 	"failed",
@@ -255,12 +260,13 @@ const TailnetStatus = Schema.Union([
 	Schema.Struct({ state: Schema.Literal("missing") })
 ]).annotate({ identifier: "TailnetStatus" });
 /**
-* `state` is what the runtime reports: `missing` when it doesn't have the machine, and `unknown`
-* when it couldn't be read. `desired` is what the last request asked for, `phase` what the host is
-* doing about it, and `error` why the last step failed, until the next request. `ssh` is only
-* on a running machine whose runtime gives it an endpoint, and `hostKey`, `<type> <base64>`, once
-* preparation has recorded it. `tailnet` is on a running machine of a host that joins its machines
-* to a tailnet, once the host has checked it.
+* `state` is what the runtime reports: `paused` while it holds the machine's saved execution,
+* `missing` when it doesn't have the machine, and `unknown` when it couldn't be read. `desired` is
+* what the last request asked for, `phase` what the host is doing about it, and `error` why the
+* last step failed, until the next request. `ssh` is only on a running machine whose runtime gives
+* it an endpoint, and `hostKey`, `<type> <base64>`, once preparation has recorded it. `tailnet` is
+* on a running machine of a host that joins its machines to a tailnet, once the host has checked
+* it.
 */
 const Machine = Schema.Struct({
 	id: Id,
@@ -274,6 +280,7 @@ const Machine = Schema.Struct({
 	state: Schema.Literals([
 		"running",
 		"stopped",
+		"paused",
 		"missing",
 		"unknown"
 	]),
@@ -446,14 +453,21 @@ const Http = ActionHttp.make([
 	Action.make("startMachine", {
 		...write,
 		error: converging,
-		description: "Ask for a machine to run, and wait until it does: start it and prepare it again, also when it runs already.",
+		description: "Ask for a machine to run, and wait until it does: start it, or resume it when it is paused, and prepare it again, also when it runs already. A paused linux machine resumes only under the smolvm build that paused it, and a paused mac machine only while the Mac's session is unlocked, keeping its saved state when it can't.",
 		input: ById,
 		success: Machine
 	}),
 	Action.make("stopMachine", {
 		...write,
 		error: converging,
-		description: "Ask for a machine to stay stopped, and wait until it is: a power-off that keeps its disk and ends its processes. A start under way is cut short; a machine still being made is made first, and its create answers Superseded.",
+		description: "Ask for a machine to stay stopped, and wait until it is: a power-off that keeps its disk and ends its processes. A start under way is cut short; a machine still being made is made first, and its create answers Superseded. A paused linux machine is resumed to end its processes, so it needs room as a start does and the runtime build that paused it; a paused mac machine's saved state is discarded.",
+		input: ById,
+		success: Machine
+	}),
+	Action.make("pauseMachine", {
+		...write,
+		error: converging,
+		description: "Ask for a machine to stay paused, and wait until it is: the runtime saves its RAM, processes and disks and stops its VM, and a start resumes it. A machine that is stopped stays stopped, and one whose VM the runtime can't save, booted under another smolvm build or by an older mac host, is stopped instead.",
 		input: ById,
 		success: Machine
 	}),
@@ -539,7 +553,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.23.0";
+const version = "0.24.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. */
@@ -736,6 +750,7 @@ const make = (hosts, options) => Effect.gen(function* () {
 		getMachine: (input) => onResource("getMachine", input),
 		startMachine: (input) => onResource("startMachine", input),
 		stopMachine: (input) => onResource("stopMachine", input),
+		pauseMachine: (input) => onResource("pauseMachine", input),
 		deleteMachine: (input) => deleting(onResource("deleteMachine", input)),
 		forkMachine: (input) => onResource("forkMachine", input, input.name),
 		restoreMachine: (input) => onResource("restoreMachine", input, input.name),
@@ -747,4 +762,4 @@ const make = (hosts, options) => Effect.gen(function* () {
 });
 const layer = (hosts, options) => Layer.effect(Client, make(hosts, options));
 //#endregion
-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 };
+export { Name as A, Invalid as B, SshLogin as C, stateLabel as D, loginUser as E, ClankerboxError as F, PinMismatch as G, NotFound as H, Conflict as I, Unavailable as J, ScriptFailed as K, Desired as L, parseId as M, parseName as N, HostId as O, Capacity as P, retryable as Q, HostError as R, SshEndpoint as S, Usage as T, NotMade as U, Missing as V, NotOffered 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, Kind as m, layer as n, version as o, Host as p, Superseded as q, describeFileError as r, versionHeader as s, client_exports as t, readTimeout as u, PrebuildRequest as v, TailnetStatus as w, Setup as x, Prebuilt as y, Internal as z };

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

@@ -34,13 +34,21 @@ declare const Conflict_base: Schema.Class<Conflict, Schema.TaggedStruct<"Conflic
 }>, import("effect/Cause").YieldableError>;
 /** The name is taken. */
 declare class Conflict extends Conflict_base {}
+/**
+ * What the operator asked a machine to be; the host keeps moving the machine toward it. `paused`
+ * keeps its RAM, processes and disks, saved by the runtime with the VM stopped, and a start
+ * resumes it; a machine that is stopped when a pause comes stays stopped, and one the runtime
+ * can't save, such as a VM an older runtime booted, is stopped instead.
+ */
+declare const Desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+type Desired = typeof Desired.Type;
 declare const Superseded_base: Schema.Class<Superseded, Schema.TaggedStruct<"Superseded", {
   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 by: Schema.Literals<readonly ["running", "stopped", "deleted"]>;
+  readonly by: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
 }>, import("effect/Cause").YieldableError>;
 /**
  * A later request on the machine replaced this one before the host got there: `by` is what that
@@ -83,9 +91,11 @@ declare const PinMismatch_base: Schema.Class<PinMismatch, Schema.TaggedStruct<"P
   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. */
+/**
+ * The checkpoint or paused machine `id` holds RAM state saved under another runtime pin than the
+ * one the host runs, and restores or resumes only under that one.
+ */
 declare class PinMismatch extends PinMismatch_base {}
 declare const WrongState_base: Schema.Class<WrongState, Schema.TaggedStruct<"WrongState", {
   readonly host: Schema.optionalKey<Schema.String>;
@@ -183,9 +193,9 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -213,9 +223,9 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -253,9 +263,9 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -283,9 +293,9 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -313,9 +323,39 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 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 tailnet: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly state: Schema.Literal<"joined">;
+    readonly name: Schema.optionalKey<Schema.String>;
+  }>, Schema.Struct<{
+    readonly state: Schema.Literal<"failed">;
+    readonly error: Schema.String;
+  }>, 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 Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"pauseMachine", Schema.Struct<{
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly kind: Schema.Literals<readonly ["linux", "mac"]>;
+  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", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -346,9 +386,9 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -377,9 +417,9 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -511,9 +551,9 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+    readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+    readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -549,9 +589,9 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+    readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+    readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -611,9 +651,9 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+    readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+    readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -651,9 +691,9 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+    readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+    readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -671,6 +711,37 @@ declare const actionsByName: {
       readonly state: Schema.Literal<"missing">;
     }>]>>;
   }>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>;
+  readonly pauseMachine: Action.Action<"pauseMachine", Schema.Struct<{
+    readonly id: Schema.String;
+  }>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["linux", "mac"]>;
+    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", "paused", "missing", "unknown"]>;
+    readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+    readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 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 tailnet: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+      readonly state: Schema.Literal<"joined">;
+      readonly name: Schema.optionalKey<Schema.String>;
+    }>, Schema.Struct<{
+      readonly state: Schema.Literal<"failed">;
+      readonly error: Schema.String;
+    }>, 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 Capacity | typeof Internal)[], false, typeof Action.Anyone>;
   readonly prebuildCheckpoint: Action.Action<"prebuildCheckpoint", Schema.Struct<{
     readonly base: Schema.String;
     readonly cpu: Schema.Int;
@@ -709,9 +780,9 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+    readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+    readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -740,9 +811,9 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+    readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+    readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -771,9 +842,9 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+    readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+    readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
     readonly ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
@@ -804,18 +875,15 @@ type Kind = typeof Kind.Type;
  * 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;
 /**
  * What the host is doing about a machine. A request waits for a rest: `settled`, at rest with what
  * was asked; `failed`, after a step failed, until the next request; `lost`, one the runtime no
  * longer has, which can only be deleted; and `waiting`, one the runtime can't read, which fails the
  * request and is read again at the host's next recheck. `creating` copies the machine and runs its
  * setup, and a machine whose create or setup fails is deleted. `starting` starts the machine, also
- * when it runs already, and prepares it.
+ * when it runs already, resumes a paused one, and prepares it.
  */
-declare const Phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
+declare const Phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "deleting", "settled", "failed", "lost"]>;
 type Phase = typeof Phase.Type;
 declare const SshEndpoint: Schema.Struct<{
   readonly host: Schema.String;
@@ -846,12 +914,13 @@ declare const TailnetStatus: Schema.Union<readonly [Schema.Struct<{
 }>]>;
 type TailnetStatus = typeof TailnetStatus.Type;
 /**
- * `state` is what the runtime reports: `missing` when it doesn't have the machine, and `unknown`
- * when it couldn't be read. `desired` is what the last request asked for, `phase` what the host is
- * doing about it, and `error` why the last step failed, until the next request. `ssh` is only
- * on a running machine whose runtime gives it an endpoint, and `hostKey`, `<type> <base64>`, once
- * preparation has recorded it. `tailnet` is on a running machine of a host that joins its machines
- * to a tailnet, once the host has checked it.
+ * `state` is what the runtime reports: `paused` while it holds the machine's saved execution,
+ * `missing` when it doesn't have the machine, and `unknown` when it couldn't be read. `desired` is
+ * what the last request asked for, `phase` what the host is doing about it, and `error` why the
+ * last step failed, until the next request. `ssh` is only on a running machine whose runtime gives
+ * it an endpoint, and `hostKey`, `<type> <base64>`, once preparation has recorded it. `tailnet` is
+ * on a running machine of a host that joins its machines to a tailnet, once the host has checked
+ * it.
  */
 declare const Machine: Schema.Struct<{
   readonly id: Schema.String;
@@ -862,9 +931,9 @@ declare const Machine: Schema.Struct<{
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  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 state: Schema.Literals<readonly ["running", "stopped", "paused", "missing", "unknown"]>;
+  readonly desired: Schema.Literals<readonly ["running", "stopped", "paused", "deleted"]>;
+  readonly phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "pausing", "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 Capacity, typeof Internal]>>;
   readonly ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
@@ -1105,4 +1174,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 { 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 };
+export { ClankerboxError as A, PinMismatch as B, loginUser as C, actionsByName as D, Http as E, Invalid as F, WrongState as G, Superseded as H, Missing as I, hostErrors as K, NotFound as L, Desired as M, HostError as N, readTimeout as O, Internal as P, NotMade as R, Usage as S, Declared as T, Unavailable as U, ScriptFailed as V, Unsizable as W, Reading as _, Options as a, SshLogin 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, Host 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, Kind as u, Setup as v, stateLabel as w, TailnetStatus as x, SshEndpoint as y, NotOffered as z };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-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 { A as ClankerboxError, B as PinMismatch, C as loginUser, D as actionsByName, E as Http, F as Invalid, G as WrongState, H as Superseded, I as Missing, K as hostErrors, L as NotFound, M as Desired, N as HostError, O as readTimeout, P as Internal, R as NotMade, S as Usage, T as Declared, U as Unavailable, V as ScriptFailed, W as Unsizable, _ as Reading, b as SshLogin, 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 Host, m as PrebuildRequest, n as CreateOptions$1, o as client_d_exports, p as Phase, q as retryable, s as Checkpoint, u as Kind, v as Setup, w as stateLabel, x as TailnetStatus, y as SshEndpoint, z as NotOffered } from "./client-Cdz6BWfg.mjs";
 import { Effect, FileSystem, Path, PlatformError, Schema, Scope } from "effect";
 //#region src/ids.d.ts
 export declare const HostId: Schema.String;

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.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-CM0M6Czt.mjs";
+import { A as Name, B as Invalid, C as SshLogin, D as stateLabel, E as loginUser, F as ClankerboxError, G as PinMismatch, H as NotFound, I as Conflict, J as Unavailable, K as ScriptFailed, L as Desired, M as parseId, N as parseName, O as HostId, P as Capacity, Q as retryable, R as HostError, S as SshEndpoint, T as Usage, U as NotMade, V as Missing, W as NotOffered, 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 Kind, o as version, p as Host, q as Superseded, r as describeFileError, s as versionHeader, t as client_exports, u as readTimeout, v as PrebuildRequest, w as TailnetStatus, x as Setup, y as Prebuilt, z as Internal } from "./client-BFhJ4z-h.mjs";
 import { Effect, FileSystem, Option, Path, Predicate, Record, Schema } from "effect";
 import { Base64, Hex } from "effect/encoding";
 //#region src/prebuild.ts

package/dist/node.d.mts

@@ -1,4 +1,4 @@
-import { F as Invalid, a as Options, r as HostEntry, t as Client } from "./client-D6pHB56g.mjs";
+import { F as Invalid, a as Options, r as HostEntry, t as Client } from "./client-Cdz6BWfg.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-CM0M6Czt.mjs";
+import { n as layer$1 } from "./client-BFhJ4z-h.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.23.0",
+  "version": "0.24.0",
   "description": "clankerbox's API contract and client library, for Effect",
   "license": "MIT",
   "repository": {