@gjermundgaraba/clankerbox-sdk 0.16.0 → 0.18.1

package/dist/{client-CLemHDCl.mjs → client-JikMOSHo.mjs}

@@ -1,14 +1,14 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 import * as ActionHttp from "@gjermundgaraba/effect-actions/ActionHttp";
-import { Context, Duration, Effect, Fiber, Layer, Match, Predicate, Result, Schema, SchemaIssue } from "effect";
+import { Context, Duration, Effect, Fiber, Layer, Match, Predicate, Record, Result, Schema, SchemaIssue } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/http";
 //#region src/errors.ts
-/** A host sends none of these; the client library sets them. */
 const located = {
 	host: Schema.optionalKey(Schema.String),
 	action: Schema.optionalKey(Schema.String),
-	id: Schema.optionalKey(Schema.String)
+	id: Schema.optionalKey(Schema.String),
+	made: Schema.optionalKey(Schema.String)
 };
 /**
 * The request is malformed, or the host list is one a client can't route by, or a config,
@@ -18,49 +18,80 @@ var Invalid = class extends Schema.TaggedError()("Invalid", {
 	message: Schema.String,
 	...located,
 	file: Schema.optionalKey(Schema.String)
-}, { httpApiStatus: 400 }) {
-	get retryable() {
-		return false;
-	}
-};
+}, { httpApiStatus: 400 }) {};
 /** The machine or checkpoint doesn't exist. A `delete` that meets it is done. */
 var NotFound = class extends Schema.TaggedError()("NotFound", {
 	message: Schema.String,
 	...located
-}, { httpApiStatus: 404 }) {
-	get retryable() {
-		return false;
-	}
-};
+}, { httpApiStatus: 404 }) {};
 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,
 	...located
-}, { 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", {
+}, { httpApiStatus: 409 }) {};
+/** No host offers `base`: the host a create names, or any in the client's list. */
+var NotOffered = class extends Schema.TaggedError()("NotOffered", {
+	message: Schema.String,
+	...located,
+	base: Schema.String
+}, { httpApiStatus: 412 }) {};
+/** `machine`'s create, fork or restore failed before it was made: it can only be deleted. */
+var NotMade = class extends Schema.TaggedError()("NotMade", {
+	message: Schema.String,
+	...located,
+	machine: Schema.String
+}, { httpApiStatus: 412 }) {};
+/** The runtime no longer has `machine`: it can only be deleted. */
+var Missing = class extends Schema.TaggedError()("Missing", {
+	message: Schema.String,
+	...located,
+	machine: Schema.String
+}, { httpApiStatus: 412 }) {};
+/** `checkpoint`'s capture failed, so nothing restores from it: it can only be deleted. */
+var NotReady = class extends Schema.TaggedError()("NotReady", {
+	message: Schema.String,
+	...located,
+	checkpoint: Schema.String
+}, { httpApiStatus: 412 }) {};
+/** `checkpoint` holds RAM state saved under another runtime pin than the one the host runs. */
+var PinMismatch = class extends Schema.TaggedError()("PinMismatch", {
+	message: Schema.String,
+	...located,
+	checkpoint: Schema.String
+}, { httpApiStatus: 412 }) {};
+/** `machine` is in `state`, which the action doesn't act from. */
+var WrongState = class extends Schema.TaggedError()("WrongState", {
+	message: Schema.String,
+	...located,
+	machine: Schema.String,
+	state: Schema.String
+}, { httpApiStatus: 412 }) {};
+/** The runtime can't give the requested sizes, such as a disk below the base's. */
+var Unsizable = class extends Schema.TaggedError()("Unsizable", {
 	message: Schema.String,
 	...located
-}, { httpApiStatus: 412 }) {
-	get retryable() {
-		return false;
-	}
-};
+}, { httpApiStatus: 422 }) {};
+/**
+* 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.
+*/
+var ScriptFailed = class extends Schema.TaggedError()("ScriptFailed", {
+	message: Schema.String,
+	...located,
+	script: Schema.Literals(["setup", "preparation"])
+}, { httpApiStatus: 422 }) {};
+/** The provider under the runtime refused the call for good, such as for its plan or API key. */
+var Refused = class extends Schema.TaggedError()("Refused", {
+	message: Schema.String,
+	...located
+}, { httpApiStatus: 403 }) {};
 /** The host has no room now; room can free up, so a later call may succeed. */
 var Capacity = class extends Schema.TaggedError()("Capacity", {
 	message: Schema.String,
 	...located
-}, { httpApiStatus: 503 }) {
-	get retryable() {
-		return true;
-	}
-};
+}, { httpApiStatus: 503 }) {};
 /**
 * No reply: only the client library makes it. A mutation's request may have reached the host
 * and run, so it is retryable only when `readOnly`.
@@ -69,46 +100,64 @@ var Unavailable = class extends Schema.TaggedError()("Unavailable", {
 	message: Schema.String,
 	readOnly: Schema.Boolean,
 	...located
-}) {
-	get retryable() {
-		return this.readOnly;
-	}
-};
+}) {};
 var Internal = class extends Schema.TaggedError()("Internal", {
 	message: Schema.String,
 	...located
-}, { httpApiStatus: 500 }) {
-	get retryable() {
-		return false;
-	}
-};
+}, { httpApiStatus: 500 }) {};
 /** What a host may answer with; each action declares its own share. */
 const hostErrors = [
 	Invalid,
 	NotFound,
 	Conflict,
-	Precondition,
+	NotOffered,
+	NotMade,
+	Missing,
+	NotReady,
+	PinMismatch,
+	WrongState,
+	Unsizable,
+	ScriptFailed,
+	Refused,
 	Capacity,
 	Internal
 ];
