@akterjs/client 0.0.0-stage → 0.1.0

package/dist/actor-rpc.pure.d.mts

@@ -0,0 +1,28 @@
+import { ActorKind, ActorRequest } from "./actor-operations.pure.mjs";
+import { Cause, Duration, Effect, Schema, Scope, Stream } from "effect";
+import { RpcClient } from "effect/rpc";
+interface WireFailure {
+  readonly _tag: string;
+}
+type WireRequest = Readonly<Record<string, Schema.Json>>;
+type WireSend = (tag: string, request: WireRequest) => Effect.Effect<Schema.Json | undefined, WireFailure>;
+type WireWatch = (tag: string, request: WireRequest) => Stream.Stream<Schema.Json, WireFailure>;
+type WireKind = ActorKind | "files/upload/append" | "files/upload/close" | "files/upload/open";
+interface Addressed {
+  readonly kind: WireKind;
+  readonly tag: string;
+}
+declare function unaryClient(addressed: Addressed): Effect.Effect<WireSend, never, RpcClient.Protocol | Scope.Scope>;
+declare function streamClient(addressed: Addressed): Effect.Effect<WireWatch, never, RpcClient.Protocol | Scope.Scope>;
+declare const uploadChunkBytes = 1048576;
+type Transferring = RpcClient.Protocol | Scope.Scope;
+type TransferFailure = Cause.TimeoutError | WireFailure;
+interface Transfer {
+  readonly request: ActorRequest;
+  readonly wait: Duration.Input;
+}
+declare const uploadSession: (upload: Transfer & {
+  readonly content: Uint8Array;
+}) => Effect.Effect<Schema.Json | undefined, TransferFailure, Transferring>;
+declare const downloadChunks: ({ request, wait }: Transfer) => Effect.Effect<readonly Schema.Json[], TransferFailure, Transferring>;
+export { type Transfer, type TransferFailure, type WireFailure, type WireKind, type WireRequest, downloadChunks, streamClient, unaryClient, uploadChunkBytes, uploadSession };

package/dist/actor-rpc.pure.mjs

