@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/serve/rpc/actor-rpc.handlers.mjs

@@ -0,0 +1,142 @@
+import { creationModesOf } from "../../contract/client/actor-rpc.contract.mjs";
+import { admit, clientPrincipal, operatorKinds } from "../../contract/caller/caller-admission.pure.mjs";
+import { CurrentCaller } from "../../contract/caller/current-caller.service.mjs";
+import { exitCodec, jsonCodec } from "../../contract/json-codec.pure.mjs";
+import { ActorHost } from "../engine/actor-host.service.mjs";
+import { stateUpdates } from "../engine/actor-state.pure.mjs";
+import { Array, Effect, Option, Record, Schema, Stream } from "effect";
+// src/serve/rpc/actor-rpc.handlers.ts
+function wireExit(declaration) {
+	return exitCodec(declaration);
+}
+function wireJson(declaration) {
+	return jsonCodec(declaration.payload);
+}
+function wireKey(key) {
+	return key;
+}
+const addressOf = Effect.fnUntraced(function* addressOf(actor, request) {
+	const caller = yield* CurrentCaller;
+	const principal = yield* clientPrincipal({
+		actor: actor.name,
+		caller
+	});
+	const key = yield* Effect.orDie(Schema.encodeEffect(wireKey(actor.key))(request.key));
+	return {
+		actor: actor.name,
+		key,
+		principal
+	};
+});
+const callOf = Effect.fnUntraced(function* callOf({ actor, declaration, member }, request) {
+	const address = yield* addressOf(actor, request);
+	const payload = yield* Effect.orDie(Schema.encodeEffect(wireJson(declaration))(request.payload));
+	return {
+		...address,
+		member,
+		payload
+	};
+});
+const replyOf = (declaration, reply) => {
+	const exit = Effect.orDie(Schema.decodeEffect(wireExit(declaration))(reply));
+	return Effect.flatten(exit);
+};
+const commandHandler = (target, run) => (request) => Effect.gen(function* handleCommand() {
+	const reply = yield* run({
+		...yield* callOf(target, request),
+		commandId: request.commandId
+	});
+	return yield* replyOf(target.declaration, reply);
+});
+const creationOf = (create) => ({
+	callers: Option.none(),
+	error: Schema.Never,
+	payload: create,
+	success: Schema.Void
+});
+const createHandler = (actor, host, mode) => commandHandler({
+	actor,
+	declaration: creationOf(actor.create),
+	host,
+	member: mode
+}, (call) => host.create({
+	...call,
+	mode
+}));
+const queryHandler = (target) => (request) => Effect.gen(function* handleQuery() {
+	const call = yield* callOf(target, request);
+	const reply = yield* target.host.query(call);
+	return yield* replyOf(target.declaration, reply);
+});
+const subscribeHandler = (target) => (request) => Stream.unwrap(Effect.map(callOf(target, request), (call) => Stream.mapEffect(target.host.subscribe(call), ({ value, version }) => Effect.map(replyOf(target.declaration, value), (decoded) => ({
+	value: decoded,
+	version
+})))));
+const stateHandler = (actor, host) => (request) => Stream.unwrap(Effect.map(addressOf(actor, request), ({ key, principal }) => stateUpdates({
+	actor,
+	principal,
+	updates: host.state({
+		actor: actor.name,
+		key
+	})
+})));
+const warmHandler = (actor, host) => (request) => Effect.flatMap(addressOf(actor, request), ({ key }) => host.warm({
+	actor: actor.name,
+	key
+}));
+const forkMember = "fork";
+/**
+* Forks the actor at `key` into `into`. Only the operator kinds (`user` and `apiKey`) the actor declares may fork,
+* since the copy holds everything the actor holds and a fork runs no handler that could check the caller.
+*/
+const forkHandler = (actor, host) => (request) => Effect.gen(function* handleFork() {
+	const { key, principal } = yield* addressOf(actor, request);
+	const admission = {
+		actor: actor.name,
+		allowed: Option.some(operatorKinds),
+		callers: actor.callers,
+		member: forkMember
+	};
+	yield* admit({
+		...admission,
+		principal
+	});
+	const into = yield* Effect.orDie(Schema.encodeEffect(wireKey(actor.key))(request.into));
+	return { version: yield* host.fork({
+		actor: actor.name,
+		commandId: request.commandId,
+		into,
+		key
+	}) };
+});
+function handlersOf({ actors, host }) {
+	return Record.fromEntries(Array.flatMap(actors, (actor) => [
+		...Array.map(Record.toEntries(actor.commands), ([member, declaration]) => [`${actor.name}/${member}`, commandHandler({
+			actor,
+			declaration,
+			host,
+			member
+		}, host.command)]),
+		...Array.map(Record.toEntries(actor.queries), ([member, declaration]) => [`${actor.name}/${member}`, queryHandler({
+			actor,
+			declaration,
+			host,
+			member
+		})]),
+		...Array.map(Record.toEntries(actor.queries), ([member, declaration]) => [`${actor.name}/${member}/subscribe`, subscribeHandler({
+			actor,
+			declaration,
+			host,
+			member
+		})]),
+		...Array.map(creationModesOf(actor.create), (mode) => [`${actor.name}/${mode}`, createHandler(actor, host, mode)]),
+		[`${actor.name}/warm`, warmHandler(actor, host)],
+		[`${actor.name}/state/subscribe`, stateHandler(actor, host)],
+		[`${actor.name}/fork`, forkHandler(actor, host)]
+	]));
+}
+const actorRpcHandlers = (actors) => ActorHost.use((host) => Effect.succeed(handlersOf({
+	actors,
+	host
+})));
+export { actorRpcHandlers };

