@gjermundgaraba/clankerbox-sdk 0.18.3 → 0.20.0

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

@@ -25,18 +25,28 @@ declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFoun
 }>, import("effect/Cause").YieldableError>;
 /** The machine or checkpoint doesn't exist. A `delete` that meets it is done. */
 declare class NotFound extends NotFound_base {}
-declare const ConflictKind: Schema.Literals<readonly ["exists", "busy"]>;
-type ConflictKind = typeof ConflictKind.Type;
 declare const Conflict_base: Schema.Class<Conflict, Schema.TaggedStruct<"Conflict", {
   readonly host: Schema.optionalKey<Schema.String>;
   readonly action: Schema.optionalKey<Schema.String>;
   readonly id: Schema.optionalKey<Schema.String>;
   readonly made: Schema.optionalKey<Schema.String>;
   readonly message: Schema.String;
-  readonly kind: Schema.Literals<readonly ["exists", "busy"]>;
 }>, import("effect/Cause").YieldableError>;
-/** The name is taken (`exists`), or another action holds the resource (`busy`). */
+/** The name is taken. */
 declare class Conflict extends Conflict_base {}
+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"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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.
+ */
+declare class Superseded extends Superseded_base {}
 declare const NotOffered_base: Schema.Class<NotOffered, Schema.TaggedStruct<"NotOffered", {
   readonly host: Schema.optionalKey<Schema.String>;
   readonly action: Schema.optionalKey<Schema.String>;
@@ -55,7 +65,7 @@ declare const NotMade_base: Schema.Class<NotMade, Schema.TaggedStruct<"NotMade",
   readonly message: Schema.String;
   readonly machine: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-/** `machine`'s create, fork or restore failed before it was made: it can only be deleted. */
+/** `machine` isn't made yet: its create or setup still runs, so it can't be copied or captured. */
 declare class NotMade extends NotMade_base {}
 declare const Missing_base: Schema.Class<Missing, Schema.TaggedStruct<"Missing", {
   readonly host: Schema.optionalKey<Schema.String>;
@@ -67,16 +77,6 @@ declare const Missing_base: Schema.Class<Missing, Schema.TaggedStruct<"Missing",
 }>, import("effect/Cause").YieldableError>;
 /** The runtime no longer has `machine`: it can only be deleted. */
 declare class Missing extends Missing_base {}
-declare const NotReady_base: Schema.Class<NotReady, Schema.TaggedStruct<"NotReady", {
-  readonly host: Schema.optionalKey<Schema.String>;
-  readonly action: Schema.optionalKey<Schema.String>;
-  readonly id: Schema.optionalKey<Schema.String>;
-  readonly made: Schema.optionalKey<Schema.String>;
-  readonly message: Schema.String;
-  readonly checkpoint: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/** `checkpoint`'s capture failed, so nothing restores from it: it can only be deleted. */
-declare class NotReady extends NotReady_base {}
 declare const PinMismatch_base: Schema.Class<PinMismatch, Schema.TaggedStruct<"PinMismatch", {
   readonly host: Schema.optionalKey<Schema.String>;
   readonly action: Schema.optionalKey<Schema.String>;
@@ -113,11 +113,12 @@ declare const ScriptFailed_base: Schema.Class<ScriptFailed, Schema.TaggedStruct<
   readonly id: Schema.optionalKey<Schema.String>;
   readonly made: Schema.optionalKey<Schema.String>;
   readonly message: Schema.String;
-  readonly script: Schema.Literals<readonly ["setup", "preparation"]>;
+  readonly script: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 /**
  * A guest script exited non-zero or ran past its timeout; the message says which, with its
- * output's tail. A failed `setup` leaves the machine unmade, a failed `preparation` made.
+ * output's tail, and `script` names it: a failed `setup` deletes the machine, and a failed
+ * `preparation` runs again on the next start.
  */
 declare class ScriptFailed extends ScriptFailed_base {}
 declare const Refused_base: Schema.Class<Refused, Schema.TaggedStruct<"Refused", {
@@ -160,20 +161,22 @@ 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 NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal];
-declare const HostError: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
+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]>;
 type HostError = typeof HostError.Type;
 /**
  * Each carries, where known: `host` and `action`, which the client sets; `id`, the resource the
  * error is about, which a host sets on `NotFound` and `Conflict` and the client sets to the call's
- * subject otherwise; and `made`, the resource a create, fork, restore or capture makes, which a
- * failure may leave behind.
+ * subject otherwise; and `made`, the resource a create, fork, restore or capture makes. The host
+ * deletes a machine whose copy or setup fails, again at each recheck while that delete fails, and
+ * 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 NotOffered, typeof NotMade, typeof Missing, typeof NotReady, 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 Refused, typeof Capacity, typeof Internal, typeof Unavailable]>;
 type ClankerboxError = typeof ClankerboxError.Type;
 /**
- * Whether the same call may succeed later: a busy resource or a full host may free up, and a read
- * that got no reply may get one.
+ * Whether the same call may succeed later: a full host may free up, and a read that got no reply
+ * may get one.
  */
 declare const retryable: (error: ClankerboxError) => boolean;
 //#endregion
@@ -190,21 +193,24 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly made: Schema.Boolean;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
+  readonly 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 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 Internal)[], true, typeof Action.Anyone>, Action.Action<"getMachine", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
@@ -217,21 +223,24 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly made: Schema.Boolean;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
+  readonly 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 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 Internal)[], true, typeof Action.Anyone>, Action.Action<"createMachine", Schema.Struct<{
   readonly base: Schema.String;
   readonly cpu: Schema.Int;
@@ -240,6 +249,7 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly setup: Schema.optionalKey<Schema.Struct<{
     readonly script: Schema.String;
     readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+    readonly authorizedKeys: Schema.optionalKey<Schema.String>;
   }>>;
   readonly profile: Schema.optionalKey<Schema.String>;
   readonly id: Schema.String;
@@ -253,22 +263,25 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly made: Schema.Boolean;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
+  readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
     readonly user: Schema.String;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly (typeof Invalid | typeof Conflict | typeof NotOffered | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"startMachine", Schema.Struct<{
+  readonly 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 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 id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
@@ -280,22 +293,25 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly made: Schema.Boolean;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
+  readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
     readonly user: Schema.String;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"stopMachine", Schema.Struct<{
+  readonly 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 Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"stopMachine", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
@@ -307,24 +323,27 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly made: Schema.Boolean;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
+  readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
     readonly user: Schema.String;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"deleteMachine", Schema.Struct<{
+  readonly 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 Refused | 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 Conflict | typeof Refused | 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 Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"forkMachine", Schema.Struct<{
   readonly machine: Schema.String;
   readonly name: Schema.String;
 }>, Schema.Struct<{
@@ -337,22 +356,25 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly made: Schema.Boolean;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
+  readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
     readonly user: Schema.String;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"restoreMachine", Schema.Struct<{
+  readonly 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 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 checkpoint: Schema.String;
   readonly name: Schema.String;
 }>, Schema.Struct<{
@@ -365,22 +387,25 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly made: Schema.Boolean;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
+  readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
     readonly host: Schema.String;
     readonly port: Schema.Int;
     readonly user: Schema.String;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotReady | typeof PinMismatch | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"listCheckpoints", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+  readonly 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 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 id: Schema.String;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly machine: Schema.String;
@@ -390,14 +415,6 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
 }>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"getCheckpoint", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
@@ -410,14 +427,6 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
 }>, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"captureCheckpoint", Schema.Struct<{
   readonly machine: Schema.String;
   readonly name: Schema.String;
@@ -431,17 +440,34 @@ declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", S
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
 }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"deleteCheckpoint", Schema.Struct<{
   readonly id: Schema.String;
-}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"getHost", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"prebuildCheckpoint", Schema.Struct<{
+  readonly base: Schema.String;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.String;
+  readonly setup: Schema.Struct<{
+    readonly script: Schema.String;
+    readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+    readonly authorizedKeys: Schema.optionalKey<Schema.String>;
+  }>;
+}>, Schema.Struct<{
+  readonly checkpoint: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly machine: Schema.String;
+    readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+  }>;
+  readonly 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 id: Schema.String;
   readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
   readonly version: Schema.String;
@@ -473,14 +499,6 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
   }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
   readonly createMachine: Action.Action<"createMachine", Schema.Struct<{
     readonly base: Schema.String;
@@ -490,6 +508,7 @@ declare const actionsByName: {
     readonly setup: Schema.optionalKey<Schema.Struct<{
       readonly script: Schema.String;
       readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+      readonly authorizedKeys: Schema.optionalKey<Schema.String>;
     }>>;
     readonly profile: Schema.optionalKey<Schema.String>;
     readonly id: Schema.String;
@@ -503,28 +522,31 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-    readonly made: Schema.Boolean;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
+    readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
       readonly user: Schema.String;
     }>>;
     readonly hostKey: Schema.optionalKey<Schema.String>;
-  }>, readonly (typeof Invalid | typeof Conflict | typeof NotOffered | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+    readonly 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 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 deleteCheckpoint: Action.Action<"deleteCheckpoint", Schema.Struct<{
     readonly id: Schema.String;
-  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>;
   readonly deleteMachine: Action.Action<"deleteMachine", Schema.Struct<{
     readonly id: Schema.String;
-  }>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>;
+  }>, 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>;
   readonly forkMachine: Action.Action<"forkMachine", Schema.Struct<{
     readonly machine: Schema.String;
     readonly name: Schema.String;
@@ -538,22 +560,25 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-    readonly made: Schema.Boolean;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
+    readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
       readonly user: Schema.String;
     }>>;
     readonly hostKey: Schema.optionalKey<Schema.String>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+    readonly 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 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 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"]>;
@@ -577,14 +602,6 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
   }>, readonly (typeof Invalid | typeof NotFound | typeof Internal)[], true, typeof Action.Anyone>;
   readonly getHost: Action.Action<"getHost", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
     readonly id: Schema.String;
@@ -606,21 +623,24 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-    readonly made: Schema.Boolean;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
+    readonly 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 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 Internal)[], true, typeof Action.Anyone>;
   readonly listCheckpoints: Action.Action<"listCheckpoints", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
     readonly id: Schema.String;
@@ -632,14 +652,6 @@ declare const actionsByName: {
     readonly cpu: Schema.Int;
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
   }>>, readonly (typeof Invalid | typeof Internal)[], true, typeof Action.Anyone>;
   readonly listMachines: Action.Action<"listMachines", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
     readonly id: Schema.String;
@@ -651,22 +663,51 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-    readonly made: Schema.Boolean;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
+    readonly 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 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 Internal)[], true, typeof Action.Anyone>;
+  readonly prebuildCheckpoint: Action.Action<"prebuildCheckpoint", Schema.Struct<{
+    readonly base: Schema.String;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly id: Schema.String;
+    readonly setup: Schema.Struct<{
+      readonly script: Schema.String;
+      readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+      readonly authorizedKeys: Schema.optionalKey<Schema.String>;
+    }>;
+  }>, Schema.Struct<{
+    readonly checkpoint: Schema.Struct<{
+      readonly id: Schema.String;
+      readonly createdAt: Schema.DateTimeUtcFromString;
+      readonly machine: Schema.String;
+      readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+      readonly base: Schema.String;
+      readonly profile: Schema.optionalKey<Schema.String>;
+      readonly cpu: Schema.Int;
+      readonly ramMib: Schema.Int;
+      readonly diskGib: Schema.Int;
+    }>;
+    readonly 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 restoreMachine: Action.Action<"restoreMachine", Schema.Struct<{
     readonly checkpoint: Schema.String;
     readonly name: Schema.String;
@@ -680,22 +721,25 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-    readonly made: Schema.Boolean;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
+    readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
       readonly user: Schema.String;
     }>>;
     readonly hostKey: Schema.optionalKey<Schema.String>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotReady | typeof PinMismatch | typeof Unsizable | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+    readonly 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 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 startMachine: Action.Action<"startMachine", Schema.Struct<{
     readonly id: Schema.String;
   }>, Schema.Struct<{
@@ -708,22 +752,25 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-    readonly made: Schema.Boolean;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
+    readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
       readonly user: Schema.String;
     }>>;
     readonly hostKey: Schema.optionalKey<Schema.String>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof NotMade | typeof Missing | typeof WrongState | typeof ScriptFailed | typeof Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
+    readonly 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 Refused | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>;
   readonly stopMachine: Action.Action<"stopMachine", Schema.Struct<{
     readonly id: Schema.String;
   }>, Schema.Struct<{
@@ -736,22 +783,25 @@ declare const actionsByName: {
     readonly ramMib: Schema.Int;
     readonly diskGib: Schema.Int;
     readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-    readonly made: Schema.Boolean;
-    readonly action: Schema.Union<readonly [Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literals<readonly ["running", "done"]>;
-    }>, Schema.Struct<{
-      readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-      readonly status: Schema.Literal<"failed">;
-      readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-    }>]>;
+    readonly 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 ssh: Schema.optionalKey<Schema.Struct<{
       readonly host: Schema.String;
       readonly port: Schema.Int;
       readonly user: Schema.String;
     }>>;
     readonly hostKey: Schema.optionalKey<Schema.String>;
-  }>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Refused | typeof Internal)[], false, typeof Action.Anyone>;
+    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 Refused | 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"];
@@ -759,21 +809,19 @@ type Declared<N extends keyof typeof actionsByName> = (typeof actionsByName)[N][
 //#region src/resources.d.ts
 declare const Runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
 type Runtime = typeof Runtime.Type;
-/** The contract's mutations, which record themselves on a resource's `action`. */
-declare const ActionName: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-type ActionName = typeof ActionName.Type;
-declare const ActionStatus: Schema.Literals<readonly ["running", "failed", "done"]>;
-type ActionStatus = typeof ActionStatus.Type;
-/** A resource's last action; the next action replaces it. */
-declare const ActionRecord: Schema.Union<readonly [Schema.Struct<{
-  readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-  readonly status: Schema.Literals<readonly ["running", "done"]>;
-}>, Schema.Struct<{
-  readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-  readonly status: Schema.Literal<"failed">;
-  readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-}>]>;
-type ActionRecord = typeof ActionRecord.Type;
+/** 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.
+ */
+declare const Phase: Schema.Literals<readonly ["observing", "waiting", "creating", "starting", "stopping", "deleting", "settled", "failed", "lost"]>;
+type Phase = typeof Phase.Type;
 declare const SshEndpoint: Schema.Struct<{
   readonly host: Schema.String;
   readonly port: Schema.Int;
@@ -786,10 +834,29 @@ declare const SshLogin: Schema.Struct<{
 }>;
 type SshLogin = typeof SshLogin.Type;
 /**
- * `state` is `missing` when the runtime doesn't have the machine, and `unknown` when it couldn't
- * be read. Until its create, fork or restore has `made` it, a machine can only be read, stopped or
- * deleted. `ssh` is only on a running machine whose runtime gives it an endpoint, and `hostKey`,
- * `<type> <base64>`, once preparation has recorded it.
+ * A running machine's place on the tailnet, as the host last checked it: `joined` once
+ * `tailscaled` runs signed in, with the MagicDNS name Tailscale gave it, if any; `failed` with
+ * why; or `missing` when the guest has no `tailscaled`. Kept in the host's memory only: each start
+ * checks again, a joined machine is checked again every half hour or so, and a failed one sooner,
+ * waiting longer after each failure.
+ */
+declare const TailnetStatus: 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">;
+}>]>;
+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.
  */
 declare const Machine: Schema.Struct<{
   readonly id: Schema.String;
@@ -801,26 +868,35 @@ declare const Machine: Schema.Struct<{
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
   readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly made: Schema.Boolean;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
+  readonly 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 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">;
+  }>]>>;
 }>;
 type Machine = typeof Machine.Type;
-/** The state as people read it: `running`, or `stopped (unmade)` for one never made. */
-declare const stateLabel: ({ state, made }: Machine) => string;
-/** `kind` is `ram` (RAM and disks) on smolvm, and `disk` on Tart and boat. */
+/**
+ * The state as people read it: `running` at rest, `running (failed)` where it is but not at rest,
+ * and `stopped, wants running (starting)` on the way.
+ */
+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.
+ */
 declare const Checkpoint: Schema.Struct<{
   readonly id: Schema.String;
   readonly createdAt: Schema.DateTimeUtcFromString;
@@ -831,18 +907,8 @@ declare const Checkpoint: Schema.Struct<{
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
   readonly diskGib: Schema.Int;
-  readonly action: Schema.Union<readonly [Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literals<readonly ["running", "done"]>;
-  }>, Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["createMachine", "startMachine", "stopMachine", "deleteMachine", "forkMachine", "restoreMachine", "captureCheckpoint", "deleteCheckpoint"]>;
-    readonly status: Schema.Literal<"failed">;
-    readonly error: Schema.Union<readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof NotOffered, typeof NotMade, typeof Missing, typeof NotReady, typeof PinMismatch, typeof WrongState, typeof Unsizable, typeof ScriptFailed, typeof Refused, typeof Capacity, typeof Internal]>;
-  }>]>;
 }>;
 type Checkpoint = typeof Checkpoint.Type;