@@ -0,0 +1,154 @@
+import { Array, Effect, Schema, Stream } from "effect";
+import { Rpc, RpcClient, RpcGroup } from "effect/rpc";
+// src/actor-rpc.pure.ts
+const commandFields = {
+	commandId: Schema.String,
+	key: Schema.Json,
+	payload: Schema.Json
+};
+const queryFields = {
+	key: Schema.Json,
+	payload: Schema.Json
+};
+const keyFields = { key: Schema.Json };
+const computerFields = {
+	computer: Schema.Json,
+	key: Schema.Json
+};
+const listFields = {
+	cursor: Schema.optionalKey(Schema.Json),
+	key: Schema.Json,
+	limit: Schema.optionalKey(Schema.Json),
+	prefix: Schema.optionalKey(Schema.Json)
+};
+const fieldsOf = {
+	call: commandFields,
+	"computers/cp": {
+		...computerFields,
+		computerPath: Schema.Json,
+		direction: Schema.Json,
+		path: Schema.Json
+	},
+	"computers/delete": computerFields,
+	"computers/get": computerFields,
+	"computers/list": keyFields,
+	"computers/logs": {
+		...computerFields,
+		after: Schema.optionalKey(Schema.Json),
+		limit: Schema.optionalKey(Schema.Json)
+	},
+	"computers/pause": computerFields,
+	"computers/resume": computerFields,
+	"computers/stop": computerFields,
+	create: commandFields,
+	ensure: commandFields,
+	"files/download": {
+		key: Schema.Json,
+		length: Schema.optionalKey(Schema.Json),
+		offset: Schema.optionalKey(Schema.Json),
+		path: Schema.Json
+	},
+	"files/list": listFields,
+	"files/upload": keyFields,
+	"files/upload/append": {
+		bytes: Schema.Json,
+		key: Schema.Json,
+		offset: Schema.Json,
+		upload: Schema.Json
+	},
+	"files/upload/close": {
+		bytes: Schema.Json,
+		key: Schema.Json,
+		upload: Schema.Json
+	},
+	"files/upload/open": keyFields,
+	"files/usage": listFields,
+	fork: {
+		commandId: Schema.String,
+		into: Schema.Json,
+		key: Schema.Json
+	},
+	query: queryFields,
+	state: keyFields,
+	"steps/get": {
+		key: Schema.Json,
+		step: Schema.Json
+	},
+	"steps/list": {
+		key: Schema.Json,
+		limit: Schema.optionalKey(Schema.Json)
+	},
+	warm: keyFields,
+	watch: queryFields
+};
+function unaryClient({ kind, tag }) {
+	const rpc = Rpc.make(tag, {
+		error: Schema.Json,
+		payload: Schema.Struct(fieldsOf[kind]),
+		success: Schema.UndefinedOr(Schema.Json)
+	});
+	return RpcClient.make(RpcGroup.make(rpc), { flatten: true });
+}
+function streamClient({ kind, tag }) {
+	const rpc = Rpc.make(tag, {
+		error: Schema.Json,
+		payload: Schema.Struct(fieldsOf[kind]),
+		stream: true,
+		success: Schema.Json
+	});
+	return RpcClient.make(RpcGroup.make(rpc), { flatten: true });
+}
+const uploadChunkBytes = 1048576;
+const Base64 = Schema.Uint8ArrayFromBase64;
+const Opened = Schema.Struct({ upload: Schema.String });
+const appended = Effect.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 = Array.makeBy(count, (index) => ({
+		bytes: content.subarray(index * uploadChunkBytes, index * uploadChunkBytes + uploadChunkBytes),
+		offset: index * uploadChunkBytes
+	}));
+	yield* Effect.forEach(chunks, ({ bytes, offset }) => Effect.flatMap(Effect.orDie(Schema.encodeEffect(Base64)(bytes)), (encoded) => Effect.timeout(append(tag, {
+		...request.payload,
+		bytes: encoded,
+		offset,
+		upload
+	}), wait)));
+});
+const uploadSession = (upload) => Effect.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* Effect.timeout(open(`${request.tag}/open`, request.payload), wait);
+	const session = yield* Effect.orDie(Schema.decodeUnknownEffect(Opened)(opened));
+	yield* appended({
+		content,
+		request,
+		upload: session.upload,
+		wait
+	});
+	const closing = {
+		...request.payload,
+		bytes: content.length,
+		upload: session.upload
+	};
+	return yield* Effect.timeout(close(`${request.tag}/close`, closing), wait);
+});
+const downloadChunks = ({ request, wait }) => Effect.gen(function* collectDownload() {
+	const download = yield* streamClient({
+		kind: "files/download",
+		tag: request.tag
+	});
+	return yield* Effect.timeout(Stream.runCollect(download(request.tag, request.payload)), wait);
+});
+export { downloadChunks, streamClient, unaryClient, uploadChunkBytes, uploadSession };

package/dist/akter-client.layer.d.mts

@@ -0,0 +1,13 @@
+import { Layer } from "effect";
+import { RpcClient } from "effect/rpc";
+import { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, CallerNotAllowedError, CommandIdExpiredError, HandlerFailedError, InvalidRequestError, SpendCapReachedError, StorageLimitError, UnauthenticatedError } from "@akterjs/effect/contract/errors";
+import { ActorClients } from "@akterjs/effect/contract/actor-client";
+import { ActorFileClients } from "@akterjs/effect/contract/file-clients";
+interface AkterClientOptions {
+  readonly fetch?: typeof globalThis.fetch;
+  readonly headers?: () => Readonly<Record<string, string>>;
+  readonly url: string;
+  readonly webSocket?: typeof globalThis.WebSocket;
+}
+export declare const akterClient: ({ fetch, headers, url, webSocket }: AkterClientOptions) => Layer.Layer<ActorClients | ActorFileClients | RpcClient.Protocol>;
+export { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, type AkterClientOptions, BillingUnavailableError, CallerNotAllowedError, CommandIdExpiredError, HandlerFailedError, InvalidRequestError, SpendCapReachedError, StorageLimitError, UnauthenticatedError };

