@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/contract/hosted/hosted-query.service.mjs

@@ -0,0 +1,42 @@
+import { refusedActorState, scopeOf } from "../state/actor-state.pure.mjs";
+import { rejectFailedStatement } from "./handler-failure.pure.mjs";
+import { prepare } from "./hosted-request.pure.mjs";
+import { exitCodec } from "../json-codec.pure.mjs";
+import { fileAccessMember } from "../file/access/file-access.contract.mjs";
+import { Context, Effect, Layer, Option, Record, Schema } from "effect";
+// src/contract/hosted/hosted-query.service.ts
+/** The actor's queries, and its `files.authorize` rule as the reserved `akter.files` query when it declares files. */
+const queriesOf = ({ definition, implementation }) => {
+	const rule = Option.all({
+		declaration: definition.fileAccess,
+		handler: Option.map(Option.fromNullishOr(implementation.files), (files) => files.authorize)
+	});
+	return Option.match(rule, {
+		onNone: () => ({
+			declarations: definition.queries,
+			handlers: implementation.queries ?? {}
+		}),
+		onSome: ({ declaration, handler }) => ({
+			declarations: Record.set(definition.queries, fileAccessMember, declaration),
+			handlers: Record.set(implementation.queries ?? {}, fileAccessMember, handler)
+		})
+	});
+};
+const runQuery = Effect.fn("HostedActor.runQuery")(function* runQuery(parts, request, environment) {
+	const prepared = yield* prepare(parts, queriesOf(parts), request);
+	const scope = scopeOf({
+		environment,
+		principal: prepared.principal
+	});
+	const finished = yield* Effect.exit(parts.provide(prepared.handler(prepared.state, prepared.payload), scope, refusedActorState));
+	const exit = yield* rejectFailedStatement(finished, {
+		actor: parts.name,
+		member: request.member,
+		query: true
+	});
+	return yield* Effect.orDie(Schema.encodeEffect(exitCodec(prepared.declaration))(exit));
+});
+var HostedQuery = class extends Context.Service()("@akterjs/effect/contract/hosted/hosted-query.service/HostedQuery", { make: Effect.succeed({ run: runQuery }) }) {
+	static layer = Layer.effect(this, this.make);
+};
+export { HostedQuery };

package/dist/contract/hosted/hosted-request.pure.d.mts

@@ -0,0 +1,61 @@
+import { ActorState } from "../state/actor-state.service.mjs";
+import { ActorDefinition, CommandScope, Decoded, HostedRequest, HostedResult, Migrations, StateFields, StateMigration, StateSchema } from "../actor/actor.contract.mjs";
+import { Akter } from "../akter.service.mjs";
+import { AnyCommand, AnyQuery, PlainSchema } from "../command/command.contract.mjs";
+import { HostedError } from "./hosted-error.contract.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { Principal } from "../caller/principal.schema.mjs";
+import { Effect, Option } from "effect";
+type ErasedHandler = (state: StateFields, payload: Decoded) => Effect.Effect<never, never, Akter | ActorState>;
+type ErasedResultHandler = (state: StateFields, payload: Decoded, job: {
+  readonly id: string;
+}) => Effect.Effect<never, never, Akter | ActorState>;
+type ErasedQueryHandler = (state: StateFields, payload: Decoded) => Effect.Effect<never, never, Akter>;
+type ErasedCreateHandler = (input: Decoded) => Effect.Effect<StateFields, never, Akter>;
+type ProvideScope = <Success, Failure>(effect: Effect.Effect<Success, Failure, Akter | ActorState>, scope: CommandScope, state: ActorState["Service"]) => Effect.Effect<Success, Failure>;
+interface ErasedImplementation {
+  readonly commands: Readonly<Record<string, ErasedHandler>>;
+  readonly create?: ErasedCreateHandler;
+  readonly files?: {
+    readonly authorize: ErasedQueryHandler;
+  };
+  readonly migrations?: Migrations;
+  readonly queries?: Readonly<Record<string, ErasedQueryHandler>>;
+  readonly results?: Readonly<Record<string, ErasedResultHandler>>;
+  readonly state?: StateMigration<StateFields>;
+}
+interface ErasedSpec {
+  readonly definition: ActorDefinition;
+  readonly initial: Option.Option<() => StateFields>;
+  readonly name: string;
+  readonly provide: ProvideScope;
+}
+interface ErasedParts extends ErasedSpec {
+  readonly implementation: ErasedImplementation;
+}
+interface Members {
+  readonly declarations: Readonly<Record<string, AnyCommand | AnyQuery>>;
+  readonly handlers: Readonly<Record<string, ErasedHandler>>;
+}
+interface Prepared {
+  readonly declaration: AnyCommand | AnyQuery;
+  readonly handler: ErasedHandler;
+  readonly payload: Decoded;
+  readonly principal: Principal;
+  readonly state: StateFields;
+}
+interface Decoding<Target extends PlainSchema> {
+  readonly actor: string;
+  readonly schema: Target;
+  readonly text: string;
+}
+declare const decodeRequest: <Target extends PlainSchema>({ actor, schema, text }: Decoding<Target>) => Effect.Effect<Target["Type"], InvalidRequestError>;
+interface StateSource {
+  readonly initial: Option.Option<() => StateFields>;
+  readonly name: string;
+  readonly state: StateSchema;
+}
+declare const startingState: (source: StateSource, stored: Option.Option<string>) => Effect.Effect<Readonly<Record<string, unknown>>, HostedError, never>;
+declare const prepare: (parts: ErasedParts, members: Members, request: HostedRequest) => Effect.Effect<Prepared, HostedError, never>;
+declare const prepareResult: (parts: ErasedParts, request: HostedResult) => Effect.Effect<Prepared, HostedError, never>;
+export { type ErasedImplementation, type ErasedParts, type ErasedSpec, type Members, type Prepared, type ProvideScope, type StateSource, decodeRequest, prepare, prepareResult, startingState };