-/** A checkpoint restores once its capture is done; it never changes after. */
-declare const isReady: (checkpoint: Pick<Checkpoint, "action">) => boolean;
 /**
  * `runtimeVersion` is boat's API version on boat. `captureFrom` is the state a machine must be in
  * to be captured: Tart's is `stopped`.
@@ -880,10 +946,20 @@ type Usage = typeof Usage.Type;
 type WithoutHost<Row> = Row extends unknown ? Omit<Row, "host"> : never;
 /** A `Usage` row as a runtime reads it, before the host names itself on it. */
 type Reading = WithoutHost<Usage>;
-/** Nothing logs the script: it can carry secrets. */
+/**
+ * Public keys, as `.pub` files hold them: each line that isn't blank is `<type> <base64>
+ * [comment]`, the type an OpenSSH key's, its certificate's or a hardware key's, and at least one
+ * line is. Anything else, a private key included, is refused.
+ */
+declare const PublicKeys: Schema.String;
+/**
+ * Nothing logs the script: it can carry secrets. `authorizedKeys` is appended to the login user's
+ * `~/.ssh/authorized_keys` once the script exits 0, through the guest's `sudo`.
+ */
 declare const Setup: Schema.Struct<{
   readonly script: Schema.String;
   readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+  readonly authorizedKeys: Schema.optionalKey<Schema.String>;
 }>;
 type Setup = typeof Setup.Type;
 /** A profile file fills these in; the host sees only the `profile` label. */