package/dist/akter-client.layer.mjs

@@ -0,0 +1,27 @@
+import { actorProtocol } from "./actor-protocol.layer.mjs";
+import { Effect, Layer } from "effect";
+import { SecureRandom } from "effect/crypto";
+import { RpcClient, RpcSerialization } from "effect/rpc";
+import { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, CallerNotAllowedError, CommandIdExpiredError, HandlerFailedError, InvalidRequestError, SpendCapReachedError, StorageLimitError, UnauthenticatedError } from "@akterjs/effect/contract/errors";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+import { ActorClients } from "@akterjs/effect/contract/actor-client";
+import { rpcFileClients } from "@akterjs/effect/contract/file-clients";
+// src/akter-client.layer.ts
+const noHeaders = () => ({});
+const rpcPath = "/rpc";
+const akterClient = ({ fetch = globalThis.fetch, headers = noHeaders, url, webSocket = globalThis.WebSocket }) => {
+	const rpcUrl = new globalThis.URL(rpcPath, url).href;
+	const httpClient = Layer.effect(HttpClient.HttpClient, Effect.gen(function* withHeaders() {
+		const client = yield* HttpClient.HttpClient;
+		return HttpClient.mapRequest(client, (request) => HttpClientRequest.setHeaders(HttpClientRequest.prependUrl(request, rpcUrl), headers()));
+	})).pipe(Layer.provide(FetchHttpClient.layer), Layer.provide(Layer.succeed(FetchHttpClient.Fetch)(fetch)));
+	const protocol = Layer.effect(RpcClient.Protocol, Effect.flatMap(HttpClient.HttpClient, (http) => actorProtocol({
+		headers,
+		http,
+		url: rpcUrl,
+		webSocket
+	}))).pipe(Layer.provide([httpClient, RpcSerialization.layerNdjson]));
+	const clients = Layer.merge(ActorClients.layer.pipe(Layer.provide(SecureRandom.layerWebCrypto)), rpcFileClients);
+	return Layer.provideMerge(clients, protocol);
+};
+export { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, CallerNotAllowedError, CommandIdExpiredError, HandlerFailedError, InvalidRequestError, SpendCapReachedError, StorageLimitError, UnauthenticatedError, akterClient };

package/dist/promise-client.adapter.d.mts

