@akterjs/sdk 0.0.0-stage → 0.1.0

package/dist/actor/resource/plain-computers.contract.d.mts

@@ -0,0 +1,89 @@
+import { Effect } from "effect";
+import { ComputerClient } from "@akterjs/effect/contract";
+/** A computer's size: memory in MiB and virtual CPUs. */
+interface ComputerSize {
+  readonly memoryMib: number;
+  readonly vcpu: number;
+}
+/**
+ * A computer to keep: its image, its size and the hosts it may reach. `name` is lowercase letters, digits and hyphens,
+ * starting with a letter. `egress` lists hosts or rules, never credentials.
+ */
+interface ComputerSpec {
+  readonly egress: readonly string[];
+  readonly image: string;
+  readonly name: string;
+  readonly size: ComputerSize;
+}
+/** `paused` keeps memory, processes and files; `stopped` and `failed` keep files; `gone` means the disk is gone. */
+type ComputerState = "starting" | "running" | "paused" | "stopped" | "failed" | "gone";
+interface Computer extends ComputerSpec {
+  readonly state: ComputerState;
+}
+/**
+ * One exec step: at most 100 KiB of command and stdin together, and 300 seconds. `key` names the logical operation,
+ * such as the `step.key` of the `steps.run` it runs in, so the same step sent again reads its outcome back.
+ */
+interface ExecRequest {
+  readonly command: string;
+  readonly cwd?: string;
+  readonly key: string;
+  readonly stdin?: Uint8Array;
+  readonly timeoutSeconds?: number;
+}
+/**
+ * `Ran`: the step ran to an end, or its recorded outcome was read back. `exitCode` is absent when the process ended
+ * without one; `truncated` is set past 4 MiB of a stream. `Unknown`: the step started but recorded no outcome, so it
+ * is not run again; reconcile with the outside system by its key.
+ */
+type ExecResult = {
+  readonly _tag: "Ran";
+  readonly exitCode?: number;
+  readonly stderr: string;
+  readonly stdout: string;
+  readonly truncated: boolean;
+} | {
+  readonly _tag: "Unknown";
+};
+/** Where a fork goes: another actor by name and key, and optionally a new name for the copy. */
+interface ComputerFork {
+  readonly into: {
+    readonly actor: string;
+    readonly key: string;
+  };
+  readonly name?: string;
+}
+/** A hold on a paused computer, such as a fork's id: only a `resume` with the same hold runs it again. */
+interface ComputerHold {
+  readonly hold?: string;
+}
+/**
+ * One actor's computers, from `steps.computer(Actor, key)` in a job. Each call reaches a provider, so make it inside
+ * `steps.run`. Each rejects with the error the Effect `ComputerClient` fails with, such as `ComputerHeldError`, by
+ * its `_tag`; a spec or exec request past the limits rejects with `InvalidRequestError` before it reaches a provider.
+ */
+interface Computers {
+  readonly ensure: (spec: ComputerSpec) => Promise<Computer>;
+  readonly exec: (computer: string, request: ExecRequest) => Promise<ExecResult>;
+  /** Copies the computer, its files and memory, to the target actor. A resend finds the copy already made. */
+  readonly fork: (computer: string, fork: ComputerFork) => Promise<Computer>;
+  readonly get: (computer: string) => Promise<Computer>;
+  readonly list: () => Promise<readonly Computer[]>;
+  readonly pause: (computer: string, hold?: ComputerHold) => Promise<Computer>;
+  readonly remove: (computer: string) => Promise<void>;
+  readonly resume: (computer: string, hold?: ComputerHold) => Promise<Computer>;
+  readonly stop: (computer: string) => Promise<Computer>;
+}
+interface Connecting {
+  readonly actor: string;
+  /** The actor's Effect computer client, as `Actor.computer(key)` returns it. */
+  readonly connected: Effect.Effect<ComputerClient, Error>;
+  /** Runs an effect in the job's context; a failure rejects with the error. */
+  readonly run: <Success>(effect: Effect.Effect<Success, Error>) => Promise<Success>;
+}
+/** The Promise face of one actor's Effect computer client. */
+declare const computersOf: ({ actor, connected, run }: Connecting) => Computers;
+export declare const PlainComputers: {
+  readonly computersOf: typeof computersOf;
+};
+export type { Computer, ComputerFork, ComputerHold, ComputerSize, ComputerSpec, ComputerState, Computers, ExecRequest, ExecResult };

package/dist/actor/resource/plain-computers.contract.mjs

