@gjermundgaraba/clankerbox-sdk 0.12.2 → 0.13.0

package/dist/{client-DXuiPvxU.mjs → client-Bb5qTz-i.mjs}

@@ -1,11 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
-import * as ActionGroup from "@gjermundgaraba/effect-actions/ActionGroup";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import { Context, Duration, Effect, Fiber, Match, Predicate, Result, Schema } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/http";
-import { HttpApiClient } from "effect/http-api";
 //#region src/errors.ts
+/**
+* The seven errors every clankerbox call can fail with. `retryable` is derived from the
+* tag, so callers never keep their own table of which failures to repeat.
+*/
 /** The request is malformed: a bad ID or name, an undeclared field, a value out of range. */
 var Invalid = class extends Schema.TaggedError()("Invalid", { message: Schema.String }, { httpApiStatus: 400 }) {
 	get retryable() {
@@ -42,15 +44,15 @@ var Capacity = class extends Schema.TaggedError()("Capacity", { message: Schema.
 };
 /**
 * The client couldn't reach the host, or lost its reply. Only the client library produces
-* it. `access` is the access of the action that met it: a mutation's request may have
-* reached the host and run, so it is never retryable.
+* it. `readOnly` is that of the action that met it: a mutation's request may have reached
+* the host and run, so it is never retryable.
 */
 var Unavailable = class extends Schema.TaggedError()("Unavailable", {
 	message: Schema.String,
-	access: Schema.Literals(["read", "write"])
+	readOnly: Schema.Boolean
 }) {
 	get retryable() {
-		return this.access === "read";
+		return this.readOnly;
 	}
 };
 var Internal = class extends Schema.TaggedError()("Internal", { message: Schema.String }, { httpApiStatus: 500 }) {
@@ -58,7 +60,7 @@ var Internal = class extends Schema.TaggedError()("Internal", { message: Schema.
 		return false;
 	}
 };
-/** What a host answers with; every action group declares these. */
+/** What a host answers with; every action declares these. */
 const hostErrors = [
 	Invalid,
 	NotFound,
@@ -127,7 +129,7 @@ const formatId = (host, name) => {
 };
 //#endregion
 //#region package.json
-var version$1 = "0.12.2";
+var version$1 = "0.13.0";
 //#endregion
 //#region src/resources.ts
 /** The resources a host reports: machines, checkpoints and the host itself. */
@@ -270,24 +272,11 @@ const Profile = Schema.Struct({
 //#endregion
 //#region src/api.ts
 /**
-* The host API: three effect-actions groups, served as JSON POST routes under `/api`.
-* A mutation replies when its action has finished.
+* The host API: one effect-actions binding, each action a JSON POST route at `/api/<action>`.
+* A mutation replies when its action has finished. Every action is public: a host listens
+* only on the tailnet or loopback.
 */
 /**
-* Without a policy, effect-actions answers undeclared or malformed input with an empty 400.
-* Schema issues never carry the rejected values, so a setup script never reaches a message.
-*/
-const schemaError = {
-	invalid: {
-		schema: Invalid,
-		make: (failure) => new Invalid({ message: `the request doesn't match the action's input: ${failure.cause.message}` })
-	},
-	internal: {
-		schema: Internal,
-		make: () => new Internal({ message: "the host's reply did not encode" })
-	}
-};
-/**
 * How long a client waits for a read's reply from one host, unless it sets its own. A host
 * bounds its own reads of runtime state under it, so a list answers in time.
 */
@@ -304,89 +293,106 @@ const FromMachine = Schema.Struct({
 	machine: Id,
 	name: Name
 });
-const MachineGroup = ActionGroup.make({
-	name: "machine",
-	errors: hostErrors,
-	schemaError
-}, Action.make("list", {
-	description: "List the host's machines.",
-	success: Schema.Array(Machine),
-	access: "read"
-}), Action.make("get", {
-	description: "Read one machine.",
-	input: ById,
-	success: Machine,
-	access: "read"
-}), Action.make("create", {
-	description: "Create a machine from a base, run its setup once, and prepare it.",
-	input: CreateRequest,
-	success: Machine,
-	access: "write"
-}), Action.make("start", {
-	description: "Start a machine. On a running machine, run preparation again.",
-	input: ById,
-	success: Machine,
-	access: "write"
-}), Action.make("stop", {
-	description: "Stop a machine. A stopped machine stays stopped, and the stop is still its last action.",
-	input: ById,
-	success: Machine,
-	access: "write"
-}), Action.make("delete", {
-	description: "Delete a machine and everything native it owns.",
-	input: ById,
-	success: Schema.Void,
-	access: "write"
-}), Action.make("fork", {
-	description: "Copy a machine to a new name on the same host.",
-	input: FromMachine,
-	success: Machine,
-	access: "write"
-}), Action.make("restore", {
-	description: "Create a machine on the checkpoint's host from that checkpoint.",
-	input: Schema.Struct({
-		checkpoint: Id,
-		name: Name
+/**
+* What every action shares, by whether it reads or changes the host. Every action declares
+* `hostErrors`, so a client decodes the `Invalid` the host's version check answers with.
+*/
+const read = {
+	caller: Action.Anyone,
+	error: hostErrors,
+	readOnly: true
+};
+const write = {
+	caller: Action.Anyone,
+	error: hostErrors,
+	readOnly: false
+};
+const Http = ActionHttp.make([
+	Action.make("listMachines", {
+		...read,
+		description: "List the host's machines.",
+		success: Schema.Array(Machine)
 	}),
-	success: Machine,
-	access: "write"
-}));
-const CheckpointGroup = ActionGroup.make({
-	name: "checkpoint",
-	errors: hostErrors,
-	schemaError
-}, Action.make("list", {
-	description: "List the host's checkpoints.",
-	success: Schema.Array(Checkpoint),
-	access: "read"
-}), Action.make("get", {
-	description: "Read one checkpoint.",
-	input: ById,
-	success: Checkpoint,
-	access: "read"
-}), Action.make("capture", {
-	description: "Capture a checkpoint of a machine. Its kind follows the runtime: ram on smolvm, which captures only a running machine, and disk on Tart and boat.",
-	input: FromMachine,
-	success: Checkpoint,
-	access: "write"
-}), Action.make("delete", {
-	description: "Delete a checkpoint.",
-	input: ById,
-	success: Schema.Void,
-	access: "write"
-}));
-const HostGroup = ActionGroup.make({
-	name: "host",
-	errors: hostErrors,
-	schemaError
-}, Action.make("get", {
-	description: "Read the host: its runtime, versions and bases.",
-	success: Host,
-	access: "read"
-}));
-const Http = ActionHttp.make({ apiPath: "/api" }, MachineGroup, CheckpointGroup, HostGroup);
+	Action.make("getMachine", {
+		...read,
+		description: "Read one machine.",
+		input: ById,
+		success: Machine
+	}),
+	Action.make("createMachine", {
+		...write,
+		description: "Create a machine from a base, run its setup once, and prepare it.",
+		input: CreateRequest,
+		success: Machine
+	}),
+	Action.make("startMachine", {
+		...write,
+		description: "Start a machine. On a running machine, run preparation again.",
+		input: ById,
+		success: Machine
+	}),
+	Action.make("stopMachine", {
+		...write,
+		description: "Stop a machine. A stopped machine stays stopped, and the stop is still its last action.",
+		input: ById,
+		success: Machine
+	}),
+	Action.make("deleteMachine", {
+		...write,
+		description: "Delete a machine and everything native it owns.",
+		input: ById
+	}),
+	Action.make("forkMachine", {
+		...write,
+		description: "Copy a machine to a new name on the same host.",
+		input: FromMachine,
+		success: Machine
+	}),
+	Action.make("restoreMachine", {
+		...write,
+		description: "Create a machine on the checkpoint's host from that checkpoint.",
+		input: Schema.Struct({
+			checkpoint: Id,
+			name: Name
+		}),
+		success: Machine
+	}),
+	Action.make("listCheckpoints", {
+		...read,
+		description: "List the host's checkpoints.",
+		success: Schema.Array(Checkpoint)
+	}),
+	Action.make("getCheckpoint", {
+		...read,
+		description: "Read one checkpoint.",
+		input: ById,
+		success: Checkpoint
+	}),
+	Action.make("captureCheckpoint", {
+		...write,
+		description: "Capture a checkpoint of a machine. Its kind follows the runtime: ram on smolvm, which captures only a running machine, and disk on Tart and boat.",
+		input: FromMachine,
+		success: Checkpoint
+	}),
+	Action.make("deleteCheckpoint", {
+		...write,
+		description: "Delete a checkpoint.",
+		input: ById
+	}),
+	Action.make("getHost", {
+		...read,
+		description: "Read the host: its runtime, versions and bases.",
+		success: Host
+	})
+], { prefix: "/api" });
 //#endregion
 //#region src/client.ts
+/**
+* The client library: a host list in placement order, routing by ID, list fan-out and
+* create placement. Nothing here retries: a mutation whose reply is lost, or that outlasts
+* the client's mutation timeout, is `Unavailable`, and the caller reads the resource to see
+* what happened.
+*/
 var client_exports = /* @__PURE__ */ __exportAll({
 	Client: () => Client,
 	HostEntry: () => HostEntry,
@@ -400,28 +406,26 @@ const HostEntry = Schema.Struct({
 var Client = class extends Context.Service()("@gjermundgaraba/clankerbox-sdk/Client") {};
 /**
 * A client for one host. Every request carries the SDK's version, which the host checks
-* against its own. Its reply decoding is the only step `transformResponse` wraps, so a reply
-* that doesn't decode is `Internal` here, and a `SchemaError` that reaches `settle` came from
-* encoding the request.
+* against its own. Input that doesn't encode fails as `InvalidInput` before anything is
+* sent, so a `SchemaError` that reaches `settle` is a reply that didn't decode.
 */
-const makeHostApi = (entry) => HttpApiClient.make(Http.api, {
+const makeHostApi = (entry) => ActionHttp.client(Http, {
 	baseUrl: entry.url,
-	transformClient: HttpClient.mapRequest(HttpClientRequest.setHeader(versionHeader, version)),
-	transformResponse: (reply) => Effect.mapError(reply, (error) => Schema.isSchemaError(error) ? new Internal({ message: `host ${entry.id}'s reply didn't decode: ${error.message}` }) : error)
+	transformClient: HttpClient.mapRequest(HttpClientRequest.setHeader(versionHeader, version))
 });
-/** Every action's contract, keyed `<group>.<action>`: a call reads its access from its action. */
-const actions = ActionGroup.contracts(MachineGroup, CheckpointGroup, HostGroup);
+/** Every action's contract, by name: a call's timeout and retry follow its `readOnly`. */
+const actions = Action.byName(Http.actions);
 const causeDetail = (error) => error.cause instanceof Error ? error.cause.message : error.message;
 /**
 * No reply came: the connection failed or dropped, or the timeout passed. A mutation's
 * request may or may not have reached its host, so it may have run.
 */
-const unanswered = (context, detail) => context.access === "read" ? new Unavailable({
+const unanswered = (context, detail) => context.readOnly ? new Unavailable({
 	message: `host ${context.host.id} (${context.host.url}) didn't answer ${context.action}: ${detail}`,
-	access: "read"
+	readOnly: context.readOnly
 }) : new Unavailable({
 	message: `no reply from host ${context.host.id} to ${context.action} (${detail}); the action may have run: read ${context.target ?? "the resource"} to see`,
-	access: "write"
+	readOnly: context.readOnly
 });
 /** Bounds the wait for the reply; the clock starts when the request is sent. */
 const bounded = (call, context) => {
@@ -431,10 +435,18 @@ const bounded = (call, context) => {
 		orElse: () => Effect.fail(unanswered(context, `timed out after ${Duration.format(timeout)}`))
 	});
 };
-const settle = (call, context) => bounded(call, context).pipe(Effect.catchTag("HttpClientError", (error) => Effect.fail(Match.value(error.reason).pipe(Match.tag("TransportError", () => unanswered(context, causeDetail(error))), Match.when({
-	_tag: "DecodeError",
-	cause: (cause) => cause !== void 0 && !(cause instanceof SyntaxError)
-}, () => unanswered(context, causeDetail(error))), Match.orElse(() => new Internal({ message: `host ${context.host.id} answered ${context.action} unexpectedly: ${error.message}` }))))), Effect.catchTag("SchemaError", (error) => Effect.fail(new Invalid({ message: `${context.action}: the request doesn't match the action's input: ${error.message}` }))));
+/** The host answered with something the call doesn't expect. */
+const unexpected = (context, error) => new Internal({ message: `host ${context.host.id} answered ${context.action} unexpectedly: ${error.message}` });
+const settle = (call, context) => bounded(call, context).pipe(Effect.catchTags({
+	HttpClientError: (error) => Effect.fail(Match.value(error.reason).pipe(Match.tag("TransportError", () => unanswered(context, causeDetail(error))), Match.when({
+		_tag: "DecodeError",
+		cause: (cause) => cause !== void 0 && !(cause instanceof SyntaxError)
+	}, () => unanswered(context, causeDetail(error))), Match.orElse(() => unexpected(context, error)))),
+	InvalidInput: (error) => Effect.fail(new Invalid({ message: `${context.action}: the request doesn't match the action's input: ${error.message}` })),
+	SchemaError: (error) => Effect.fail(new Internal({ message: `host ${context.host.id}'s reply didn't decode: ${error.message}` })),
+	Unauthenticated: (error) => Effect.fail(unexpected(context, error)),
+	Forbidden: (error) => Effect.fail(unexpected(context, error))
+}));
 /** A host this client can use: it calls itself by its entry's ID. */
 const checkHost = (entry, host) => host.id === entry.id ? Effect.succeed(host) : Effect.fail(new Invalid({ message: `host ${entry.id} (${entry.url}) calls itself ${host.id}; its entry in the host list must use that ID` }));
 /** Every entry is checked here, so a call never meets a malformed URL. */
@@ -453,23 +465,18 @@ const make = (hosts, options) => Effect.gen(function* () {
 		api
 	})));
 	const routes = new Map(routed.map((route) => [route.entry.id, route]));
-	/** How long a call waits for its reply, by its action's access. */
-	const bounds = {
-		read: options?.readTimeout ?? readTimeout,
-		write: options?.timeout
-	};
 	const route = (host) => {
 		const found = routes.get(host);
 		return found === void 0 ? Effect.fail(new Invalid({ message: `host ${host} isn't in the host list` })) : Effect.succeed(found);
 	};
 	/**
-	* Sends one call to one host, bounded by its action's access. `target` is the ID to read
-	* when a mutation's reply is lost.
+	* Sends one call to one host, bounded by the read or the mutation timeout. `target` is the
+	* ID to read when a mutation's reply is lost.
 	*/
-	const ask = ({ entry, api }, contract, action, call, target) => settle(call(api), {
+	const ask = ({ entry, api }, { readOnly }, action, call, target) => settle(call(api), {
 		host: entry,
-		timeout: bounds[contract.access],
-		access: contract.access,
+		timeout: readOnly ? options?.readTimeout ?? readTimeout : options?.timeout,
+		readOnly,
 		action,
 		target
 	});
@@ -502,13 +509,13 @@ const make = (hosts, options) => Effect.gen(function* () {
 	* Reads a host. IDs route by its entry's ID, so a host that calls itself something else
 	* fails rather than being placed on.
 	*/
-	const readHost = (route) => ask(route, actions["host.get"], "get host", (api) => Effect.flatMap(api.host.get({ payload: {} }), (host) => checkHost(route.entry, host)));
+	const readHost = (route) => ask(route, actions.getHost, "get host", (api) => Effect.flatMap(api.getHost(), (host) => checkHost(route.entry, host)));
 	const createOn = (host, name, spec) => Effect.gen(function* () {
 		const id = yield* formatId(host, name);
-		return yield* ask(yield* route(host), actions["machine.create"], `create ${id}`, (api) => api.machine.create({ payload: {
+		return yield* ask(yield* route(host), actions.createMachine, `create ${id}`, (api) => api.createMachine({
 			...spec,
 			id
-		} }), id);
+		}), id);
 	});
 	/**
 	* Asks every host at once and goes through the answers in list order: the first host
@@ -538,7 +545,7 @@ const make = (hosts, options) => Effect.gen(function* () {
 		const message = `no host offers base ${base}: ${misses.join("; ")}`;
 		return yield* noReply ? new Unavailable({
 			message,
-			access: "read"
+			readOnly: true
 		}) : new Precondition({ message });
 	}).pipe(Effect.scoped);
 	const create = (name, spec, options) => Effect.gen(function* () {
@@ -550,28 +557,28 @@ const make = (hosts, options) => Effect.gen(function* () {
 	const sibling = (source, name) => Effect.flatMap(parseId(source), ({ host }) => formatId(host, name));
 	return {
 		hosts: gather((route) => Effect.map(readHost(route), (host) => [host])),
-		machines: gather((route) => ask(route, actions["machine.list"], "list machines", (api) => api.machine.list({ payload: {} }))),
-		checkpoints: gather((route) => ask(route, actions["checkpoint.list"], "list checkpoints", (api) => api.checkpoint.list({ payload: {} }))),
-		machine: (id) => byId(id, actions["machine.get"], `get ${id}`, (api) => api.machine.get({ payload: { id } })),
-		checkpoint: (id) => byId(id, actions["checkpoint.get"], `get ${id}`, (api) => api.checkpoint.get({ payload: { id } })),
+		machines: gather((route) => ask(route, actions.listMachines, "list machines", (api) => api.listMachines())),
+		checkpoints: gather((route) => ask(route, actions.listCheckpoints, "list checkpoints", (api) => api.listCheckpoints())),
+		machine: (id) => byId(id, actions.getMachine, `get ${id}`, (api) => api.getMachine({ id })),
+		checkpoint: (id) => byId(id, actions.getCheckpoint, `get ${id}`, (api) => api.getCheckpoint({ id })),
 		create,
-		start: (id) => byId(id, actions["machine.start"], `start ${id}`, (api) => api.machine.start({ payload: { id } })),
-		stop: (id) => byId(id, actions["machine.stop"], `stop ${id}`, (api) => api.machine.stop({ payload: { id } })),
-		delete: (id) => byId(id, actions["machine.delete"], `delete ${id}`, (api) => api.machine.delete({ payload: { id } })),
-		fork: (machine, name) => Effect.flatMap(sibling(machine, name), (made) => byId(machine, actions["machine.fork"], `fork ${machine} to ${made}`, (api) => api.machine.fork({ payload: {
+		start: (id) => byId(id, actions.startMachine, `start ${id}`, (api) => api.startMachine({ id })),
+		stop: (id) => byId(id, actions.stopMachine, `stop ${id}`, (api) => api.stopMachine({ id })),
+		delete: (id) => byId(id, actions.deleteMachine, `delete ${id}`, (api) => api.deleteMachine({ id })),
+		fork: (machine, name) => Effect.flatMap(sibling(machine, name), (made) => byId(machine, actions.forkMachine, `fork ${machine} to ${made}`, (api) => api.forkMachine({
 			machine,
 			name
-		} }), made)),
-		restore: (checkpoint, name) => Effect.flatMap(sibling(checkpoint, name), (made) => byId(checkpoint, actions["machine.restore"], `restore ${checkpoint} to ${made}`, (api) => api.machine.restore({ payload: {
+		}), made)),
+		restore: (checkpoint, name) => Effect.flatMap(sibling(checkpoint, name), (made) => byId(checkpoint, actions.restoreMachine, `restore ${checkpoint} to ${made}`, (api) => api.restoreMachine({
 			checkpoint,
 			name
-		} }), made)),
-		capture: (machine, name) => Effect.flatMap(sibling(machine, name), (made) => byId(machine, actions["checkpoint.capture"], `capture ${machine} to ${made}`, (api) => api.checkpoint.capture({ payload: {
+		}), made)),
+		capture: (machine, name) => Effect.flatMap(sibling(machine, name), (made) => byId(machine, actions.captureCheckpoint, `capture ${machine} to ${made}`, (api) => api.captureCheckpoint({
 			machine,
 			name
-		} }), made)),
-		deleteCheckpoint: (id) => byId(id, actions["checkpoint.delete"], `delete ${id}`, (api) => api.checkpoint.delete({ payload: { id } }))
+		}), made)),
+		deleteCheckpoint: (id) => byId(id, actions.deleteCheckpoint, `delete ${id}`, (api) => api.deleteCheckpoint({ id }))
 	};
 });
 //#endregion
-export { Conflict as A, HostId as C, parseId as D, formatId as E, Invalid as F, NotFound as I, Precondition as L, ErrorTag as M, HostErrorTag as N, parseName as O, Internal as P, Unavailable as R, version as S, Name as T, Profile as _, HostGroup as a, SshEndpoint as b, readTimeout as c, ActionRecord as d, Checkpoint as f, MachineSpec as g, Machine as h, CheckpointGroup as i, ConflictKind as j, Capacity as k, versionHeader as l, Host as m, client_exports as n, Http as o, CreateRequest as p, make as r, MachineGroup as s, Client as t, ActionName as u, Runtime as v, Id as w, release as x, Setup as y, hostErrors as z };
+export { HostErrorTag as A, formatId as C, Conflict as D, Capacity as E, Unavailable as F, hostErrors as I, Invalid as M, NotFound as N, ConflictKind as O, Precondition as P, Name as S, parseName as T, SshEndpoint as _, readTimeout as a, HostId as b, ActionRecord as c, Host as d, Machine as f, Setup as g, Runtime as h, Http as i, Internal as j, ErrorTag as k, Checkpoint as l, Profile as m, client_exports as n, versionHeader as o, MachineSpec as p, make as r, ActionName as s, Client as t, CreateRequest as u, release as v, parseId as w, Id as x, version as y };

package/dist/{client-C6ll48AB.d.mts → client-mIuehl40.d.mts}

@@ -41,12 +41,12 @@ declare class Capacity extends Capacity_base {
 }
 declare const Unavailable_base: Schema.Class<Unavailable, Schema.TaggedStruct<"Unavailable", {
   readonly message: Schema.String;
-  readonly access: Schema.Literals<("read" | "write")[]>;
+  readonly readOnly: Schema.Boolean;
 }>, import("effect/Cause").YieldableError>;
 /**
  * The client couldn't reach the host, or lost its reply. Only the client library produces
- * it. `access` is the access of the action that met it: a mutation's request may have
- * reached the host and run, so it is never retryable.
+ * it. `readOnly` is that of the action that met it: a mutation's request may have reached
+ * the host and run, so it is never retryable.
  */
 declare class Unavailable extends Unavailable_base {
   get retryable(): boolean;
@@ -57,7 +57,7 @@ declare const Internal_base: Schema.Class<Internal, Schema.TaggedStruct<"Interna
 declare class Internal extends Internal_base {
   get retryable(): boolean;
 }
-/** What a host answers with; every action group declares these. */
+/** What a host answers with; every action declares these. */
 declare const hostErrors: readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal];
 type HostError = InstanceType<(typeof hostErrors)[number]>;
 /** What a call through the client library fails with. */

package/dist/index.d.mts

@@ -1,6 +1,5 @@
-import { A as hostErrors, C as HostError, D as NotFound, E as Invalid, O as Precondition, S as ErrorTag, T as Internal, _ as version, a as ActionName, b as Conflict, c as CreateRequest, d as MachineSpec, f as Profile, g as release, h as SshEndpoint, i as client_d_exports, k as Unavailable, l as Host, m as Setup, o as ActionRecord, p as Runtime, s as Checkpoint, u as Machine, v as Capacity, w as HostErrorTag, x as ConflictKind, y as ClankerboxError } from "./client-C6ll48AB.mjs";
+import { A as hostErrors, C as HostError, D as NotFound, E as Invalid, O as Precondition, S as ErrorTag, T as Internal, _ as version, a as ActionName, b as Conflict, c as CreateRequest, d as MachineSpec, f as Profile, g as release, h as SshEndpoint, i as client_d_exports, k as Unavailable, l as Host, m as Setup, o as ActionRecord, p as Runtime, s as Checkpoint, u as Machine, v as Capacity, w as HostErrorTag, x as ConflictKind, y as ClankerboxError } from "./client-mIuehl40.mjs";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
-import * as ActionGroup from "@gjermundgaraba/effect-actions/ActionGroup";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
 import { Duration, Effect, FileSystem, Path, Schema } from "effect";
 import { ChildProcessSpawner } from "effect/process";
@@ -16,7 +15,7 @@ export declare const readTimeout: Duration.Duration;
  * anything.
  */
 export declare const versionHeader = "clankerbox-version";
-export declare const MachineGroup: ActionGroup.Group<"machine", readonly [Action.Action<"list", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+export declare const Http: ActionHttp.Binding<readonly [Action.Action<"listMachines", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
   readonly id: Schema.String;
   readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
   readonly createdAt: Schema.DateTimeUtcFromString;
@@ -39,7 +38,7 @@ export declare const MachineGroup: ActionGroup.Group<"machine", readonly [Action
     readonly port: Schema.Int;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>, Action.Action<"get", Schema.Struct<{
+}>>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"getMachine", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
@@ -64,7 +63,7 @@ export declare const MachineGroup: ActionGroup.Group<"machine", readonly [Action
     readonly port: Schema.Int;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>, Action.Action<"create", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"createMachine", Schema.Struct<{
   readonly base: Schema.String;
   readonly cpu: Schema.Int;
   readonly ramMib: Schema.Int;
@@ -98,7 +97,7 @@ export declare const MachineGroup: ActionGroup.Group<"machine", readonly [Action
     readonly port: Schema.Int;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"start", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"startMachine", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
@@ -123,7 +122,7 @@ export declare const MachineGroup: ActionGroup.Group<"machine", readonly [Action
     readonly port: Schema.Int;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"stop", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"stopMachine", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
@@ -148,9 +147,9 @@ export declare const MachineGroup: ActionGroup.Group<"machine", readonly [Action
     readonly port: Schema.Int;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"delete", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | 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 Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"fork", Schema.Struct<{
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"forkMachine", Schema.Struct<{
   readonly machine: Schema.String;
   readonly name: Schema.String;
 }>, Schema.Struct<{
@@ -176,7 +175,7 @@ export declare const MachineGroup: ActionGroup.Group<"machine", readonly [Action
     readonly port: Schema.Int;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"restore", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"restoreMachine", Schema.Struct<{
   readonly checkpoint: Schema.String;
   readonly name: Schema.String;
 }>, Schema.Struct<{
@@ -202,8 +201,7 @@ export declare const MachineGroup: ActionGroup.Group<"machine", readonly [Action
     readonly port: Schema.Int;
   }>>;
   readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>], typeof Invalid | typeof Internal>;
-export declare const CheckpointGroup: ActionGroup.Group<"checkpoint", readonly [Action.Action<"list", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"listCheckpoints", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
   readonly id: Schema.String;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly machine: Schema.String;
@@ -221,7 +219,7 @@ export declare const CheckpointGroup: ActionGroup.Group<"checkpoint", readonly [
       readonly message: Schema.String;
     }>>;
   }>;
-}>>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>, Action.Action<"get", Schema.Struct<{
+}>>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"getCheckpoint", Schema.Struct<{
   readonly id: Schema.String;
 }>, Schema.Struct<{
   readonly id: Schema.String;
@@ -241,7 +239,7 @@ export declare const CheckpointGroup: ActionGroup.Group<"checkpoint", readonly [
       readonly message: Schema.String;
     }>>;
   }>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>, Action.Action<"capture", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], true, typeof Action.Anyone>, Action.Action<"captureCheckpoint", Schema.Struct<{
   readonly machine: Schema.String;
   readonly name: Schema.String;
 }>, Schema.Struct<{
@@ -262,270 +260,15 @@ export declare const CheckpointGroup: ActionGroup.Group<"checkpoint", readonly [
       readonly message: Schema.String;
     }>>;
   }>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"delete", Schema.Struct<{
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], false, typeof Action.Anyone>, Action.Action<"deleteCheckpoint", Schema.Struct<{
   readonly id: Schema.String;
-}>, Schema.Void, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>], typeof Invalid | typeof Internal>;
-export declare const HostGroup: ActionGroup.Group<"host", readonly [Action.Action<"get", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
+}>, Schema.Void, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | 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;
   readonly runtimeVersion: Schema.String;
   readonly bases: Schema.$Array<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>], typeof Invalid | typeof Internal>;
-export declare const Http: ActionHttp.Http<readonly [ActionGroup.Group<"machine", readonly [Action.Action<"list", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
-  readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-  readonly ssh: Schema.optionalKey<Schema.Struct<{
-    readonly host: Schema.String;
-    readonly port: Schema.Int;
-  }>>;
-  readonly hostKey: Schema.optionalKey<Schema.String>;
-}>>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>, Action.Action<"get", Schema.Struct<{
-  readonly id: Schema.String;
-}>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-  readonly ssh: Schema.optionalKey<Schema.Struct<{
-    readonly host: Schema.String;
-    readonly port: Schema.Int;
-  }>>;
-  readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>, Action.Action<"create", Schema.Struct<{
-  readonly base: Schema.String;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly setup: Schema.optionalKey<Schema.Struct<{
-    readonly script: Schema.String;
-    readonly timeoutSeconds: Schema.Int;
-  }>>;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly id: Schema.String;
-}>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-  readonly ssh: Schema.optionalKey<Schema.Struct<{
-    readonly host: Schema.String;
-    readonly port: Schema.Int;
-  }>>;
-  readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"start", Schema.Struct<{
-  readonly id: Schema.String;
-}>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-  readonly ssh: Schema.optionalKey<Schema.Struct<{
-    readonly host: Schema.String;
-    readonly port: Schema.Int;
-  }>>;
-  readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"stop", Schema.Struct<{
-  readonly id: Schema.String;
-}>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-  readonly ssh: Schema.optionalKey<Schema.Struct<{
-    readonly host: Schema.String;
-    readonly port: Schema.Int;
-  }>>;
-  readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"delete", Schema.Struct<{
-  readonly id: Schema.String;
-}>, Schema.Void, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"fork", Schema.Struct<{
-  readonly machine: Schema.String;
-  readonly name: Schema.String;
-}>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-  readonly ssh: Schema.optionalKey<Schema.Struct<{
-    readonly host: Schema.String;
-    readonly port: Schema.Int;
-  }>>;
-  readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"restore", Schema.Struct<{
-  readonly checkpoint: Schema.String;
-  readonly name: Schema.String;
-}>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly state: Schema.Literals<readonly ["running", "stopped", "missing", "unknown"]>;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-  readonly ssh: Schema.optionalKey<Schema.Struct<{
-    readonly host: Schema.String;
-    readonly port: Schema.Int;
-  }>>;
-  readonly hostKey: Schema.optionalKey<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>], typeof Invalid | typeof Internal>, ActionGroup.Group<"checkpoint", readonly [Action.Action<"list", Schema.$Record<Schema.String, Schema.Never>, Schema.$Array<Schema.Struct<{
-  readonly id: Schema.String;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly machine: Schema.String;
-  readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-}>>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>, Action.Action<"get", Schema.Struct<{
-  readonly id: Schema.String;
-}>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly machine: Schema.String;
-  readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>, Action.Action<"capture", Schema.Struct<{
-  readonly machine: Schema.String;
-  readonly name: Schema.String;
-}>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly createdAt: Schema.DateTimeUtcFromString;
-  readonly machine: Schema.String;
-  readonly kind: Schema.Literals<readonly ["ram", "disk"]>;
-  readonly base: Schema.String;
-  readonly profile: Schema.optionalKey<Schema.String>;
-  readonly cpu: Schema.Int;
-  readonly ramMib: Schema.Int;
-  readonly diskGib: Schema.Int;
-  readonly action: Schema.Struct<{
-    readonly name: Schema.Literals<readonly ["create", "start", "stop", "delete", "fork", "restore", "capture"]>;
-    readonly status: Schema.Literals<readonly ["running", "failed", "done"]>;
-    readonly error: Schema.optionalKey<Schema.Struct<{
-      readonly tag: Schema.Literals<("Capacity" | "Conflict" | "Internal" | "Invalid" | "NotFound" | "Precondition")[]>;
-      readonly message: Schema.String;
-    }>>;
-  }>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>, Action.Action<"delete", Schema.Struct<{
-  readonly id: Schema.String;
-}>, Schema.Void, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "write", undefined>], typeof Invalid | typeof Internal>, ActionGroup.Group<"host", readonly [Action.Action<"get", Schema.$Record<Schema.String, Schema.Never>, Schema.Struct<{
-  readonly id: Schema.String;
-  readonly runtime: Schema.Literals<readonly ["smolvm", "tart", "boat"]>;
-  readonly version: Schema.String;
-  readonly runtimeVersion: Schema.String;
-  readonly bases: Schema.$Array<Schema.String>;
-}>, readonly [typeof Invalid, typeof NotFound, typeof Conflict, typeof Precondition, typeof Capacity, typeof Internal], "read", undefined>], typeof Invalid | typeof Internal>], []>;
+}>, readonly (typeof Invalid | typeof NotFound | typeof Conflict | typeof Precondition | typeof Capacity | typeof Internal)[], true, typeof Action.Anyone>], [], undefined>;
 //#endregion
 //#region src/ids.d.ts
 /** A host's part of every ID it holds. */

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as Conflict, C as HostId, D as parseId, E as formatId, F as Invalid, I as NotFound, L as Precondition, M as ErrorTag, N as HostErrorTag, O as parseName, P as Internal, R as Unavailable, S as version, T as Name, _ as Profile, a as HostGroup, b as SshEndpoint, c as readTimeout, d as ActionRecord, f as Checkpoint, g as MachineSpec, h as Machine, i as CheckpointGroup, j as ConflictKind, k as Capacity, l as versionHeader, m as Host, n as client_exports, o as Http, p as CreateRequest, s as MachineGroup, u as ActionName, v as Runtime, w as Id, x as release, y as Setup, z as hostErrors } from "./client-DXuiPvxU.mjs";
+import { A as HostErrorTag, C as formatId, D as Conflict, E as Capacity, F as Unavailable, I as hostErrors, M as Invalid, N as NotFound, O as ConflictKind, P as Precondition, S as Name, T as parseName, _ as SshEndpoint, a as readTimeout, b as HostId, c as ActionRecord, d as Host, f as Machine, g as Setup, h as Runtime, i as Http, j as Internal, k as ErrorTag, l as Checkpoint, m as Profile, n as client_exports, o as versionHeader, p as MachineSpec, s as ActionName, u as CreateRequest, v as release, w as parseId, x as Id, y as version } from "./client-Bb5qTz-i.mjs";
 import { Effect, FileSystem, Path, Predicate, Schema, Stream } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
 //#region src/profile.ts
@@ -103,4 +103,4 @@ const readSetup = (path) => Effect.gen(function* () {
 	return yield* fs.readFileString(path);
 }).pipe(Effect.catchTag("PlatformError", (error) => Effect.fail(new Invalid({ message: `couldn't read setup ${path}: ${error.message}` }))));
 //#endregion
-export { ActionName, ActionRecord, Capacity, Checkpoint, CheckpointGroup, client_exports as Client, Conflict, ConflictKind, CreateRequest, ErrorTag, Host, HostErrorTag, HostGroup, HostId, Http, Id, Internal, Invalid, Machine, MachineGroup, MachineSpec, Name, NotFound, Precondition, Profile, Runtime, Setup, SshEndpoint, Unavailable, formatId, hostErrors, loadProfile, packRecipe, parseId, parseName, readSetup, readTimeout, release, version, versionHeader };
+export { ActionName, ActionRecord, Capacity, Checkpoint, client_exports as Client, Conflict, ConflictKind, CreateRequest, ErrorTag, Host, HostErrorTag, HostId, Http, Id, Internal, Invalid, Machine, MachineSpec, Name, NotFound, Precondition, Profile, Runtime, Setup, SshEndpoint, Unavailable, formatId, hostErrors, loadProfile, packRecipe, parseId, parseName, readSetup, readTimeout, release, version, versionHeader };

package/dist/node.d.mts

@@ -1,4 +1,4 @@
-import { E as Invalid, n as HostEntry, r as Options, t as Client } from "./client-C6ll48AB.mjs";
+import { E as Invalid, n as HostEntry, r as Options, t as Client } from "./client-mIuehl40.mjs";
 import { Layer } from "effect";
 //#region src/node.d.ts
 /** Node's `http` module sets no timeout of its own: a mutation can run for hours. */

package/dist/node.mjs

@@ -1,4 +1,4 @@
-import { r as make, t as Client } from "./client-DXuiPvxU.mjs";
+import { r as make, t as Client } from "./client-Bb5qTz-i.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.12.2",
+  "version": "0.13.0",
   "description": "clankerbox's API contract and client library, for Effect",
   "license": "MIT",
   "repository": {
@@ -28,19 +28,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@gjermundgaraba/effect-actions": "0.9.0"
+    "@gjermundgaraba/effect-actions": "0.11.0"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.0",
+    "@effect/platform-node": "4.0.2",
     "@types/node": "26.6.4",
-    "effect": "4.0.0",
+    "effect": "4.0.2",
     "typescript": "7.0.2",
-    "vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
-    "vite-plus": "1.0.0"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
+    "vite-plus": "1.1.0"
   },
   "peerDependencies": {
-    "@effect/platform-node": "^4.0.0",
-    "effect": "^4.0.0"
+    "@effect/platform-node": "~4.0.2",
+    "effect": "~4.0.2"
   },
   "peerDependenciesMeta": {
     "@effect/platform-node": {