@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/actor-call.service-CGM_vD9u.mjs

@@ -0,0 +1,1269 @@
+import { R as some, T as join, j as map, k as makeBy, l as filter, r as contains, s as ensure, y as head } from "./Array-B4kuTQeW.mjs";
+import { t as match } from "./Boolean-kILIvmhE.mjs";
+import { a as option, i as String$1 } from "./Config-B6OND9WR.mjs";
+import { t as error } from "./Console-BKHUkH6a.mjs";
+import { $t as suspend, A as ensuring, An as spaced, At as provideContext, B as flatMap, Bn as build, Dt as orElseSucceed, En as exponential, Et as orDie, Ft as repeat, Gt as scoped, Jn as succeed, K as forEach, Kn as provide, Lt as retry, M as fail, Nt as raceFirst, Q as fromOption, T as context, Vn as effect, W as fnUntraced, Wn as merge, X as forkScoped, Xt as succeed$1, Yt as sleep, _n as when, a as all, aa as Service, d as asVoid, dt as map$1, en as sync, et as gen, ft as mapBoth, g as catchDefect, gn as void_, ht as mapError, in as timeout, l as as, ln as try_, n as acquireRelease, o as andThen, q as forever, qn as provideMerge, sn as transposeOption, tt as ignore, x as catchTag, yt as matchEffect } from "./Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "./FileSystem-4pPcEb_i.mjs";
+import { C as orElse, S as none, T as toArray, _ as isSome, b as map$2, c as flatten, cn as isString, d as fromUndefinedOr, f as getOrElse, h as isNone, i as filter$1, o as flatMap$1, p as getOrNull, t as all$1, u as fromNullishOr, un as isTagged, v as liftPredicate, w as some$1, x as match$1 } from "./Option-DkxSnBhp.mjs";
+import { B as TaggedStruct, F as String$2, I as Struct, J as UndefinedOr, T as NonEmptyArray, U as Tuple, X as Unknown, Y as Union, an as optionalKey, ar as filter$2, at as decodeUnknownEffect, cr as getSomes, ct as encodeOption, ft as encodeUnknownOption, g as Finite, hr as toEntries, mt as is, n as ArraySchema, nt as decodeOption, or as fromEntries, ot as decodeUnknownOption, pt as fromJsonString, q as Uint8ArrayFromBase64, sr as get, st as encodeEffect, tt as decodeEffect, un as toEncoded, v as Int, y as Json } from "./Schema-MiKt5K1v.mjs";
+import { i as value } from "./Redacted-RkJrG5Me.mjs";
+import { n as getUnsafe, o as set, r as make, t as get$1 } from "./Ref-BIPOxJNH.mjs";
+import { t as Stdio } from "./Stdio-KylmOBX_.mjs";
+import { H as runFold, I as provideContext$1, T as make$2, U as runFoldEffect, W as runForEach, Y as take, dt as make$1, k as mapError$1, m as flatMap$2, nt as unwrap, p as filter$3, pt as open, y as fromIterable, z as run } from "./Stream-bK9QIETN.mjs";
+import { d as replace, g as toLowerCase, h as startsWith, m as split, p as slice, r as endsWith } from "./String-q5dcsVe4.mjs";
+import { D as uploadChunkBytes$1, E as fileTag, It as make$6, Lt as remove, Ot as fromWebSocket, Rt as run$1, T as fileRpcsOf, X as ActorUnavailableError, et as Protocol, ft as isTerminalResponse, mt as RpcClientError, n as ActorFileClients, nt as makeProtocolHttp, o as Authentication, ot as layerNdjson, pt as RpcClientDefect, t as ActorClients, tt as make$4, ut as constPing, wt as make$3, yt as make$5 } from "./actor-client.adapter-Coem7gF1.mjs";
+import { n as layerWebCrypto, t as SecureRandom } from "./SecureRandom-B_U4ysO3.mjs";
+import { n as Fetch, r as layer, t as CloudClient } from "./cloud-client.adapter-DOVMoYAj.mjs";
+import { f as HttpClient, g as mapRequest } from "./cloud-client.adapter-Cy1BjDbG.mjs";
+import { P as currentTimeMillis, S as prependUrl, w as setHeaders } from "./HttpClientResponse-D5ZKICVV.mjs";
+import { l as millis } from "./Duration-EH9Vy4U6.mjs";
+import { a as tags, r as orElse$1, s as value$1 } from "./Match-CGPLZYrV.mjs";
+import { Credentials } from "./credentials/credentials.service.mjs";
+import { refusalCode, rejectedRequest, unansweredOf } from "./registry/actor-refusal.pure.mjs";
+import { compactJson, printJson, reported, signInFailure } from "./registry/operation-output.pure.mjs";
+import { RunnerExitedError } from "./runner-exited.errors.mjs";
+import { CliExitError } from "./terminal/cli-exit.errors.mjs";
+// ../client/src/actor-rpc.pure.ts
+const commandFields = {
+	commandId: String$2,
+	key: Json,
+	payload: Json
+};
+const queryFields = {
+	key: Json,
+	payload: Json
+};
+const keyFields = { key: Json };
+const computerFields = {
+	computer: Json,
+	key: Json
+};
+const listFields = {
+	cursor: optionalKey(Json),
+	key: Json,
+	limit: optionalKey(Json),
+	prefix: optionalKey(Json)
+};
+const fieldsOf = {
+	call: commandFields,
+	"computers/cp": {
+		...computerFields,
+		computerPath: Json,
+		direction: Json,
+		path: Json
+	},
+	"computers/delete": computerFields,
+	"computers/get": computerFields,
+	"computers/list": keyFields,
+	"computers/logs": {
+		...computerFields,
+		after: optionalKey(Json),
+		limit: optionalKey(Json)
+	},
+	"computers/pause": computerFields,
+	"computers/resume": computerFields,
+	"computers/stop": computerFields,
+	create: commandFields,
+	ensure: commandFields,
+	"files/download": {
+		key: Json,
+		length: optionalKey(Json),
+		offset: optionalKey(Json),
+		path: Json
+	},
+	"files/list": listFields,
+	"files/upload": keyFields,
+	"files/upload/append": {
+		bytes: Json,
+		key: Json,
+		offset: Json,
+		upload: Json
+	},
+	"files/upload/close": {
+		bytes: Json,
+		key: Json,
+		upload: Json
+	},
+	"files/upload/open": keyFields,
+	"files/usage": listFields,
+	fork: {
+		commandId: String$2,
+		into: Json,
+		key: Json
+	},
+	query: queryFields,
+	state: keyFields,
+	"steps/get": {
+		key: Json,
+		step: Json
+	},
+	"steps/list": {
+		key: Json,
+		limit: optionalKey(Json)
+	},
+	warm: keyFields,
+	watch: queryFields
+};
+function unaryClient({ kind, tag }) {
+	const rpc = make$3(tag, {
+		error: Json,
+		payload: Struct(fieldsOf[kind]),
+		success: UndefinedOr(Json)
+	});
+	return make$4(make$5(rpc), { flatten: true });
+}
+function streamClient({ kind, tag }) {
+	const rpc = make$3(tag, {
+		error: Json,
+		payload: Struct(fieldsOf[kind]),
+		stream: true,
+		success: Json
+	});
+	return make$4(make$5(rpc), { flatten: true });
+}
+const uploadChunkBytes = 1048576;
+const Base64$1 = Uint8ArrayFromBase64;
+const Opened = Struct({ upload: String$2 });
+const appended = fnUntraced(function* appended({ content, request, upload, wait }) {
+	const tag = `${request.tag}/append`;
+	const append = yield* unaryClient({
+		kind: "files/upload/append",
+		tag
+	});
+	const count = Math.ceil(content.length / uploadChunkBytes);
+	const chunks = makeBy(count, (index) => ({
+		bytes: content.subarray(index * uploadChunkBytes, index * uploadChunkBytes + uploadChunkBytes),
+		offset: index * uploadChunkBytes
+	}));
+	yield* forEach(chunks, ({ bytes, offset }) => flatMap(orDie(encodeEffect(Base64$1)(bytes)), (encoded) => timeout(append(tag, {
+		...request.payload,
+		bytes: encoded,
+		offset,
+		upload
+	}), wait)));
+});
+const uploadSession = (upload) => gen(function* runUploadSession() {
+	const { content, request, wait } = upload;
+	const open = yield* unaryClient({
+		kind: "files/upload/open",
+		tag: `${request.tag}/open`
+	});
+	const close = yield* unaryClient({
+		kind: "files/upload/close",
+		tag: `${request.tag}/close`
+	});
+	const opened = yield* timeout(open(`${request.tag}/open`, request.payload), wait);
+	const session = yield* orDie(decodeUnknownEffect(Opened)(opened));
+	yield* appended({
+		content,
+		request,
+		upload: session.upload,
+		wait
+	});
+	const closing = {
+		...request.payload,
+		bytes: content.length,
+		upload: session.upload
+	};
+	return yield* timeout(close(`${request.tag}/close`, closing), wait);
+});
+// ../effect/src/contract/file/rpc/rpc-file-clients.layer.ts
+const retryMillis = 50;
+const retryLimit = 5;
+const firstByte = 0;
+const one = 1;
+function wireOf(actor) {
+	const group = make$5(...fileRpcsOf(actor)).middleware(Authentication);
+	return map$1(make$4(group, { flatten: true }), (client) => ({
+		send: client,
+		watch: client
+	}));
+}
+const unavailable = (actor, message) => ActorUnavailableError.make({
+	actor,
+	message
+});
+/**
+* What a network file client answers for a failure: a lost reply, after its retries, means the actor is unavailable,
+* and the actor RPC failures a file request can't cause fold into the same retryable answer.
+*/
+const clientFailure = (actor) => (failure) => value$1(failure).pipe(tags({
+	ActorNotCreatedError: () => unavailable(actor, "the actor's files are unavailable"),
+	CommandIdExpiredError: () => unavailable(actor, "the actor's files are unavailable"),
+	HandlerFailedError: () => unavailable(actor, "the actor's files are unavailable"),
+	RpcClientError: () => unavailable(actor, "the server didn't answer. Retry shortly.")
+}), orElse$1((other) => other));
+const tagOf$1 = (address, operation) => fileTag({
+	actor: address.actor,
+	operation
+});
+/** One unary file RPC. A lost reply is retried, which every file RPC allows: reads, and appends by their offset. */
+const call = ({ address, protocol }, operation, payload) => {
+	const sent = flatMap(wireOf(address.actor), (wire) => wire.send(tagOf$1(address, operation), {
+		...payload,
+		key: address.key
+	}));
+	const retried = retry(scoped(sent), {
+		schedule: exponential(millis(retryMillis)),
+		times: retryLimit,
+		while: (failure) => isTagged(failure, "RpcClientError")
+	});
+	return provideContext(mapError(retried, clientFailure(address.actor)), protocol);
+};
+const listingOf = ({ cursor, limit, prefix }) => ({
+	...getSomes({
+		cursor: fromNullishOr(cursor),
+		prefix: fromNullishOr(prefix)
+	}),
+	...getSomes({ limit: fromNullishOr(limit) })
+});
+const slices = (bytes) => makeBy(Math.max(one, Math.ceil(bytes.length / uploadChunkBytes$1)), (index) => bytes.subarray(index * uploadChunkBytes$1, (index + one) * uploadChunkBytes$1));
+const appendAll = (bound, upload, source) => source.pipe(flatMap$2((chunk) => fromIterable(slices(chunk))), filter$3((chunk) => chunk.length > firstByte), runFoldEffect(() => firstByte, (offset, bytes) => as(call(bound, "upload/append", {
+	bytes,
+	offset,
+	upload
+}), offset + bytes.length)));
+/** An upload is a session: `upload/open`, the source's bytes as ordered `upload/append` chunks, then `upload/close`. */
+const uploadWith = (bound) => (source) => gen(function* upload() {
+	const opened = yield* call(bound, "upload/open", {});
+	const bytes = yield* appendAll(bound, opened.upload, source);
+	return (yield* call(bound, "upload/close", {
+		bytes,
+		upload: opened.upload
+	})).receipt;
+});
+const downloadWith = ({ address, protocol }) => (path, range) => {
+	const bytes = unwrap(map$1(wireOf(address.actor), (wire) => wire.watch(tagOf$1(address, "download"), {
+		key: address.key,
+		path,
+		...range
+	})));
+	return provideContext$1(mapError$1(bytes, clientFailure(address.actor)), protocol);
+};
+const clientWith = (bound) => ({
+	download: downloadWith(bound),
+	fileUsage: (listing = {}) => call(bound, "usage", listingOf(listing)),
+	list: (listing = {}) => call(bound, "list", listingOf(listing)),
+	upload: uploadWith(bound)
+});
+/**
+* File clients that reach an actor's files over its `<Actor>/files/<operation>` RPCs, for `@akterjs/client` and the
+* in-process client. They give the same `FileClient` an actor's own host gives, so customer code is the same either
+* way.
+*/
+const rpcFileClients = effect(ActorFileClients, map$1(context(), (protocol) => ({ connect: (address) => clientWith({
+	address,
+	protocol
+}) })));
+// ../client/src/read-floors.pure.ts
+const floorHeader = "akter-floor";
+const Keyed = Struct({ key: Unknown });
+const Versioned = Struct({
+	requestId: Union([String$2, Finite]),
+	version: Int
+});
+const KeyText = fromJsonString(Unknown);
+const keyedOf = decodeUnknownOption(Keyed);
+const versionedOf = decodeUnknownOption(Versioned);
+const keyTextOf = encodeUnknownOption(KeyText);
+const actorKeyOf = ({ payload, tag }) => flatMap$1(keyedOf(payload), ({ key }) => map$2(keyTextOf(key), (keyText) => `${getOrElse(head(split(tag, "/")), () => tag)}\n${keyText}`));
+const pendingOf = (clientId, requestId) => `${clientId}/${requestId}`;
+const trackedFloors = () => {
+	const floors = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const floored = (clientId, request) => match$1(actorKeyOf(request), {
+		onNone: () => request,
+		onSome: (actorKey) => {
+			pending.set(pendingOf(clientId, request.id), actorKey);
+			return match$1(fromNullishOr(floors.get(actorKey)), {
+				onNone: () => request,
+				onSome: (floor) => ({
+					...request,
+					headers: [...request.headers, [floorHeader, String(floor)]]
+				})
+			});
+		}
+	});
+	const sent = (clientId, message) => {
+		if (isTagged(message, "Request")) return floored(clientId, message);
+		return message;
+	};
+	const received = (clientId, response) => {
+		if (!isTagged(response, "Exit")) return;
+		const id = pendingOf(clientId, response.requestId);
+		const actorKey = pending.get(id);
+		pending.delete(id);
+		map$2(all$1([fromNullishOr(actorKey), versionedOf(response)]), ([key, { version }]) => {
+			floors.set(key, Math.max(version, floors.get(key) ?? version));
+		});
+	};
+	return {
+		received,
+		sent
+	};
+};
+// ../client/src/remote-interrupt.pure.ts
+const InterruptReasons = NonEmptyArray(TaggedStruct("Interrupt", {}));
+const InterruptedOnly = Struct({ exit: TaggedStruct("Failure", { cause: InterruptReasons }) });
+const UnavailableWire = toEncoded(ActorUnavailableError);
+const FailReason = TaggedStruct("Fail", { error: UnavailableWire });
+/** An encoded exit that failed with one error, as Effect RPC writes it. */
+const FailedExit = TaggedStruct("Failure", { cause: Tuple([FailReason]) });
+const isInterruptedOnly = is(InterruptedOnly);
+const encodeUnavailable = encodeOption(ActorUnavailableError);
+const message = "the server stopped this request before it answered. Retry shortly.";
+const requestOf$1 = (clientId, requestId) => `${clientId}/${requestId}`;
+/** `Room/files/list` and `Room/post` are both Room's. */
+const actorOf = (tag) => getOrElse(head(split(tag, "/")), () => tag);
+const failedWith = (error) => FailedExit.make({ cause: [FailReason.make({ error })] });
+const answered$1 = (actor, response) => match$1(encodeUnavailable(ActorUnavailableError.make({
+	actor,
+	message
+})), {
+	onNone: () => response,
+	onSome: (error) => ({
+		...response,
+		exit: failedWith(error)
+	})
+});
+const remoteInterrupts = () => {
+	const actors = /* @__PURE__ */ new Map();
+	const sent = (clientId, outgoing) => {
+		if (isTagged(outgoing, "Request")) actors.set(requestOf$1(clientId, outgoing.id), actorOf(outgoing.tag));
+	};
+	const received = (clientId, response) => {
+		if (!isTagged(response, "Exit")) return response;
+		const id = requestOf$1(clientId, response.requestId);
+		const actor = fromNullishOr(actors.get(id));
+		actors.delete(id);
+		if (isNone(actor) || !isInterruptedOnly(response)) return response;
+		return answered$1(actor.value, response);
+	};
+	return {
+		received,
+		sent
+	};
+};
+// ../client/src/actor-protocol.layer.ts
+const streamSuffix = "/subscribe";
+const liveProtocol = "akter-rpc";
+const authProtocol = "akter-auth.";
+const authorizationHeader = "authorization";
+const bearerPrefix = "Bearer ";
+const pingEvery = "10 seconds";
+const silentMillis = 25e3;
+const openTimeout = "10 seconds";
+const normalClose = 1e3;
+const ClientProtocolError = TaggedStruct("ClientProtocolError", {
+	error: RpcClientError,
+	requestIds: ArraySchema(Union([String$2, Finite]))
+});
+const JsonText$1 = fromJsonString(Unknown);
+const encodeJson = encodeEffect(JsonText$1);
+const decodeJson = decodeEffect(JsonText$1);
+const utf8 = new globalThis.TextDecoder();
+function serverMessages(values) {
+	return values;
+}
+const textOf = (message) => orDie(encodeJson(message));
+const tokenOf = (headers) => map$2(filter$1(get(headers, authorizationHeader), startsWith(bearerPrefix)), slice(7));
+const withoutAuthorization = (headers) => filter(toEntries(headers), ([name]) => toLowerCase(name) !== authorizationHeader);
+const socketUrl = (url, request) => map$1(textOf({
+	...request,
+	headers: []
+}), (text) => {
+	const target = new globalThis.URL(url);
+	target.protocol = replace(/^http/u, "ws")(target.protocol);
+	target.searchParams.set("request", text);
+	return target.href;
+});
+const lost = (message, cause) => RpcClientError.make({ reason: RpcClientDefect.make({
+	cause,
+	message
+}) });
+const textFrom = (frame) => {
+	if (isString(frame)) return frame;
+	return utf8.decode(frame);
+};
+const decodeFrame = (frame) => mapBoth(decodeJson(textFrom(frame)), {
+	onFailure: (cause) => lost("the live socket sent a frame that isn't RPC JSON", cause),
+	onSuccess: (decoded) => serverMessages(ensure(decoded))
+});
+const opened = ({ headers, url, webSocket }, request) => gen(function* openLiveSocket() {
+	const sent = headers();
+	const credentials = map$2(tokenOf(sent), (token) => `${authProtocol}${token}`);
+	const protocols = [liveProtocol, ...toArray(credentials)];
+	const target = yield* socketUrl(url, request);
+	const socket = yield* fromWebSocket(acquireRelease(sync(() => new webSocket(target, protocols)), (native) => sync(() => {
+		native.close(normalClose);
+	})), { openTimeout });
+	const reader = yield* socket.reader;
+	const writer = yield* socket.writer;
+	const opening = yield* textOf({
+		...request,
+		headers: [...request.headers, ...withoutAuthorization(sent)]
+	});
+	yield* writer.write(opening);
+	return {
+		reader,
+		writer
+	};
+});
+const received = ({ deliver, ended }) => (response) => {
+	if (isTagged(response, "Pong")) return void_;
+	if (isTerminalResponse(response)) return andThen(deliver(response), open(ended));
+	return deliver(response);
+};
+const receiving = (live) => {
+	const onFrame = (frame) => flatMap(decodeFrame(frame), (responses) => andThen(flatMap(currentTimeMillis, (now) => set(live.seen, now)), forEach(responses, received(live), { discard: true })));
+	return forever(flatMap(live.reader.pull, (frames) => forEach(frames, onFrame)));
+};
+const pinging = ({ seen, writer }) => forever(gen(function* pingLiveSocket() {
+	yield* sleep(pingEvery);
+	const now = yield* currentTimeMillis;
+	const last = yield* get$1(seen);
+	if (now - last > silentMillis) return yield* lost("the live socket went silent", now - last);
+	const frame = yield* textOf(constPing);
+	return yield* writer.write(frame);
+}));
+const transportFailure = (failure) => {
+	if (isTagged(failure, "RpcClientError")) return failure;
+	return RpcClientError.make({ reason: failure.reason });
+};
+const liveStream = (options, writers) => ({ deliver, request }) => {
+	const served = gen(function* serveLiveRequest() {
+		const { reader, writer } = yield* opened(options, request);
+		const ended = yield* make$1();
+		const now = yield* currentTimeMillis;
+		const live = {
+			deliver,
+			ended,
+			reader,
+			seen: yield* make(now),
+			writer
+		};
+		yield* acquireRelease(sync(() => writers.set(request.id, writer)), () => sync(() => writers.delete(request.id)));
+		yield* raceFirst(raceFirst(receiving(live), pinging(live)), ended.await);
+	});
+	return matchEffect(scoped(served), {
+		onFailure: (failure) => deliver(ClientProtocolError.make({
+			error: transportFailure(failure),
+			requestIds: [request.id]
+		})),
+		onSuccess: () => void_
+	});
+};
+const liveRequestOf = (message) => {
+	if (isTagged(message, "Request") && endsWith(streamSuffix)(message.tag)) return some$1(message);
+	return none();
+};
+const deliveries = (http) => {
+	const delivers = /* @__PURE__ */ new Map();
+	const floors = trackedFloors();
+	const interrupts = remoteInterrupts();
+	const deliverTo = (clientId) => (response) => match$1(fromNullishOr(delivers.get(clientId)), {
+		onNone: () => void_,
+		onSome: (deliver) => deliver(interrupts.received(clientId, response))
+	});
+	const run = (clientId, deliver) => ensuring(suspend(() => {
+		delivers.set(clientId, deliver);
+		return http.run(clientId, (response) => andThen(sync(() => {
+			floors.received(clientId, response);
+		}), suspend(() => deliver(interrupts.received(clientId, response)))));
+	}), sync(() => delivers.delete(clientId)));
+	return {
+		deliverTo,
+		floors,
+		interrupts,
+		run
+	};
+};
+const actorProtocol = fnUntraced(function* actorProtocol(options) {
+	const http = yield* makeProtocolHttp(options.http);
+	const lives = yield* make$6();
+	const writers = /* @__PURE__ */ new Map();
+	const { deliverTo, floors, interrupts, run } = deliveries(http);
+	const serve = liveStream(options, writers);
+	const writeTo = (requestId, message) => match$1(fromNullishOr(writers.get(requestId)), {
+		onNone: () => void_,
+		onSome: (writer) => ignore(flatMap(textOf(message), (frame) => writer.write(frame)))
+	});
+	const send = (clientId, message, transferables) => {
+		const live = liveRequestOf(message);
+		interrupts.sent(clientId, message);
+		if (isSome(live)) {
+			const streamed = serve({
+				deliver: deliverTo(clientId),
+				request: live.value
+			});
+			return asVoid(run$1(lives, live.value.id, streamed));
+		}
+		if (isTagged(message, "Ack")) return writeTo(message.requestId, message);
+		if (isTagged(message, "Interrupt")) return andThen(writeTo(message.requestId, message), remove(lives, message.requestId));
+		return http.send(clientId, floors.sent(clientId, message), transferables);
+	};
+	return Protocol.of({
+		codecFor: http.codecFor,
+		run,
+		send,
+		supportsAck: true,
+		supportsTransferables: false
+	});
+});
+// ../client/src/akter-client.layer.ts
+const noHeaders$1 = () => ({});
+const rpcPath = "/rpc";
+const akterClient = ({ fetch = globalThis.fetch, headers = noHeaders$1, url, webSocket = globalThis.WebSocket }) => {
+	const rpcUrl = new globalThis.URL(rpcPath, url).href;
+	const httpClient = effect(HttpClient, gen(function* withHeaders() {
+		const client = yield* HttpClient;
+		return mapRequest(client, (request) => setHeaders(prependUrl(request, rpcUrl), headers()));
+	})).pipe(provide(layer), provide(succeed(Fetch)(fetch)));
+	const protocol = effect(Protocol, flatMap(HttpClient, (http) => actorProtocol({
+		headers,
+		http,
+		url: rpcUrl,
+		webSocket
+	}))).pipe(provide([httpClient, layerNdjson]));
+	const clients = merge(ActorClients.layer.pipe(provide(layerWebCrypto)), rpcFileClients);
+	return provideMerge(clients, protocol);
+};
+// ../client/src/actor-fields.pure.ts
+const fieldSchemas = {
+	actor: {
+		description: "The actor's name in the app, such as Sale.",
+		type: "string"
+	},
+	after: {
+		description: "Only log lines after this seq, the last one a page before printed, to read on from there.",
+		type: "integer"
+	},
+	commandId: {
+		description: "An id for this call, so a retry with the same id runs it once. A new one is made when it is missing.",
+		type: "string"
+	},
+	computer: {
+		description: "The computer's name, as the actor named it.",
+		type: "string"
+	},
+	computerPath: {
+		description: "Relative path in the computer's files directory.",
+		type: "string"
+	},
+	content: {
+		description: "The file's bytes, as base64.",
+		type: "string"
+	},
+	cursor: {
+		description: "Where the page to read starts, from the cursor of the page before.",
+		type: "string"
+	},
+	direction: {
+		description: "toComputer or fromComputer; copy-back returns an upload receipt.",
+		enum: ["toComputer", "fromComputer"],
+		type: "string"
+	},
+	into: { description: "The new actor's key, as JSON. A bare word is taken as a string key." },
+	key: { description: "The actor's key, as JSON. A bare word is taken as a string key." },
+	length: {
+		description: "How many bytes to read, from offset; give both or neither.",
+		type: "integer"
+	},
+	limit: {
+		description: "The most entries to return.",
+		type: "integer"
+	},
+	member: {
+		description: "The command or query to run.",
+		type: "string"
+	},
+	offset: {
+		description: "The byte to start reading at, with length; give both or neither.",
+		type: "integer"
+	},
+	path: {
+		description: "The file's path in the actor, such as photos/cat.png.",
+		type: "string"
+	},
+	payload: { description: "The command's, query's or create input's payload, as JSON." },
+	prefix: {
+		description: "Only paths that start with this.",
+		type: "string"
+	},
+	step: {
+		description: "The step's id, as steps list prints it.",
+		type: "string"
+	}
+};
+const optional = [
+	"after",
+	"commandId",
+	"cursor",
+	"length",
+	"limit",
+	"offset",
+	"payload",
+	"prefix"
+];
+const inputOf = (fields) => ({
+	additionalProperties: false,
+	properties: fromEntries(map(fields, (name) => [name, fieldSchemas[name]])),
+	required: filter(fields, (name) => !contains(optional, name)),
+	type: "object"
+});
+// ../client/src/actor-operations.pure.ts
+const group = "actors";
+const commandOfKind = (kind) => {
+	const [owner, name] = split("/")(kind);
+	return match$1(fromUndefinedOr(name), {
+		onNone: () => [group, kind],
+		onSome: (found) => [owner, found]
+	});
+};
+const subscribe = "/subscribe";
+const declared = [
+	{
+		description: "Run one of an actor's commands and print its reply.",
+		fields: [
+			"actor",
+			"key",
+			"member",
+			"payload",
+			"commandId"
+		],
+		idempotent: false,
+		kind: "call",
+		readOnly: false
+	},
+	{
+		description: "Run one of an actor's queries and print its reply.",
+		fields: [
+			"actor",
+			"key",
+			"member",
+			"payload"
+		],
+		idempotent: true,
+		kind: "query",
+		readOnly: true
+	},
+	{
+		description: "Print an actor's state once.",
+		fields: ["actor", "key"],
+		idempotent: true,
+		kind: "state",
+		readOnly: true
+	},
+	{
+		description: "Print a query's reply, then each new reply as the actor changes, one JSON line each.",
+		fields: [
+			"actor",
+			"key",
+			"member",
+			"payload"
+		],
+		idempotent: true,
+		kind: "watch",
+		readOnly: true
+	},
+	{
+		description: "Create an actor from its create input; fails when it already exists.",
+		fields: [
+			"actor",
+			"key",
+			"payload",
+			"commandId"
+		],
+		idempotent: false,
+		kind: "create",
+		readOnly: false
+	},
+	{
+		description: "Create an actor from its create input unless it already exists.",
+		fields: [
+			"actor",
+			"key",
+			"payload",
+			"commandId"
+		],
+		idempotent: true,
+		kind: "ensure",
+		readOnly: false
+	},
+	{
+		description: "List an actor's files a page at a time, with each path, size, digest and write time.",
+		fields: [
+			"actor",
+			"key",
+			"prefix",
+			"cursor",
+			"limit"
+		],
+		idempotent: true,
+		kind: "files/list",
+		readOnly: true
+	},
+	{
+		description: "List an actor's files a page at a time, with the total bytes they hold.",
+		fields: [
+			"actor",
+			"key",
+			"prefix",
+			"cursor",
+			"limit"
+		],
+		idempotent: true,
+		kind: "files/usage",
+		readOnly: true
+	},
+	{
+		description: "Download one of an actor's files, whole or the byte range offset and length give.",
+		fields: [
+			"actor",
+			"key",
+			"path",
+			"offset",
+			"length"
+		],
+		idempotent: true,
+		kind: "files/download",
+		readOnly: true
+	},
+	{
+		description: "Upload a file for an actor and print its receipt, which a command attaches at a path.",
+		fields: [
+			"actor",
+			"key",
+			"content"
+		],
+		idempotent: false,
+		kind: "files/upload",
+		readOnly: false
+	},
+	{
+		description: "Fork an actor into a new actor at another key: a copy of its state and files at one moment, with none of its work in flight (its jobs, timers and undelivered messages stay with the original). A retry with the same commandId makes one copy.",
+		fields: [
+			"actor",
+			"key",
+			"into",
+			"commandId"
+		],
+		idempotent: false,
+		kind: "fork",
+		readOnly: false
+	},
+	{
+		description: "List an actor's computers, each with its image, size, egress and state.",
+		fields: ["actor", "key"],
+		idempotent: true,
+		kind: "computers/list",
+		readOnly: true
+	},
+	{
+		description: "Copy one file (at most 1 MiB) between an actor and its computer. fromComputer returns a receipt; attach it with an actor command.",
+		fields: [
+			"actor",
+			"key",
+			"computer",
+			"direction",
+			"path",
+			"computerPath"
+		],
+		flag: "computerFiles",
+		idempotent: false,
+		kind: "computers/cp",
+		readOnly: false
+	},
+	{
+		description: "Show one of an actor's computers: its image, size, egress and state.",
+		fields: [
+			"actor",
+			"key",
+			"computer"
+		],
+		idempotent: true,
+		kind: "computers/get",
+		readOnly: true
+	},
+	{
+		description: "Read a page of a computer's log, oldest first; pass the last seq printed as after to read on.",
+		fields: [
+			"actor",
+			"key",
+			"computer",
+			"after",
+			"limit"
+		],
+		idempotent: true,
+		kind: "computers/logs",
+		readOnly: true
+	},
+	{
+		description: "Pause a computer, keeping its memory and disk, and print it.",
+		fields: [
+			"actor",
+			"key",
+			"computer"
+		],
+		idempotent: true,
+		kind: "computers/pause",
+		readOnly: false
+	},
+	{
+		description: "Resume a paused computer and print it; fails while a fork holds it.",
+		fields: [
+			"actor",
+			"key",
+			"computer"
+		],
+		idempotent: true,
+		kind: "computers/resume",
+		readOnly: false
+	},
+	{
+		description: "Stop a computer, keeping its disk, and print it.",
+		fields: [
+			"actor",
+			"key",
+			"computer"
+		],
+		idempotent: true,
+		kind: "computers/stop",
+		readOnly: false
+	},
+	{
+		description: "Delete a computer and its disk. The actor's own jobs make computers; this only removes one.",
+		fields: [
+			"actor",
+			"key",
+			"computer"
+		],
+		idempotent: true,
+		kind: "computers/delete",
+		readOnly: false
+	},
+	{
+		description: "List an actor's durable computer steps, newest first: each one's job, name, computer, command and state, and its exit code once it ran.",
+		fields: [
+			"actor",
+			"key",
+			"limit"
+		],
+		flag: "computerSteps",
+		idempotent: true,
+		kind: "steps/list",
+		readOnly: true
+	},
+	{
+		description: "Show one of an actor's durable computer steps with its output. A step in state unknown may have done its work; reconcile it by its id.",
+		fields: [
+			"actor",
+			"key",
+			"step"
+		],
+		flag: "computerSteps",
+		idempotent: true,
+		kind: "steps/get",
+		readOnly: true
+	},
+	{
+		description: "Load an actor ahead of its first call, so that call answers sooner.",
+		fields: ["actor", "key"],
+		idempotent: true,
+		kind: "warm",
+		readOnly: true
+	}
+];
+const streams = [
+	"files/download",
+	"state",
+	"watch"
+];
+const dangerous = ["computers/delete"];
+const operationOf = ({ description, fields, flag, idempotent, kind, readOnly }) => {
+	const [owner, name] = commandOfKind(kind);
+	const confirm = contains(dangerous, kind);
+	const operation = {
+		annotations: {
+			confirm,
+			destructive: confirm,
+			idempotent,
+			openWorld: false,
+			readOnly
+		},
+		command: [owner, name],
+		description,
+		fields,
+		flag: fromUndefinedOr(flag),
+		id: `${owner}.${name}`,
+		input: inputOf(fields),
+		kind,
+		stream: contains(streams, kind),
+		tool: `${owner}_${name}`
+	};
+	if (kind === "computers/cp") return {
+		...operation,
+		tool: "computers_files"
+	};
+	return operation;
+};
+const unexposedKinds = ["warm"];
+const actorOperations = map(filter(declared, ({ kind }) => !contains(unexposedKinds, kind)), operationOf);
+const tagOf = ({ actor, kind, member }) => {
+	return {
+		call: `${actor}/${member}`,
+		"computers/cp": `${actor}/computer/files`,
+		"computers/delete": `${actor}/computer/delete`,
+		"computers/get": `${actor}/computer/get`,
+		"computers/list": `${actor}/computer/list`,
+		"computers/logs": `${actor}/computer/logs`,
+		"computers/pause": `${actor}/computer/pause`,
+		"computers/resume": `${actor}/computer/resume`,
+		"computers/stop": `${actor}/computer/stop`,
+		create: `${actor}/create`,
+		ensure: `${actor}/ensure`,
+		"files/download": `${actor}/files/download`,
+		"files/list": `${actor}/files/list`,
+		"files/upload": `${actor}/files/upload`,
+		"files/usage": `${actor}/files/usage`,
+		fork: `${actor}/fork`,
+		query: `${actor}/${member}`,
+		state: `${actor}/state${subscribe}`,
+		"steps/get": `${actor}/computer/step`,
+		"steps/list": `${actor}/computer/steps`,
+		warm: `${actor}/warm`,
+		watch: `${actor}/${member}${subscribe}`
+	}[kind];
+};
+const fileRpcs = {
+	"files/download": {
+		fields: "key,length,offset,path",
+		kind: "files/download",
+		stream: true
+	},
+	"files/list": {
+		fields: "cursor,key,limit,prefix",
+		kind: "files/list",
+		stream: false
+	},
+	"files/upload/append": {
+		fields: "bytes,key,offset,upload",
+		kind: "files/upload",
+		stream: false
+	},
+	"files/upload/close": {
+		fields: "bytes,key,upload",
+		kind: "files/upload",
+		stream: false
+	},
+	"files/upload/open": {
+		fields: "key",
+		kind: "files/upload",
+		stream: false
+	},
+	"files/usage": {
+		fields: "cursor,key,limit,prefix",
+		kind: "files/usage",
+		stream: false
+	}
+};
+const computerRpcs = {
+	"computer/delete": {
+		fields: "computer,key",
+		kind: "computers/delete",
+		stream: false
+	},
+	"computer/files": {
+		fields: "computer,computerPath,direction,key,path",
+		kind: "computers/cp",
+		stream: false
+	},
+	"computer/get": {
+		fields: "computer,key",
+		kind: "computers/get",
+		stream: false
+	},
+	"computer/list": {
+		fields: "key",
+		kind: "computers/list",
+		stream: false
+	},
+	"computer/logs": {
+		fields: "after,computer,key,limit",
+		kind: "computers/logs",
+		stream: false
+	},
+	"computer/pause": {
+		fields: "computer,key",
+		kind: "computers/pause",
+		stream: false
+	},
+	"computer/resume": {
+		fields: "computer,key",
+		kind: "computers/resume",
+		stream: false
+	},
+	"computer/step": {
+		fields: "key,step",
+		kind: "steps/get",
+		stream: false
+	},
+	"computer/steps": {
+		fields: "key,limit",
+		kind: "steps/list",
+		stream: false
+	},
+	"computer/stop": {
+		fields: "computer,key",
+		kind: "computers/stop",
+		stream: false
+	}
+};
+({
+	...fileRpcs,
+	...computerRpcs
+});
+const someField = (name, value) => match$1(value, {
+	onNone: () => ({}),
+	onSome: (found) => ({ [name]: found })
+});
+const actorRequestOf = (operation) => (input) => gen(function* buildRequest() {
+	const takes = (name) => contains(operation.fields, name);
+	const minted = SecureRandom.use((random) => random.uuidV7());
+	const fresh = yield* when(minted, succeed$1(takes("commandId") && isNone(input.commandId)));
+	const commandId = filter$1(orElse(input.commandId, () => fresh), () => takes("commandId"));
+	const payload = liftPredicate(getOrNull(input.payload), () => takes("payload"));
+	return {
+		payload: {
+			...filter$2(input.fileFields, (_value, name) => some(operation.fields, (field) => field === name)),
+			...someField("commandId", commandId),
+			...someField("into", filter$1(input.into, () => takes("into"))),
+			...someField("payload", payload),
+			key: input.key
+		},
+		tag: tagOf({
+			actor: input.actor,
+			kind: operation.kind,
+			member: input.member
+		})
+	};
+});
+// src/registry/actor-call.service.ts
+const callWait = "2 minutes";
+const firstOnly = 1;
+const fromFile = "@";
+const fromStdin = "-";
+const Base64 = Uint8ArrayFromBase64;
+const textFields = [
+	"computer",
+	"computerPath",
+	"direction",
+	"cursor",
+	"path",
+	"prefix",
+	"step"
+];
+const numberFields = [
+	"after",
+	"length",
+	"limit",
+	"offset"
+];
+const loopbackHosts = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+const JsonText = fromJsonString(Json);
+const usage = (message) => CliExitError.make({
+	code: CliExitError.codes.usage,
+	message,
+	reason: "InvalidInput"
+});
+const appUrl = fnUntraced(function* appUrl(flag) {
+	const configured = yield* option(String$1("AKTER_APP_URL")).pipe(orElseSucceed(() => none()));
+	const given = yield* fromOption(orElse(flag, () => configured)).pipe(mapError(() => usage("Pass --url with the app's URL, such as the one akter dev prints, or set AKTER_APP_URL.")));
+	return yield* try_({
+		catch: () => usage(`${given} is not a URL.`),
+		try: () => new globalThis.URL(given)
+	});
+});
+const noHeaders = { current: succeed$1({}) };
+const headersFor = fnUntraced(function* headersFor(url) {
+	if (loopbackHosts.has(url.hostname)) return noHeaders;
+	const credentials = yield* Credentials;
+	const cloudUrl = yield* credentials.url(none());
+	const credential = yield* credentials.credentialFor(cloudUrl);
+	const cloud = yield* CloudClient.use((factory) => factory.connect({
+		apiKey: credential.secret,
+		url: cloudUrl
+	}));
+	return { current: mapBoth(cloud.bearer, {
+		onFailure: signInFailure,
+		onSuccess: (token) => ({ authorization: `Bearer ${value(token)}` })
+	}) };
+});
+/** How often a call that outlives its token, such as a watch, reads the current headers. */
+const headerCheck = "10 seconds";
+const keyOf = (text) => getOrElse(decodeOption(JsonText)(text), () => text);
+const payloadOf = (text) => transposeOption(map$2(text, (raw) => mapError(decodeEffect(JsonText)(raw), () => usage("--payload is not JSON."))));
+const given = (options, name) => flatten(get(options.values, name));
+const required = (operation, options) => (name) => {
+	if (!contains(operation.fields, name)) return succeed$1("");
+	const value = given(options, name);
+	return mapError(fromOption(value), () => usage(`akter ${join(operation.command, " ")} needs --${name}.`));
+};
+const wholeNumber = (name) => (text) => mapError(decodeEffect(fromJsonString(Int))(text), () => usage(`--${name} must be a whole number.`));
+const fileFieldsOf = (operation, options) => {
+	const taken = (names) => filter(names, (name) => contains(operation.fields, name) && isSome(given(options, name)));
+	const flag = (name) => getOrElse(given(options, name), () => "");
+	const texts = map(taken(textFields), (name) => succeed$1([name, flag(name)]));
+	const numbers = map(taken(numberFields), (name) => map$1(wholeNumber(name)(flag(name)), (value) => [name, value]));
+	return map$1(all([...texts, ...numbers]), fromEntries);
+};
+const unreadable = (message) => () => usage(message);
+const concatBytes = (before, chunk) => {
+	const joined = new Uint8Array(before.length + chunk.length);
+	joined.set(before);
+	joined.set(chunk, before.length);
+	return joined;
+};
+const contentOf = fnUntraced(function* contentOf(raw) {
+	if (raw === fromStdin) {
+		const stdio = yield* Stdio;
+		return yield* runFold(stdio.stdin, () => /* @__PURE__ */ new Uint8Array(), concatBytes).pipe(mapError(unreadable("Could not read --content from stdin.")));
+	}
+	if (startsWith(fromFile)(raw)) {
+		const file = slice(1)(raw);
+		return yield* (yield* FileSystem).readFile(file).pipe(mapError(unreadable(`Could not read --content from ${file}.`)));
+	}
+	return yield* decodeEffect(Base64)(raw).pipe(mapError(unreadable("--content is not base64; pass @<file> or - to read the file's bytes.")));
+});
+const transferOf = fnUntraced(function* transferOf(operation, options) {
+	const fields = yield* fileFieldsOf(operation, options);
+	const flag = yield* required(operation, options)("content");
+	const raw = liftPredicate(flag, () => contains(operation.fields, "content"));
+	return {
+		content: yield* transposeOption(map$2(raw, contentOf)),
+		fields
+	};
+});
+const requestOf = fnUntraced(function* requestOf(operation, options) {
+	const url = yield* appUrl(options.url);
+	const need = required(operation, options);
+	const actor = yield* need("actor");
+	const key = yield* need("key");
+	const member = yield* need("member");
+	const payload = yield* payloadOf(given(options, "payload"));
+	const commandId = given(options, "commandId");
+	const { content, fields } = yield* transferOf(operation, options);
+	return {
+		...yield* actorRequestOf(operation)({
+			actor,
+			commandId,
+			fileFields: fields,
+			into: map$2(given(options, "into"), keyOf),
+			key: keyOf(key),
+			member,
+			payload
+		}),
+		content,
+		operation,
+		options,
+		url
+	};
+});
+const refused = fnUntraced(function* refused({ options, tag }, failure) {
+	const unanswered = unansweredOf(tag)(failure);
+	if (isSome(unanswered)) return yield* unanswered.value;
+	const body = yield* orDie(decodeUnknownEffect(Json)(failure));
+	if (options.json) yield* printJson(true)(body);
+	else yield* flatMap(compactJson(body), (line) => error(`${tag} failed: ${line}`));
+	return yield* RunnerExitedError.make({ code: refusalCode(failure) });
+});
+const printed = (json) => (reply) => printJson(json)(getOrNull(fromUndefinedOr(reply)));
+const unary = fnUntraced(function* unary(request) {
+	const send = yield* unaryClient({
+		kind: request.operation.kind,
+		tag: request.tag
+	});
+	const reply = yield* timeout(send(request.tag, request.payload), callWait);
+	return yield* printed(request.options.json)(reply);
+});
+const downloaded = fnUntraced(function* downloaded(request) {
+	const chunks = (yield* streamClient({
+		kind: "files/download",
+		tag: request.tag
+	}))(request.tag, request.payload);
+	if (request.options.json) return yield* runForEach(chunks, printed(true));
+	const stdout = (yield* Stdio).stdout({ endOnDone: false });
+	return yield* runForEach(chunks, (chunk) => orDie(flatMap(decodeUnknownEffect(Base64)(chunk), (bytes) => run(make$2(bytes), stdout))));
+});
+const uploaded = fnUntraced(function* uploaded(request) {
+	const content = getOrElse(request.content, () => /* @__PURE__ */ new Uint8Array());
+	const receipt = yield* uploadSession({
+		content,
+		request,
+		wait: callWait
+	});
+	return yield* printed(request.options.json)(receipt);
+});
+const streamed = fnUntraced(function* streamed(request) {
+	const updates = (yield* streamClient({
+		kind: request.operation.kind,
+		tag: request.tag
+	}))(request.tag, request.payload);
+	const once = liftPredicate(firstOnly, () => request.operation.kind === "state");
+	const count = orElse(once, () => request.options.count);
+	const limited = match$1(count, {
+		onNone: () => updates,
+		onSome: (most) => take(updates, most)
+	});
+	return yield* runForEach(limited, printed(true));
+});
+const answered = fnUntraced(function* answered(request, headers) {
+	const protocol = yield* build(akterClient({
+		headers,
+		url: request.url.href
+	}));
+	const { kind } = request.operation;
+	if (kind === "files/download" || kind === "files/upload") {
+		const transfer = match(kind === "files/download", {
+			onFalse: () => uploaded(request),
+			onTrue: () => downloaded(request)
+		});
+		return yield* provideContext(transfer, protocol);
+	}
+	if (request.operation.stream) return yield* provideContext(streamed(request), protocol);
+	return yield* provideContext(unary(request), protocol);
+}, scoped, (effect, request) => matchEffect(effect, {
+	onFailure: (failure) => refused(request, failure),
+	onSuccess: succeed$1
+}), (effect, request) => catchDefect(effect, (defect) => fail(rejectedRequest(request.tag)(String(defect)))));
+const sent = fnUntraced(function* sent(request) {
+	const { current } = yield* headersFor(request.url);
+	const first = yield* current;
+	const headers = yield* make(first);
+	const refresh = ignore(flatMap(current, (fresh) => set(headers, fresh)));
+	yield* forkScoped(repeat(refresh, spaced(headerCheck)));
+	return yield* answered(request, () => getUnsafe(headers));
+}, scoped);
+const plan = (request) => printJson(request.options.json)({
+	dryRun: true,
+	operation: request.operation.id,
+	payload: request.payload,
+	tag: request.tag,
+	url: request.url.href
+});
+const callActor = fnUntraced(function* callActor(operation, options) {
+	const request = yield* requestOf(operation, options);
+	if (options.dryRun) return yield* plan(request);
+	return yield* sent(request);
+});
+var ActorCall = class extends Service()("@akterjs/cli/registry/actor-call.service/ActorCall", { make: gen(function* makeActorCall() {
+	const context$1 = yield* context();
+	return { call: (operation, options) => callActor(operation, options).pipe(catchTag("CliExitError", reported(options.json)), provideContext(context$1)) };
+}) }) {
+	static layer = effect(this, this.make);
+};
+export { actorOperations as n, ActorCall as t };