package/dist/serve/rpc/akter-server.layer.d.mts

@@ -0,0 +1,18 @@
+import { ActorHost } from "../engine/actor-host.service.mjs";
+import "./served-rpc.layer.mjs";
+import { ActorsNotHostedError } from "../engine/actors-not-hosted.errors.mjs";
+import { ServedActor } from "./actor-rpc.handlers.mjs";
+import { ListenerNotLoopbackError } from "./listener-not-loopback.errors.mjs";
+import { Effect, Layer } from "effect";
+import { HttpRouter, HttpServer } from "effect/http";
+interface ServeOptions<Actors extends readonly ServedActor[]> {
+  readonly actors: Actors;
+  readonly allowedHosts?: readonly string[] | true;
+  readonly hostname?: string;
+  readonly port?: number;
+  readonly unsafeExposeDevelopmentAuth?: boolean;
+}
+declare const rpcPath = "/rpc";
+declare const rpcRoutes: (actors: readonly ServedActor[]) => Effect.Effect<Layer.Layer<never, never, ActorHost | HttpRouter.HttpRouter>, ActorsNotHostedError>;
+declare const serve: (options: ServeOptions<readonly ServedActor[]>) => Layer.Layer<never, ActorsNotHostedError | ListenerNotLoopbackError, ActorHost | HttpServer.HttpServer>;
+export { type ServeOptions, type ServedActor, rpcPath, rpcRoutes, serve };

package/dist/serve/rpc/akter-server.layer.mjs