+const HostError = Schema.Union(hostErrors);
+/**
+* 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.
+*/
 const ClankerboxError = Schema.Union([...hostErrors, Unavailable]);
-const HostErrorTag = Schema.Literals(hostErrors.map((error) => error.fields._tag.schema.literal));
+/**
+* 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.
+*/
+const retryable = (error) => Match.value(error).pipe(Match.tagsExhaustive({
+	Invalid: () => false,
+	NotFound: () => false,
+	Conflict: ({ kind }) => kind === "busy",
+	NotOffered: () => false,
+	NotMade: () => false,
+	Missing: () => false,
+	NotReady: () => false,
+	PinMismatch: () => false,
+	WrongState: () => false,
+	Unsizable: () => false,
+	ScriptFailed: () => false,
+	Refused: () => false,
+	Capacity: () => true,
+	Unavailable: ({ readOnly }) => readOnly,
+	Internal: () => false
+}));
 //#endregion
 //#region src/ids.ts
 const separator = "_";
 const maxIdLength = 62;
-/** The ID is written to `/var/lib/clankerbox/machine-id`, and clankercreds accepts only this. */
 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";
 const HostId = Schema.String.check(Schema.isPattern(hostIdPattern, { message: hostIdRule }));
@@ -147,37 +196,31 @@ const Runtime = Schema.Literals([
 	"boat"
 ]);
 const Size = Schema.Int.check(Schema.isGreaterThan(0));
-/** The mutations that record themselves on a resource's `action`. */
+/** The contract's mutations, which record themselves on a resource's `action`. */
 const ActionName = Schema.Literals([
-	"create",
-	"start",
-	"stop",
-	"delete",
-	"fork",
-	"restore",
-	"capture"
+	"createMachine",
+	"startMachine",
+	"stopMachine",
+	"deleteMachine",
+	"forkMachine",
+	"restoreMachine",
+	"captureCheckpoint",
+	"deleteCheckpoint"
 ]);
 const ActionStatus = Schema.Literals([
 	"running",
 	"failed",
 	"done"
 ]);