@@ -0,0 +1,55 @@
+import { AkterClientOptions } from "./akter-client.layer.mjs";
+import { FileListing, FilePage, FileRange, FileRef, FileUsage, PromiseFiles } from "./promise-files.pure.mjs";
+import { UploadSourceError } from "./upload-source.errors.mjs";
+import { Effect, Option, Schema, Scope, Stream } from "effect";
+import { RpcClient } from "effect/rpc";
+import { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, BlobTransferError, CallerNotAllowedError, CommandIdExpiredError, FileAccessDeniedError, FileNotFoundError, FileTooLargeError, FilesUnavailableError, HandlerFailedError, InvalidFileRequestError, InvalidRequestError, SpendCapReachedError, StorageLimitError, UnauthenticatedError } from "@akterjs/effect/contract/errors";
+import { ActorClients } from "@akterjs/effect/contract/actor-client";
+import { FileClient } from "@akterjs/effect/contract";
+type ClientServices = ActorClients | RpcClient.Protocol | Scope.Scope;
+interface ClientActor {
+  readonly client: (key: never) => Effect.Effect<object, never, ClientServices>;
+  readonly fileAccess: Option.Option<unknown>;
+  readonly files: (key: never) => Effect.Effect<FileClient, Error>;
+  readonly key: Schema.Top & {
+    readonly DecodingServices: never;
+    readonly Encoded: string;
+  };
+  readonly name: string;
+  readonly queries: Readonly<Record<string, {
+    readonly payload: Schema.Top;
+  }>>;
+}
+type EffectClientOf<Actor extends ClientActor> = Effect.Success<ReturnType<Actor["client"]>>;
+type Stop = () => void;
+type OnError = (error: Error) => void;
+type PromiseCall<Call> = Call extends ((payload: infer Payload) => Effect.Effect<infer Success, infer _Failure>) ? (payload: Payload) => Promise<Success> : never;
+/** A query declared without a payload subscribes as `subscribe(onUpdate, onError?)`; one with a payload takes it first. */
+type PromiseSubscribe<Call> = Call extends {
+  readonly subscribe: (payload: infer Payload) => Stream.Stream<infer Update, infer _Failure>;
+} ? undefined extends Payload ? {
+  readonly subscribe: (onUpdate: (update: Update) => void, onError?: OnError) => Stop;
+} : {
+  readonly subscribe: (payload: Payload, onUpdate: (update: Update) => void, onError?: OnError) => Stop;
+} : unknown;
+type PromiseState<Updates> = Updates extends Stream.Stream<infer Update, infer _Failure> ? {
+  readonly subscribe: (onUpdate: (update: Update) => void, onError?: OnError) => Stop;
+} : never;
+/** An actor's files, when its contract declares file calls (`files: Akter.fileAccess(...)`); otherwise none. */
+type PromiseFilesOf<Actor extends ClientActor> = Actor["fileAccess"] extends Option.None<unknown> ? unknown : {
+  readonly files: PromiseFiles;
+};
+type PromiseActor<Actor extends ClientActor> = { readonly [Member in Exclude<keyof EffectClientOf<Actor>, "files" | "fork" | "state" | "warm">]: PromiseCall<EffectClientOf<Actor>[Member]> & PromiseSubscribe<EffectClientOf<Actor>[Member]>; } & PromiseFilesOf<Actor> & {
+  /** Forks this actor into a new one at `into` and answers the copy's client (ADR 0017). */
+  readonly fork: (into: Actor["key"]["Encoded"]) => Promise<PromiseActor<Actor>>;
+  readonly state: PromiseState<EffectClientOf<Actor>["state" & keyof EffectClientOf<Actor>]>;
+  readonly warm: () => Promise<void>;
+};
+type PromiseClient<Actors extends readonly ClientActor[]> = { readonly [Actor in Actors[number] as Actor["name"]]: (key: Actor["key"]["Encoded"]) => PromiseActor<Actor>; } & {
+  readonly close: () => Promise<void>;
+};
+interface PromiseClientOptions<Actors extends readonly ClientActor[]> extends AkterClientOptions {
+  readonly actors: Actors;
+}
+declare function createClient<const Actors extends readonly ClientActor[]>(options: PromiseClientOptions<Actors>): PromiseClient<Actors>;
+export { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, BlobTransferError, CallerNotAllowedError, CommandIdExpiredError, FileAccessDeniedError, type FileListing, FileNotFoundError, type FilePage, type FileRange, type FileRef, FileTooLargeError, type FileUsage, FilesUnavailableError, HandlerFailedError, InvalidFileRequestError, InvalidRequestError, type PromiseActor, type PromiseClient, type PromiseClientOptions, type PromiseFiles, SpendCapReachedError, StorageLimitError, UnauthenticatedError, UploadSourceError, createClient };

package/dist/promise-client.adapter.mjs