@@ -0,0 +1,61 @@
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { servedRpcHandlers } from "./served-rpc.layer.mjs";
+import { ActorsNotHostedError } from "../engine/actors-not-hosted.errors.mjs";
+import { DevelopmentAuthentication } from "./development-authentication.handlers.mjs";
+import { ListenerNotLoopbackError } from "./listener-not-loopback.errors.mjs";
+import { developmentGuard } from "./development-guard.pure.mjs";
+import { Array, Effect, Exit, Layer, Option } from "effect";
+import { RpcGroup, RpcSerialization, RpcServer } from "effect/rpc";
+import { HttpRouter, HttpServer } from "effect/http";
+// src/serve/rpc/akter-server.layer.ts
+const rpcPath = "/rpc";
+const loopbackAddress = /^http:\/\/(?:127(?:\.\d{1,3}){3}|\[::1\]|\[::ffff:(?:127(?:\.\d{1,3}){3}|7f[\da-f]{2}:[\da-f]{1,4})\]):\d+$/iu;
+const formatted = Option.liftThrowable(HttpServer.formatAddress);
+const loopbackOnly = (options) => HttpServer.HttpServer.use((server) => {
+	const address = formatted(server.address);
+	if (options.unsafeExposeDevelopmentAuth === true || Option.exists(address, (shown) => loopbackAddress.test(shown))) return Effect.void;
+	const shown = Option.getOrElse(address, () => "an address it can't format");
+	return Effect.fail(ListenerNotLoopbackError.make({
+		address: shown,
+		message: `the listener is on ${shown}, which isn't loopback; development authentication lets any caller pick its principal, so it only serves on 127.0.0.0/8, ::1 or ::ffff:127.0.0.1. Set unsafeExposeDevelopmentAuth to serve it on this address`
+	}));
+});
+const unhosted = Effect.fnUntraced(function* unhosted(actors) {
+	const registry = yield* Effect.serviceOption(ActorRegistry);
+	if (Option.isNone(registry)) return [];
+	const lookups = yield* Effect.forEach(actors, (actor) => Effect.exit(registry.value.lookup(actor.name)));
+	return Array.map(Array.filter(Array.zip(actors, lookups), ([, lookup]) => Exit.isFailure(lookup)), ([actor]) => actor.name);
+});
+const rpcRoutes = (actors) => Effect.gen(function* routes() {
+	const missing = yield* unhosted(actors);
+	if (Array.isReadonlyArrayNonEmpty(missing)) return yield* ActorsNotHostedError.make({
+		actors: missing,
+		message: `no handlers for ${Array.join(missing, ", ")}: provide each actor's toLayer to the engine`
+	});
+	const group = RpcGroup.make().merge(...Array.map(actors, (actor) => actor.rpcs));
+	const handlers = group.toLayer(servedRpcHandlers(actors));
+	const calls = RpcServer.layerHttp({
+		group,
+		path: rpcPath,
+		protocol: "http"
+	}).pipe(Layer.provide(RpcSerialization.layerNdjson));
+	const live = RpcServer.layerHttp({
+		group,
+		path: rpcPath,
+		protocol: "websocket"
+	}).pipe(Layer.provide(RpcSerialization.layerJson));
+	return Layer.merge(calls, live).pipe(Layer.provide([handlers, DevelopmentAuthentication]));
+});
+const serve = (options) => Layer.unwrap(Effect.gen(function* makeServer() {
+	yield* loopbackOnly(options);
+	const routes = yield* rpcRoutes(options.actors);
+	return HttpRouter.serve(routes, {
+		disableListenLog: true,
+		disableLogger: true,
+		middleware: developmentGuard({
+			allowedHosts: options.allowedHosts ?? [],
+			exposed: options.unsafeExposeDevelopmentAuth === true
+		})
+	});
+}));
+export { rpcPath, rpcRoutes, serve };

package/dist/serve/rpc/computer/computer-copy.layer.d.mts

@@ -0,0 +1,22 @@
+import { CurrentCaller } from "../../../contract/caller/current-caller.service.mjs";
+import { ComputerCopy } from "../../../contract/computer/files/computer-files.schema.mjs";
+import { ComputerClientFailure } from "../../../contract/computer/computer-client-failure.contract.mjs";
+import { ComputerClient } from "../../../contract/computer/computer-client.contract.mjs";
+import { ActorHost } from "../../engine/actor-host.service.mjs";
+import { FileActor } from "../file/file-rpc-access.pure.mjs";
+import { Effect } from "effect";
+interface Copying {
+  readonly actor: FileActor;
+  readonly client: ComputerClient;
+  readonly host: ActorHost["Service"];
+  readonly request: ComputerCopy;
+}
+/** Both directions pass the actor's file authorization rule; a copy never bypasses a command to attach a file. */
+declare const copyComputerFile: (copying: Copying) => Effect.Effect<{
+  bytes: number;
+  receipt?: never;
+} | {
+  bytes: number;
+  receipt: string;
+}, ComputerClientFailure, CurrentCaller>;
+export { copyComputerFile };

package/dist/serve/rpc/computer/computer-copy.layer.mjs