@@ -0,0 +1,34 @@
+import { Effect, Option, Schema } from "effect";
+import { ComputerName, ComputerSpec, ExecRequest } from "@akterjs/effect/contract/computer";
+import { InvalidRequestError } from "@akterjs/effect/contract/errors";
+// src/actor/resource/plain-computers.contract.ts
+/** The Promise face of one actor's Effect computer client. */
+const computersOf = ({ actor, connected, run }) => {
+	const refused = (invalid) => InvalidRequestError.make({
+		actor,
+		message: invalid.message
+	});
+	const spec = (wanted) => Effect.mapError(Schema.decodeEffect(ComputerSpec)(wanted), refused);
+	const request = (wanted) => Effect.mapError(Schema.decodeEffect(ExecRequest)(wanted), refused);
+	const name = (wanted) => Effect.mapError(Schema.decodeEffect(ComputerName)(wanted), refused);
+	const call = (use) => run(Effect.flatMap(connected, use));
+	return {
+		ensure: (wanted) => call((client) => Effect.flatMap(spec(wanted), client.ensure)),
+		exec: (computer, wanted) => call((client) => Effect.flatMap(request(wanted), (valid) => client.exec(computer, valid))),
+		fork: (computer, { into, name: renamed }) => call((client) => Option.match(Option.fromUndefinedOr(renamed), {
+			onNone: () => client.fork(computer, { into }),
+			onSome: (wanted) => Effect.flatMap(name(wanted), (valid) => client.fork(computer, {
+				into,
+				name: valid
+			}))
+		})),
+		get: (computer) => call((client) => client.get(computer)),
+		list: () => call((client) => client.list),
+		pause: (computer, hold) => call((client) => client.pause(computer, hold)),
+		remove: (computer) => call((client) => client.remove(computer)),
+		resume: (computer, hold) => call((client) => client.resume(computer, hold)),
+		stop: (computer) => call((client) => client.stop(computer))
+	};
+};
+const PlainComputers = { computersOf };
+export { PlainComputers };

package/dist/actor/resource/plain-file-access.contract.d.mts

@@ -0,0 +1,38 @@
+import { FileAccess } from "@akterjs/effect/contract";
+/** Which caller kinds may make file calls to an actor, as `Akter.fileAccess` declares them. */
+interface PlainFileAccess<Kinds extends string = string> {
+  readonly callers: readonly [Kinds, ...Kinds[]];
+  readonly kind: "files";
+}
+/**
+ * What a file call asks the actor's `files.authorize` rule: `read` for a download, a listing or the usage (`path` is
+ * the file, or the listing's prefix), `write` for an upload (`path` is empty: the command that attaches it names it).
+ */
+interface FileRequest {
+  readonly access: "read" | "write";
+  readonly path: string;
+}
+/**
+ * The `files` an implementation needs when its actor declares file calls: `authorize` decides each call from `ctx.state`
+ * and `ctx.principal`, the verified caller, never the request. Only `true` allows the call.
+ */
+type FileRulesOf<Options, Context> = Options extends {
+  readonly files: PlainFileAccess;
+} ? {
+  readonly files: {
+    readonly authorize: (ctx: Context, request: FileRequest) => boolean;
+  };
+} : unknown;
+type FileAccessOf = <const Kinds extends string>(options: {
+  readonly callers: readonly [Kinds, ...Kinds[]];
+}) => PlainFileAccess<Kinds>;
+/**
+ * The Effect declaration a plain actor compiles to. An actor that declares no file calls compiles to one admitting no
+ * caller kind, which the engine reads as none, so every compiled actor has the same type.
+ */
+declare const compiledFileAccess: (declared: PlainFileAccess | undefined) => FileAccess;
+export declare const PlainFileAccesses: {
+  readonly compiledFileAccess: typeof compiledFileAccess;
+  readonly fileAccess: FileAccessOf;
+};
+export type { FileAccessOf, FileRequest, FileRulesOf, PlainFileAccess };

package/dist/actor/resource/plain-file-access.contract.mjs

@@ -0,0 +1,23 @@
+import { Option } from "effect";
+import { Akter } from "@akterjs/effect/contract";
+// src/actor/resource/plain-file-access.contract.ts
+const fileAccess = (options) => ({
+	callers: options.callers,
+	kind: "files"
+});
+/**
+* The Effect declaration a plain actor compiles to. An actor that declares no file calls compiles to one admitting no
+* caller kind, which the engine reads as none, so every compiled actor has the same type.
+*/
+const compiledFileAccess = (declared) => Option.match(Option.fromUndefinedOr(declared), {
+	onNone: () => ({
+		...Akter.fileAccess({ callers: ["user"] }),
+		callers: Option.some([])
+	}),
+	onSome: ({ callers }) => Akter.fileAccess({ callers })
+});
+const PlainFileAccesses = {
+	compiledFileAccess,
+	fileAccess
+};
+export { PlainFileAccesses };