@@ -0,0 +1,114 @@
+import { akterClient } from "./akter-client.layer.mjs";
+import { promiseFiles } from "./promise-files.pure.mjs";
+import { UploadSourceError } from "./upload-source.errors.mjs";
+import { Array, Effect, Fiber, ManagedRuntime, Option, Record, Schema, Stream } from "effect";
+import { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, BlobTransferError, CallerNotAllowedError, CommandIdExpiredError, FileAccessDeniedError, FileNotFoundError, FileTooLargeError, FilesUnavailableError, HandlerFailedError, InvalidFileRequestError, InvalidRequestError, SpendCapReachedError, StorageLimitError, UnauthenticatedError } from "@akterjs/effect/contract/errors";
+// src/promise-client.adapter.ts
+const filesMember = "files";
+const stateMember = "state";
+const warmMember = "warm";
+const forkMember = "fork";
+const thenMember = "then";
+function wireActor(actor) {
+	return actor;
+}
+function asCall(member) {
+	return member;
+}
+function asWarm(member) {
+	return member;
+}
+function asFork(member) {
+	return member;
+}
+function asUpdates(member) {
+	return member;
+}
+const listen = (runtime, { onError, onUpdate, updates }) => {
+	const delivered = Stream.runForEach(updates, (update) => Effect.sync(() => {
+		onUpdate(update);
+	}));
+	const reported = Effect.matchEffect(delivered, {
+		onFailure: (error) => Effect.sync(() => {
+			onError?.(error);
+		}),
+		onSuccess: () => Effect.void
+	});
+	const fiber = runtime.runFork(reported);
+	return () => {
+		runtime.runFork(Fiber.interrupt(fiber));
+	};
+};
+const listenTo = (runtime, updates) => (onUpdate, onError) => listen(runtime, {
+	onError,
+	onUpdate,
+	updates: Stream.unwrap(updates)
+});
+const memberOf = (actor, key, member) => Effect.gen(function* findMember() {
+	const decoded = yield* Schema.decodeEffect(actor.key)(key);
+	const client = yield* actor.client(decoded);
+	return yield* Option.match(Record.get(client, member), {
+		onNone: () => Effect.die(`${actor.name} has no member ${member}`),
+		onSome: Effect.succeed
+	});
+});
+const callOf = ({ actor, key, runtime }) => (member) => {
+	const found = memberOf(actor, key, member);
+	const call = (payload) => runtime.runPromise(Effect.scoped(Effect.flatMap(found, (send) => asCall(send)(payload))));
+	if (Option.exists(Record.get(actor.queries, member), (query) => query.payload === Schema.Void)) return Object.assign(call, { subscribe: listenTo(runtime, Effect.map(found, (query) => asCall(query).subscribe())) });
+	const withPayload = (payload, onUpdate, onError) => listenTo(runtime, Effect.map(found, (query) => asCall(query).subscribe(payload)))(onUpdate, onError);
+	return Object.assign(call, { subscribe: withPayload });
+};
+const forkOf = ({ actor, key, open, runtime }) => (into) => {
+	const forked = Effect.gen(function* forkActor() {
+		yield* (yield* Effect.map(memberOf(actor, key, forkMember), asFork))(yield* Schema.decodeEffect(actor.key)(into));
+	});
+	return runtime.runPromise(Effect.as(Effect.scoped(forked), open(into)));
+};
+const stateOf = ({ actor, key, runtime }) => ({ subscribe: (onUpdate, onError) => {
+	const updates = Stream.unwrap(Effect.map(memberOf(actor, key, stateMember), asUpdates));
+	return listen(runtime, {
+		onError,
+		onUpdate,
+		updates
+	});
+} });
+const warmOf = ({ actor, key, runtime }) => {
+	const warmed = Effect.flatMap(memberOf(actor, key, warmMember), (warm) => Effect.asVoid(asWarm(warm)));
+	return () => runtime.runPromise(Effect.scoped(warmed));
+};
+const filesOf = ({ actor, key, runtime }) => {
+	const connected = Effect.flatMap(Schema.decodeEffect(actor.key)(key), actor.files);
+	return promiseFiles({
+		connected,
+		run: (effect) => runtime.runPromise(effect)
+	});
+};
+const actionMember = (handle, member) => {
+	if (member === forkMember) return forkOf(handle);
+	if (member === warmMember) return warmOf(handle);
+	return callOf(handle)(member);
+};
+const handleMember = (handle, member) => {
+	if (member === thenMember) return Option.getOrUndefined(Option.none());
+	if (member === stateMember) return stateOf(handle);
+	if (member === filesMember) return Option.getOrUndefined(Option.map(handle.actor.fileAccess, () => filesOf(handle)));
+	return actionMember(handle, member);
+};
+const handleOf = (runtime, actor) => (key) => {
+	const handle = {
+		actor,
+		key,
+		open: handleOf(runtime, actor),
+		runtime
+	};
+	return new Proxy({}, { get: (_target, property) => handleMember(handle, String(property)) });
+};
+function createClient({ actors, ...connection }) {
+	const runtime = ManagedRuntime.make(akterClient(connection));
+	return {
+		...Record.fromEntries(Array.map(actors, (actor) => [actor.name, handleOf(runtime, wireActor(actor))])),
+		close: () => runtime.dispose()
+	};
+}
+export { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, BlobTransferError, CallerNotAllowedError, CommandIdExpiredError, FileAccessDeniedError, FileNotFoundError, FileTooLargeError, FilesUnavailableError, HandlerFailedError, InvalidFileRequestError, InvalidRequestError, SpendCapReachedError, StorageLimitError, UnauthenticatedError, UploadSourceError, createClient };