@@ -0,0 +1,70 @@
+import { CurrentCaller } from "../../../contract/caller/current-caller.service.mjs";
+import { InvalidRequestError } from "../../../contract/client/invalid-request.errors.mjs";
+import { ComputerFileRequest } from "../../../contract/computer/files/computer-files.schema.mjs";
+import { filePathOf } from "../../../contract/file/file-path.pure.mjs";
+import { hostFileClient } from "../../../runtime/local-file-clients.layer.mjs";
+import { ownerOf } from "../file/file-rpc-access.pure.mjs";
+import { Boolean, Effect, Predicate, Stream } from "effect";
+// src/serve/rpc/computer/computer-copy.layer.ts
+const invalid = (actor, message) => InvalidRequestError.make({
+	actor,
+	message
+});
+const collect = (actor, source) => Stream.runFoldEffect(source, () => /* @__PURE__ */ new Uint8Array(), (before, chunk) => {
+	if (before.byteLength + chunk.byteLength > 1048576) return Effect.fail(invalid(actor, "a computer file holds at most 1 MiB"));
+	const joined = new Uint8Array(before.byteLength + chunk.byteLength);
+	joined.set(before);
+	joined.set(chunk, before.byteLength);
+	return Effect.succeed(joined);
+});
+const transfer = Effect.fnUntraced(function* transfer({ actor, client, request }, files) {
+	const computerPath = yield* filePathOf(request.computerPath);
+	if (request.direction === "toComputer") {
+		const content = yield* collect(actor.name, files.download(request.path));
+		yield* client.files(request.computer, ComputerFileRequest.cases.Write.make({
+			content,
+			path: computerPath
+		}));
+		return { bytes: content.byteLength };
+	}
+	const content = yield* client.files(request.computer, ComputerFileRequest.cases.Read.make({ path: computerPath }));
+	const receipt = yield* files.upload(Stream.make(content));
+	return {
+		bytes: content.byteLength,
+		receipt
+	};
+});
+/** Both directions pass the actor's file authorization rule; a copy never bypasses a command to attach a file. */
+const copyComputerFile = Effect.fnUntraced(function* copyComputerFile(copying) {
+	const { actor, host, request } = copying;
+	const caller = yield* CurrentCaller;
+	const path = yield* filePathOf(request.path);
+	const asked = {
+		access: Boolean.match(request.direction === "toComputer", {
+			onFalse: () => "write",
+			onTrue: () => "read"
+		}),
+		path
+	};
+	const { address } = yield* ownerOf({
+		actor,
+		asked,
+		caller,
+		host,
+		key: request.key
+	});
+	return yield* transfer({
+		...copying,
+		request: {
+			...request,
+			path
+		}
+	}, hostFileClient({
+		address,
+		host
+	}));
+}, Effect.mapError((failure) => {
+	if (Predicate.isTagged(failure, "ComputersUnavailableError") || Predicate.isTagged(failure, "ComputerHeldError") || Predicate.isTagged(failure, "ComputerNotFoundError") || Predicate.isTagged(failure, "ComputerLostError")) return failure;
+	return invalid("computer", failure.message);
+}));
+export { copyComputerFile };

package/dist/serve/rpc/computer/computer-rpc-access.pure.d.mts

@@ -0,0 +1,29 @@
+import { CallersSchemas, KeySchema } from "../../../contract/actor/actor.contract.mjs";
+import { CurrentCaller } from "../../../contract/caller/current-caller.service.mjs";
+import { ComputerAddress } from "../../../contract/computer/computer-client.contract.mjs";
+import { ComputerClientFailure } from "../../../contract/computer/computer-client-failure.contract.mjs";
+import { ComputersUnavailableError } from "../../../contract/computer/computers-unavailable.errors.mjs";
+import { ComputerRpcFailureType } from "../../../contract/computer/rpc/computer-rpc.contract.mjs";
+import { HostedError } from "../../../contract/hosted/hosted-error.contract.mjs";
+import { Effect } from "effect";
+interface ComputerActor {
+  readonly callers: CallersSchemas;
+  readonly key: KeySchema;
+  readonly name: string;
+}
+interface Keyed {
+  readonly key: string;
+}
+declare const unavailable: ComputersUnavailableError;
+/** What a computer RPC answers for a failure its schema doesn't carry. */
+declare const served: (actor: string) => (failure: ComputerClientFailure | HostedError) => ComputerRpcFailureType;
+/**
+ * Admits the caller through the actor's callers gate as a command with no `callers` list is admitted: any caller kind
+ * the actor declares, never the engine's own actor caller. The key must decode with the actor's key schema, so one
+ * actor's request can't name another's computers.
+ */
+declare const addressOf: ({ actor, caller, key }: Keyed & {
+  readonly actor: ComputerActor;
+  readonly caller: CurrentCaller["Service"];
+}) => Effect.Effect<ComputerAddress, ComputerRpcFailureType>;
+export { type ComputerActor, type Keyed, addressOf, served, unavailable };

package/dist/serve/rpc/computer/computer-rpc-access.pure.mjs