package/dist/actor/resource/plain-files.contract.d.mts

@@ -0,0 +1,53 @@
+import { Effect } from "effect";
+import { Akter } from "@akterjs/effect/contract";
+import { FileAccessDeniedError } from "@akterjs/effect/contract/errors";
+/** 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;
+}
+/** 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;
+}
+/** What a query reads of its actor's files: pages of them, and the bytes they hold. */
+interface ReadingFiles {
+  readonly list: (listing?: FileListing) => FilePage;
+  readonly usage: (listing?: FileListing) => FileUsage;
+}
+/**
+ * The actor's files in a command or result handler. `attach(path, receipt)` binds a file a client uploaded (the receipt
+ * its `files.upload` returned) at `path` in this command's transaction, replacing any file there; `remove` drops one.
+ * Both commit or roll back with the command. File bytes never pass through a handler: clients upload and download them.
+ */
+interface Files extends ReadingFiles {
+  readonly attach: (path: string, receipt: string) => FileRef;
+  readonly remove: (path: string) => void;
+}
+type ReadRun = <Success, Failure>(effect: Effect.Effect<Success, Failure, Akter>) => Success;
+type ChangeRun = <Success, Failure>(effect: Effect.Effect<Success, Failure, Effect.Services<ReturnType<typeof Akter.cancel>> | Akter>) => Success;
+declare const readingFilesOf: (run: ReadRun) => ReadingFiles;
+declare const filesOf: (run: ChangeRun) => Files;
+/** What a file call asks an actor's `files.authorize` rule: the same `access` and `path` its refusal names. */
+type FileQuestion = Pick<FileAccessDeniedError, "access" | "path">;
+/** The refusal of a file call whose rule didn't return `true`. */
+declare const denied: ({ access, path }: FileQuestion) => FileAccessDeniedError;
+export declare const PlainFiles: {
+  readonly denied: typeof denied;
+  readonly filesOf: typeof filesOf;
+  readonly readingFilesOf: typeof readingFilesOf;
+};
+export type { FileListing, FilePage, FileQuestion, FileRef, FileUsage, Files, ReadingFiles };

package/dist/actor/resource/plain-files.contract.mjs

@@ -0,0 +1,47 @@
+import { Effect, Option, Record } from "effect";
+import { Akter } from "@akterjs/effect/contract";
+import { FileAccessDeniedError } from "@akterjs/effect/contract/errors";
+// src/actor/resource/plain-files.contract.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 readingFilesOf = (run) => ({
+	list: (listing) => pageOf(run(Effect.flatMap(Akter.files, (files) => files.list(listingOf(listing))))),
+	usage: (listing) => {
+		const usage = run(Effect.flatMap(Akter.files, (files) => files.fileUsage(listingOf(listing))));
+		return {
+			...pageOf(usage),
+			bytes: Number(usage.bytes)
+		};
+	}
+});
+const filesOf = (run) => ({
+	...readingFilesOf(run),
+	attach: (path, receipt) => run(Effect.flatMap(Akter.files, (files) => files.attach(path, receipt))),
+	remove: (path) => {
+		run(Effect.flatMap(Akter.files, (files) => files.remove(path)));
+	}
+});
+/** The refusal of a file call whose rule didn't return `true`. */
+const denied = ({ access, path }) => FileAccessDeniedError.make({
+	access,
+	message: "the actor's files.authorize rule refused this call",
+	path
+});
+const PlainFiles = {
+	denied,
+	filesOf,
+	readingFilesOf
+};
+export { PlainFiles };

package/dist/actor/standard-schema.schema.d.mts

