@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/contract/command/command.contract.mjs

@@ -0,0 +1,111 @@
+import { carrying, patchedOf, patchesKey, withPatches } from "../job/job-patches.contract.mjs";
+import { ReservedPayloadFieldError } from "../job/reserved-payload-field.errors.mjs";
+import { Array, Context, Duration, Effect, Option, Record, Schema, SchemaTransformation, Struct, pipe } from "effect";
+import { Workflow } from "effect/workflow";
+// src/contract/command/command.contract.ts
+function declaredSchema(input) {
+	if (Schema.isSchema(input)) return input;
+	return Schema.Struct(input);
+}
+const payloadSchema = (options) => pipe(Option.fromNullishOr(options.payload), Option.match({
+	onNone: () => Schema.Void,
+	onSome: (input) => declaredSchema(input)
+}));
+function command(options = {}) {
+	return {
+		callers: Option.fromNullishOr(options.callers),
+		error: options.error ?? Schema.Never,
+		payload: payloadSchema(options),
+		success: options.success ?? Schema.Void
+	};
+}
+function query(options = {}) {
+	return {
+		...command(options),
+		staleFor: Option.map(Option.fromNullishOr(options.staleFor), Duration.fromInputUnsafe)
+	};
+}
+const JobCodecsOf = Context.Reference("@akterjs/effect/contract/command/command.contract/JobCodecsOf", { defaultValue: Option.none });
+function job(options) {
+	return {
+		error: options.error ?? Schema.Never,
+		patches: options.patches ?? [],
+		payload: options.payload,
+		success: options.success ?? Schema.Void
+	};
+}
+const jobTag = ({ actor, member }) => `${actor}/${member}`;
+const jobResult = ({ error, success }) => Schema.Exit(success, error, Schema.Defect());
+/**
+* A job's payload as its journal keeps it: the declared fields, plus the patches the starting code declared under
+* `patchesKey` when it declared any. Code that predates patches ignores the extra key, so a rollback still reads it.
+*/
+const jobCodecs = (declared) => {
+	const fields = Schema.Struct(declared.payload);
+	const stored = Schema.Struct({
+		...declared.payload,
+		[patchesKey]: Schema.optionalKey(Schema.Array(Schema.String))
+	});
+	const result = Schema.fromJsonString(Schema.toCodecJson(jobResult(declared)));
+	const decodeStored = Schema.decodeEffect(Schema.fromJsonString(Schema.toCodecJson(stored)));
+	const withDeclaredPatches = (payload) => {
+		if (Array.isReadonlyArrayEmpty(declared.patches)) return payload;
+		return {
+			...payload,
+			[patchesKey]: declared.patches
+		};
+	};
+	const started = Schema.toEncoded(stored).pipe(Schema.decodeTo(fields, SchemaTransformation.transform({
+		decode: (payload) => Struct.omit(payload, [patchesKey]),
+		encode: withDeclaredPatches
+	})));
+	return {
+		decodePayload: (text) => Effect.map(decodeStored(text), (payload) => carrying({
+			fields: Struct.omit(payload, [patchesKey]),
+			patches: payload[patchesKey]
+		})),
+		decodeResult: Schema.decodeEffect(result),
+		encodeResult: Schema.encodeEffect(result),
+		startedPayload: Schema.fromJsonString(Schema.toCodecJson(started))
+	};
+};
+const workflowOf = (name, member, declared) => {
+	if (Record.has(declared.payload, "~akter/patches")) throw ReservedPayloadFieldError.make({
+		field: patchesKey,
+		job: jobTag({
+			actor: name,
+			member
+		})
+	});
+	const annotations = Context.make(JobCodecsOf, Option.some(jobCodecs(declared)));
+	const made = Workflow.make(jobTag({
+		actor: name,
+		member
+	}), {
+		annotations,
+		error: declared.error,
+		idempotencyKey: () => jobTag({
+			actor: name,
+			member
+		}),
+		payload: declared.payload,
+		success: declared.success
+	});
+	const register = made.toLayer.bind(made);
+	const toLayer = (execute) => register(withPatches(execute));
+	return Object.assign(made, {
+		patched: patchedOf({
+			patches: declared.patches,
+			tag: jobTag({
+				actor: name,
+				member
+			})
+		}),
+		patches: declared.patches,
+		toLayer
+	});
+};
+function jobsOf({ jobs, name }) {
+	return Record.map(jobs, (declared, member) => workflowOf(name, member, declared));
+}
+export { JobCodecsOf, command, declaredSchema, job, jobCodecs, jobResult, jobTag, jobsOf, query };