@@ -0,0 +1,46 @@
+import { admit, clientPrincipal } from "../../../contract/caller/caller-admission.pure.mjs";
+import { ActorUnavailableError } from "../../../contract/client/actor-unavailable.errors.mjs";
+import { InvalidRequestError } from "../../../contract/client/invalid-request.errors.mjs";
+import { ComputersUnavailableError } from "../../../contract/computer/computers-unavailable.errors.mjs";
+import { Effect, Match, Option, Schema } from "effect";
+// src/serve/rpc/computer/computer-rpc-access.pure.ts
+const computerMember = "computer";
+const unavailable = ComputersUnavailableError.make({ message: "computers aren't available on this host" });
+/** What a computer RPC answers for a failure its schema doesn't carry. */
+const served = (actor) => (failure) => Match.value(failure).pipe(Match.tag("UnauthenticatedError", () => ActorUnavailableError.make({
+	actor,
+	message: "the caller wasn't authenticated before its computers were read"
+})), Match.tag("ActorAlreadyExistsError", () => InvalidRequestError.make({
+	actor,
+	message: "a computer request can't create an actor"
+})), Match.tag("ComputerLimitError", (limit) => ComputersUnavailableError.make({ message: `computer ${limit.computer} is past its ${limit.limit} limit` })), Match.orElse((other) => other));
+/**
+* Admits the caller through the actor's callers gate as a command with no `callers` list is admitted: any caller kind
+* the actor declares, never the engine's own actor caller. The key must decode with the actor's key schema, so one
+* actor's request can't name another's computers.
+*/
+const addressOf = ({ actor, caller, key }) => Effect.gen(function* admitted() {
+	const principal = yield* clientPrincipal({
+		actor: actor.name,
+		caller
+	});
+	const admission = {
+		actor: actor.name,
+		allowed: Option.none(),
+		callers: actor.callers,
+		member: computerMember
+	};
+	yield* admit({
+		...admission,
+		principal
+	});
+	yield* Effect.mapError(Schema.decodeEffect(actor.key)(key), () => InvalidRequestError.make({
+		actor: actor.name,
+		message: "the actor key is invalid"
+	}));
+	return {
+		actor: actor.name,
+		key
+	};
+}).pipe(Effect.mapError(served(actor.name)));
+export { addressOf, served, unavailable };

package/dist/serve/rpc/computer/computer-rpc.layer.d.mts

@@ -0,0 +1,39 @@
+import { CurrentCaller } from "../../../contract/caller/current-caller.service.mjs";
+import { ComputerCopy, ComputerCopyResult } from "../../../contract/computer/files/computer-files.schema.mjs";
+import { ActorComputerClients } from "../../../contract/computer/computer-client.adapter.mjs";
+import { Computer, ComputerLogLine, ComputerLogPage } from "../../../contract/computer/computer.schema.mjs";
+import { ComputerRpcFailureType } from "../../../contract/computer/rpc/computer-rpc.contract.mjs";
+import { ActorHost } from "../../engine/actor-host.service.mjs";
+import { ComputerActor, Keyed } from "./computer-rpc-access.pure.mjs";
+import { StepHandler, StepReader } from "./step-rpc.handlers.mjs";
+import { copyComputerFile } from "./computer-copy.layer.mjs";
+import { Effect, Option } from "effect";
+type FileActor = Parameters<typeof copyComputerFile>[number]["actor"];
+interface Named extends Keyed {
+  readonly computer: string;
+}
+type Logged = Named & ComputerLogPage;
+type Answer<Value> = Effect.Effect<Value, ComputerRpcFailureType, CurrentCaller>;
+type ComputerHandler = ((request: ComputerCopy) => Answer<ComputerCopyResult>) | ((request: Keyed) => Answer<readonly Computer[]>) | ((request: Logged) => Answer<readonly ComputerLogLine[]>) | ((request: Named) => Answer<Computer>) | ((request: Named) => Answer<void>) | StepHandler;
+type ComputerHandlers = Readonly<Record<string, ComputerHandler>>;
+type Clients = ActorComputerClients["Service"];
+interface Serving {
+  readonly clients: Option.Option<Clients>;
+  readonly host: ActorHost["Service"];
+  readonly steps: Option.Option<StepReader>;
+}
+/**
+ * The `<Actor>/computer/<operation>` handlers of every served actor. They admit each caller through the actor's
+ * callers gate, then reach the actor's computers through the host's `ActorComputerClients`; on a host without
+ * computers every one answers `ComputersUnavailableError`. The engine reads an actor's durable steps from its journal
+ * only while it runs computers, so with `AKTER_LOCAL_COMPUTERS` off `steps` and `step` answer the same.
+ */
+declare const computerRpcHandlers: (actors: readonly (ComputerActor & Partial<FileActor>)[]) => Effect.Effect<ComputerHandlers, never, ActorHost>;
+/**
+ * One actor's computer handlers, by tag. `steps` reads its durable steps; a host that doesn't serve them yet passes
+ * none, and `steps` and `step` answer `ComputersUnavailableError`.
+ */
+declare const computerHandlersFor: ({ actor, clients, steps, host }: Serving & {
+  readonly actor: ComputerActor & Partial<FileActor>;
+}) => ComputerHandlers;
+export { type ComputerActor, type ComputerHandlers, computerHandlersFor, computerRpcHandlers };