@@ -0,0 +1,76 @@
+import { JsonNode } from "./json-document.schema.mjs";
+import { PlainDefinitionError } from "./plain-definition.errors.mjs";
+import { StateFields, Validator } from "./plain-types.contract.mjs";
+import { Effect, Schema, SchemaIssue } from "effect";
+/** Where a declaration sits in an actor, so a refusal names it. */
+interface Site {
+  readonly actor: string;
+  readonly member: string;
+  readonly part: string;
+}
+interface Documents {
+  readonly input: JsonNode;
+  readonly output: JsonNode;
+}
+type JsonCodec = Schema.Codec<Schema.Json, Schema.Json>;
+type KeyCodec = Schema.Codec<string, string>;
+type StateCodec = Schema.Codec<StateFields, Schema.Json>;
+/** What Akter asks a validator to check: a JSON value it received, or an error instance a handler threw. */
+type Checked = Schema.Json | Error;
+interface Declaring {
+  readonly site: Site;
+  readonly validator: Validator;
+}
+interface Refusing {
+  readonly reasons: readonly string[];
+  readonly site: Site;
+}
+declare const refuse: ({ reasons, site }: Refusing) => PlainDefinitionError;
+interface Bridged<Codec> {
+  readonly codec: Codec;
+  readonly documents: Documents;
+}
+declare const documentsOf: ({ site, validator: declared }: Declaring) => Documents;
+/** Runs a validator as a schema step: a refusal becomes the issue the engine reports. */
+declare const validating: (declared: Validator) => (input: Checked) => Effect.Effect<Schema.Json, SchemaIssue.Issue>;
+/** Bridges a Standard validator to an Effect codec over JSON values: decode and encode both run the validator and keep its output, which must stay JSON. */
+declare const bridge: (declaring: Declaring) => Bridged<JsonCodec>;
+declare const bridgeState: (declaring: Declaring) => Bridged<StateCodec>;
+declare const bridgeKey: (declaring: Declaring) => Bridged<KeyCodec>;
+/** The fields of an error declared without any: an empty object. */
+declare const noFields: Validator;
+/** The default principal of a `user` caller. */
+declare const principal: import("effect/StandardSchema").StandardJSONSchemaV1<{
+  readonly id: string;
+}, {
+  readonly id: string;
+}> & import("effect/StandardSchema").StandardSchemaV1<{
+  readonly id: string;
+}, {
+  readonly id: string;
+}> & Schema.Struct<{
+  readonly id: Schema.String;
+}>;
+/** The principal another actor calls with. */
+declare const actorPrincipal: import("effect/StandardSchema").StandardJSONSchemaV1<{
+  readonly actor: string;
+  readonly id: string;
+  readonly key: string;
+}, {
+  readonly actor: string;
+  readonly id: string;
+  readonly key: string;
+}> & import("effect/StandardSchema").StandardSchemaV1<{
+  readonly actor: string;
+  readonly id: string;
+  readonly key: string;
+}, {
+  readonly actor: string;
+  readonly id: string;
+  readonly key: string;
+}> & Schema.Struct<{
+  readonly actor: Schema.String;
+  readonly id: Schema.String;
+  readonly key: Schema.String;
+}>;
+export { type Bridged, type Checked, type Declaring, type Documents, type JsonCodec, type KeyCodec, type Site, type StateCodec, actorPrincipal, bridge, bridgeKey, bridgeState, documentsOf, noFields, principal, refuse, validating };

package/dist/actor/standard-schema.schema.mjs