package/dist/contract/hosted/hosted-request.pure.mjs

@@ -0,0 +1,91 @@
+import { ActorNotCreatedError } from "../actor/actor-not-created.errors.mjs";
+import { admit } from "../caller/caller-admission.pure.mjs";
+import { jobResult } from "../command/command.contract.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { jsonCodec } from "../json-codec.pure.mjs";
+import { ActorPrincipal } from "../caller/principal.schema.mjs";
+import { Effect, Option, Record, Schema } from "effect";
+// src/contract/hosted/hosted-request.pure.ts
+const decodeRequest = ({ actor, schema, text }) => Schema.decodeEffect(jsonCodec(schema))(text).pipe(Effect.mapError((issue) => InvalidRequestError.make({
+	actor,
+	message: issue.message
+})));
+const startingState = Effect.fnUntraced(function* startingState(source, stored) {
+	if (Option.isSome(stored)) return yield* decodeRequest({
+		actor: source.name,
+		schema: source.state,
+		text: stored.value
+	});
+	if (Option.isNone(source.initial)) return yield* ActorNotCreatedError.make({ actor: source.name });
+	return source.initial.value();
+});
+const prepare = Effect.fnUntraced(function* prepare(parts, members, request) {
+	const declaration = Record.get(members.declarations, request.member);
+	const handler = Record.get(members.handlers, request.member);
+	if (Option.isNone(declaration) || Option.isNone(handler)) return yield* InvalidRequestError.make({
+		actor: parts.name,
+		message: `${request.member} is not a member`
+	});
+	const principal = yield* admit({
+		actor: parts.name,
+		allowed: declaration.value.callers,
+		callers: parts.definition.callers,
+		member: request.member,
+		principal: request.principal
+	});
+	const payload = yield* decodeRequest({
+		actor: parts.name,
+		schema: declaration.value.payload,
+		text: request.payload
+	});
+	const state = yield* startingState({
+		initial: parts.initial,
+		name: parts.name,
+		state: parts.definition.state
+	}, request.state);
+	return {
+		declaration: declaration.value,
+		handler: handler.value,
+		payload,
+		principal,
+		state
+	};
+});
+const prepareResult = Effect.fnUntraced(function* prepareResult(parts, request) {
+	const job = Record.get(parts.definition.jobs, request.member);
+	const handler = Record.get(parts.implementation.results ?? {}, request.member);
+	if (Option.isNone(job) || Option.isNone(handler)) return yield* InvalidRequestError.make({
+		actor: parts.name,
+		message: `${request.member} is not a job with a result handler`
+	});
+	const declaration = {
+		callers: Option.none(),
+		error: Schema.Never,
+		payload: jobResult(job.value),
+		success: Schema.Void
+	};
+	const { principal } = yield* decodeRequest({
+		actor: parts.name,
+		schema: Schema.Struct({ principal: ActorPrincipal }),
+		text: request.principal
+	});
+	const payload = yield* decodeRequest({
+		actor: parts.name,
+		schema: declaration.payload,
+		text: request.payload
+	});
+	const state = yield* startingState({
+		initial: parts.initial,
+		name: parts.name,
+		state: parts.definition.state
+	}, request.state);
+	const delivered = (current, result) => handler.value(current, result, { id: request.jobId });
+	return {
+		declaration,
+		handler: delivered,
+		payload,
+		principal,
+		state
+	};
+});
+export { decodeRequest, prepare, prepareResult, startingState };

