@gjermundgaraba/clankerbox-sdk 0.15.6 → 0.18.0

package/dist/client-CbMWwHdT.mjs

@@ -0,0 +1,708 @@
+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, Record, Result, Schema, SchemaIssue } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+//#region src/errors.ts
+const located = {
+	host: Schema.optionalKey(Schema.String),
+	action: 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,
+* profile or setup file couldn't be read or doesn't hold what it should: then `file` names it.
+*/
+var Invalid = class extends Schema.TaggedError()("Invalid", {
+	message: Schema.String,
+	...located,
+	file: Schema.optionalKey(Schema.String)
+}, { 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 }) {};
+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 }) {};
+/** 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: 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 }) {};
+/**
+* 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`.
+*/
+var Unavailable = class extends Schema.TaggedError()("Unavailable", {
+	message: Schema.String,
+	readOnly: Schema.Boolean,
+	...located
+}) {};
+var Internal = class extends Schema.TaggedError()("Internal", {
+	message: Schema.String,
+	...located
+}, { httpApiStatus: 500 }) {};
+/** What a host may answer with; each action declares its own share. */
+const hostErrors = [
+	Invalid,
+	NotFound,
+	Conflict,
+	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]);
+/**
+* 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;
+const idPattern = /^[A-Za-z0-9_-]{1,62}$/u;
+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";
+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 }));
+/** 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}`;
+};
+/** `<host>_<name>`: neither part contains `_`, so an ID has exactly one. */
+const Id = Schema.String.check(Schema.makeFilter((id) => describeId(id) ?? true));
+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)
+	});
+};
+const parseName = (name) => namePattern.test(name) ? Effect.succeed(name) : Effect.fail(new Invalid({ message: `name ${JSON.stringify(name)}: ${nameRule}` }));
+/** Checks 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 src/resources.ts
+const Runtime = Schema.Literals([
+	"smolvm",
+	"tart",
+	"boat"
+]);
+const Size = Schema.Int.check(Schema.isGreaterThan(0));
+/** The contract's mutations, which record themselves on a resource's `action`. */
+const ActionName = Schema.Literals([
+	"createMachine",
+	"startMachine",
+	"stopMachine",
+	"deleteMachine",
+	"forkMachine",
+	"restoreMachine",
+	"captureCheckpoint",
+	"deleteCheckpoint"
+]);
+const ActionStatus = Schema.Literals([
+	"running",
+	"failed",
+	"done"
+]);
+/** 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: ActionName,
+	status: Schema.Literal("failed"),
+	error: HostError
+})]);
+const SshEndpoint = Schema.Struct({
+	host: Schema.String,
+	port: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 65535
+	}))
+});
+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,
+	createdAt: Schema.DateTimeUtcFromString,
+	base: Schema.String,
+	profile: Schema.optionalKey(Schema.String),
+	cpu: Size,
+	ramMib: Size,
+	diskGib: Size,
+	state: Schema.Literals([
+		"running",
+		"stopped",
+		"missing",
+		"unknown"
+	]),
+	made: Schema.Boolean,
+	action: ActionRecord,
+	ssh: Schema.optionalKey(SshLogin),
+	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,
+	kind: Schema.Literals(["ram", "disk"]),
+	base: Schema.String,
+	profile: Schema.optionalKey(Schema.String),
+	cpu: Size,
+	ramMib: Size,
+	diskGib: Size,
+	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,
+	runtimeVersion: Schema.String,
+	captureFrom: Schema.Literals(["running", "stopped"]),
+	bases: Schema.Array(Schema.String)
+}).annotate({ identifier: "Host" });
+const usageFields = {
+	host: HostId,
+	resource: Schema.Literals([
+		"cpu",
+		"ramMib",
+		"runningVms",
+		"activeSandboxes",
+		"startsPerMinute",
+		"startsPerHour",
+		"startsPerDay"
+	]),
+	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
+}), 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,
+	timeoutSeconds: Schema.optionalKey(Size)
+});
+const specFields = {
+	base: Schema.String,
+	cpu: Size,
+	ramMib: Size,
+	diskGib: Size,
+	setup: Schema.optionalKey(Setup),
+	profile: Schema.optionalKey(Schema.String)
+};
+/** A profile file fills these in; the host sees only the `profile` label. */
+const MachineSpec = Schema.Struct(specFields);
+/** The host checks that `id` names it, so a create never lands under another host's ID. */
+const CreateRequest = Schema.Struct({
+	id: Id,
+	...specFields
+});
+//#endregion
+//#region src/api.ts
+/** A host bounds its own reads of runtime state under it, so a list answers in time. */
+const readTimeout = Duration.seconds(10);
+const ById = Schema.Struct({ id: Id });
+const FromMachine = Schema.Struct({
+	machine: Id,
+	name: Name
+});
+const read = {
+	caller: Action.Anyone,
+	readOnly: true
+};
+const write = {
+	caller: Action.Anyone,
+	readOnly: false
+};
+const listing = [Invalid, Internal];
+const reading = [
+	Invalid,
+	NotFound,
+	Internal
+];
+const changing = [
+	Invalid,
+	NotFound,
+	Conflict,
+	Refused,
+	Internal
+];
+const booting = [
+	...changing,
+	NotMade,
+	Missing,
+	WrongState,
+	Capacity
+];
+const Http = ActionHttp.make([
+	Action.make("listMachines", {
+		...read,
+		error: listing,
+		description: "List the host's machines.",
+		success: Schema.Array(Machine)
+	}),
+	Action.make("getMachine", {
+		...read,
+		error: reading,
+		description: "Read one machine.",
+		input: ById,
+		success: Machine
+	}),
+	Action.make("createMachine", {
+		...write,
+		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: [...booting, ScriptFailed],
+		description: "Start a machine. On a running machine, run preparation again.",
+		input: ById,
+		success: Machine
+	}),
+	Action.make("stopMachine", {
+		...write,
+		error: changing,
+		description: "Stop a machine: a power-off that keeps its disk and ends its processes. A stopped machine stays stopped, and the stop is still its last action.",
+		input: ById,
+		success: Machine
+	}),
+	Action.make("deleteMachine", {
+		...write,
+		error: changing,
+		description: "Delete a machine and everything native it owns.",
+		input: ById
+	}),
+	Action.make("forkMachine", {
+		...write,
+		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: [
+			...changing,
+			NotReady,
+			PinMismatch,
+			Unsizable,
+			ScriptFailed,
+			Capacity
+		],
+		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,
+		error: listing,
+		description: "List the host's checkpoints.",
+		success: Schema.Array(Checkpoint)
+	}),
+	Action.make("getCheckpoint", {
+		...read,
+		error: reading,
+		description: "Read one checkpoint.",
+		input: ById,
+		success: Checkpoint
+	}),
+	Action.make("captureCheckpoint", {
+		...write,
+		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
+	}),
+	Action.make("deleteCheckpoint", {
+		...write,
+		error: changing,
+		description: "Delete a checkpoint.",
+		input: ById
+	}),
+	Action.make("getHost", {
+		...read,
+		error: [Invalid],
+		description: "Read the host: its runtime, versions and bases.",
+		success: Host
+	}),
+	Action.make("getCapacity", {
+		...read,
+		error: [
+			Invalid,
+			Refused,
+			Internal
+		],
+		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.18.0";
+/** major.minor: releases that share it speak the same API. */
+const release = (of) => of.split(".").slice(0, 2).join(".");
+/** A host refuses a request whose `release` differs from its own, or that has none. */
+const versionHeader = "clankerbox-version";
+//#endregion
+//#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)}`;
+}).join("");
+const flatten = SchemaIssue.makeFormatterStandardSchemaV1({ leafHook: (issue) => Match.value(issue).pipe(Match.tag("MissingKey", () => "missing"), Match.tag("UnexpectedKey", () => "not a known field"), Match.orElse(SchemaIssue.defaultLeafHook)) });
+/** On one line: `cpu: missing; ram: not a known field`. `names` renames top-level fields. */
+const describeIssues = (error, names) => flatten(error.issue).issues.map(({ path = [], message }) => {
+	const keys = path.map((segment) => Predicate.isPropertyKey(segment) ? segment : segment.key);
+	return keys.length === 0 ? message : `${jsonPath(keys, names)}: ${message}`;
+}).join("; ");
+/**
+* Node describes a failure only in its cause, so what has no wording here reads as the system's
+* own.
+*/
+const describeFileError = ({ reason }) => {
+	if (Predicate.isTagged(reason, "NotFound")) return "no such file or directory";
+	if (Predicate.isTagged(reason, "PermissionDenied")) return "permission denied";
+	return reason.description ?? (reason.cause instanceof Error ? reason.cause.message : reason._tag);
+};
+//#endregion
+//#region src/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({
+	Client: () => Client,
+	HostEntry: () => HostEntry,
+	layer: () => layer,
+	make: () => make
+});
+/** `id` is the host part of every ID the host holds. */
+const HostEntry = Schema.Struct({
+	id: HostId,
+	url: Schema.String.check(Schema.makeFilter((url) => URL.canParse(url) || "a URL, such as http://linux:8484"))
+});
+/**
+* Nothing retries: a mutation whose reply is lost or times out is `Unavailable`, and the caller
+* reads the resource to see what happened.
+*/
+var Client = class extends Context.Service()("@gjermundgaraba/clankerbox-sdk/Client") {};
+const hostApi = (entry) => ActionHttp.client(Http, {
+	baseUrl: entry.url,
+	transformClient: HttpClient.mapRequest(HttpClientRequest.setHeader(versionHeader, version))
+});
+const causeDetail = (error) => error.cause instanceof Error ? error.cause.message : error.message;
+const unanswered = (context, detail) => context.readOnly ? new Unavailable({
+	message: `host ${context.host.id} (${context.host.url}) didn't answer ${context.what}: ${detail}`,
+	readOnly: true
+}) : new Unavailable({
+	message: `no reply from host ${context.host.id} to ${context.what} (${detail}); the action may have run: read ${context.target ?? "the resource"} to see`,
+	readOnly: false
+});
+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 unexpected = (context, error) => new Internal({ message: `host ${context.host.id} answered ${context.what} 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.what}: 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))
+}));
+const encodeError = Schema.encodeSync(ClankerboxError);
+const decodeError = Schema.decodeSync(ClankerboxError);
+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.
+*/
+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, { errors: "all" }).pipe(Effect.mapError((error) => new Invalid({ message: `host list: ${describeIssues(error)}` })));
+	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(hostApi(entry), (api) => ({
+		entry,
+		api
+	})));
+	const routes = new Map(routed.map((route) => [route.entry.id, route]));
+	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);
+	};
+	const send = ({ entry, api }, name, input, subject, made) => {
+		const { readOnly } = actionsByName[name];
+		const method = api[name];
+		return settle(method(input), {
+			host: entry,
+			timeout: readOnly ? options?.readTimeout ?? readTimeout : options?.timeout,
+			readOnly,
+			what: subject === void 0 ? name : `${name} ${subject}`,
+			target: made ?? subject
+		}).pipe(Effect.mapError(locate({
+			action: name,
+			host: entry.id,
+			id: subject,
+			made
+		})));
+	};
+	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,
+		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
+		};
+	}));
+	const readHost = (route) => Effect.flatMap(send(route, "getHost", {}), (host) => checkHost(route.entry, host)).pipe(Effect.mapError(locate({
+		action: "getHost",
+		host: route.entry.id
+	})));
+	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,
+			fiber
+		})));
+		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.message}`);
+			} else if (result.success.bases.includes(base)) return result.success;
+			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,
+			readOnly: true
+		}) : new NotOffered({
+			message,
+			base
+		});
+	}).pipe(Effect.scoped);
+	const create = (name, spec, options) => Effect.gen(function* () {
+		yield* parseName(name);
+		if (options?.host !== void 0) return yield* createOn(options.host, name, spec);
+		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 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", {})),
+		place: (base, options) => naming("getHost")(place(base, options)),
+		create: (name, spec, options) => naming("createMachine")(create(name, spec, options)),
+		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 { 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 };