@@ -0,0 +1,113 @@
+import { exportDocument } from "./json-document.schema.mjs";
+import { PlainDefinitionError } from "./plain-definition.errors.mjs";
+import { Array, Effect, Option, Predicate, Result, Schema, SchemaIssue, SchemaTransformation, pipe } from "effect";
+// src/actor/standard-schema.schema.ts
+const refuse = ({ reasons, site }) => PlainDefinitionError.make({
+	...site,
+	message: `${site.actor}.${site.member} ${site.part}: ${Array.join(reasons, "; ")}`,
+	reasons
+});
+const asyncRefusal = "the validator is asynchronous; Akter validates synchronously";
+const isValidator = (declared) => Predicate.hasProperty(declared, "~standard") && Predicate.hasProperty(declared["~standard"], "validate") && Predicate.isFunction(declared["~standard"].validate);
+const hasExporter = (declared) => Predicate.hasProperty(declared["~standard"], "jsonSchema") && Predicate.hasProperty(declared["~standard"].jsonSchema, "input") && Predicate.isFunction(declared["~standard"].jsonSchema.input) && Predicate.hasProperty(declared["~standard"].jsonSchema, "output") && Predicate.isFunction(declared["~standard"].jsonSchema.output);
+const keyOfSegment = (segment) => {
+	if (Predicate.isString(segment) || Predicate.isNumber(segment) || Predicate.isSymbol(segment)) return String(segment);
+	return String(segment.key);
+};
+const describeIssue = (issue) => pipe(Option.fromNullishOr(issue.path), Option.filter(Array.isReadonlyArrayNonEmpty), Option.match({
+	onNone: () => issue.message,
+	onSome: (path) => `${Array.join(Array.map(path, keyOfSegment), ".")}: ${issue.message}`
+}));
+const decodeJson = Schema.decodeUnknownOption(Schema.Json);
+/** Runs a validator synchronously and requires a JSON output, or names why it failed. */
+const validatedJson = (declared, input) => {
+	const outcome = declared["~standard"].validate(input);
+	if (Predicate.isPromiseLike(outcome)) return Result.fail(asyncRefusal);
+	if (Predicate.hasProperty(outcome, "value")) return Result.fromOption(decodeJson(outcome.value), () => "the validator's output is not JSON");
+	return Result.fail(Array.join(Array.map(outcome.issues, describeIssue), "; "));
+};
+const exported = (converter, side) => pipe(Result.try({
+	catch: (failure) => `its ${side} JSON Schema export failed: ${String(failure)}`,
+	try: () => exportDocument({
+		converter,
+		side
+	})
+}), Result.flatMap((checked) => Array.match(checked.refusals, {
+	onEmpty: () => Result.succeed(checked.document),
+	onNonEmpty: (refusals) => Result.fail(`its ${side} JSON Schema: ${Array.join(refusals, "; ")}`)
+})));
+const failureOf = (result) => Option.toArray(Result.getFailure(result));
+const documentsOf = ({ site, validator: declared }) => {
+	if (!isValidator(declared)) throw refuse({
+		reasons: ["is not a Standard Schema validator"],
+		site
+	});
+	if (!hasExporter(declared)) throw refuse({
+		reasons: ["has no Standard JSON Schema export; use a validator that exports JSON Schema (ADR 0015)"],
+		site
+	});
+	const input = exported(declared["~standard"].jsonSchema, "input");
+	const output = exported(declared["~standard"].jsonSchema, "output");
+	if (Result.isSuccess(input) && Result.isSuccess(output)) return {
+		input: input.success,
+		output: output.success
+	};
+	throw refuse({
+		reasons: [...failureOf(input), ...failureOf(output)],
+		site
+	});
+};
+const describedJson = (document) => Schema.Json.check(Schema.makeFilter(() => true, { toJsonSchema: () => document }));
+const describedString = (document) => Schema.String.check(Schema.makeFilter(() => true, { toJsonSchema: () => document }));
+/** Runs a validator as a schema step: a refusal becomes the issue the engine reports. */
+const validating = (declared) => (input) => Effect.fromResult(Result.mapError(validatedJson(declared, input), (message) => new SchemaIssue.InvalidValue({ message }, Option.some(input))));
+/** Bridges a Standard validator to an Effect codec over JSON values: decode and encode both run the validator and keep its output, which must stay JSON. */
+const bridge = (declaring) => {
+	const documents = documentsOf(declaring);
+	const run = validating(declaring.validator);
+	return {
+		codec: describedJson(documents.output).pipe(Schema.decodeTo(Schema.Json, SchemaTransformation.transformEffect({
+			decode: run,
+			encode: run
+		}))),
+		documents
+	};
+};
+const StateRecord = Schema.Record(Schema.String, Schema.Json);
+const isStateRecord = Schema.is(StateRecord);
+const stateOf = (value) => Effect.mapError(Effect.fromOption(Option.liftPredicate(value, isStateRecord)), () => new SchemaIssue.InvalidValue({ message: "the state must be an object" }, Option.some(value)));
+const bridgeState = (declaring) => {
+	const documents = documentsOf(declaring);
+	const run = validating(declaring.validator);
+	return {
+		codec: describedJson(documents.output).pipe(Schema.decodeTo(StateRecord, SchemaTransformation.transformEffect({
+			decode: (input) => Effect.flatMap(run(input), stateOf),
+			encode: run
+		}))),
+		documents
+	};
+};
+const textOf = (value) => Effect.mapError(Effect.fromOption(Option.liftPredicate(value, Predicate.isString)), () => new SchemaIssue.InvalidValue({ message: "a key must be a string" }, Option.some(value)));
+const bridgeKey = (declaring) => {
+	const documents = documentsOf(declaring);
+	const check = validating(declaring.validator);
+	const run = (input) => Effect.flatMap(check(input), textOf);
+	return {
+		codec: describedString(documents.output).pipe(Schema.decodeTo(Schema.String, SchemaTransformation.transformEffect({
+			decode: run,
+			encode: run
+		}))),
+		documents
+	};
+};
+/** The fields of an error declared without any: an empty object. */
+const noFields = Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(Schema.Struct({})));
+/** The default principal of a `user` caller. */
+const principal = Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(Schema.Struct({ id: Schema.String })));
+/** The principal another actor calls with. */
+const actorPrincipal = Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(Schema.Struct({
+	actor: Schema.String,
+	id: Schema.String,
+	key: Schema.String
+})));
+export { actorPrincipal, bridge, bridgeKey, bridgeState, documentsOf, noFields, principal, refuse, validating };