package/dist/contract/job/job-id.pure.d.mts

@@ -0,0 +1,11 @@
+import { Option } from "effect";
+interface JobAddress {
+  readonly actor: string;
+  readonly key: string;
+}
+interface Minting extends JobAddress {
+  readonly id: string;
+}
+declare const jobIdOf: ({ actor, id, key }: Minting) => string;
+declare const jobAddress: (jobId: string) => Option.Option<JobAddress>;
+export { type JobAddress, jobAddress, jobIdOf };

package/dist/contract/job/job-id.pure.mjs

@@ -0,0 +1,20 @@
+import { Array, Option, String } from "effect";
+// src/contract/job/job-id.pure.ts
+const separator = "/";
+const addressParts = 3;
+const actorPart = 0;
+const keyPart = 1;
+const jobIdOf = ({ actor, id, key }) => Array.join([
+	actor,
+	encodeURIComponent(key),
+	id
+], separator);
+const jobAddress = (jobId) => {
+	const parts = String.split(jobId, separator);
+	if (parts.length !== addressParts) return Option.none();
+	return Option.map(Option.all([Array.get(parts, actorPart), Array.get(parts, keyPart)]), ([actor, key]) => ({
+		actor,
+		key: decodeURIComponent(key)
+	}));
+};
+export { jobAddress, jobIdOf };

package/dist/contract/job/job-patches.contract.d.mts

@@ -0,0 +1,32 @@
+import { Effect } from "effect";
+/**
+ * The payload key a job's stored payload carries its patches under: the patches its contract declared when a command
+ * started it. A job whose payload has none was started by code without patches.
+ */
+declare const patchesKey = "~akter/patches";
+/** Where a decoded payload keeps its patches on the way to the job's run: a symbol, so the run's payload stays its fields. */
+declare const carriedPatches: unique symbol;
+/** A decoded payload, which may carry the patches its start declared. */
+interface CarriedPayload {
+  readonly [carriedPatches]?: unknown;
+}
+/**
+ * A decoded payload carrying the patches its start declared, hidden from its fields, so the job's run sees exactly the
+ * payload it declared and the patches stay out of `Object.keys`, equality and logs.
+ */
+declare const carrying: <Fields extends object>({ fields, patches }: {
+  readonly fields: Fields;
+  readonly patches: readonly string[] | undefined;
+}) => Fields;
+/** Runs a job's `execute` with the patches its stored payload carries. */
+declare const withPatches: <Payload extends CarriedPayload, Success, Failure, Services>(execute: (payload: Payload, executionId: string) => Effect.Effect<Success, Failure, Services>) => (payload: Payload, executionId: string) => Effect.Effect<Success, Failure, Services>;
+/**
+ * A job's `patched(name)`: whether the running job was started by code that declared `name` in the job's patches. A
+ * job keeps the answer for its whole run, across restarts and deploys, so a job started before a deploy takes the old
+ * path to the end.
+ */
+declare const patchedOf: ({ patches: declared, tag }: {
+  readonly patches: readonly string[];
+  readonly tag: string;
+}) => (name: string) => Effect.Effect<boolean>;
+export { carriedPatches, carrying, patchedOf, patchesKey, withPatches };

package/dist/contract/job/job-patches.contract.mjs

