@gjermundgaraba/clankerbox-sdk 0.4.0 → 0.12.0

package/dist/client-jXYWrnuZ.mjs

@@ -0,0 +1,583 @@
+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 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() {
+		return false;
+	}
+};
+/** The machine or checkpoint doesn't exist. A `delete` that meets it is done. */
+var NotFound = class extends Schema.TaggedError()("NotFound", { message: Schema.String }, { httpApiStatus: 404 }) {
+	get retryable() {
+		return false;
+	}
+};
+const ConflictKind = Schema.Literals(["exists", "busy"]);
+/** The name is taken (`exists`), or another action holds the resource (`busy`). */
+var Conflict = class extends Schema.TaggedError()("Conflict", {
+	message: Schema.String,
+	kind: ConflictKind
+}, { httpApiStatus: 409 }) {
+	get retryable() {
+		return this.kind === "busy";
+	}
+};
+/** The resource's state doesn't allow the action, or no host offers the requested base. */
+var Precondition = class extends Schema.TaggedError()("Precondition", { message: Schema.String }, { httpApiStatus: 412 }) {
+	get retryable() {
+		return false;
+	}
+};
+/** The host has no room now; room can free up, so a later call may succeed. */
+var Capacity = class extends Schema.TaggedError()("Capacity", { message: Schema.String }, { httpApiStatus: 503 }) {
+	get retryable() {
+		return true;
+	}
+};
+/**
+* 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.
+*/
+var Unavailable = class extends Schema.TaggedError()("Unavailable", {
+	message: Schema.String,
+	access: Schema.Literals(["read", "write"])
+}) {
+	get retryable() {
+		return this.access === "read";
+	}
+};
+var Internal = class extends Schema.TaggedError()("Internal", { message: Schema.String }, { httpApiStatus: 500 }) {
+	get retryable() {
+		return false;
+	}
+};
+/** What a host answers with; every action group declares these. */
+const hostErrors = [
+	Invalid,
+	NotFound,
+	Conflict,
+	Precondition,
+	Capacity,
+	Internal
+];
+/** The tag a host records on a failed action: always one of the errors it answers with. */
+const HostErrorTag = Schema.Literals(hostErrors.map((error) => error.fields._tag.schema.literal));
+/** The tag of any error a call through the client library can fail with. */
+const ErrorTag = Schema.Literals([...HostErrorTag.literals, Unavailable.fields._tag.schema.literal]);
+//#endregion
+//#region src/ids.ts
+/**
+* Machine and checkpoint IDs, `<host>_<name>`: the one place that parses and formats them.
+* Neither part contains `_`, so an ID has exactly one. The whole ID matches
+* `^[A-Za-z0-9_-]{1,62}$` because it is written to `/var/lib/clankerbox/machine-id`, and
+* clankercreds accepts only that pattern.
+*/
+const separator = "_";
+const maxIdLength = 62;
+const idPattern = /^[A-Za-z0-9_-]{1,62}$/u;
+/**
+* boat's named snapshots are `cbx-<host>-<inst>`, and boat allows `^[a-z0-9][a-z0-9-]{0,62}$`:
+* a lowercase host ID of at most 32 characters keeps the name within 63.
+*/
+const hostIdPattern = /^[a-z][a-z0-9-]{0,31}$/u;
+const hostIdRule = "a host ID is 1 to 32 lowercase letters, digits and '-', starting with a letter";
+/**
+* smolvm names a machine `<name>-<inst>` and refuses consecutive hyphens, so a name has no
+* `--` and doesn't end in `-`.
+*/
+const namePattern = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*$/u;
+const nameRule = "a name starts with a letter, then letters, digits and '-', with no '--' and no '-' at the end";
+/** A host's part of every ID it holds. */
+const HostId = Schema.String.check(Schema.isPattern(hostIdPattern, { message: hostIdRule }));
+/** A machine's or checkpoint's name, unique per host and per resource type. */
+const Name = Schema.String.check(Schema.isPattern(namePattern, { message: nameRule }));
+const describeId = (id) => {
+	if (!idPattern.test(id)) return `ID ${JSON.stringify(id)} must be 1 to ${maxIdLength} letters, digits, '_' or '-'`;
+	const at = id.indexOf(separator);
+	if (at <= 0 || at === id.length - 1) return `ID ${JSON.stringify(id)} must be <host>_<name>`;
+	if (!hostIdPattern.test(id.slice(0, at))) return `ID ${JSON.stringify(id)} has an invalid host: ${hostIdRule}`;
+	if (!namePattern.test(id.slice(at + 1))) return `ID ${JSON.stringify(id)} has an invalid name: ${nameRule}`;
+};
+/** A full `<host>_<name>` ID. */
+const Id = Schema.String.check(Schema.makeFilter((id) => describeId(id) ?? true));
+/** Whether `create`'s target is a full ID rather than a bare name: a name has no `_`. */
+const isId = (target) => target.includes(separator);
+/** Splits an ID at its `_` into host and name. */
+const parseId = (id) => {
+	const problem = describeId(id);
+	if (problem !== void 0) return Effect.fail(new Invalid({ message: problem }));
+	const at = id.indexOf(separator);
+	return Effect.succeed({
+		host: id.slice(0, at),
+		name: id.slice(at + 1)
+	});
+};
+/** Checks a name on its own, before it is joined to a host. */
+const parseName = (name) => namePattern.test(name) ? Effect.succeed(name) : Effect.fail(new Invalid({ message: `name ${JSON.stringify(name)}: ${nameRule}` }));
+/** Joins a host ID and a name into the resource's ID, checking both parts and the whole. */
+const formatId = (host, name) => {
+	if (!hostIdPattern.test(host)) return Effect.fail(new Invalid({ message: `host ID ${JSON.stringify(host)}: ${hostIdRule}` }));
+	const id = `${host}${separator}${name}`;
+	return parseName(name).pipe(Effect.andThen(parseId(id)), Effect.as(id));
+};
+//#endregion
+//#region package.json
+var version$1 = "0.12.0";
+//#endregion
+//#region src/resources.ts
+/** The resources a host reports: machines, checkpoints and the host itself. */
+const Runtime = Schema.Literals([
+	"smolvm",
+	"tart",
+	"boat"
+]);
+const Size = Schema.Int.check(Schema.isGreaterThan(0));
+/** The mutations that record themselves on a resource's `action`. */
+const ActionName = Schema.Literals([
+	"create",
+	"start",
+	"stop",
+	"delete",
+	"fork",
+	"restore",
+	"capture"
+]);
+/**
+* A resource's last action: `running` while it holds the row, `failed` with its error
+* after a native failure, `done` after a success. The next action replaces it.
+*/
+const ActionRecord = Schema.Struct({
+	name: ActionName,
+	status: Schema.Literals([
+		"running",
+		"failed",
+		"done"
+	]),
+	error: Schema.optionalKey(Schema.Struct({
+		tag: HostErrorTag,
+		message: Schema.String
+	}))
+});
+/** Where a machine's guest port 22 is reached. */
+const SshEndpoint = Schema.Struct({
+	host: Schema.String,
+	port: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 65535
+	}))
+});
+const Machine = Schema.Struct({
+	id: Id,
+	runtime: Runtime,
+	createdAt: Schema.DateTimeUtcFromString,
+	base: Schema.String,
+	/** The label the client passed at create, normally its profile's name. */
+	profile: Schema.optionalKey(Schema.String),
+	cpu: Size,
+	ramMib: Size,
+	diskGib: Size,
+	/**
+	* Read from the runtime, never stored: `missing` when the runtime doesn't have the machine,
+	* `unknown` when it couldn't be read.
+	*/
+	state: Schema.Literals([
+		"running",
+		"stopped",
+		"missing",
+		"unknown"
+	]),
+	action: ActionRecord,
+	ssh: Schema.optionalKey(SshEndpoint),
+	/** The guest's SSH host public key, as `<type> <base64>`. */
+	hostKey: Schema.optionalKey(Schema.String)
+}).annotate({ identifier: "Machine" });
+const Checkpoint = Schema.Struct({
+	id: Id,
+	createdAt: Schema.DateTimeUtcFromString,
+	/** The ID of the machine it was captured from. */
+	machine: Id,
+	/** What it holds, by runtime: `ram` (RAM and disks) on smolvm, `disk` on Tart and boat. */
+	kind: Schema.Literals(["ram", "disk"]),
+	base: Schema.String,
+	profile: Schema.optionalKey(Schema.String),
+	cpu: Size,
+	ramMib: Size,
+	diskGib: Size,
+	action: ActionRecord
+}).annotate({ identifier: "Checkpoint" });
+/** The SDK's version, which is also the version of the clankerbox binaries it ships with. */
+const version = version$1;
+/** A version's major.minor: releases that share it speak the same API. */
+const release = (of) => of.split(".").slice(0, 2).join(".");
+const Host = Schema.Struct({
+	id: HostId,
+	runtime: Runtime,
+	/** The clankerbox version the host runs. */
+	version: Schema.String,
+	/** The runtime's version; for boat, its API version. */
+	runtimeVersion: Schema.String,
+	bases: Schema.Array(Schema.String)
+}).annotate({ identifier: "Host" });
+/** A setup script and how long it may run. Nothing logs the script: it can carry secrets. */
+const Setup = Schema.Struct({
+	script: Schema.String,
+	timeoutSeconds: Size
+});
+const specFields = {
+	base: Schema.String,
+	cpu: Size,
+	ramMib: Size,
+	diskGib: Size,
+	setup: Schema.optionalKey(Setup),
+	profile: Schema.optionalKey(Schema.String)
+};
+/**
+* What a new machine is made from: a base, its sizes, an optional setup script with its
+* timeout, and an optional `profile` label. A profile file fills these in; the host never
+* sees the profile itself.
+*/
+const MachineSpec = Schema.Struct(specFields);
+/**
+* `machine.create`'s input: the spec and the new machine's full ID. The host checks that the ID
+* names it, so a create never lands under another host's ID.
+*/
+const CreateRequest = Schema.Struct({
+	id: Id,
+	...specFields
+});
+/**
+* A profile file: a client-side file that fills in a create request. `setup.path` is a script
+* file or a recipe directory, relative to the profile file, and comes with its timeout: the
+* profile's author sets it, and there is no default. `host` places the create on that host
+* instead of by base.
+*/
+const Profile = Schema.Struct({
+	base: specFields.base,
+	cpu: specFields.cpu,
+	ramMib: specFields.ramMib,
+	diskGib: specFields.diskGib,
+	setup: Schema.optionalKey(Schema.Struct({
+		path: Schema.String,
+		timeoutSeconds: Size
+	})),
+	host: Schema.optionalKey(HostId)
+});
+//#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.
+*/
+/**
+* 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.
+*/
+const readTimeout = Duration.seconds(10);
+/**
+* The header every client request carries the SDK's `version` in. A host refuses a request
+* whose release (major.minor) differs from its own, or that carries none, before it runs
+* anything.
+*/
+const versionHeader = "clankerbox-version";
+const ById = Schema.Struct({ id: Id });
+/** Input of the actions that make a new resource from a machine: its ID and the new name. */
+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
+	}),
+	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);
+//#endregion
+//#region src/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({
+	Client: () => Client,
+	HostEntry: () => HostEntry,
+	make: () => make
+});
+/** One host a client talks to. `id` is the host part of every ID it holds. */
+const HostEntry = Schema.Struct({
+	id: HostId,
+	url: Schema.String.check(Schema.makeFilter((url) => URL.canParse(url) || "a URL, such as http://linux:8484"))
+});
+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.
+*/
+const makeHostApi = (entry) => HttpApiClient.make(Http.api, {
+	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)
+});
+/** Every action's contract, keyed `<group>.<action>`: a call reads its access from its action. */
+const actions = ActionGroup.contracts(MachineGroup, CheckpointGroup, HostGroup);
+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({
+	message: `host ${context.host.id} (${context.host.url}) didn't answer ${context.action}: ${detail}`,
+	access: "read"
+}) : 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"
+});
+/** Bounds the wait for the reply; the clock starts when the request is sent. */
+const bounded = (call, context) => {
+	const { timeout } = context;
+	return timeout === void 0 ? call : Effect.timeoutOrElse(call, {
+		duration: timeout,
+		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}` }))));
+/** 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. */
+const decodeHosts = Schema.decodeUnknownEffect(Schema.Array(HostEntry));
+/**
+* Builds a client over `hosts`, in placement order. Making it sends nothing. An empty list
+* is Invalid, and so is a malformed entry or a host ID that appears twice: IDs route by it.
+*/
+const make = (hosts, options) => Effect.gen(function* () {
+	if (hosts.length === 0) return yield* new Invalid({ message: "the host list is empty: a client needs a host" });
+	yield* decodeHosts(hosts).pipe(Effect.mapError((error) => new Invalid({ message: `host list: ${error.message}` })));
+	const twice = hosts.find(({ id }, index) => hosts.findIndex((other) => other.id === id) < index);
+	if (twice !== void 0) return yield* new Invalid({ message: `host ${twice.id} appears twice in the host list` });
+	const routed = yield* Effect.forEach(hosts, (entry) => Effect.map(makeHostApi(entry), (api) => ({
+		entry,
+		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.
+	*/
+	const ask = ({ entry, api }, contract, action, call, target) => settle(call(api), {
+		host: entry,
+		timeout: bounds[contract.access],
+		access: contract.access,
+		action,
+		target
+	});
+	/**
+	* Routes a call by the ID's host part: no network is needed to find the host. `made` is
+	* the ID of the resource the call makes, if any, which is what to read after a lost reply.
+	*/
+	const byId = (id, contract, action, call, made) => Effect.gen(function* () {
+		const { host } = yield* parseId(id);
+		return yield* ask(yield* route(host), contract, action, call, made ?? id);
+	});
+	/** Asks every host at once; a host that fails is named rather than failing the whole. */
+	const gather = (call) => Effect.forEach(routed, (route) => Effect.map(Effect.result(call(route)), (result) => ({
+		host: route.entry.id,
+		result
+	})), { concurrency: "unbounded" }).pipe(Effect.map((results) => {
+		const answers = [];
+		const unreachable = [];
+		for (const { host, result } of results) if (Result.isSuccess(result)) answers.push(...result.success);
+		else unreachable.push({
+			host,
+			error: result.failure
+		});
+		return {
+			answers,
+			unreachable
+		};
+	}));
+	/**
+	* 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 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: {
+			...spec,
+			id
+		} }), id);
+	});
+	/**
+	* Asks every host at once and goes through the answers in list order: the first host
+	* that answers and offers `base` wins, and the requests still out are interrupted, so a
+	* silent host after it delays nothing. With no winner the create is `Unavailable` only if
+	* a host gave no reply; otherwise asking again changes nothing, and it is `Precondition`.
+	*/
+	const place = (base) => Effect.gen(function* () {
+		const asked = yield* Effect.forEach(routed, (route) => Effect.map(Effect.forkScoped(Effect.result(readHost(route))), (fiber) => ({
+			host: route.entry.id,
+			fiber
+		})));
+		/** What each host answered, in list order. */
+		const misses = [];
+		let noReply = false;
+		for (const { host, fiber } of asked) {
+			const result = yield* Fiber.join(fiber);
+			if (Result.isFailure(result)) {
+				noReply ||= Predicate.isTagged(result.failure, "Unavailable");
+				misses.push(`${host} failed: ${result.failure._tag}: ${result.failure.message}`);
+			} else if (result.success.bases.includes(base)) return host;
+			else {
+				const { bases } = result.success;
+				misses.push(`${host} offers ${bases.length > 0 ? bases.join(", ") : "no bases"}`);
+			}
+		}
+		const message = `no host offers base ${base}: ${misses.join("; ")}`;
+		return yield* noReply ? new Unavailable({
+			message,
+			access: "read"
+		}) : new Precondition({ message });
+	}).pipe(Effect.scoped);
+	const create = (target, spec, options) => Effect.gen(function* () {
+		if (isId(target)) {
+			const { host, name } = yield* parseId(target);
+			return yield* createOn(host, name, spec);
+		}
+		const name = yield* parseName(target);
+		if (options?.host !== void 0) return yield* createOn(options.host, name, spec);
+		return yield* createOn(yield* place(spec.base), name, spec);
+	});
+	/** The ID a call that makes a resource on `source`'s host gives it. */
+	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 } })),
+		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: {
+			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: {
+			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: {
+			machine,
+			name
+		} }), made)),
+		deleteCheckpoint: (id) => byId(id, actions["checkpoint.delete"], `delete ${id}`, (api) => api.checkpoint.delete({ payload: { id } }))
+	};
+});
+//#endregion
+export { Capacity as A, hostErrors as B, HostId as C, isId as D, formatId as E, Internal as F, Invalid as I, NotFound as L, ConflictKind as M, ErrorTag as N, parseId as O, HostErrorTag as P, Precondition 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, Conflict as j, parseName 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, Unavailable as z };