package/dist/local-server.adapter.d.mts

@@ -0,0 +1,23 @@
+import { PlainApp } from "./actor/plain-types.contract.mjs";
+/** A running local engine: the same `akter dev` engine, in this process. */
+interface LocalServer {
+  readonly close: () => Promise<void>;
+  /** Explicit local administration: stops the actor and erases its database, files and computers. Not an app RPC. */
+  readonly erase: (address: {
+    readonly actor: string;
+    readonly key: string;
+  }) => Promise<void>;
+  readonly url: string;
+}
+interface LocalServerOptions {
+  readonly app: PlainApp;
+  /** Overrides AKTER_LOCAL_COMPUTERS for this server. Local steps run on this machine, without isolation. */
+  readonly computers?: boolean;
+  /** The folder that holds every actor's database. A fresh temporary folder, removed on close, when omitted. */
+  readonly directory?: string;
+  /** The port to listen on, on 127.0.0.1. Any free port when omitted. */
+  readonly port?: number;
+}
+/** Serves an app on the local engine, for tests and scripts. Point `createClient` at its `url`. */
+declare const serveLocal: (options: LocalServerOptions) => Promise<LocalServer>;
+export { type LocalServer, type LocalServerOptions, serveLocal };

package/dist/local-server.adapter.mjs

@@ -0,0 +1,43 @@
+import { engineOf } from "./plain-engine.layer.mjs";
+import { layer } from "@effect/platform-node/NodeFileSystem";
+import { ActorHost, Akter } from "@akterjs/effect";
+import { ConfigProvider, Context, Effect, Exit, FileSystem, Layer, Option, Scope } from "effect";
+import { HttpServer } from "effect/http";
+// src/local-server.adapter.ts
+const anyPort = 0;
+const localServerLayer = Effect.fnUntraced(function* localServerLayer({ app, computers, port = anyPort }, folder) {
+	const { actors, layer } = yield* Effect.sync(() => engineOf(app));
+	const engine = Akter.local(folder).pipe(Layer.provide(layer), Layer.provide(Akter.jobs));
+	const served = Akter.serve({
+		actors,
+		port
+	}).pipe(Layer.provideMerge(engine));
+	return Option.match(Option.fromNullishOr(computers), {
+		onNone: () => served,
+		onSome: (enabled) => {
+			const provider = ConfigProvider.fromUnknown({ AKTER_LOCAL_COMPUTERS: String(enabled) });
+			const setting = ConfigProvider.layerAdd(provider, { asPrimary: true });
+			return served.pipe(Layer.provide(setting));
+		}
+	});
+});
+/** Serves an app on the local engine, for tests and scripts. Point `createClient` at its `url`. */
+const serveLocal = (options) => Effect.runPromise(Effect.gen(function* startLocal() {
+	const scope = yield* Scope.make();
+	const temporary = Scope.provide(scope)(FileSystem.FileSystem.use((fileSystem) => fileSystem.makeTempDirectoryScoped({ prefix: "akter-local-" })));
+	const folder = yield* Option.match(Option.fromUndefinedOr(options.directory), {
+		onNone: () => Effect.orDie(temporary),
+		onSome: Effect.succeed
+	});
+	const served = yield* localServerLayer(options, folder);
+	const services = yield* Effect.orDie(Layer.buildWithScope(served, scope));
+	const url = yield* HttpServer.addressFormattedWith(Effect.succeed).pipe(Effect.provide(services));
+	const context = yield* Effect.context();
+	const host = Context.get(services, ActorHost);
+	return {
+		close: () => Effect.runPromiseWith(context)(Scope.close(scope, Exit.void)),
+		erase: (address) => Effect.runPromiseWith(context)(host.erase?.(address) ?? Effect.die("the local engine has no actor erasure")),
+		url
+	};
+}).pipe(Effect.provide(layer)));
+export { serveLocal };

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