@@ -0,0 +1,45 @@
+import { Array, Context, Effect, Option, Schema } from "effect";
+// src/contract/job/job-patches.contract.ts
+/**
+* The payload key a job's stored payload carries its patches under: the patches its contract declared when a command
+* started it. A job whose payload has none was started by code without patches.
+*/
+const patchesKey = "~akter/patches";
+/** Where a decoded payload keeps its patches on the way to the job's run: a symbol, so the run's payload stays its fields. */
+const carriedPatches = Symbol.for("@akterjs/effect/contract/job/job-patches.contract/carriedPatches");
+const Patches = Schema.Array(Schema.String);
+const isPatches = Schema.is(Patches);
+/** The patches the running job started with; none outside a job's run. */
+const CurrentJobPatches = Context.Reference("@akterjs/effect/contract/job/job-patches.contract/CurrentJobPatches", { defaultValue: Option.none });
+/**
+* A decoded payload carrying the patches its start declared, hidden from its fields, so the job's run sees exactly the
+* payload it declared and the patches stay out of `Object.keys`, equality and logs.
+*/
+const carrying = ({ fields, patches }) => {
+	if (Array.isReadonlyArrayEmpty(patches ?? [])) return fields;
+	return Object.defineProperty(fields, carriedPatches, {
+		enumerable: false,
+		value: patches
+	});
+};
+/** The patches a decoded payload carries, or none for a payload from code without patches. */
+const patchesOf = (payload) => {
+	const carried = payload[carriedPatches];
+	if (isPatches(carried)) return carried;
+	return [];
+};
+/** Runs a job's `execute` with the patches its stored payload carries. */
+const withPatches = (execute) => (payload, executionId) => Effect.provideService(execute(payload, executionId), CurrentJobPatches, Option.some(patchesOf(payload)));
+/**
+* A job's `patched(name)`: whether the running job was started by code that declared `name` in the job's patches. A
+* job keeps the answer for its whole run, across restarts and deploys, so a job started before a deploy takes the old
+* path to the end.
+*/
+const patchedOf = ({ patches: declared, tag }) => (name) => Effect.flatMap(CurrentJobPatches, Option.match({
+	onNone: () => Effect.die(`${tag}.patched("${name}") runs only inside the job's run`),
+	onSome: (patches) => {
+		if (!Array.contains(declared, name)) return Effect.die(`${tag} declares no patch "${name}": add it to the job's patches in Akter.job`);
+		return Effect.succeed(Array.contains(patches, name));
+	}
+}));
+export { carriedPatches, carrying, patchedOf, patchesKey, withPatches };

package/dist/contract/job/job-signal.schema.d.mts

@@ -0,0 +1,13 @@
+import { Exit, Schema } from "effect";
+/** A job's exit as its journal keeps it: the exit its own schemas encoded, written as JSON text. */
+export declare const StoredExit: Schema.Codec<Exit.Exit<unknown, unknown>, string>;
+/**
+ * A signal a command sends one of its own actor's jobs (`Akter.signal`): the job's id, the durable deferred's name and
+ * the value as a stored exit. It is written with the command, so a command that rolls back sends nothing.
+ */
+export declare const JobSignal: Schema.Struct<{
+  readonly deferred: Schema.String;
+  readonly exit: Schema.String;
+  readonly id: Schema.String;
+}>;
+export type JobSignal = typeof JobSignal.Type;

package/dist/contract/job/job-signal.schema.mjs

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+// src/contract/job/job-signal.schema.ts
+const encodedValue = Schema.UndefinedOr(Schema.Json);
+const exitSchema = Schema.Exit(encodedValue, encodedValue, Schema.Defect());
+/** A job's exit as its journal keeps it: the exit its own schemas encoded, written as JSON text. */
+const StoredExit = Schema.fromJsonString(Schema.toCodecJson(exitSchema));
+/**
+* A signal a command sends one of its own actor's jobs (`Akter.signal`): the job's id, the durable deferred's name and
+* the value as a stored exit. It is written with the command, so a command that rolls back sends nothing.
+*/
+const JobSignal = Schema.Struct({
+	deferred: Schema.String,
+	exit: Schema.String,
+	id: Schema.String
+});
+export { JobSignal, StoredExit };