package/dist/serve/rpc/computer/computer-rpc.layer.mjs

@@ -0,0 +1,84 @@
+import { CurrentCaller } from "../../../contract/caller/current-caller.service.mjs";
+import { ActorComputerClients } from "../../../contract/computer/computer-client.adapter.mjs";
+import { computerTag } from "../../../contract/computer/rpc/computer-rpc.contract.mjs";
+import { ActorHost } from "../../engine/actor-host.service.mjs";
+import { addressOf, served, unavailable } from "./computer-rpc-access.pure.mjs";
+import { stepEntries } from "./step-rpc.handlers.mjs";
+import { copyComputerFile } from "./computer-copy.layer.mjs";
+import { Array, Effect, Option, Record } from "effect";
+// src/serve/rpc/computer/computer-rpc.layer.ts
+/** Admits the caller for the actor, then reaches its computers; with no computers on this host, refuses at once. */
+const answered = (actor, clients, use) => (request) => Effect.gen(function* answer() {
+	const caller = yield* CurrentCaller;
+	const address = yield* addressOf({
+		actor,
+		caller,
+		key: request.key
+	});
+	const present = yield* Effect.mapError(Effect.fromOption(clients), () => unavailable);
+	return yield* Effect.mapError(use(present, address, request), served(actor.name));
+});
+const pageOf = ({ after, limit }) => Record.getSomes({
+	after: Option.fromNullishOr(after),
+	limit: Option.fromNullishOr(limit)
+});
+const listed = (clients, address) => clients.connect(address).list;
+const got = (clients, address, { computer }) => clients.connect(address).get(computer);
+const paused = (clients, address, { computer }) => clients.connect(address).pause(computer);
+const resumed = (clients, address, { computer }) => clients.connect(address).resume(computer);
+const stopped = (clients, address, { computer }) => clients.connect(address).stop(computer);
+const deleted = (clients, address, { computer }) => clients.connect(address).remove(computer);
+const logged = (clients, address, request) => clients.logs(address, request.computer, pageOf(request));
+const entriesOf = (actor, { clients, host, steps }) => {
+	const tag = (operation) => computerTag({
+		actor: actor.name,
+		operation
+	});
+	const copied = (available, address, request) => copyComputerFile({
+		actor: {
+			...actor,
+			fileAccess: actor.fileAccess ?? Option.none()
+		},
+		client: available.connect(address),
+		host,
+		request
+	});
+	return [
+		[tag("files"), answered(actor, clients, copied)],
+		[tag("list"), answered(actor, clients, listed)],
+		[tag("get"), answered(actor, clients, got)],
+		[tag("pause"), answered(actor, clients, paused)],
+		[tag("resume"), answered(actor, clients, resumed)],
+		[tag("stop"), answered(actor, clients, stopped)],
+		[tag("delete"), answered(actor, clients, deleted)],
+		[tag("logs"), answered(actor, clients, logged)],
+		...stepEntries({
+			actor,
+			steps
+		})
+	];
+};
+/**
+* The `<Actor>/computer/<operation>` handlers of every served actor. They admit each caller through the actor's
+* callers gate, then reach the actor's computers through the host's `ActorComputerClients`; on a host without
+* computers every one answers `ComputersUnavailableError`. The engine reads an actor's durable steps from its journal
+* only while it runs computers, so with `AKTER_LOCAL_COMPUTERS` off `steps` and `step` answer the same.
+*/
+const computerRpcHandlers = (actors) => Effect.map(Effect.all([Effect.serviceOption(ActorComputerClients), ActorHost]), ([clients, host]) => {
+	const steps = Option.as(clients, host);
+	return Record.fromEntries(Array.flatMap(actors, (actor) => entriesOf(actor, {
+		clients,
+		host,
+		steps
+	})));
+});
+/**
+* One actor's computer handlers, by tag. `steps` reads its durable steps; a host that doesn't serve them yet passes
+* none, and `steps` and `step` answer `ComputersUnavailableError`.
+*/
+const computerHandlersFor = ({ actor, clients, steps, host }) => Record.fromEntries(entriesOf(actor, {
+	clients,
+	host,
+	steps
+}));
+export { computerHandlersFor, computerRpcHandlers };