@@ -0,0 +1,60 @@
+import { PlainFileAccess } from "./actor/resource/plain-file-access.contract.mjs";
+import { ActorContract, ActorOptions, CreateOf, DeclaredInput, KeyOf, MemberNames, OptionsOf, PayloadArgs, PayloadIn, QueriesOf, StateOf, SuccessOut } from "./actor/plain-types.contract.mjs";
+import { PromiseFiles, PromiseFiles as PromiseFiles$1 } from "@akterjs/client";
+/** One delivery of a subscribed value: the value and the actor's version after the commit that produced it. */
+interface LiveUpdate<Value> {
+  readonly value: Value;
+  readonly version: number;
+}
+type Stop = () => void;
+type OnError = (error: Error) => void;
+type CommandCall<Options> = (...payload: PayloadArgs<PayloadIn<Options>>) => Promise<SuccessOut<Options>>;
+type OnUpdate<Options> = (update: LiveUpdate<SuccessOut<Options>>) => void;
+/** A query declared without a payload subscribes as `subscribe(onUpdate, onError?)`; one with a payload takes it first. */
+type QueryCall<Options> = CommandCall<Options> & {
+  readonly subscribe: [PayloadIn<Options>] extends [undefined] ? (onUpdate: OnUpdate<Options>, onError?: OnError) => Stop : (payload: PayloadIn<Options>, onUpdate: OnUpdate<Options>, onError?: OnError) => Stop;
+};
+type CreationCalls<Options extends ActorOptions> = [CreateOf<Options>] extends [never] ? unknown : {
+  readonly create: (input: DeclaredInput<CreateOf<Options>>) => Promise<void>;
+  readonly ensure: (input: DeclaredInput<CreateOf<Options>>) => Promise<void>;
+};
+/** The actor's files, when it declares file calls: `upload` returns the receipt a command passes to `ctx.files.attach`. */
+type FilesOf<Options extends ActorOptions> = Options extends {
+  readonly files: PlainFileAccess;
+} ? {
+  readonly files: PromiseFiles$1;
+} : unknown;
+/** One actor, addressed by key, called over the network. Calls reject with the declared error classes or an Akter failure carrying `_tag`. */
+type ActorHandle<Options extends ActorOptions> = { readonly [Member in MemberNames<Options["commands"]>]: CommandCall<OptionsOf<Options["commands"][Member]>>; } & { readonly [Member in MemberNames<QueriesOf<Options>>]: QueryCall<OptionsOf<QueriesOf<Options>[Member]>>; } & FilesOf<Options> & {
+  /** Copies this actor into a new one at `into` and resolves with the copy's handle. The copy starts quiet (ADR 0017). */
+  readonly fork: (into: KeyOf<Options>) => Promise<ActorHandle<Options>>;
+  readonly state: {
+    readonly subscribe: (onUpdate: (update: LiveUpdate<StateOf<Options>>) => void, onError?: OnError) => Stop;
+  };
+  readonly warm: () => Promise<void>;
+} & CreationCalls<Options>;
+/** Any actor `Akter.make` defined, as the client takes it. */
+interface AnyPlainActor {
+  readonly "~options"?: ActorOptions;
+  readonly contract: ActorContract;
+  readonly name: string;
+}
+type OptionsOfActor<Actor> = Actor extends {
+  readonly "~options"?: infer Options extends ActorOptions;
+} ? Options : never;
+type HandleOf<Actor> = ActorHandle<OptionsOfActor<Actor>>;
+type KeyOfActor<Actor> = KeyOf<OptionsOfActor<Actor>>;
+/** A client for a set of actors: `client.Ledger("acct-1").deposit({ amount: 5 })`. */
+type PlainClient<Actors extends readonly AnyPlainActor[]> = { readonly [Actor in Actors[number] as Actor["name"]]: (key: KeyOfActor<Actor>) => HandleOf<Actor>; } & {
+  readonly close: () => Promise<void>;
+};
+interface PlainClientOptions<Actors extends readonly AnyPlainActor[]> {
+  readonly actors: Actors;
+  readonly fetch?: typeof globalThis.fetch;
+  readonly headers?: () => Readonly<Record<string, string>>;
+  readonly url: string;
+  readonly webSocket?: typeof globalThis.WebSocket;
+}
+/** Connects to `akter dev` or Akter Cloud. Calls return Promises; queries and state can be subscribed to. */
+declare function createClient<const Actors extends readonly AnyPlainActor[]>(options: PlainClientOptions<Actors>): PlainClient<Actors>;
+export { type ActorHandle, type AnyPlainActor, type LiveUpdate, type OnError, type PlainClient, type PlainClientOptions, type PromiseFiles, type Stop, createClient };