package/dist/contract/job/reserved-payload-field.errors.d.mts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+declare const ReservedPayloadFieldError_base: Schema.Class<ReservedPayloadFieldError, Schema.TaggedStruct<"ReservedPayloadFieldError", {
+  readonly field: Schema.String;
+  readonly job: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** A job's payload declares a field Akter keeps for itself, such as the patches its start stored (`~akter/patches`). */
+export declare class ReservedPayloadFieldError extends ReservedPayloadFieldError_base {}
+export {};

package/dist/contract/job/reserved-payload-field.errors.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/contract/job/reserved-payload-field.errors.ts
+/** A job's payload declares a field Akter keeps for itself, such as the patches its start stored (`~akter/patches`). */
+var ReservedPayloadFieldError = class extends Schema.TaggedError()("ReservedPayloadFieldError", {
+	field: Schema.String,
+	job: Schema.String
+}) {};
+export { ReservedPayloadFieldError };

package/dist/contract/job/started-job.schema.d.mts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+export declare const StartedJob: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly job: Schema.String;
+  readonly payload: Schema.String;
+}>;
+export type StartedJob = typeof StartedJob.Type;

package/dist/contract/job/started-job.schema.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/contract/job/started-job.schema.ts
+const StartedJob = Schema.Struct({
+	id: Schema.String,
+	job: Schema.String,
+	payload: Schema.String
+});
+export { StartedJob };

package/dist/contract/json-codec.pure.d.mts

@@ -0,0 +1,7 @@
+import { Decoded } from "./actor/actor.contract.mjs";
+import { AnyCommand, AnyQuery, PlainSchema } from "./command/command.contract.mjs";
+import { Exit, Schema } from "effect";
+type ExitCodec = Schema.Codec<Exit.Exit<Decoded, Decoded>, string>;
+declare const jsonCodec: <Target extends PlainSchema>(schema: Target) => Schema.Codec<Target["Type"], string>;
+declare const exitCodec: (declaration: AnyCommand | AnyQuery) => ExitCodec;
+export { exitCodec, jsonCodec };

package/dist/contract/json-codec.pure.mjs

@@ -0,0 +1,14 @@
+import { Option, Schema } from "effect";
+// src/contract/json-codec.pure.ts
+const jsonCodec = (schema) => Schema.fromJsonString(Schema.toCodecJson(schema));
+/**
+* Exit codecs by declaration. Building one derives the JSON codec of the whole Exit schema, about 25 times the cost of
+* encoding a reply with it, and the engine encodes every command's and query's reply.
+*/
+const exitCodecs = /* @__PURE__ */ new WeakMap();
+const exitCodec = (declaration) => Option.getOrElse(Option.fromUndefinedOr(exitCodecs.get(declaration)), () => {
+	const codec = jsonCodec(Schema.Exit(declaration.success, declaration.error, Schema.Defect()));
+	exitCodecs.set(declaration, codec);
+	return codec;
+});
+export { exitCodec, jsonCodec };

package/dist/contract/room.contract.d.mts

@@ -0,0 +1,75 @@
+import { Command, Query } from "./command/command.contract.mjs";
+import { ActorHistory } from "./history/actor-journal.service.mjs";
+import { FileAccess } from "./file/access/file-access.contract.mjs";
+import "./akter.service.mjs";
+import { Actor, DefinitionOf } from "./actor/actor.contract.mjs";
+import { Schema } from "effect";
+declare const RoomId: Schema.brand<Schema.String, "RoomId">;
+type RoomId = typeof RoomId.Type;
+declare const Message: Schema.Struct<{
+  readonly at: Schema.Int;
+  readonly author: Schema.String;
+  readonly id: Schema.String;
+  readonly text: Schema.String;
+}>;
+type Message = typeof Message.Type;
+declare const NotMemberError_base: Schema.Class<NotMemberError, Schema.TaggedStruct<"NotMemberError", {}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+declare class NotMemberError extends NotMemberError_base {}
+declare const Room: Actor<"Room", DefinitionOf<{
+  readonly commands: {
+    join: Command<Schema.Void, Schema.Void, Schema.Never, never>;
+    post: Command<Schema.Struct<{
+      readonly text: Schema.String;
+    }>, Schema.String, typeof NotMemberError, never>;
+  };
+  readonly files: FileAccess<"user">;
+  readonly initial: () => {
+    members: never[];
+    title: string;
+  };
+  readonly key: Schema.brand<Schema.String, "RoomId">;
+  readonly queries: {
+    messages: Query<Schema.Struct<{
+      readonly limit: Schema.Int;
+    }>, Schema.$Array<Schema.Struct<{
+      readonly at: Schema.Int;
+      readonly author: Schema.String;
+      readonly id: Schema.String;
+      readonly text: Schema.String;
+    }>>, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly members: Schema.$Array<Schema.String>;
+    readonly title: Schema.String;
+  }>;
+}>> & ActorHistory<DefinitionOf<{
+  readonly commands: {
+    join: Command<Schema.Void, Schema.Void, Schema.Never, never>;
+    post: Command<Schema.Struct<{
+      readonly text: Schema.String;
+    }>, Schema.String, typeof NotMemberError, never>;
+  };
+  readonly files: FileAccess<"user">;
+  readonly initial: () => {
+    members: never[];
+    title: string;
+  };
+  readonly key: Schema.brand<Schema.String, "RoomId">;
+  readonly queries: {
+    messages: Query<Schema.Struct<{
+      readonly limit: Schema.Int;
+    }>, Schema.$Array<Schema.Struct<{
+      readonly at: Schema.Int;
+      readonly author: Schema.String;
+      readonly id: Schema.String;
+      readonly text: Schema.String;
+    }>>, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly members: Schema.$Array<Schema.String>;
+    readonly title: Schema.String;
+  }>;
+}>>;
+export { Message, NotMemberError, Room, RoomId };