@@ -895,6 +971,7 @@ declare const MachineSpec: Schema.Struct<{
   setup: Schema.optionalKey<Schema.Struct<{
     readonly script: Schema.String;
     readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+    readonly authorizedKeys: Schema.optionalKey<Schema.String>;
   }>>;
   profile: Schema.optionalKey<Schema.String>;
 }>;
@@ -908,11 +985,43 @@ declare const CreateRequest: Schema.Struct<{
   readonly setup: Schema.optionalKey<Schema.Struct<{
     readonly script: Schema.String;
     readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+    readonly authorizedKeys: Schema.optionalKey<Schema.String>;
   }>>;
   readonly profile: Schema.optionalKey<Schema.String>;
   readonly id: Schema.String;
 }>;
 type CreateRequest = typeof CreateRequest.Type;
+/** A prebuild is the checkpoint `id` of a machine made from the spec, setup and all. */
+declare const PrebuildRequest: Schema.Struct<{
+  readonly base: Schema.String;
+  readonly cpu: Schema.Int;
+  readonly ramMib: Schema.Int;
+  readonly diskGib: Schema.Int;
+  readonly profile: Schema.optionalKey<Schema.String>;
+  readonly id: Schema.String;
+  readonly setup: Schema.Struct<{
+    readonly script: Schema.String;
+    readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+    readonly authorizedKeys: Schema.optionalKey<Schema.String>;
+  }>;
+}>;
+type PrebuildRequest = typeof PrebuildRequest.Type;
+/** `built` is false when the host already had the checkpoint. */
+declare const Prebuilt: Schema.Struct<{
+  readonly checkpoint: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly machine: Schema.String;
+    readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
+    readonly base: Schema.String;
+    readonly profile: Schema.optionalKey<Schema.String>;
+    readonly cpu: Schema.Int;
+    readonly ramMib: Schema.Int;
+    readonly diskGib: Schema.Int;
+  }>;
+  readonly built: Schema.Boolean;
+}>;
+type Prebuilt = typeof Prebuilt.Type;
 declare namespace client_d_exports {
   export { Calls, Client, CreateOptions, Deleted, ErrorOf, Gathered, HostAction, HostEntry, Interface, Options, Routed, Unreachable, layer, make };
 }