package/dist/promise-files.pure.d.mts

@@ -0,0 +1,48 @@
+import { Effect } from "effect";
+import { FileClient } from "@akterjs/effect/contract";
+/** One file an actor holds. */
+interface FileRef {
+  readonly bytes: number;
+  readonly path: string;
+  readonly sha256: string;
+  readonly writtenAt: number;
+}
+/** Which files to list: those under `prefix`, at most `limit`, after the `cursor` a previous page returned. */
+interface FileListing {
+  readonly cursor?: string | undefined;
+  readonly limit?: number | undefined;
+  readonly prefix?: string | undefined;
+}
+/** A byte range of one file. */
+interface FileRange {
+  readonly length: number;
+  readonly offset: number;
+}
+/** One page of files; `cursor` is present when there are more. */
+interface FilePage {
+  readonly cursor?: string;
+  readonly entries: readonly FileRef[];
+}
+/** One page of files and the total bytes every file the listing matches holds. */
+interface FileUsage extends FilePage {
+  readonly bytes: number;
+}
+/**
+ * An actor's files over its `<Actor>/files/*` RPCs (ADR 0016). `upload` returns the receipt a command attaches the file
+ * with; the others read what the actor holds. Each rejects with the hosted error classes the Effect client fails with.
+ */
+interface PromiseFiles {
+  readonly download: (path: string, range?: FileRange) => Promise<ReadableStream<Uint8Array>>;
+  readonly list: (listing?: FileListing) => Promise<FilePage>;
+  readonly upload: (body: ReadableStream<Uint8Array> | Uint8Array) => Promise<string>;
+  readonly usage: (listing?: FileListing) => Promise<FileUsage>;
+}
+interface Filing {
+  /** Connects to one actor's files. */
+  readonly connected: Effect.Effect<FileClient, Error>;
+  /** Runs an effect on the client's runtime. */
+  readonly run: <Success>(effect: Effect.Effect<Success, Error>) => Promise<Success>;
+}
+/** The Promise face of one actor's file client. */
+declare const promiseFiles: ({ connected, run }: Filing) => PromiseFiles;
+export { type FileListing, type FilePage, type FileRange, type FileRef, type FileUsage, type PromiseFiles, promiseFiles };

package/dist/promise-files.pure.mjs