package/dist/contract/command/outbox-id.pure.d.mts

@@ -0,0 +1,9 @@
+import { OutboxMessage } from "./outbox.schema.mjs";
+declare const outboxCommandId: (id: string) => string;
+declare const isOutboxCommandId: (commandId: string) => boolean;
+declare const mintedIdOf: (commandId: string) => string;
+interface Unsent extends Omit<OutboxMessage, "commandId"> {
+  readonly id: string;
+}
+declare const outboxMessage: ({ id, ...unsent }: Unsent) => OutboxMessage;
+export { isOutboxCommandId, mintedIdOf, outboxCommandId, outboxMessage };

package/dist/contract/command/outbox-id.pure.mjs

@@ -0,0 +1,14 @@
+import { String } from "effect";
+// src/contract/command/outbox-id.pure.ts
+const outboxPrefix = "outbox:";
+const outboxCommandId = (id) => `${outboxPrefix}${id}`;
+const isOutboxCommandId = String.startsWith(outboxPrefix);
+const mintedIdOf = (commandId) => {
+	if (isOutboxCommandId(commandId)) return String.slice(7)(commandId);
+	return commandId;
+};
+const outboxMessage = ({ id, ...unsent }) => ({
+	...unsent,
+	commandId: outboxCommandId(id)
+});
+export { isOutboxCommandId, mintedIdOf, outboxCommandId, outboxMessage };

package/dist/contract/command/outbox.schema.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+export declare const OutboxMessage: Schema.Struct<{
+  readonly actor: Schema.String;
+  readonly commandId: Schema.String;
+  readonly key: Schema.String;
+  readonly member: Schema.String;
+  readonly payload: Schema.String;
+}>;
+export type OutboxMessage = typeof OutboxMessage.Type;

package/dist/contract/command/outbox.schema.mjs

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+// src/contract/command/outbox.schema.ts
+const OutboxMessage = Schema.Struct({
+	actor: Schema.String,
+	commandId: Schema.String,
+	key: Schema.String,
+	member: Schema.String,
+	payload: Schema.String
+});
+export { OutboxMessage };

package/dist/contract/command/timer.schema.d.mts

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+export declare const TimerId: Schema.brand<Schema.String, "TimerId">;
+export type TimerId = typeof TimerId.Type;
+export declare const ScheduledTimer: Schema.Struct<{
+  readonly after: Schema.Duration;
+  readonly command: Schema.String;
+  readonly id: Schema.brand<Schema.String, "TimerId">;
+  readonly payload: Schema.String;
+}>;
+export type ScheduledTimer = typeof ScheduledTimer.Type;
+export declare const TimerChanges: Schema.Struct<{
+  readonly cancelled: Schema.$Array<Schema.brand<Schema.String, "TimerId">>;
+  readonly scheduled: Schema.$Array<Schema.Struct<{
+    readonly after: Schema.Duration;
+    readonly command: Schema.String;
+    readonly id: Schema.brand<Schema.String, "TimerId">;
+    readonly payload: Schema.String;
+  }>>;
+}>;
+export type TimerChanges = typeof TimerChanges.Type;

package/dist/contract/command/timer.schema.mjs

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+// src/contract/command/timer.schema.ts
+const TimerId = Schema.String.pipe(Schema.brand("TimerId"));
+const ScheduledTimer = Schema.Struct({
+	after: Schema.Duration,
+	command: Schema.String,
+	id: TimerId,
+	payload: Schema.String
+});
+const TimerChanges = Schema.Struct({
+	cancelled: Schema.Array(TimerId),
+	scheduled: Schema.Array(ScheduledTimer)
+});
+export { ScheduledTimer, TimerChanges, TimerId };