package/dist/serve/rpc/computer/step-rpc.handlers.d.mts

@@ -0,0 +1,23 @@
+import { CurrentCaller } from "../../../contract/caller/current-caller.service.mjs";
+import { ComputerRpcFailureType } from "../../../contract/computer/rpc/computer-rpc.contract.mjs";
+import { ComputerStep, StepPage } from "../../../contract/computer/step/computer-step.schema.mjs";
+import { ActorHost } from "../../engine/actor-host.service.mjs";
+import { ComputerActor, Keyed } from "./computer-rpc-access.pure.mjs";
+import { Effect, Option } from "effect";
+/** What reads an actor's durable steps from its journal: the host that owns the actor. */
+type StepReader = Pick<ActorHost["Service"], "step" | "steps">;
+type Answer<Value> = Effect.Effect<Value, ComputerRpcFailureType, CurrentCaller>;
+type StepHandler = ((request: Keyed & StepPage) => Answer<readonly ComputerStep[]>) | ((request: Stepped) => Answer<ComputerStep>);
+interface Stepped extends Keyed {
+  readonly step: string;
+}
+/**
+ * The `<Actor>/computer/steps` and `<Actor>/computer/step` handlers of one actor: they admit the caller through the
+ * actor's callers gate, then read the actor's own journal through `steps`. With no reader, as on a host that doesn't
+ * serve durable steps yet, both answer `ComputersUnavailableError`.
+ */
+declare const stepEntries: ({ actor, steps }: {
+  readonly actor: ComputerActor;
+  readonly steps: Option.Option<StepReader>;
+}) => readonly (readonly [string, StepHandler])[];
+export { type StepHandler, type StepReader, stepEntries };

package/dist/serve/rpc/computer/step-rpc.handlers.mjs

@@ -0,0 +1,43 @@
+import { CurrentCaller } from "../../../contract/caller/current-caller.service.mjs";
+import { ComputersUnavailableError } from "../../../contract/computer/computers-unavailable.errors.mjs";
+import { computerTag } from "../../../contract/computer/rpc/computer-rpc.contract.mjs";
+import { StepNotFoundError } from "../../../contract/computer/step/step-not-found.errors.mjs";
+import { addressOf } from "./computer-rpc-access.pure.mjs";
+import { Effect, Option, Record } from "effect";
+// src/serve/rpc/computer/step-rpc.handlers.ts
+const notServed = ComputersUnavailableError.make({ message: "durable steps aren't served on this host" });
+/** Admits the caller for the actor as every computer RPC does, then reads its journal; with no reader, refuses at once. */
+const reading = (actor, steps, read) => (request) => Effect.gen(function* readSteps() {
+	const caller = yield* CurrentCaller;
+	yield* addressOf({
+		actor,
+		caller,
+		key: request.key
+	});
+	return yield* read(yield* Effect.mapError(Effect.fromOption(steps), () => notServed), request);
+});
+const pageOf = (actor, { key, limit }) => ({
+	...Record.getSomes({ limit: Option.fromUndefinedOr(limit) }),
+	actor,
+	key
+});
+/**
+* The `<Actor>/computer/steps` and `<Actor>/computer/step` handlers of one actor: they admit the caller through the
+* actor's callers gate, then read the actor's own journal through `steps`. With no reader, as on a host that doesn't
+* serve durable steps yet, both answer `ComputersUnavailableError`.
+*/
+const stepEntries = ({ actor, steps }) => [[computerTag({
+	actor: actor.name,
+	operation: "steps"
+}), reading(actor, steps, (reader, request) => reader.steps(pageOf(actor.name, request)))], [computerTag({
+	actor: actor.name,
+	operation: "step"
+}), reading(actor, steps, (reader, { key, step }) => Effect.flatMap(reader.step({
+	actor: actor.name,
+	key,
+	step
+}), Option.match({
+	onNone: () => Effect.fail(StepNotFoundError.make({ step })),
+	onSome: (found) => Effect.succeed(found)
+})))]];
+export { stepEntries };