@@ -0,0 +1,35 @@
+import { UploadSourceError } from "./upload-source.errors.mjs";
+import { Effect, Option, Predicate, Record, Stream } from "effect";
+// src/promise-files.pure.ts
+const pageOf = ({ cursor, entries }) => Option.match(cursor, {
+	onNone: () => ({ entries }),
+	onSome: (next) => ({
+		cursor: next,
+		entries
+	})
+});
+const listingOf = ({ cursor, limit, prefix } = {}) => ({
+	...Record.getSomes({
+		cursor: Option.fromUndefinedOr(cursor),
+		prefix: Option.fromUndefinedOr(prefix)
+	}),
+	...Record.getSomes({ limit: Option.fromUndefinedOr(limit) })
+});
+const sourceOf = (body) => {
+	if (Predicate.isUint8Array(body)) return Stream.make(body);
+	return Stream.fromReadableStream({
+		evaluate: () => body,
+		onError: (cause) => UploadSourceError.make({ message: `the upload's source stream failed: ${String(cause)}` })
+	});
+};
+/** The Promise face of one actor's file client. */
+const promiseFiles = ({ connected, run }) => ({
+	download: (path, range) => run(Effect.map(connected, (files) => Stream.toReadableStream(files.download(path, range)))),
+	list: (listing) => run(Effect.map(Effect.flatMap(connected, (files) => files.list(listingOf(listing))), pageOf)),
+	upload: (body) => run(Effect.flatMap(connected, (files) => files.upload(sourceOf(body)))),
+	usage: (listing) => run(Effect.map(Effect.flatMap(connected, (files) => files.fileUsage(listingOf(listing))), (usage) => ({
+		...pageOf(usage),
+		bytes: Number(usage.bytes)
+	})))
+});
+export { promiseFiles };

package/dist/read-floors.pure.d.mts

@@ -0,0 +1,7 @@
+import { RpcMessage } from "effect/rpc";
+interface ReadFloors {
+  readonly received: (clientId: number, response: RpcMessage.FromServerEncoded) => void;
+  readonly sent: (clientId: number, message: RpcMessage.FromClientEncoded) => RpcMessage.FromClientEncoded;
+}
+declare const trackedFloors: () => ReadFloors;
+export { type ReadFloors, trackedFloors };

package/dist/read-floors.pure.mjs