package/dist/contract/computer/checkpoint-expired.errors.d.mts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+declare const CheckpointExpiredError_base: Schema.Class<CheckpointExpiredError, Schema.TaggedStruct<"CheckpointExpiredError", {
+  readonly computer: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The computer's saved checkpoint can no longer be forked: Archil keeps only the current session's checkpoint and
+ * the one before it. Resume the computer to take a new one, or fork without it.
+ */
+export declare class CheckpointExpiredError extends CheckpointExpiredError_base {}
+export {};

package/dist/contract/computer/checkpoint-expired.errors.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/contract/computer/checkpoint-expired.errors.ts
+/**
+* The computer's saved checkpoint can no longer be forked: Archil keeps only the current session's checkpoint and
+* the one before it. Resume the computer to take a new one, or fork without it.
+*/
+var CheckpointExpiredError = class extends Schema.TaggedError()("CheckpointExpiredError", { computer: Schema.String }) {};
+export { CheckpointExpiredError };

package/dist/contract/computer/computer-client-failure.contract.d.mts

@@ -0,0 +1,16 @@
+import { ActorUnavailableError } from "../client/actor-unavailable.errors.mjs";
+import { CallerNotAllowedError } from "../caller/caller-not-allowed.errors.mjs";
+import { UnauthenticatedError } from "../caller/unauthenticated.errors.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { ComputerHeldError } from "./computer-held.errors.mjs";
+import { ComputerLimitError } from "./computer-limit.errors.mjs";
+import { ComputerLostError } from "./computer-lost.errors.mjs";
+import { ComputerNotFoundError } from "./computer-not-found.errors.mjs";
+import { ComputersUnavailableError } from "./computers-unavailable.errors.mjs";
+/**
+ * What a computer client can fail with. A network client adds the caller's refusals, `CallerNotAllowedError` and
+ * `UnauthenticatedError`; a host's own client never refuses its caller. A request past the exec limits is an
+ * `InvalidRequestError`.
+ */
+type ComputerClientFailure = ActorUnavailableError | CallerNotAllowedError | ComputerHeldError | ComputerLimitError | ComputerLostError | ComputerNotFoundError | ComputersUnavailableError | InvalidRequestError | UnauthenticatedError;
+export type { ComputerClientFailure };

package/dist/contract/computer/computer-client-failure.contract.mjs

@@ -0,0 +1 @@
+export {};

package/dist/contract/computer/computer-client.adapter.d.mts

@@ -0,0 +1,21 @@
+import { ActorDefinition } from "../actor/actor.contract.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { ActorComputers, ComputerAddress, ComputerClient } from "./computer-client.contract.mjs";
+import { ComputerClientFailure } from "./computer-client-failure.contract.mjs";
+import { ComputerLogLine, ComputerLogPage } from "./computer.schema.mjs";
+import { ComputersUnavailableError } from "./computers-unavailable.errors.mjs";
+import { Context, Effect } from "effect";
+interface ComputerClientSource {
+  readonly definition: ActorDefinition;
+  readonly name: string;
+}
+type ComputerClientOf<Definition extends ActorDefinition> = (key: Definition["key"]["Type"]) => Effect.Effect<ActorComputers, ComputersUnavailableError | InvalidRequestError>;
+declare const ActorComputerClients_base: Context.ServiceClass<ActorComputerClients, "@akterjs/effect/contract/computer/computer-client.adapter/ActorComputerClients", {
+  readonly connect: (address: ComputerAddress) => ComputerClient;
+  /** A page of one computer's log, read from outside the actor (`<Actor>/computer/logs`). */
+  readonly logs: (address: ComputerAddress, computer: string, page: ComputerLogPage) => Effect.Effect<readonly ComputerLogLine[], ComputerClientFailure>;
+}>;
+export declare class ActorComputerClients extends ActorComputerClients_base {
+  static clientOf<Definition extends ActorDefinition>(source: ComputerClientSource): ComputerClientOf<Definition>;
+}
+export type { ComputerClientOf };

package/dist/contract/computer/computer-client.adapter.mjs

@@ -0,0 +1,70 @@
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { ComputerSpec, ExecRequest } from "./computer.schema.mjs";
+import { ComputersUnavailableError } from "./computers-unavailable.errors.mjs";
+import { SecretUnavailableError } from "../secret/secret-unavailable.errors.mjs";
+import { step } from "./step/computer-step.contract.mjs";
+import { StepRequest } from "./step/computer-step.schema.mjs";
+import { Array, Context, Effect, Option, Schema } from "effect";
+// src/contract/computer/computer-client.adapter.ts
+const checked = (schema, actor) => {
+	const decode = Schema.decodeUnknownEffect(schema);
+	return (value) => Effect.mapError(decode(value), (invalid) => InvalidRequestError.make({
+		actor,
+		message: invalid.message
+	}));
+};
+/** A spec binds only secrets the actor declares, so a computer never gets a credential its actor may not read. */
+const declared = ({ definition, name }) => (spec) => {
+	const undeclared = Array.findFirst(spec.secrets ?? [], ({ secret }) => !Array.contains(definition.secrets, secret));
+	return Option.match(undeclared, {
+		onNone: () => Effect.succeed(spec),
+		onSome: ({ secret }) => Effect.fail(SecretUnavailableError.make({
+			actor: name,
+			reason: "undeclared",
+			secret
+		}))
+	});
+};
+/**
+* Checks every spec and exec request against the contract, so an engine never sees one past the limits, and every
+* secret a spec binds against the actor's declaration.
+*/
+const bounded = (client, source) => {
+	const spec = checked(ComputerSpec, source.name);
+	const request = checked(ExecRequest, source.name);
+	const allowed = declared(source);
+	const stepRequest = checked(StepRequest, source.name);
+	const checkedClient = {
+		...client,
+		ensure: (wanted) => Effect.flatMap(Effect.flatMap(spec(wanted), allowed), client.ensure),
+		exec: (computer, wanted) => Effect.flatMap(request(wanted), (valid) => client.exec(computer, valid))
+	};
+	return {
+		...checkedClient,
+		step: (computer, wanted) => Effect.flatMap(stepRequest(wanted), (valid) => step({
+			client: checkedClient,
+			computer,
+			request: valid
+		}))
+	};
+};
+var ActorComputerClients = class ActorComputerClients extends Context.Service()("@akterjs/effect/contract/computer/computer-client.adapter/ActorComputerClients") {
+	static clientOf({ definition, name }) {
+		return (key) => Effect.gen(function* connectComputers() {
+			const clients = yield* Effect.serviceOption(ActorComputerClients);
+			if (Option.isNone(clients)) return yield* ComputersUnavailableError.make({ message: "computers aren't available on this host" });
+			const encoded = yield* Schema.encodeEffect(definition.key)(key).pipe(Effect.mapError(() => InvalidRequestError.make({
+				actor: name,
+				message: "the actor key is invalid"
+			})));
+			return bounded(clients.value.connect({
+				actor: name,
+				key: encoded
+			}), {
+				definition,
+				name
+			});
+		});
+	}
+};
+export { ActorComputerClients };

package/dist/contract/computer/computer-client.contract.d.mts

@@ -0,0 +1,56 @@
+import { ComputerClientFailure } from "./computer-client-failure.contract.mjs";
+import { Computer, ComputerName, ComputerSpec, ExecRequest, ExecResult } from "./computer.schema.mjs";
+import { CheckpointExpiredError } from "./checkpoint-expired.errors.mjs";
+import { SecretUnavailableError } from "../secret/secret-unavailable.errors.mjs";
+import { StepRequest } from "./step/computer-step.schema.mjs";
+import { ComputerFileRequest } from "./files/computer-files.schema.mjs";
+import { Effect } from "effect";
+import { WorkflowEngine } from "effect/workflow";
+interface ComputerAddress {
+  readonly actor: string;
+  readonly key: string;
+}
+/**
+ * One actor's computers. Each call reaches a provider, so call it from a job activity or the host, never from a
+ * command or query (ADR 0007). `ensure`, `pause`, `resume`, `stop` and `remove` drive the computer to that state
+ * and are safe to send again after a lost reply. `exec` runs one step, keyed so a resend reads its outcome back.
+ */
+/**
+ * Where a fork goes: another actor, by its encoded key, and optionally a new name. A live computer is paused for
+ * its checkpoint and resumed; a paused or stopped one forks from its saved checkpoint.
+ */
+interface ComputerFork {
+  readonly into: ComputerAddress;
+  readonly name?: ComputerName;
+}
+/**
+ * A hold on a computer, such as a fork's id. `pause` with a hold keeps the computer paused, or stopped if it was stopped: `ensure`, `exec`
+ * and a `resume` or `pause` without the same hold fail with `ComputerHeldError`, so nothing changes its pause under a fork. `resume` with the hold releases it and returns the computer to where the held `pause` found it, running, paused or stopped. A hold survives restarts, so a retried fork releases what an earlier attempt held.
+ */
+interface ComputerHold {
+  readonly hold?: string;
+}
+interface ComputerClient {
+  /** A spec's `secrets` must be among the actor's declared secrets, and set in its environment. */
+  readonly ensure: (spec: ComputerSpec) => Effect.Effect<Computer, ComputerClientFailure | SecretUnavailableError>;
+  readonly exec: (computer: string, request: ExecRequest) => Effect.Effect<ExecResult, ComputerClientFailure>;
+  /** Reads or replaces one file in the computer's files directory; a write answers empty bytes. */
+  readonly files: (computer: string, request: ComputerFileRequest) => Effect.Effect<Uint8Array, ComputerClientFailure>;
+  /** Copies the computer, its files and memory, to the target actor. A resend finds the copy already made. */
+  readonly fork: (computer: string, fork: ComputerFork) => Effect.Effect<Computer, ComputerClientFailure | CheckpointExpiredError>;
+  readonly get: (computer: string) => Effect.Effect<Computer, ComputerClientFailure>;
+  readonly list: Effect.Effect<readonly Computer[], ComputerClientFailure>;
+  readonly pause: (computer: string, hold?: ComputerHold) => Effect.Effect<Computer, ComputerClientFailure>;
+  readonly remove: (computer: string) => Effect.Effect<void, ComputerClientFailure>;
+  readonly resume: (computer: string, hold?: ComputerHold) => Effect.Effect<Computer, ComputerClientFailure>;
+  readonly stop: (computer: string) => Effect.Effect<Computer, ComputerClientFailure>;
+}
+/**
+ * An actor's computers as its jobs reach them through `Actor.computer(key)`: the client, plus `step`, which runs one
+ * command as a durable step of the calling job (`./step/computer-step.contract.ts`). Call `step` from a job, never from
+ * inside an activity.
+ */
+interface ActorComputers extends ComputerClient {
+  readonly step: (computer: string, request: StepRequest) => Effect.Effect<ExecResult, ComputerClientFailure, WorkflowEngine.WorkflowEngine | WorkflowEngine.WorkflowInstance>;
+}
+export type { ActorComputers, ComputerAddress, ComputerClient, ComputerClientFailure, ComputerFork, ComputerHold };

package/dist/contract/computer/computer-client.contract.mjs

@@ -0,0 +1 @@
+export {};

package/dist/contract/computer/computer-held.errors.d.mts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+declare const ComputerHeldError_base: Schema.Class<ComputerHeldError, Schema.TaggedStruct<"ComputerHeldError", {
+  readonly computer: Schema.String;
+  readonly hold: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * A fork holds the computer paused. Nothing but that fork's resume, carrying the same hold, may run or resume it;
+ * try again once the fork ends.
+ */
+export declare class ComputerHeldError extends ComputerHeldError_base {}
+export {};

package/dist/contract/computer/computer-held.errors.mjs

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+// src/contract/computer/computer-held.errors.ts
+/**
+* A fork holds the computer paused. Nothing but that fork's resume, carrying the same hold, may run or resume it;
+* try again once the fork ends.
+*/
+var ComputerHeldError = class extends Schema.TaggedError()("ComputerHeldError", {
+	computer: Schema.String,
+	hold: Schema.String
+}) {};
+export { ComputerHeldError };

package/dist/contract/computer/computer-limit.errors.d.mts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+declare const ComputerLimitError_base: Schema.Class<ComputerLimitError, Schema.TaggedStruct<"ComputerLimitError", {
+  readonly computer: Schema.String;
+  readonly limit: Schema.Literals<readonly ["store", "account"]>;
+  readonly maximum: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * A new computer would pass a limit, so none was made: `store`, the computers one app environment may keep, or
+ * `account`, the sandboxes the platform's provider account may run at once. Remove a computer, or try again once
+ * one is gone. Nothing waits for room.
+ */
+export declare class ComputerLimitError extends ComputerLimitError_base {}
+export {};

package/dist/contract/computer/computer-limit.errors.mjs

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+// src/contract/computer/computer-limit.errors.ts
+/**
+* A new computer would pass a limit, so none was made: `store`, the computers one app environment may keep, or
+* `account`, the sandboxes the platform's provider account may run at once. Remove a computer, or try again once
+* one is gone. Nothing waits for room.
+*/
+var ComputerLimitError = class extends Schema.TaggedError()("ComputerLimitError", {
+	computer: Schema.String,
+	limit: Schema.Literals(["store", "account"]),
+	maximum: Schema.Int
+}) {};
+export { ComputerLimitError };

package/dist/contract/computer/computer-lost.errors.d.mts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+declare const ComputerLostError_base: Schema.Class<ComputerLostError, Schema.TaggedStruct<"ComputerLostError", {
+  readonly computer: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The computer's disk no longer exists, so it can't be resumed or run in. It is not recreated empty under the same
+ * name; remove it and ensure it again to start over.
+ */
+export declare class ComputerLostError extends ComputerLostError_base {}
+export {};

package/dist/contract/computer/computer-lost.errors.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/contract/computer/computer-lost.errors.ts
+/**
+* The computer's disk no longer exists, so it can't be resumed or run in. It is not recreated empty under the same
+* name; remove it and ensure it again to start over.
+*/
+var ComputerLostError = class extends Schema.TaggedError()("ComputerLostError", { computer: Schema.String }) {};
+export { ComputerLostError };

package/dist/contract/computer/computer-not-found.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const ComputerNotFoundError_base: Schema.Class<ComputerNotFoundError, Schema.TaggedStruct<"ComputerNotFoundError", {
+  readonly computer: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The actor has no computer of that name. */
+export declare class ComputerNotFoundError extends ComputerNotFoundError_base {}
+export {};

package/dist/contract/computer/computer-not-found.errors.mjs

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+// src/contract/computer/computer-not-found.errors.ts
+/** The actor has no computer of that name. */
+var ComputerNotFoundError = class extends Schema.TaggedError()("ComputerNotFoundError", { computer: Schema.String }) {};
+export { ComputerNotFoundError };

package/dist/contract/computer/computer.schema.d.mts

@@ -0,0 +1,122 @@
+import { ComputerSecret } from "../secret/secret.schema.mjs";
+import { ComputerCopy, ComputerCopyResult, ComputerFileRequest, computerFileBytes } from "./files/computer-files.schema.mjs";
+import { Schema } from "effect";
+/**
+ * Archil's serverless exec limits, applied to every exec step so a step behaves the same in any engine: five
+ * minutes, 100 KiB of command and standard input together, and 4 MiB of each output stream returned. Longer work
+ * runs as a process in the computer; longer output belongs in files.
+ */
+declare const execLimits: {
+  readonly inputBytes: number;
+  readonly outputBytes: number;
+  readonly seconds: 300;
+};
+/** One of an actor's computers. Lowercase letters, digits and hyphens, starting with a letter. */
+declare const ComputerName: Schema.brand<Schema.String, "ComputerName">;
+type ComputerName = typeof ComputerName.Type;
+declare const ComputerSize: Schema.Struct<{
+  readonly memoryMib: Schema.Int;
+  readonly vcpu: Schema.Int;
+}>;
+type ComputerSize = typeof ComputerSize.Type;
+/**
+ * A computer to keep: its image, its size and the hosts it may reach. `egress` lists hosts or rules, never
+ * credentials. `secrets` names the credentials the platform adds to an allowed host's requests on the way out, from
+ * the actor's declared secrets, so no value ever reaches the computer.
+ */
+declare const ComputerSpec: Schema.Struct<{
+  readonly egress: Schema.$Array<Schema.String>;
+  readonly image: Schema.String;
+  readonly name: Schema.brand<Schema.String, "ComputerName">;
+  readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly header: Schema.String;
+    readonly host: Schema.String;
+    readonly prefix: Schema.optionalKey<Schema.String>;
+    readonly secret: Schema.String;
+  }>>>;
+  readonly size: Schema.Struct<{
+    readonly memoryMib: Schema.Int;
+    readonly vcpu: Schema.Int;
+  }>;
+}>;
+type ComputerSpec = typeof ComputerSpec.Type;
+/**
+ * Where a computer is. `paused` keeps its memory, processes and files; `stopped` and `failed` keep only its files;
+ * `gone` means its disk no longer exists, so it is never recreated empty under the same name by accident.
+ */
+declare const ComputerState: Schema.Literals<readonly ["starting", "running", "paused", "stopped", "failed", "gone"]>;
+type ComputerState = typeof ComputerState.Type;
+declare const Computer: Schema.Struct<{
+  readonly egress: Schema.$Array<Schema.String>;
+  readonly image: Schema.String;
+  readonly name: Schema.brand<Schema.String, "ComputerName">;
+  readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly header: Schema.String;
+    readonly host: Schema.String;
+    readonly prefix: Schema.optionalKey<Schema.String>;
+    readonly secret: Schema.String;
+  }>>>;
+  readonly size: Schema.Struct<{
+    readonly memoryMib: Schema.Int;
+    readonly vcpu: Schema.Int;
+  }>;
+  readonly state: Schema.Literals<readonly ["starting", "running", "paused", "stopped", "failed", "gone"]>;
+}>;
+type Computer = typeof Computer.Type;
+/**
+ * One exec step. `key` is the step's stable logical-operation key, such as `Activity.idempotencyKey(name)`: the
+ * computer records the outcome under it, so the same step sent again reads that outcome back instead of running.
+ */
+declare const ExecRequest: Schema.Struct<{
+  readonly command: Schema.String;
+  readonly cwd: Schema.optionalKey<Schema.String>;
+  readonly key: Schema.String;
+  readonly stdin: Schema.optionalKey<Schema.Uint8Array>;
+  readonly timeoutSeconds: Schema.optionalKey<Schema.Int>;
+}>;
+type ExecRequest = typeof ExecRequest.Type;
+/**
+ * The step ran to an end, or its recorded outcome was read back; the two look the same. `exitCode` is absent when
+ * the process was ended without one, such as at the time limit. Past 4 MiB a stream, output is not returned and
+ * `truncated` is set; the whole of each stream stays in the step's directory on the computer.
+ */
+declare const ExecRan: Schema.TaggedStruct<"Ran", {
+  readonly exitCode: Schema.optionalKey<Schema.Int>;
+  readonly stderr: Schema.String;
+  readonly stdout: Schema.String;
+  readonly truncated: Schema.Boolean;
+}>;
+/**
+ * The step started once but no outcome was recorded: the computer lost power, or the step is still running. It is
+ * not run again, because whatever it did outside the computer may already have happened. Reconcile with the
+ * outside system by the step's key.
+ */
+declare const ExecUnknown: Schema.TaggedStruct<"Unknown", {}>;
+declare const ExecResult: Schema.Union<readonly [Schema.TaggedStruct<"Ran", {
+  readonly exitCode: Schema.optionalKey<Schema.Int>;
+  readonly stderr: Schema.String;
+  readonly stdout: Schema.String;
+  readonly truncated: Schema.Boolean;
+}>, Schema.TaggedStruct<"Unknown", {}>]>;
+type ExecResult = typeof ExecResult.Type;
+/** How much a log page returns at most, and when a request names no limit. */
+declare const logPageLines = 1000;
+/**
+ * One line of a computer's log, oldest first: what the platform did to it (made, paused, resumed, stopped, forked,
+ * deleted) and each exec step's key and outcome. `seq` rises by one per line of the computer, so a reader passes the
+ * last `seq` it saw as `after` to read on.
+ */
+declare const ComputerLogLine: Schema.Struct<{
+  readonly at: Schema.Int;
+  readonly level: Schema.Literals<readonly ["info", "warn", "error"]>;
+  readonly message: Schema.String;
+  readonly seq: Schema.Int;
+}>;
+type ComputerLogLine = typeof ComputerLogLine.Type;
+/** A page of a computer's log: the lines after `after`, at most `limit` (1 to 1,000; 1,000 when absent). */
+declare const ComputerLogPage: Schema.Struct<{
+  readonly after: Schema.optionalKey<Schema.Int>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+type ComputerLogPage = typeof ComputerLogPage.Type;
+export { Computer, ComputerCopy, ComputerCopyResult, ComputerFileRequest, ComputerLogLine, ComputerLogPage, ComputerName, ComputerSecret, ComputerSize, ComputerSpec, ComputerState, ExecRan, ExecRequest, ExecResult, ExecUnknown, computerFileBytes, execLimits, logPageLines };