-const actionRecord = (name) => Schema.Union([Schema.Struct({
-	name,
+/** A resource's last action; the next action replaces it. */
+const ActionRecord = Schema.Union([Schema.Struct({
+	name: ActionName,
 	status: Schema.Literals(["running", "done"])
 }), Schema.Struct({
-	name,
+	name: ActionName,
 	status: Schema.Literal("failed"),
-	error: Schema.Struct({
-		tag: HostErrorTag,
-		message: Schema.String
-	})
+	error: HostError
 })]);
-/** A resource's last action; the next action replaces it. */
-const ActionRecord = actionRecord(ActionName);
-/** A checkpoint is only ever captured or deleted. */
-const CheckpointActionName = Schema.Literals(["capture", "delete"]);
-const CheckpointActionRecord = actionRecord(CheckpointActionName);
 const SshEndpoint = Schema.Struct({
 	host: Schema.String,
 	port: Schema.Int.check(Schema.isBetween({
@@ -189,6 +232,12 @@ const SshLogin = Schema.Struct({
 	user: Schema.String,
 	...SshEndpoint.fields
 });
+/**
+* `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.
+*/
 const Machine = Schema.Struct({
 	id: Id,
 	runtime: Runtime,
@@ -198,55 +247,50 @@ const Machine = Schema.Struct({
 	cpu: Size,
 	ramMib: Size,
 	diskGib: Size,
-	/** `missing`: the runtime doesn't have it; `unknown`: it couldn't be read. */
 	state: Schema.Literals([
 		"running",
 		"stopped",
 		"missing",
 		"unknown"
 	]),
-	/** Until its create, fork or restore has made it, it can only be read, stopped or deleted. */
 	made: Schema.Boolean,
 	action: ActionRecord,
-	/** Only on a running machine whose runtime gives it an endpoint. */
 	ssh: Schema.optionalKey(SshLogin),
-	/** `<type> <base64>`, once preparation has recorded it. */
 	hostKey: Schema.optionalKey(Schema.String)
 }).annotate({ identifier: "Machine" });
+/** The state as people read it: `running`, or `stopped (unmade)` for one never made. */
+const stateLabel = ({ state, made }) => made ? state : `${state} (unmade)`;
+/** `kind` is `ram` (RAM and disks) on smolvm, and `disk` on Tart and boat. */
 const Checkpoint = Schema.Struct({
 	id: Id,
 	createdAt: Schema.DateTimeUtcFromString,
 	machine: Id,
-	/** `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: CheckpointActionRecord
+	action: ActionRecord
 }).annotate({ identifier: "Checkpoint" });
+/** A checkpoint restores once its capture is done; it never changes after. */
+const isReady = (checkpoint) => checkpoint.action.status === "done";
+/**
+* `runtimeVersion` is boat's API version on boat. `captureFrom` is the state a machine must be in
+* to be captured: Tart's is `stopped`.
+*/
 const Host = Schema.Struct({
 	id: HostId,
 	runtime: Runtime,
 	version: Schema.String,
-	/** For boat, its API version. */
 	runtimeVersion: Schema.String,
-	/** The state a machine must be in to be captured: Tart's is `stopped`. */
 	captureFrom: Schema.Literals(["running", "stopped"]),
 	bases: Schema.Array(Schema.String)
 }).annotate({ identifier: "Host" });
-/**
-* `used` is counted as a `Capacity` refusal counts it, so it needn't match the host's own
-* machines.
-*/
-const Limit = Schema.Struct({
+const usageFields = {
 	host: HostId,
-	/**
-	* `ramMib`: smolvm's RAM budget. `runningVms`: Tart's, Apple's two VMs per Mac.
-	* `activeSandboxes` and the `starts` of each rolling window: the boat account's.
-	*/
 	resource: Schema.Literals([
+		"cpu",
 		"ramMib",
 		"runningVms",
 		"activeSandboxes",
@@ -254,9 +298,24 @@ const Limit = Schema.Struct({
 		"startsPerHour",
 		"startsPerDay"
 	]),
-	limit: Schema.Int,
+	limit: Schema.optionalKey(Schema.Int)
+};
+/**
+* A resource of a host and how much of it is in use, counted as a refusal counts it, so it
+* needn't match the host's own machines. When a machine the sum counts couldn't be read, the
+* sum would be a guess, so the row names those machines instead.
+*
+* `cpu` and `ramMib` are what the host's running machines were given, `runningVms` Apple's two
+* VMs per Mac, and `activeSandboxes` and the `starts` of each rolling window the boat account's.
+* `limit` is there only where the host refuses an action that would pass it.
+*/
+const Usage = Schema.Union([Schema.Struct({
+	...usageFields,
 	used: Schema.Int
-}).annotate({ identifier: "Limit" });
+}), Schema.Struct({
+	...usageFields,
+	unread: Schema.Array(Id)
+})]).annotate({ identifier: "Usage" });
 /** Nothing logs the script: it can carry secrets. */
 const Setup = Schema.Struct({
 	script: Schema.String,
@@ -286,7 +345,6 @@ const FromMachine = Schema.Struct({
 	machine: Id,
 	name: Name
 });
-/** Every action is public, as a host listens only on the tailnet or loopback. */
 const read = {
 	caller: Action.Anyone,
 	readOnly: true
@@ -295,7 +353,6 @@ const write = {
 	caller: Action.Anyone,
 	readOnly: false
 };
-/** What each action fails with; each has `Invalid`, which the host's version check answers. */
 const listing = [Invalid, Internal];
 const reading = [
 	Invalid,
@@ -306,10 +363,16 @@ const changing = [
 	Invalid,
 	NotFound,
 	Conflict,
-	Precondition,
+	Refused,
 	Internal
 ];
-const takingRoom = [...changing, Capacity];
+const booting = [
+	...changing,
+	NotMade,
+	Missing,
+	WrongState,
+	Capacity
+];
 const Http = ActionHttp.make([
 	Action.make("listMachines", {
 		...read,
@@ -326,14 +389,23 @@ const Http = ActionHttp.make([
 	}),
 	Action.make("createMachine", {
 		...write,
-		error: takingRoom,
+		error: [
+			Invalid,
+			Conflict,
+			NotOffered,
+			Unsizable,
+			ScriptFailed,
+			Refused,
+			Capacity,
+			Internal
+		],
 		description: "Create a machine from a base, run its setup once, and prepare it.",
 		input: CreateRequest,
 		success: Machine
 	}),
 	Action.make("startMachine", {
 		...write,
-		error: takingRoom,
+		error: [...booting, ScriptFailed],
 		description: "Start a machine. On a running machine, run preparation again.",
 		input: ById,
 		success: Machine
@@ -353,14 +425,25 @@ const Http = ActionHttp.make([
 	}),
 	Action.make("forkMachine", {
 		...write,
-		error: takingRoom,
+		error: [
+			...booting,
+			Unsizable,
+			ScriptFailed
+		],
 		description: "Copy a machine to a new name on the same host.",
 		input: FromMachine,
 		success: Machine
 	}),
 	Action.make("restoreMachine", {
 		...write,
-		error: takingRoom,
+		error: [
+			...changing,
+			NotReady,
+			PinMismatch,
+			Unsizable,
+			ScriptFailed,
+			Capacity
+		],
 		description: "Create a machine on the checkpoint's host from that checkpoint.",
 		input: Schema.Struct({
 			checkpoint: Id,
@@ -383,7 +466,7 @@ const Http = ActionHttp.make([
 	}),
 	Action.make("captureCheckpoint", {
 		...write,
-		error: takingRoom,
+		error: booting,
 		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
@@ -404,27 +487,24 @@ const Http = ActionHttp.make([
 		...read,
 		error: [
 			Invalid,
-			Precondition,
+			Refused,
 			Internal
 		],
-		description: "Read the host's limits and how much of each is in use. It fails when the runtime can't be read.",
-		success: Schema.Array(Limit)
+		description: "Read the host's resources, how much of each is in use, and their limits. A machine whose state can't be read leaves the rows that count it unread; it fails when the runtime can't be read at all.",
+		success: Schema.Array(Usage)
 	})
 ], { prefix: "/api" });
 const actionsByName = Action.byName(Http.actions);
 //#endregion
 //#region src/release.ts
 /** Also the version of the clankerbox binaries it ships with. */
-const version = "0.16.0";
+const version = "0.18.1";
 /** major.minor: releases that share it speak the same API. */
 const release = (of) => of.split(".").slice(0, 2).join(".");
 /** A host refuses a request whose `release` differs from its own, or that has none. */
 const versionHeader = "clankerbox-version";
 //#endregion
-//#region src/text.ts
-const mibPerGib = 1024;
-/** Exactly, as a size flag takes it: `32G`, `1.5G`, `512M`, `1500M`. */
-const formatMib = (mib) => mib >= 1024 && mib % 512 === 0 ? `${mib / mibPerGib}G` : `${mib}M`;
+//#region src/describe.ts
 const jsonPath = (path, names) => path.map((key, index) => {
 	if (Number.isInteger(key)) return `[${String(key)}]`;
 	return index === 0 ? names?.get(key) ?? String(key) : `.${String(key)}`;
@@ -462,10 +542,6 @@ const HostEntry = Schema.Struct({
 * reads the resource to see what happened.
 */
 var Client = class extends Context.Service()("@gjermundgaraba/clankerbox-sdk/Client") {};
-/**
-* 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 hostApi = (entry) => ActionHttp.client(Http, {
 	baseUrl: entry.url,
 	transformClient: HttpClient.mapRequest(HttpClientRequest.setHeader(versionHeader, version))
@@ -498,13 +574,18 @@ const settle = (call, context) => bounded(call, context).pipe(Effect.catchTags({
 }));
 const encodeError = Schema.encodeSync(ClankerboxError);
 const decodeError = Schema.decodeSync(ClankerboxError);
-/** The error with the call's location set, and every other field it had. */
-const locate = (where) => (error) => decodeError({
-	...encodeError(error),
-	...where
+const locate = ({ action, host, id, made }) => (error) => decodeError({
+	...Record.filter({
+		action,
+		host,
+		id,
+		made
+	}, Predicate.isNotUndefined),
+	...encodeError(error)
 });
 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` }));
 const decodeHosts = Schema.decodeUnknownEffect(Schema.Array(HostEntry));
+const subjectOf = (input) => "id" in input ? input.id : "machine" in input ? input.machine : input.checkpoint;
 /**
 * A client over `hosts`, in placement order. It sends nothing until called. An empty list, a
 * malformed entry or a host ID that appears twice is Invalid.
@@ -523,11 +604,7 @@ const make = (hosts, options) => Effect.gen(function* () {
 		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);
 	};
-	/**
-	* A call of `name` on one host, about `subject`. Its errors carry the host, the action and
-	* `target`, the resource it reads, changes or makes.
-	*/
-	const send = ({ entry, api }, name, input, subject, target = subject) => {
+	const send = ({ entry, api }, name, input, subject, made) => {
 		const { readOnly } = actionsByName[name];
 		const method = api[name];
 		return settle(method(input), {
@@ -535,22 +612,14 @@ const make = (hosts, options) => Effect.gen(function* () {
 			timeout: readOnly ? options?.readTimeout ?? readTimeout : options?.timeout,
 			readOnly,
 			what: subject === void 0 ? name : `${name} ${subject}`,
-			target
-		}).pipe(Effect.mapError(locate(target === void 0 ? {
-			action: name,
-			host: entry.id
-		} : {
+			target: made ?? subject
+		}).pipe(Effect.mapError(locate({
 			action: name,
 			host: entry.id,
-			id: target
+			id: subject,
+			made
 		})));
 	};
-	/**
-	* A call of `name` on the host of `id`. A fork, restore or capture names the one it makes as
-	* `made`, which its errors then carry, so a caller can find what a failure left behind.
-	*/
-	const byId = (name, id, input, made) => Effect.flatMap(Effect.flatMap(parseId(id), ({ host }) => route(host)), (found) => send(found, name, input, id, made ?? id));
-	/** An error raised before the call is sent names its action too. */
 	const naming = (name) => (effect) => Effect.mapError(effect, (error) => error.action === void 0 ? locate({ action: name })(error) : error);
 	const gather = (call) => Effect.forEach(routed, (route) => Effect.map(Effect.result(call(route)), (result) => ({
 		host: route.entry.id,
@@ -572,18 +641,16 @@ const make = (hosts, options) => Effect.gen(function* () {
 		action: "getHost",
 		host: route.entry.id
 	})));
-	const createOn = (host, name, spec) => Effect.gen(function* () {
-		const id = yield* formatId(host, name);
-		return yield* send(yield* route(host), "createMachine", {
-			...spec,
-			id
-		}, id);
-	});
-	/**
-	* The first host in list order that offers `base`; the requests still out are interrupted,
-	* so a silent host after it delays nothing. With no winner it is `Unavailable` only if a
-	* host gave no reply: otherwise asking again changes nothing, and it is `Precondition`.
-	*/
+	const onResource = (name, input, makes) => naming(name)(Effect.gen(function* () {
+		const subject = subjectOf(input);
+		const { host } = yield* parseId(subject);
+		const made = makes === void 0 ? void 0 : yield* formatId(host, makes);
+		return yield* send(yield* route(host), name, input, subject, made);
+	}));
+	const createOn = (host, name, spec) => Effect.flatMap(formatId(host, name), (id) => onResource("createMachine", {
+		...spec,
+		id
+	}, name));
 	const offering = (base) => Effect.gen(function* () {
 		const asked = yield* Effect.forEach(routed, (route) => Effect.map(Effect.forkScoped(Effect.result(readHost(route))), (fiber) => ({
 			host: route.entry.id,
@@ -606,7 +673,10 @@ const make = (hosts, options) => Effect.gen(function* () {
 		return yield* noReply ? new Unavailable({
 			message,
 			readOnly: true
-		}) : new Precondition({ message });
+		}) : new NotOffered({
+			message,
+			base
+		});
 	}).pipe(Effect.scoped);
 	const create = (name, spec, options) => Effect.gen(function* () {
 		yield* parseName(name);
@@ -614,34 +684,25 @@ const make = (hosts, options) => Effect.gen(function* () {
 		return yield* createOn((yield* offering(spec.base)).id, name, spec);
 	});
 	const place = (base, options) => options?.host === void 0 ? offering(base) : Effect.flatMap(route(options.host), readHost);
-	const sibling = (source, name) => Effect.flatMap(parseId(source), ({ host }) => formatId(host, name));
+	const deleting = (removal) => removal.pipe(Effect.as("deleted"), Effect.catchTag("NotFound", () => Effect.succeed("absent")));
 	return {
 		hosts: gather((route) => Effect.map(readHost(route), (host) => [host])),
 		machines: gather((route) => send(route, "listMachines", {})),
 		checkpoints: gather((route) => send(route, "listCheckpoints", {})),
 		capacity: gather((route) => send(route, "getCapacity", {})),
-		machine: (id) => naming("getMachine")(byId("getMachine", id, { id })),
-		checkpoint: (id) => naming("getCheckpoint")(byId("getCheckpoint", id, { id })),
 		place: (base, options) => naming("getHost")(place(base, options)),
 		create: (name, spec, options) => naming("createMachine")(create(name, spec, options)),
-		start: (id) => naming("startMachine")(byId("startMachine", id, { id })),
-		stop: (id) => naming("stopMachine")(byId("stopMachine", id, { id })),
-		delete: (id) => naming("deleteMachine")(byId("deleteMachine", id, { id })),
-		fork: (machine, name) => naming("forkMachine")(Effect.flatMap(sibling(machine, name), (made) => byId("forkMachine", machine, {
-			machine,
-			name
-		}, made))),
-		restore: (checkpoint, name) => naming("restoreMachine")(Effect.flatMap(sibling(checkpoint, name), (made) => byId("restoreMachine", checkpoint, {
-			checkpoint,
-			name
-		}, made))),
-		capture: (machine, name) => naming("captureCheckpoint")(Effect.flatMap(sibling(machine, name), (made) => byId("captureCheckpoint", machine, {
-			machine,
-			name
-		}, made))),
-		deleteCheckpoint: (id) => naming("deleteCheckpoint")(byId("deleteCheckpoint", id, { id }))
+		getMachine: (input) => onResource("getMachine", input),
+		startMachine: (input) => onResource("startMachine", input),
+		stopMachine: (input) => onResource("stopMachine", input),
+		deleteMachine: (input) => deleting(onResource("deleteMachine", input)),
+		forkMachine: (input) => onResource("forkMachine", input, input.name),
+		restoreMachine: (input) => onResource("restoreMachine", input, input.name),
+		getCheckpoint: (input) => onResource("getCheckpoint", input),
+		captureCheckpoint: (input) => onResource("captureCheckpoint", input, input.name),
+		deleteCheckpoint: (input) => deleting(onResource("deleteCheckpoint", input))
 	};
 });
 const layer = (hosts, options) => Layer.effect(Client, make(hosts, options));
 //#endregion
-export { Name as A, Invalid as B, MachineSpec as C, SshLogin as D, SshEndpoint as E, ClankerboxError as F, Precondition as H, Conflict as I, ConflictKind as L, parseId as M, parseName as N, HostId as O, Capacity as P, HostErrorTag as R, Machine as S, Setup as T, Unavailable as U, NotFound as V, hostErrors as W, CheckpointActionName as _, formatMib as a, Host as b, version as c, actionsByName as d, readTimeout as f, Checkpoint as g, ActionStatus as h, describeIssues as i, formatId as j, Id as k, versionHeader as l, ActionRecord as m, layer as n, mibPerGib as o, ActionName as p, describeFileError as r, release as s, client_exports as t, Http as u, CheckpointActionRecord as v, Runtime as w, Limit as x, CreateRequest as y, Internal as z };
+export { parseId as A, NotFound as B, Usage as C, Id as D, HostId as E, ConflictKind as F, Refused as G, NotOffered as H, HostError as I, Unsizable as J, ScriptFailed as K, Internal as L, Capacity as M, ClankerboxError as N, Name as O, Conflict as P, Invalid as R, SshLogin as S, stateLabel as T, NotReady as U, NotMade as V, PinMismatch as W, hostErrors as X, WrongState as Y, retryable as Z, Machine as _, release as a, Setup as b, Http as c, ActionName as d, ActionRecord as f, Host as g, CreateRequest as h, describeIssues as i, parseName as j, formatId as k, actionsByName as l, Checkpoint as m, layer as n, version as o, ActionStatus as p, Unavailable as q, describeFileError as r, versionHeader as s, client_exports as t, readTimeout as u, MachineSpec as v, isReady as w, SshEndpoint as x, Runtime as y, Missing as z };