package/dist/serve/rpc/development-authentication.handlers.d.mts

@@ -0,0 +1,7 @@
+import { Authentication } from "../../contract/caller/authentication.api.mjs";
+import { Caller } from "../../contract/caller/caller.schema.mjs";
+import { Layer } from "effect";
+declare const principalHeader = "akter-principal";
+declare const developmentCaller: Caller;
+declare const DevelopmentAuthentication: Layer.Layer<Authentication, never, never>;
+export { DevelopmentAuthentication, developmentCaller, principalHeader };

package/dist/serve/rpc/development-authentication.handlers.mjs

@@ -0,0 +1,19 @@
+import { Authentication } from "../../contract/caller/authentication.api.mjs";
+import { Caller } from "../../contract/caller/caller.schema.mjs";
+import { CurrentCaller } from "../../contract/caller/current-caller.service.mjs";
+import { UnauthenticatedError } from "../../contract/caller/unauthenticated.errors.mjs";
+import { Effect, Layer, Option, Schema } from "effect";
+import { Headers } from "effect/http";
+// src/serve/rpc/development-authentication.handlers.ts
+const principalHeader = "akter-principal";
+const developmentCaller = {
+	kind: "user",
+	principal: { id: "developer" }
+};
+const decodeCaller = Schema.decodeEffect(Schema.fromJsonString(Schema.toCodecJson(Caller)));
+const callerOf = (headers) => Option.match(Headers.get(headers, principalHeader), {
+	onNone: () => Effect.succeed(developmentCaller),
+	onSome: (text) => Effect.mapError(decodeCaller(text), (issue) => UnauthenticatedError.make({ message: `${principalHeader}: ${issue.message}` }))
+});
+const DevelopmentAuthentication = Layer.succeed(Authentication)((effect, { headers }) => Effect.flatMap(callerOf(headers), (caller) => Effect.provideService(effect, CurrentCaller, caller)));
+export { DevelopmentAuthentication, developmentCaller, principalHeader };

package/dist/serve/rpc/development-guard.pure.d.mts

@@ -0,0 +1,10 @@
+import { AllowedHosts } from "../http/loopback-host.pure.mjs";
+import { Effect } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+type Response = HttpServerResponse.HttpServerResponse;
+interface Guarded {
+  readonly allowedHosts: AllowedHosts;
+  readonly exposed: boolean;
+}
+declare const developmentGuard: ({ allowedHosts, exposed }: Guarded) => <Failure, Services>(app: Effect.Effect<Response, Failure, Services>) => Effect.Effect<Response, Failure, Services | HttpServerRequest.HttpServerRequest>;
+export { developmentGuard };

package/dist/serve/rpc/development-guard.pure.mjs

@@ -0,0 +1,16 @@
+import { allowedHostsOnly, loopbackOriginOnly } from "../http/loopback-host.pure.mjs";
+import { ndjsonOnly } from "./ndjson-only.pure.mjs";
+import { ByteSize, Effect } from "effect";
+import { HttpIncomingMessage } from "effect/http";
+// src/serve/rpc/development-guard.pure.ts
+/**
+* The largest request body the server reads; a larger one is answered 413 before any of it is decoded. A file upload
+* chunk (1 MiB, base64 in its line) fits with room to spare, and Akter Cloud refuses a call over 4 MiB anyway.
+*/
+const maxBodyMebibytes = 8;
+const developmentGuard = ({ allowedHosts, exposed }) => (app) => {
+	const typed = ndjsonOnly(Effect.provideService(app, HttpIncomingMessage.MaxBodySize, ByteSize.mebibytes(maxBodyMebibytes)));
+	if (exposed) return typed.pipe(allowedHostsOnly(allowedHosts));
+	return typed.pipe(loopbackOriginOnly, allowedHostsOnly(allowedHosts));
+};
+export { developmentGuard };