@akterjs/effect 0.0.0-stage → 0.1.1

package/dist/contract/caller/caller-not-allowed.errors.d.mts

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+declare const CallerNotAllowedError_base: Schema.Class<CallerNotAllowedError, Schema.TaggedStruct<"CallerNotAllowedError", {
+  readonly actor: Schema.String;
+  readonly kind: Schema.String;
+  readonly member: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The caller's kind may not call this member. Its message names the refused kind and the declaration that admits it,
+ * such as `apiKey` for a script, agent or bench signed in with an Akter Cloud API key.
+ */
+export declare class CallerNotAllowedError extends CallerNotAllowedError_base {
+  get message(): string;
+}
+export {};

package/dist/contract/caller/caller-not-allowed.errors.mjs

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+// src/contract/caller/caller-not-allowed.errors.ts
+/**
+* The caller's kind may not call this member. Its message names the refused kind and the declaration that admits it,
+* such as `apiKey` for a script, agent or bench signed in with an Akter Cloud API key.
+*/
+var CallerNotAllowedError = class extends Schema.TaggedError()("CallerNotAllowedError", {
+	actor: Schema.String,
+	kind: Schema.String,
+	member: Schema.String
+}) {
+	get message() {
+		if (this.member === "akter.files") return `${this.actor}'s files refuse caller kind "${this.kind}". To admit it, list it in the actor's files: Akter.fileAccess({ callers: ["${this.kind}"] }), and allow it in files.authorize.`;
+		if (this.member === "fork") return `${this.actor}.fork refuses caller kind "${this.kind}". Fork admits only an app's operators, the "user" and "apiKey" caller kinds.`;
+		return `${this.actor}.${this.member} refuses caller kind "${this.kind}". To admit it, declare it on the actor, as in callers: { ${this.kind}: Akter.Principal, user: Akter.Principal }, and add "${this.kind}" to the member's callers if it lists them.`;
+	}
+};
+export { CallerNotAllowedError };

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

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+export declare const Caller: Schema.Struct<{
+  readonly kind: Schema.String;
+  readonly principal: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export type Caller = typeof Caller.Type;
+export declare const actorKind = "actor";

package/dist/contract/caller/caller.schema.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/contract/caller/caller.schema.ts
+const Caller = Schema.Struct({
+	kind: Schema.String,
+	principal: Schema.Json
+});
+const actorKind = "actor";
+export { Caller, actorKind };

package/dist/contract/caller/current-caller.service.d.mts

@@ -0,0 +1,7 @@
+import { Context } from "effect";
+declare const CurrentCaller_base: Context.ServiceClass<CurrentCaller, "@akterjs/effect/contract/caller/current-caller.service/CurrentCaller", {
+  readonly kind: string;
+  readonly principal: import("effect/Schema").Json;
+}>;
+export declare class CurrentCaller extends CurrentCaller_base {}
+export {};

package/dist/contract/caller/current-caller.service.mjs

@@ -0,0 +1,4 @@
+import { Context } from "effect";
+// src/contract/caller/current-caller.service.ts
+var CurrentCaller = class extends Context.Service()("@akterjs/effect/contract/caller/current-caller.service/CurrentCaller") {};
+export { CurrentCaller };

package/dist/contract/caller/principal.schema.d.mts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+export declare const PrincipalId: Schema.brand<Schema.String, "PrincipalId">;
+export type PrincipalId = typeof PrincipalId.Type;
+export declare const Principal: Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "PrincipalId">;
+}>;
+export type Principal = typeof Principal.Type;
+export declare const ActorPrincipal: Schema.Struct<{
+  readonly actor: Schema.String;
+  readonly id: Schema.brand<Schema.String, "PrincipalId">;
+  readonly key: Schema.String;
+}>;
+export type ActorPrincipal = typeof ActorPrincipal.Type;

package/dist/contract/caller/principal.schema.mjs

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+// src/contract/caller/principal.schema.ts
+const PrincipalId = Schema.String.pipe(Schema.brand("PrincipalId"));
+const Principal = Schema.Struct({ id: PrincipalId });
+const ActorPrincipal = Schema.Struct({
+	actor: Schema.String,
+	id: PrincipalId,
+	key: Schema.String
+});
+export { ActorPrincipal, Principal, PrincipalId };

package/dist/contract/caller/unauthenticated.errors.d.mts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+declare const UnauthenticatedError_base: Schema.Class<UnauthenticatedError, Schema.TaggedStruct<"UnauthenticatedError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class UnauthenticatedError extends UnauthenticatedError_base {}
+export {};

package/dist/contract/caller/unauthenticated.errors.mjs

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+// src/contract/caller/unauthenticated.errors.ts
+var UnauthenticatedError = class extends Schema.TaggedError()("UnauthenticatedError", { message: Schema.String }) {};
+export { UnauthenticatedError };

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

@@ -0,0 +1,42 @@
+import { ActorRpcs, LiveUpdate } from "./actor-rpc.contract.mjs";
+import { ActorClient, QueryClient } from "./actor-client.contract.mjs";
+import { ActorDefinition } from "../actor/actor.contract.mjs";
+import { SecretOf } from "../secret/actor-secrets.adapter.mjs";
+import { ComputerClientOf } from "../computer/computer-client.adapter.mjs";
+import { FileClientOf } from "../file/file-client.adapter.mjs";
+import { Context, Effect, Layer, Scope, Stream } from "effect";
+import { RpcClient } from "effect/rpc";
+import { SecureRandom } from "effect/crypto";
+type ClientServices = ActorClients | RpcClient.Protocol | Scope.Scope;
+type ClientOf<Definition extends ActorDefinition> = (key: Definition["key"]["Type"]) => Effect.Effect<ActorClient<Definition>, never, ClientServices>;
+interface ClientSource {
+  readonly definition: ActorDefinition;
+  readonly name: string;
+  readonly rpcs: ActorRpcs;
+}
+interface WireValue {
+  readonly wire: unique symbol;
+}
+interface WireFailure {
+  readonly _tag: string;
+}
+type WireCall = (payload: WireValue) => Effect.Effect<WireValue, WireFailure>;
+type WireUpdates = Stream.Stream<LiveUpdate<WireValue>, WireFailure>;
+type WireQuery = WireCall & {
+  readonly subscribe: (payload: WireValue) => WireUpdates;
+};
+type WireWarm = Effect.Effect<WireValue, WireFailure>;
+type WireFork = (into: WireValue) => Effect.Effect<WireClient, WireFailure>;
+type WireClient = Readonly<Record<string, WireCall | WireFork | WireQuery | WireUpdates | WireWarm>>;
+declare const ActorClients_base: Context.ServiceClass<ActorClients, "@akterjs/effect/contract/client/actor-client.adapter/ActorClients", {
+  readonly connect: (source: ClientSource, key: WireValue) => Effect.Effect<WireClient, never, RpcClient.Protocol | Scope.Scope>;
+}>;
+export declare class ActorClients extends ActorClients_base {
+  static computerOf<Definition extends ActorDefinition>(source: Pick<ClientSource, "definition" | "name">): ComputerClientOf<Definition>;
+  static filesOf<Definition extends ActorDefinition>(source: Pick<ClientSource, "definition" | "name">): FileClientOf<Definition>;
+  /** The actor's declared secrets, read in its job activities (`ActorSecrets`). */
+  static secretOf<Definition extends ActorDefinition>(source: Pick<ClientSource, "definition" | "name">): SecretOf<Definition>;
+  static readonly layer: Layer.Layer<ActorClients, never, SecureRandom.SecureRandom>;
+  static clientOf<Definition extends ActorDefinition>(source: ClientSource): ClientOf<Definition>;
+}
+export type { ActorClient, ClientOf, ComputerClientOf, FileClientOf, QueryClient, SecretOf };

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

@@ -0,0 +1,90 @@
+import { creationModesOf } from "./actor-rpc.contract.mjs";
+import { ActorSecrets } from "../secret/actor-secrets.adapter.mjs";
+import { ActorComputerClients } from "../computer/computer-client.adapter.mjs";
+import { ActorFileClients } from "../file/file-client.adapter.mjs";
+import { Array, Context, Duration, Effect, Layer, Predicate, Record, Schedule, Stream } from "effect";
+import { RpcClient } from "effect/rpc";
+import { SecureRandom } from "effect/crypto";
+// src/contract/client/actor-client.adapter.ts
+const retryMillis = 50;
+const retryLimit = 5;
+const resumeCapMillis = 5e3;
+const noVersion = -1;
+const isTransportFailure = (failure) => Predicate.isTagged(failure, "RpcClientError");
+const resubscribing = Schedule.min([Schedule.exponential(Duration.millis(retryMillis)), Schedule.spaced(Duration.millis(resumeCapMillis))]).pipe(Schedule.while(({ input }) => isTransportFailure(input)));
+const resumed = (updates) => updates.pipe(Stream.retry(resubscribing), Stream.mapAccum(() => noVersion, (last, update) => {
+	if (update.version > last) return [update.version, [update]];
+	return [last, []];
+}));
+function wireSenders(rpcs) {
+	return Effect.map(RpcClient.make(rpcs, { flatten: true }), (client) => ({
+		send: client,
+		watch: client
+	}));
+}
+const sendOnce = ({ random, senders }, tag, request) => Effect.flatMap(random.uuidV7(), (commandId) => Effect.retry(senders.send(tag, {
+	...request,
+	commandId
+}), {
+	schedule: Schedule.exponential(Duration.millis(retryMillis)),
+	times: retryLimit,
+	while: isTransportFailure
+}));
+const queriesOf = ({ senders, source }, key) => Record.map(source.definition.queries, (_declaration, member) => {
+	const call = (payload) => senders.send(`${source.name}/${member}`, {
+		key,
+		payload
+	});
+	return Object.assign(call, { subscribe: (payload) => resumed(senders.watch(`${source.name}/${member}/subscribe`, {
+		key,
+		payload
+	})) });
+});
+const wireClient = (wiring, key) => {
+	const { definition, name } = wiring.source;
+	const { send, watch } = wiring.senders;
+	const command = (tag) => (payload) => sendOnce(wiring, tag, {
+		key,
+		payload
+	});
+	const creation = Record.fromEntries(Array.map(creationModesOf(definition.create), (mode) => [mode, command(`${name}/${mode}`)]));
+	const fork = (into) => Effect.as(sendOnce(wiring, `${name}/fork`, {
+		into,
+		key
+	}), wireClient(wiring, into));
+	return {
+		...Record.map(definition.commands, (_declaration, member) => command(`${name}/${member}`)),
+		...creation,
+		...queriesOf(wiring, key),
+		fork,
+		state: resumed(watch(`${name}/state/subscribe`, { key })),
+		warm: send(`${name}/warm`, { key })
+	};
+};
+var ActorClients = class ActorClients extends Context.Service()("@akterjs/effect/contract/client/actor-client.adapter/ActorClients") {
+	static computerOf(source) {
+		return ActorComputerClients.clientOf(source);
+	}
+	static filesOf(source) {
+		return ActorFileClients.clientOf(source);
+	}
+	/** The actor's declared secrets, read in its job activities (`ActorSecrets`). */
+	static secretOf(source) {
+		return ActorSecrets.secretOf({
+			name: source.name,
+			secrets: source.definition.secrets
+		});
+	}
+	static layer = Layer.effect(ActorClients, Effect.gen(function* makeActorClients() {
+		const random = yield* SecureRandom.SecureRandom;
+		return { connect: (source, key) => Effect.map(wireSenders(source.rpcs), (senders) => wireClient({
+			random,
+			senders,
+			source
+		}, key)) };
+	}));
+	static clientOf(source) {
+		return (key) => ActorClients.use((clients) => clients.connect(source, key));
+	}
+};
+export { ActorClients };

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

@@ -0,0 +1,30 @@
+import { ActorAlreadyExistsError } from "../actor/actor-already-exists.errors.mjs";
+import { UnauthenticatedError } from "../caller/unauthenticated.errors.mjs";
+import { LiveUpdate } from "./actor-rpc.contract.mjs";
+import { ActorDefinition } from "../actor/actor.contract.mjs";
+import { AnyCommand, AnyQuery } from "../command/command.contract.mjs";
+import { HostedFailure } from "../hosted/hosted-failure.schema.mjs";
+import "./client-failure.contract.mjs";
+import { Effect, Schema, Stream } from "effect";
+import { RpcClientError } from "effect/rpc";
+type ClientFailure<Declaration extends AnyCommand | AnyQuery> = Declaration["error"]["Type"] | RpcClientError.RpcClientError | UnauthenticatedError | (typeof HostedFailure)["Type"];
+type ClientCall<Declaration extends AnyCommand | AnyQuery> = (payload: Declaration["payload"]["Type"]) => Effect.Effect<Declaration["success"]["Type"], ClientFailure<Declaration>>;
+type QueryClient<Declaration extends AnyQuery> = ClientCall<Declaration> & {
+  readonly subscribe: (payload: Declaration["payload"]["Type"]) => Stream.Stream<LiveUpdate<Declaration["success"]["Type"]>, ClientFailure<Declaration>>;
+};
+type StateFailure = RpcClientError.RpcClientError | UnauthenticatedError | (typeof HostedFailure)["Type"];
+type CreationClient<Definition extends ActorDefinition> = Definition["create"] extends Schema.Never ? unknown : {
+  readonly create: (input: Definition["create"]["Type"]) => Effect.Effect<void, ActorAlreadyExistsError | StateFailure>;
+  readonly ensure: (input: Definition["create"]["Type"]) => Effect.Effect<void, StateFailure>;
+};
+type ForkClientFailure = ActorAlreadyExistsError | StateFailure;
+type ActorClient<Definition extends ActorDefinition> = { readonly [Member in keyof Definition["commands"]]: ClientCall<Definition["commands"][Member]>; } & { readonly [Member in keyof Definition["queries"]]: QueryClient<Definition["queries"][Member]>; } & {
+  /**
+   * Forks this actor into a new one at `into`, with this actor's state and files at one cut and nothing in flight
+   * (ADR 0017), and answers the copy's client. A retried fork makes one copy.
+   */
+  readonly fork: (into: Definition["key"]["Type"]) => Effect.Effect<ActorClient<Definition>, ForkClientFailure>;
+  readonly state: Stream.Stream<LiveUpdate<Definition["state"]["Type"]>, StateFailure>;
+  readonly warm: Effect.Effect<void, StateFailure>;
+} & CreationClient<Definition>;
+export type { ActorClient, QueryClient };

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

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

package/dist/contract/client/actor-rpc.contract.d.mts

@@ -0,0 +1,33 @@
+import { KeySchema } from "../actor/actor.contract.mjs";
+import { Authentication } from "../caller/authentication.api.mjs";
+import { CommandId } from "../command/command-id.schema.mjs";
+import { PlainSchema } from "../command/command.contract.mjs";
+import { ComputerRpc, computerRpcsOf } from "../computer/rpc/computer-rpc.contract.mjs";
+import { FileRpc, FileTag, fileRpcsOf } from "../file/rpc/file-rpc.contract.mjs";
+import { ForkRpc, forkRpcOf } from "../fork/fork-rpc.contract.mjs";
+import { Schema } from "effect";
+import { Rpc, RpcGroup, RpcSchema } from "effect/rpc";
+type ActorRpc = Rpc.Rpc<`${string}/${string}`, Schema.Struct<{
+  readonly commandId: typeof CommandId;
+  readonly key: KeySchema;
+  readonly payload: PlainSchema;
+}>, PlainSchema, PlainSchema, typeof Authentication> | Rpc.Rpc<`${string}/${string}`, Schema.Struct<{
+  readonly key: KeySchema;
+  readonly payload: PlainSchema;
+}>, PlainSchema, PlainSchema, typeof Authentication> | Rpc.Rpc<`${string}/warm`, Schema.Struct<{
+  readonly key: KeySchema;
+}>, typeof Schema.Void, PlainSchema, typeof Authentication> | Rpc.Rpc<`${string}/${string}/subscribe`, Schema.Struct<{
+  readonly key: KeySchema;
+  readonly payload: PlainSchema;
+}>, RpcSchema.Stream<PlainSchema, PlainSchema>, typeof Schema.Never, typeof Authentication> | Rpc.Rpc<`${string}/${string}/subscribe`, Schema.Struct<{
+  readonly key: KeySchema;
+}>, RpcSchema.Stream<PlainSchema, PlainSchema>, typeof Schema.Never, typeof Authentication> | Rpc.AddMiddleware<FileRpc, typeof Authentication> | Rpc.AddMiddleware<ForkRpc, typeof Authentication> | Rpc.AddMiddleware<ComputerRpc, typeof Authentication>;
+type ActorRpcs = RpcGroup.RpcGroup<ActorRpc>;
+type CreationMode = "create" | "ensure";
+declare const creationErrors: Readonly<Record<CreationMode, PlainSchema>>;
+declare const creationModesOf: (create: PlainSchema) => readonly CreationMode[];
+interface LiveUpdate<Value> {
+  readonly value: Value;
+  readonly version: number;
+}
+export { type ActorRpc, type ActorRpcs, type CreationMode, type FileTag, type LiveUpdate, computerRpcsOf, creationErrors, creationModesOf, fileRpcsOf, forkRpcOf };

package/dist/contract/client/actor-rpc.contract.mjs

@@ -0,0 +1,16 @@
+import { ActorAlreadyExistsError } from "../actor/actor-already-exists.errors.mjs";
+import { fileRpcsOf } from "../file/rpc/file-rpc.contract.mjs";
+import { forkRpcOf } from "../fork/fork-rpc.contract.mjs";
+import { computerRpcsOf } from "../computer/rpc/computer-rpc.contract.mjs";
+import { Schema, SchemaAST } from "effect";
+// src/contract/client/actor-rpc.contract.ts
+const creationModes = ["create", "ensure"];
+const creationErrors = {
+	create: ActorAlreadyExistsError,
+	ensure: Schema.Never
+};
+const creationModesOf = (create) => {
+	if (SchemaAST.isNever(create.ast)) return [];
+	return creationModes;
+};
+export { computerRpcsOf, creationErrors, creationModesOf, fileRpcsOf, forkRpcOf };

package/dist/contract/client/actor-unavailable.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const ActorUnavailableError_base: Schema.Class<ActorUnavailableError, Schema.TaggedStruct<"ActorUnavailableError", {
+  readonly actor: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class ActorUnavailableError extends ActorUnavailableError_base {}
+export {};

package/dist/contract/client/actor-unavailable.errors.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+// src/contract/client/actor-unavailable.errors.ts
+var ActorUnavailableError = class extends Schema.TaggedError()("ActorUnavailableError", {
+	actor: Schema.String,
+	message: Schema.String
+}) {};
+export { ActorUnavailableError };

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

@@ -0,0 +1,28 @@
+import { ActorAlreadyExistsError } from "../actor/actor-already-exists.errors.mjs";
+import { ActorErasedError } from "../actor/actor-erased.errors.mjs";
+import { ActorNotCreatedError } from "../actor/actor-not-created.errors.mjs";
+import { ActorUnavailableError } from "./actor-unavailable.errors.mjs";
+import { CallerNotAllowedError } from "../caller/caller-not-allowed.errors.mjs";
+import { UnauthenticatedError } from "../caller/unauthenticated.errors.mjs";
+import { CommandIdExpiredError } from "../command/command-id-expired.errors.mjs";
+import { HandlerFailedError } from "../hosted/handler-failed.errors.mjs";
+import { InvalidRequestError } from "./invalid-request.errors.mjs";
+import { BillingUnavailableError } from "../spend/billing-unavailable.errors.mjs";
+import { SpendCapReachedError } from "../spend/spend-cap-reached.errors.mjs";
+import { StorageLimitError } from "./storage-limit.errors.mjs";
+import { BlobTransferError } from "../file/blob-transfer.errors.mjs";
+import { CheckpointExpiredError } from "../computer/checkpoint-expired.errors.mjs";
+import { ComputerHeldError } from "../computer/computer-held.errors.mjs";
+import { ComputerLimitError } from "../computer/computer-limit.errors.mjs";
+import { ComputerLostError } from "../computer/computer-lost.errors.mjs";
+import { ComputerNotFoundError } from "../computer/computer-not-found.errors.mjs";
+import { ComputersUnavailableError } from "../computer/computers-unavailable.errors.mjs";
+import { StepNotFoundError } from "../computer/step/step-not-found.errors.mjs";
+import { FileAccessDeniedError } from "../file/access/file-access-denied.errors.mjs";
+import { FileNotFoundError } from "../file/file-not-found.errors.mjs";
+import { FileTooLargeError } from "../file/rpc/file-too-large.errors.mjs";
+import { FilesUnavailableError } from "../file/files-unavailable.errors.mjs";
+import { InvalidFileRequestError } from "../file/invalid-file-request.errors.mjs";
+import { InvalidSecretNameError } from "../secret/invalid-secret-name.errors.mjs";
+import { SecretUnavailableError } from "../secret/secret-unavailable.errors.mjs";
+export { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, BlobTransferError, CallerNotAllowedError, CheckpointExpiredError, CommandIdExpiredError, ComputerHeldError, ComputerLimitError, ComputerLostError, ComputerNotFoundError, ComputersUnavailableError, FileAccessDeniedError, FileNotFoundError, FileTooLargeError, FilesUnavailableError, HandlerFailedError, InvalidFileRequestError, InvalidRequestError, InvalidSecretNameError, SecretUnavailableError, SpendCapReachedError, StepNotFoundError, StorageLimitError, UnauthenticatedError };

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

@@ -0,0 +1,28 @@
+import { ActorAlreadyExistsError } from "../actor/actor-already-exists.errors.mjs";
+import { ActorErasedError } from "../actor/actor-erased.errors.mjs";
+import { ActorNotCreatedError } from "../actor/actor-not-created.errors.mjs";
+import { ActorUnavailableError } from "./actor-unavailable.errors.mjs";
+import { CallerNotAllowedError } from "../caller/caller-not-allowed.errors.mjs";
+import { UnauthenticatedError } from "../caller/unauthenticated.errors.mjs";
+import { CommandIdExpiredError } from "../command/command-id-expired.errors.mjs";
+import { HandlerFailedError } from "../hosted/handler-failed.errors.mjs";
+import { InvalidRequestError } from "./invalid-request.errors.mjs";
+import { BillingUnavailableError } from "../spend/billing-unavailable.errors.mjs";
+import { SpendCapReachedError } from "../spend/spend-cap-reached.errors.mjs";
+import { StorageLimitError } from "./storage-limit.errors.mjs";
+import { BlobTransferError } from "../file/blob-transfer.errors.mjs";
+import { CheckpointExpiredError } from "../computer/checkpoint-expired.errors.mjs";
+import { ComputerHeldError } from "../computer/computer-held.errors.mjs";
+import { ComputerLimitError } from "../computer/computer-limit.errors.mjs";
+import { ComputerLostError } from "../computer/computer-lost.errors.mjs";
+import { ComputerNotFoundError } from "../computer/computer-not-found.errors.mjs";
+import { ComputersUnavailableError } from "../computer/computers-unavailable.errors.mjs";
+import { StepNotFoundError } from "../computer/step/step-not-found.errors.mjs";
+import { FileAccessDeniedError } from "../file/access/file-access-denied.errors.mjs";
+import { FileNotFoundError } from "../file/file-not-found.errors.mjs";
+import { FileTooLargeError } from "../file/rpc/file-too-large.errors.mjs";
+import { FilesUnavailableError } from "../file/files-unavailable.errors.mjs";
+import { InvalidFileRequestError } from "../file/invalid-file-request.errors.mjs";
+import { InvalidSecretNameError } from "../secret/invalid-secret-name.errors.mjs";
+import { SecretUnavailableError } from "../secret/secret-unavailable.errors.mjs";
+export { ActorAlreadyExistsError, ActorErasedError, ActorNotCreatedError, ActorUnavailableError, BillingUnavailableError, BlobTransferError, CallerNotAllowedError, CheckpointExpiredError, CommandIdExpiredError, ComputerHeldError, ComputerLimitError, ComputerLostError, ComputerNotFoundError, ComputersUnavailableError, FileAccessDeniedError, FileNotFoundError, FileTooLargeError, FilesUnavailableError, HandlerFailedError, InvalidFileRequestError, InvalidRequestError, InvalidSecretNameError, SecretUnavailableError, SpendCapReachedError, StepNotFoundError, StorageLimitError, UnauthenticatedError };

package/dist/contract/client/invalid-request.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const InvalidRequestError_base: Schema.Class<InvalidRequestError, Schema.TaggedStruct<"InvalidRequestError", {
+  readonly actor: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class InvalidRequestError extends InvalidRequestError_base {}
+export {};

package/dist/contract/client/invalid-request.errors.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+// src/contract/client/invalid-request.errors.ts
+var InvalidRequestError = class extends Schema.TaggedError()("InvalidRequestError", {
+	actor: Schema.String,
+	message: Schema.String
+}) {};
+export { InvalidRequestError };

package/dist/contract/client/storage-limit.errors.d.mts

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+declare const StorageLimitError_base: Schema.Class<StorageLimitError, Schema.TaggedStruct<"StorageLimitError", {
+  readonly actor: Schema.String;
+  readonly ceilingBytes: Schema.Finite;
+  readonly dataBytes: Schema.Finite;
+  readonly readAt: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * Akter Cloud refused a write because the app environment's stored data reached its ceiling: `dataBytes` of
+ * `ceilingBytes`, as read from storage at `readAt` (epoch milliseconds). Nothing ran. Queries and downloads still
+ * work; a write succeeds again once data is removed or the ceiling is raised.
+ */
+export declare class StorageLimitError extends StorageLimitError_base {}
+export {};

package/dist/contract/client/storage-limit.errors.mjs

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+// src/contract/client/storage-limit.errors.ts
+/**
+* Akter Cloud refused a write because the app environment's stored data reached its ceiling: `dataBytes` of
+* `ceilingBytes`, as read from storage at `readAt` (epoch milliseconds). Nothing ran. Queries and downloads still
+* work; a write succeeds again once data is removed or the ceiling is raised.
+*/
+var StorageLimitError = class extends Schema.TaggedError()("StorageLimitError", {
+	actor: Schema.String,
+	ceilingBytes: Schema.Finite,
+	dataBytes: Schema.Finite,
+	readAt: Schema.Int
+}) {};
+export { StorageLimitError };

package/dist/contract/command/command-id-expired.errors.d.mts

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+declare const CommandIdExpiredError_base: Schema.Class<CommandIdExpiredError, Schema.TaggedStruct<"CommandIdExpiredError", {
+  readonly actor: Schema.String;
+  readonly commandId: Schema.String;
+  readonly keptSince: Schema.Int;
+  readonly mintedAt: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class CommandIdExpiredError extends CommandIdExpiredError_base {}
+export {};

package/dist/contract/command/command-id-expired.errors.mjs

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+// src/contract/command/command-id-expired.errors.ts
+var CommandIdExpiredError = class extends Schema.TaggedError()("CommandIdExpiredError", {
+	actor: Schema.String,
+	commandId: Schema.String,
+	keptSince: Schema.Int,
+	mintedAt: Schema.Int
+}) {};
+export { CommandIdExpiredError };

package/dist/contract/command/command-id.schema.d.mts

@@ -0,0 +1,3 @@
+import { Schema } from "effect";
+export declare const CommandId: Schema.brand<Schema.String, "CommandId">;
+export type CommandId = typeof CommandId.Type;

package/dist/contract/command/command-id.schema.mjs

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+// src/contract/command/command-id.schema.ts
+const CommandId = Schema.String.pipe(Schema.brand("CommandId"));
+export { CommandId };

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

@@ -0,0 +1,117 @@
+import { Context, Duration, Effect, Exit, Option, Schema } from "effect";
+import { Workflow } from "effect/workflow";
+type PlainSchema = Schema.Top & {
+  readonly DecodingServices: never;
+  readonly EncodingServices: never;
+};
+type PlainFields = Readonly<Record<PropertyKey, PlainSchema>>;
+type Declared = PlainFields | PlainSchema;
+type DeclaredSchema<Input extends Declared> = Input extends PlainFields ? Schema.Struct<Input> : Input;
+interface Command<Payload extends PlainSchema, Success extends PlainSchema, Failure extends PlainSchema, Kinds extends string = string> {
+  readonly callers: Option.Option<readonly Kinds[]>;
+  readonly error: Failure;
+  readonly payload: Payload;
+  readonly success: Success;
+}
+interface Query<Payload extends PlainSchema, Success extends PlainSchema, Failure extends PlainSchema, Kinds extends string = string> extends Command<Payload, Success, Failure, Kinds> {
+  /** How old an answer may be when no `atLeast` asks for newer; none means every answer is fresh. */
+  readonly staleFor: Option.Option<Duration.Duration>;
+}
+type AnyCommand = Command<PlainSchema, PlainSchema, PlainSchema>;
+type AnyQuery = Query<PlainSchema, PlainSchema, PlainSchema>;
+interface DeclarationOptions {
+  readonly callers?: readonly string[];
+  readonly error?: PlainSchema;
+  readonly payload?: Declared;
+  readonly success?: PlainSchema;
+}
+interface QueryOptions extends DeclarationOptions {
+  /**
+   * How old an answer to this query may be. A read is at most `staleFor` old, and never older than the version the
+   * caller's `atLeast` names, so a caller reads its own writes. An engine may always answer fresher. Without it, every
+   * answer is fresh.
+   */
+  readonly staleFor?: Duration.Input;
+}
+type PayloadOf<Options extends DeclarationOptions> = Options extends {
+  readonly payload: infer Input extends Declared;
+} ? DeclaredSchema<Input> : Schema.Void;
+type SuccessOf<Options extends DeclarationOptions> = Options extends {
+  readonly success: infer Success extends PlainSchema;
+} ? Success : Schema.Void;
+type ErrorOf<Options extends DeclarationOptions> = Options extends {
+  readonly error: infer Failure extends PlainSchema;
+} ? Failure : Schema.Never;
+type KindsOf<Options extends DeclarationOptions> = Options extends {
+  readonly callers: readonly (infer Kinds extends string)[];
+} ? Kinds : never;
+declare function declaredSchema<Input extends Declared>(input: Input): DeclaredSchema<Input>;
+declare function command<const Options extends DeclarationOptions>(options?: Options): Command<PayloadOf<Options>, SuccessOf<Options>, ErrorOf<Options>, KindsOf<Options>>;
+declare function query<const Options extends QueryOptions>(options?: Options): Query<PayloadOf<Options>, SuccessOf<Options>, ErrorOf<Options>, KindsOf<Options>>;
+interface JobOptions {
+  readonly error?: PlainSchema;
+  readonly payload: PlainFields;
+  /**
+   * Named changes to the job's code. A job started while its contract declares a patch sees it with `Akter.patched`
+   * for its whole run; a job started before the patch existed doesn't, even after a deploy adds it.
+   */
+  readonly patches?: readonly string[];
+  readonly success?: PlainSchema;
+}
+interface Job<Fields extends PlainFields, Success extends PlainSchema, Failure extends PlainSchema, Patch extends string = never> {
+  readonly error: Failure;
+  readonly patches: readonly Patch[];
+  readonly payload: Fields;
+  readonly success: Success;
+}
+/**
+ * How the host reads and writes a job's payload and result. The host reads only the decoders and `encodeResult`
+ * (host interface item 2); `startedPayload` is the bundle's own, which `Akter.start` encodes with.
+ */
+interface JobCodecs {
+  readonly decodePayload: (text: string) => Effect.Effect<unknown, Schema.SchemaError>;
+  readonly decodeResult: (text: string) => Effect.Effect<Exit.Exit<unknown, unknown>, Schema.SchemaError>;
+  readonly encodeResult: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<string, Schema.SchemaError>;
+  /** The declared payload, encoded as the journal keeps it: with the patches the job declares, when it declares any. */
+  readonly startedPayload?: Schema.Codec<unknown, string>;
+}
+type AnyJob = Job<PlainFields, PlainSchema, PlainSchema, string>;
+type PatchesOf<Options extends JobOptions> = Options extends {
+  readonly patches: readonly (infer Patch extends string)[];
+} ? Patch : never;
+type Jobs = Readonly<Record<string, AnyJob>>;
+type NoJobs = Readonly<Record<string, never>>;
+type JobWorkflow<Tag extends string, Declaring extends AnyJob> = Workflow.Workflow<Tag, Schema.Struct<Declaring["payload"]>, Declaring["success"], Declaring["error"]> & {
+  /** The patches the job's contract declares now. */
+  readonly patches: Declaring["patches"];
+  /**
+   * Inside the job's run: whether the code that started this run declared `name`. Gate a change to the job's code
+   * with it while jobs started before the change are still in flight.
+   */
+  readonly patched: (name: Declaring["patches"][number]) => Effect.Effect<boolean>;
+};
+type ActorJobs<Name extends string, Declaring extends Jobs> = { readonly [Member in keyof Declaring & string]: JobWorkflow<`${Name}/${Member}`, Declaring[Member]>; };
+interface StartableJob {
+  readonly _tag: string;
+  readonly annotations: Context.Context<never>;
+  readonly payloadSchema: PlainSchema;
+}
+interface Tagging {
+  readonly actor: string;
+  readonly member: string;
+}
+interface DeclaredJobs<Name extends string, Declaring extends Jobs> {
+  readonly jobs: Declaring;
+  readonly name: Name;
+}
+declare const JobCodecsOf: Context.Reference<Option.Option<JobCodecs>>;
+declare function job<const Options extends JobOptions>(options: Options): Job<Options["payload"], SuccessOf<Options>, ErrorOf<Options>, PatchesOf<Options>>;
+declare const jobTag: ({ actor, member }: Tagging) => string;
+declare const jobResult: ({ error, success }: Pick<AnyJob, "error" | "success">) => Schema.Exit<PlainSchema, PlainSchema, 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.
+ */
+declare const jobCodecs: (declared: AnyJob) => JobCodecs;
+declare function jobsOf<Name extends string, Declaring extends Jobs>(declaring: DeclaredJobs<Name, Declaring>): ActorJobs<Name, Declaring>;
+export { type ActorJobs, type AnyCommand, type AnyJob, type AnyQuery, type Command, type DeclarationOptions, type Declared, type DeclaredSchema, type Job, type JobCodecs, JobCodecsOf, type JobOptions, type JobWorkflow, type Jobs, type NoJobs, type PatchesOf, type PlainFields, type PlainSchema, type Query, type QueryOptions, type StartableJob, command, declaredSchema, job, jobCodecs, jobResult, jobTag, jobsOf, query };