@@ -969,7 +1078,7 @@ type Routed = { readonly [N in HostAction]: Input<N> extends Subject ? N : never
 /**
  * One method per action on a resource, named and typed as in the contract, but for `create` and
  * the deletes. A create, fork, restore or capture's errors carry `made`, the resource it makes, so
- * a caller can find what a failure left behind.
+ * a caller whose answer was lost can find what it left behind.
  */
 type Calls = { readonly [N in Exclude<Routed, "createMachine" | "deleteMachine" | "deleteCheckpoint">]: (input: Input<N>) => Effect.Effect<Success<N>, ErrorOf<N>>; };
 interface Interface extends Calls {
@@ -1004,4 +1113,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 { ConflictKind as A, Refused as B, Declared as C, Capacity as D, readTimeout as E, NotFound as F, hostErrors as G, Unavailable as H, NotMade as I, retryable as K, NotOffered as L, Internal as M, Invalid as N, ClankerboxError as O, Missing as P, NotReady as R, stateLabel as S, actionsByName as T, Unsizable as U, ScriptFailed as V, WrongState as W, Setup as _, Options as a, Usage as b, ActionRecord as c, CreateRequest as d, Host as f, Runtime as g, Reading as h, Interface as i, HostError as j, Conflict as k, ActionStatus as l, MachineSpec as m, CreateOptions as n, client_d_exports as o, Machine as p, HostEntry as r, ActionName as s, Client as t, Checkpoint as u, SshEndpoint as v, Http as w, isReady as x, SshLogin as y, PinMismatch as z };
+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 };