package/dist/contract/room.contract.mjs

@@ -0,0 +1,36 @@
+import { Akter } from "./akter.service.mjs";
+import { Schema } from "effect";
+// src/contract/room.contract.ts
+const RoomId = Schema.String.pipe(Schema.brand("RoomId"));
+const Message = Schema.Struct({
+	at: Schema.Int,
+	author: Schema.String,
+	id: Schema.String,
+	text: Schema.String
+});
+var NotMemberError = class extends Schema.TaggedError()("NotMemberError", {}) {};
+const Room = Akter.make("Room", {
+	commands: {
+		join: Akter.command({ success: Schema.Void }),
+		post: Akter.command({
+			error: NotMemberError,
+			payload: { text: Schema.String },
+			success: Schema.String
+		})
+	},
+	files: Akter.fileAccess({ callers: ["user"] }),
+	initial: () => ({
+		members: [],
+		title: "Untitled"
+	}),
+	key: RoomId,
+	queries: { messages: Akter.query({
+		payload: { limit: Schema.Int },
+		success: Schema.Array(Message)
+	}) },
+	state: Schema.Struct({
+		members: Schema.Array(Schema.String),
+		title: Schema.String
+	})
+});
+export { Message, NotMemberError, Room, RoomId };

package/dist/contract/secret/actor-secrets.adapter.d.mts

@@ -0,0 +1,33 @@
+import { ActorDefinition } from "../actor/actor.contract.mjs";
+import { SecretUnavailableError } from "./secret-unavailable.errors.mjs";
+import { Context, Effect, Layer, Redacted } from "effect";
+/** One actor type asking for one of its secrets. */
+interface SecretRequest {
+  readonly actor: string;
+  readonly secret: string;
+}
+type SecretRead = Effect.Effect<Redacted.Redacted, SecretUnavailableError>;
+/** An actor's secret by name: only a name its `secrets` declares, read in a job activity. */
+type SecretOf<Definition extends ActorDefinition> = (secret: Definition["secrets"][number]) => SecretRead;
+/** An actor type's name and the secrets it declares. */
+interface SecretSource {
+  readonly name: string;
+  readonly secrets: readonly string[];
+}
+declare const ActorSecrets_base: Context.ServiceClass<ActorSecrets, "@akterjs/effect/contract/secret/actor-secrets.adapter/ActorSecrets", {
+  readonly read: (request: SecretRequest) => SecretRead;
+}>;
+/**
+ * Where an engine's actors read their secrets. A host provides it to the app's job runtime, so job activities reach
+ * it through `Actor.secret(name)`. Nothing else asks it directly: `Actor.secret` checks the declaration first.
+ */
+export declare class ActorSecrets extends ActorSecrets_base {
+  /**
+   * Secrets from the `ConfigProvider` current when it is built, each under its own name. `Akter.jobs` and `Story.run`
+   * provide it, so `akter dev` and scripts read the process environment (Bun loads `.env`), and a test builds them
+   * under a `ConfigProvider` of its own.
+   */
+  static readonly fromConfig: Layer.Layer<ActorSecrets>;
+  static secretOf<Definition extends ActorDefinition>(source: SecretSource): SecretOf<Definition>;
+}
+export type { SecretOf, SecretRequest };

package/dist/contract/secret/actor-secrets.adapter.mjs