@@ -0,0 +1,49 @@
+import { Array, Option, Predicate, Schema, String as String$1 } from "effect";
+// src/read-floors.pure.ts
+const floorHeader = "akter-floor";
+const Keyed = Schema.Struct({ key: Schema.Unknown });
+const Versioned = Schema.Struct({
+	requestId: Schema.Union([Schema.String, Schema.Finite]),
+	version: Schema.Int
+});
+const KeyText = Schema.fromJsonString(Schema.Unknown);
+const keyedOf = Schema.decodeUnknownOption(Keyed);
+const versionedOf = Schema.decodeUnknownOption(Versioned);
+const keyTextOf = Schema.encodeUnknownOption(KeyText);
+const actorKeyOf = ({ payload, tag }) => Option.flatMap(keyedOf(payload), ({ key }) => Option.map(keyTextOf(key), (keyText) => `${Option.getOrElse(Array.head(String$1.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) => Option.match(actorKeyOf(request), {
+		onNone: () => request,
+		onSome: (actorKey) => {
+			pending.set(pendingOf(clientId, request.id), actorKey);
+			return Option.match(Option.fromNullishOr(floors.get(actorKey)), {
+				onNone: () => request,
+				onSome: (floor) => ({
+					...request,
+					headers: [...request.headers, [floorHeader, String(floor)]]
+				})
+			});
+		}
+	});
+	const sent = (clientId, message) => {
+		if (Predicate.isTagged(message, "Request")) return floored(clientId, message);
+		return message;
+	};
+	const received = (clientId, response) => {
+		if (!Predicate.isTagged(response, "Exit")) return;
+		const id = pendingOf(clientId, response.requestId);
+		const actorKey = pending.get(id);
+		pending.delete(id);
+		Option.map(Option.all([Option.fromNullishOr(actorKey), versionedOf(response)]), ([key, { version }]) => {
+			floors.set(key, Math.max(version, floors.get(key) ?? version));
+		});
+	};
+	return {
+		received,
+		sent
+	};
+};
+export { trackedFloors };

package/dist/remote-interrupt.pure.d.mts

@@ -0,0 +1,13 @@
+import { RpcMessage } from "effect/rpc";
+/**
+ * What a server's answers become before they reach a caller: an `Exit` whose cause is only interrupts says the server
+ * stopped the request without an answer. Left alone, the caller's fiber ends interrupted with no message, and a CLI
+ * built on Effect's `runMain` exits 130 and prints nothing. This answers it as `ActorUnavailableError` for the request's
+ * actor instead, a typed error every call can fail with, which says to retry.
+ */
+interface RemoteInterrupts {
+  readonly received: (clientId: number, response: RpcMessage.FromServerEncoded) => RpcMessage.FromServerEncoded;
+  readonly sent: (clientId: number, message: RpcMessage.FromClientEncoded) => void;
+}
+declare const remoteInterrupts: () => RemoteInterrupts;
+export { type RemoteInterrupts, remoteInterrupts };

package/dist/remote-interrupt.pure.mjs

@@ -0,0 +1,45 @@
+import { Array, Option, Predicate, Schema, String } from "effect";
+import { ActorUnavailableError } from "@akterjs/effect/contract/errors";
+// src/remote-interrupt.pure.ts
+const InterruptReasons = Schema.NonEmptyArray(Schema.TaggedStruct("Interrupt", {}));
+const InterruptedOnly = Schema.Struct({ exit: Schema.TaggedStruct("Failure", { cause: InterruptReasons }) });
+const UnavailableWire = Schema.toEncoded(ActorUnavailableError);
+const FailReason = Schema.TaggedStruct("Fail", { error: UnavailableWire });
+/** An encoded exit that failed with one error, as Effect RPC writes it. */
+const FailedExit = Schema.TaggedStruct("Failure", { cause: Schema.Tuple([FailReason]) });
+const isInterruptedOnly = Schema.is(InterruptedOnly);
+const encodeUnavailable = Schema.encodeOption(ActorUnavailableError);
+const message = "the server stopped this request before it answered. Retry shortly.";
+const requestOf = (clientId, requestId) => `${clientId}/${requestId}`;
+/** `Room/files/list` and `Room/post` are both Room's. */
+const actorOf = (tag) => Option.getOrElse(Array.head(String.split(tag, "/")), () => tag);
+const failedWith = (error) => FailedExit.make({ cause: [FailReason.make({ error })] });
+const answered = (actor, response) => Option.match(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 (Predicate.isTagged(outgoing, "Request")) actors.set(requestOf(clientId, outgoing.id), actorOf(outgoing.tag));
+	};
+	const received = (clientId, response) => {
+		if (!Predicate.isTagged(response, "Exit")) return response;
+		const id = requestOf(clientId, response.requestId);
+		const actor = Option.fromNullishOr(actors.get(id));
+		actors.delete(id);
+		if (Option.isNone(actor) || !isInterruptedOnly(response)) return response;
+		return answered(actor.value, response);
+	};
+	return {
+		received,
+		sent
+	};
+};
+export { remoteInterrupts };

package/dist/upload-source.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const UploadSourceError_base: Schema.Class<UploadSourceError, Schema.TaggedStruct<"UploadSourceError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The upload's source stream failed before the upload finished. */
+declare class UploadSourceError extends UploadSourceError_base {}
+export { UploadSourceError };

package/dist/upload-source.errors.mjs

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+// src/upload-source.errors.ts
+/** The upload's source stream failed before the upload finished. */
+var UploadSourceError = class extends Schema.TaggedError()("UploadSourceError", { message: Schema.String }) {};
+export { UploadSourceError };