package/dist/plain-client.adapter.mjs

@@ -0,0 +1,12 @@
+import { PlainCompiler } from "./actor/plain-compile.contract.mjs";
+import { Array, Option } from "effect";
+import { createClient as createClient$1 } from "@akterjs/client";
+// src/plain-client.adapter.ts
+const effectActorOf = (actor) => Option.getOrThrowWith(PlainCompiler.compilationOf(actor), () => /* @__PURE__ */ new TypeError(`${actor.name} was not defined with Akter.make from @akterjs/sdk`)).compiled.actor;
+function createClient({ actors, ...connection }) {
+	return createClient$1({
+		...connection,
+		actors: Array.map(actors, effectActorOf)
+	});
+}
+export { createClient };

package/dist/plain-engine.layer.d.mts

@@ -0,0 +1,9 @@
+import { PlainImplement, Served } from "./actor/plain-implement.contract.mjs";
+import { PlainApp } from "./actor/plain-types.contract.mjs";
+/**
+ * The Effect actors and layer a plain app serves, for engines and the conformance suite rather than apps:
+ * `akter dev`, `akter deploy` and Akter Cloud read the same two fields from the app module.
+ * The layer needs the `WorkflowEngine`; provide `Akter.jobs` from `@akterjs/effect` beside the engine.
+ */
+declare const engineOf: (app: PlainApp) => ReturnType<typeof PlainImplement.app>;
+export { type Served, engineOf };

package/dist/plain-engine.layer.mjs

@@ -0,0 +1,10 @@
+import { PlainImplement } from "./actor/plain-implement.contract.mjs";
+import { Option } from "effect";
+// src/plain-engine.layer.ts
+/**
+* The Effect actors and layer a plain app serves, for engines and the conformance suite rather than apps:
+* `akter dev`, `akter deploy` and Akter Cloud read the same two fields from the app module.
+* The layer needs the `WorkflowEngine`; provide `Akter.jobs` from `@akterjs/effect` beside the engine.
+*/
+const engineOf = (app) => Option.getOrThrowWith(PlainImplement.servedOf(app), () => /* @__PURE__ */ new TypeError("engineOf takes an app made by Akter.app"));
+export { engineOf };

package/dist/plain-sdk.contract.d.mts

@@ -0,0 +1,7 @@
+import { Akter } from "./actor/plain-actor.contract.mjs";
+import { ActorContract, ActorOptions, CommandContext, CommandRef, CreateContext, Documents, FinishedJob, Implementation, InputOf, JobOptions, JobRef, JobResult, JobStep, JobSteps, Json, MemberContract, MemberOptions, Migrations, OutputOf, PlainActor, PlainAkter, PlainApp, PlainCommand, PlainDefinitionFailure, PlainError, PlainErrorClass, PlainImplementation, PlainJob, PlainQuery, QueryContext, StateFields, StateUpgrade, Validator } from "./actor/plain-types.contract.mjs";
+import { FileRequest, PlainFileAccess } from "./actor/resource/plain-file-access.contract.mjs";
+import { Delay, Sql, SqlRow, SqlValue } from "./actor/plain-values.contract.mjs";
+import { FileListing, FilePage, FileRef, FileUsage, Files, ReadingFiles } from "./actor/resource/plain-files.contract.mjs";
+import { Computer, ComputerFork, ComputerHold, ComputerSize, ComputerSpec, ComputerState, Computers, ExecRequest, ExecResult } from "./actor/resource/plain-computers.contract.mjs";
+export { type ActorContract, type ActorOptions, Akter, type CommandContext, type CommandRef, type Computer, type ComputerFork, type ComputerHold, type ComputerSize, type ComputerSpec, type ComputerState, type Computers, type CreateContext, type Delay, type Documents, type ExecRequest, type ExecResult, type FileListing, type FilePage, type FileRef, type FileRequest, type FileUsage, type Files, type FinishedJob, type Implementation, type InputOf, type JobOptions, type JobRef, type JobResult, type JobStep, type JobSteps, type Json, type MemberContract, type MemberOptions, type Migrations, type OutputOf, type PlainActor, type PlainAkter, type PlainApp, type PlainCommand, type PlainDefinitionFailure, type PlainError, type PlainErrorClass, type PlainFileAccess, type PlainImplementation, type PlainJob, type PlainQuery, type QueryContext, type ReadingFiles, type Sql, type SqlRow, type SqlValue, type StateFields, type StateUpgrade, type Validator };