@@ -0,0 +1,38 @@
+import { ActorState } from "../state/actor-state.service.mjs";
+import { SecretUnavailableError } from "./secret-unavailable.errors.mjs";
+import { Array, Config, ConfigProvider, Context, Effect, Layer, Option } from "effect";
+// src/contract/secret/actor-secrets.adapter.ts
+const refused = (reason) => ({ actor, secret }) => SecretUnavailableError.make({
+	actor,
+	reason,
+	secret
+});
+/** Reads each secret by its own name through `provider`: the process environment by default. */
+const fromProvider = (provider) => (request) => Config.option(Config.Redacted(request.secret)).pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider), Effect.mapError(() => refused("unavailable")(request)), Effect.flatMap((found) => Effect.mapError(Effect.fromOption(found), () => refused("unset")(request))));
+/**
+* Where an engine's actors read their secrets. A host provides it to the app's job runtime, so job activities reach
+* it through `Actor.secret(name)`. Nothing else asks it directly: `Actor.secret` checks the declaration first.
+*/
+var ActorSecrets = class ActorSecrets extends Context.Service()("@akterjs/effect/contract/secret/actor-secrets.adapter/ActorSecrets") {
+	/**
+	* Secrets from the `ConfigProvider` current when it is built, each under its own name. `Akter.jobs` and `Story.run`
+	* provide it, so `akter dev` and scripts read the process environment (Bun loads `.env`), and a test builds them
+	* under a `ConfigProvider` of its own.
+	*/
+	static fromConfig = Layer.effect(this, Effect.map(ConfigProvider.ConfigProvider, (provider) => ({ read: fromProvider(provider) })));
+	static secretOf({ name, secrets: declared }) {
+		return (secret) => Effect.gen(function* readSecret() {
+			const request = {
+				actor: name,
+				secret
+			};
+			if (!Array.contains(declared, secret)) return yield* refused("undeclared")(request);
+			const handler = yield* Effect.serviceOption(ActorState);
+			if (Option.isSome(handler)) return yield* refused("command")(request);
+			const secrets = yield* Effect.serviceOption(ActorSecrets);
+			if (Option.isNone(secrets)) return yield* refused("unavailable")(request);
+			return yield* secrets.value.read(request);
+		});
+	}
+};
+export { ActorSecrets };

package/dist/contract/secret/invalid-secret-name.errors.d.mts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+declare const InvalidSecretNameError_base: Schema.Class<InvalidSecretNameError, Schema.TaggedStruct<"InvalidSecretNameError", {
+  readonly actor: Schema.String;
+  readonly secret: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** An actor declared a secret whose name isn't a `SecretName`, so no environment could ever set it. */
+export declare class InvalidSecretNameError extends InvalidSecretNameError_base {}
+export {};

package/dist/contract/secret/invalid-secret-name.errors.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/contract/secret/invalid-secret-name.errors.ts
+/** An actor declared a secret whose name isn't a `SecretName`, so no environment could ever set it. */
+var InvalidSecretNameError = class extends Schema.TaggedError()("InvalidSecretNameError", {
+	actor: Schema.String,
+	secret: Schema.String
+}) {};
+export { InvalidSecretNameError };

package/dist/contract/secret/secret-unavailable.errors.d.mts

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+declare const SecretUnavailableError_base: Schema.Class<SecretUnavailableError, Schema.TaggedStruct<"SecretUnavailableError", {
+  readonly actor: Schema.String;
+  readonly reason: Schema.Literals<readonly ["undeclared", "unset", "unavailable", "command"]>;
+  readonly secret: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** An actor's secret could not be read; `reason` says why (`SecretRefusal`). */
+export declare class SecretUnavailableError extends SecretUnavailableError_base {}
+export {};

package/dist/contract/secret/secret-unavailable.errors.mjs

@@ -0,0 +1,10 @@
+import { SecretRefusal } from "./secret.schema.mjs";
+import { Schema } from "effect";
+// src/contract/secret/secret-unavailable.errors.ts
+/** An actor's secret could not be read; `reason` says why (`SecretRefusal`). */
+var SecretUnavailableError = class extends Schema.TaggedError()("SecretUnavailableError", {
+	actor: Schema.String,
+	reason: SecretRefusal,
+	secret: Schema.String
+}) {};
+export { SecretUnavailableError };