@akterjs/effect 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+/**
+ * A secret's name, as Akter Cloud stores it for an environment and as an environment variable: an uppercase letter,
+ * then up to 127 uppercase letters, digits or underscores.
+ */
+declare const SecretName: Schema.String;
+/**
+ * Why a secret could not be read:
+ *
+ * - `undeclared`: the actor doesn't list it in its `secrets`, so it may not read it.
+ * - `unset`: the actor declares it, but the environment has no value for it.
+ * - `unavailable`: this engine delivers no secrets, or couldn't open them just now.
+ * - `command`: a command, query, create or result handler asked; secrets are read in job activities.
+ */
+declare const SecretRefusal: Schema.Literals<readonly ["undeclared", "unset", "unavailable", "command"]>;
+type SecretRefusal = typeof SecretRefusal.Type;
+/** A computer's credential: the secret the platform adds as `header` to its requests to `host`, after `prefix`. */
+declare const ComputerSecret: Schema.Struct<{
+  readonly header: Schema.String;
+  readonly host: Schema.String;
+  readonly prefix: Schema.optionalKey<Schema.String>;
+  readonly secret: Schema.String;
+}>;
+type ComputerSecret = typeof ComputerSecret.Type;
+export { ComputerSecret, SecretName, SecretRefusal };

package/dist/contract/secret/secret.schema.mjs

@@ -0,0 +1,34 @@
+import { Schema } from "effect";
+// src/contract/secret/secret.schema.ts
+const secretNamePattern = /^[A-Z][A-Z0-9_]{0,127}$/u;
+const headerPattern = /^[A-Za-z0-9-]+$/u;
+const printablePattern = /^[\t -~]*$/u;
+/**
+* A secret's name, as Akter Cloud stores it for an environment and as an environment variable: an uppercase letter,
+* then up to 127 uppercase letters, digits or underscores.
+*/
+const SecretName = Schema.String.check(Schema.isPattern(secretNamePattern)).annotate({ description: "A secret's name, as an environment variable." });
+/**
+* Why a secret could not be read:
+*
+* - `undeclared`: the actor doesn't list it in its `secrets`, so it may not read it.
+* - `unset`: the actor declares it, but the environment has no value for it.
+* - `unavailable`: this engine delivers no secrets, or couldn't open them just now.
+* - `command`: a command, query, create or result handler asked; secrets are read in job activities.
+*/
+const SecretRefusal = Schema.Literals([
+	"undeclared",
+	"unset",
+	"unavailable",
+	"command"
+]);
+/** What the platform writes before a credential's value, such as `Bearer `: printable ASCII only. */
+const HeaderPrefix = Schema.String.check(Schema.isPattern(printablePattern));
+/** A computer's credential: the secret the platform adds as `header` to its requests to `host`, after `prefix`. */
+const ComputerSecret = Schema.Struct({
+	header: Schema.String.check(Schema.isPattern(headerPattern)),
+	host: Schema.String,
+	prefix: Schema.optionalKey(HeaderPrefix),
+	secret: SecretName
+}).annotate({ description: "A credential the platform adds to the computer's requests to one allowed host. The computer never sees its value." });
+export { ComputerSecret, SecretName, SecretRefusal };

package/dist/contract/spend/billing-unavailable.errors.d.mts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+declare const BillingUnavailableError_base: Schema.Class<BillingUnavailableError, Schema.TaggedStruct<"BillingUnavailableError", {
+  readonly retryAfterSeconds: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * Akter Cloud couldn't tell whether new spend fits under the caps for too long to admit it safely, so it
+ * refused the call. Nothing ran. Retry after `retryAfterSeconds`.
+ */
+export declare class BillingUnavailableError extends BillingUnavailableError_base {}
+export {};

package/dist/contract/spend/billing-unavailable.errors.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/contract/spend/billing-unavailable.errors.ts
+/**
+* Akter Cloud couldn't tell whether new spend fits under the caps for too long to admit it safely, so it
+* refused the call. Nothing ran. Retry after `retryAfterSeconds`.
+*/
+var BillingUnavailableError = class extends Schema.TaggedError()("BillingUnavailableError", { retryAfterSeconds: Schema.Int }) {};
+export { BillingUnavailableError };

package/dist/contract/spend/spend-cap-reached.errors.d.mts

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+declare const SpendCapReachedError_base: Schema.Class<SpendCapReachedError, Schema.TaggedStruct<"SpendCapReachedError", {
+  readonly capUsd: Schema.Finite;
+  readonly period: Schema.String;
+  readonly scope: Schema.Literals<readonly ["organization", "apiKey"]>;
+  readonly spentUsd: Schema.Finite;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * Akter Cloud refused new spend because a spend cap is reached. `scope` says whose cap: the
+ * organization's, or the calling API key's. A person raises it in the Cloud API; work already
+ * running is not stopped. Amounts are US dollars for the calendar month `period` (`YYYY-MM`), and
+ * `spentUsd` includes spend that may still be on its way.
+ */
+export declare class SpendCapReachedError extends SpendCapReachedError_base {}
+export {};

package/dist/contract/spend/spend-cap-reached.errors.mjs

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+// src/contract/spend/spend-cap-reached.errors.ts
+/**
+* Akter Cloud refused new spend because a spend cap is reached. `scope` says whose cap: the
+* organization's, or the calling API key's. A person raises it in the Cloud API; work already
+* running is not stopped. Amounts are US dollars for the calendar month `period` (`YYYY-MM`), and
+* `spentUsd` includes spend that may still be on its way.
+*/
+var SpendCapReachedError = class extends Schema.TaggedError()("SpendCapReachedError", {
+	capUsd: Schema.Finite,
+	period: Schema.String,
+	scope: Schema.Literals(["organization", "apiKey"]),
+	spentUsd: Schema.Finite
+}) {};
+export { SpendCapReachedError };

package/dist/contract/state/actor-state.pure.d.mts

@@ -0,0 +1,38 @@
+import { ActorState } from "./actor-state.service.mjs";
+import { CommandEnvironment, CommandScope, StateFields } from "../actor/actor.contract.mjs";
+import { AnyCommand, Jobs } from "../command/command.contract.mjs";
+import { TimerChanges } from "../command/timer.schema.mjs";
+import { outboxMessage } from "../command/outbox-id.pure.mjs";
+import { StartedJob } from "../job/started-job.schema.mjs";
+import { JobSignal } from "../job/job-signal.schema.mjs";
+import { Effect, Ref } from "effect";
+type OutboxMessage = ReturnType<typeof outboxMessage>;
+interface PendingChanges extends TimerChanges {
+  readonly jobs: readonly StartedJob[];
+  readonly messages: readonly OutboxMessage[];
+  readonly signals: readonly JobSignal[];
+  readonly state: StateFields;
+}
+interface StateSource {
+  readonly actor: string;
+  readonly commands: Readonly<Record<string, AnyCommand>>;
+  readonly environment: CommandEnvironment;
+  readonly jobs: Jobs;
+  readonly state: StateFields;
+}
+interface Scoping {
+  readonly environment: CommandEnvironment;
+  readonly principal: CommandScope["principal"];
+}
+interface CommandActorState {
+  readonly changes: Ref.Ref<PendingChanges>;
+  readonly service: ActorState["Service"];
+}
+declare const noTimers: TimerChanges;
+declare const noMessages: readonly OutboxMessage[];
+declare const noJobs: readonly StartedJob[];
+declare const noSignals: readonly JobSignal[];
+declare const refusedActorState: ActorState["Service"];
+declare const scopeOf: ({ environment, principal }: Scoping) => CommandScope;
+declare const commandActorState: (source: StateSource) => Effect.Effect<CommandActorState, never, never>;
+export { commandActorState, noJobs, noMessages, noSignals, noTimers, refusedActorState, scopeOf };

package/dist/contract/state/actor-state.pure.mjs

@@ -0,0 +1,153 @@
+import { jsonCodec } from "../json-codec.pure.mjs";
+import { TimerId } from "../command/timer.schema.mjs";
+import { outboxMessage } from "../command/outbox-id.pure.mjs";
+import { JobCodecsOf, jobTag } from "../command/command.contract.mjs";
+import { jobAddress, jobIdOf } from "../job/job-id.pure.mjs";
+import { StoredExit } from "../job/job-signal.schema.mjs";
+import { Array, Context, Duration, Effect, Exit, Option, Record, Ref, Schema } from "effect";
+// src/contract/state/actor-state.pure.ts
+const noTimers = {
+	cancelled: [],
+	scheduled: []
+};
+const noMessages = [];
+const noJobs = [];
+const noSignals = [];
+const onlyCommands = Effect.die("only a command changes an actor's state, timers and outbox");
+const refusedActorState = {
+	attachFile: () => onlyCommands,
+	cancel: () => onlyCommands,
+	patch: () => onlyCommands,
+	removeFile: () => onlyCommands,
+	schedule: () => onlyCommands,
+	send: () => onlyCommands,
+	signal: () => onlyCommands,
+	start: () => onlyCommands
+};
+const scopeOf = ({ environment, principal }) => ({
+	...environment,
+	principal
+});
+const commandName = (commands, command) => Option.match(Array.findFirst(Record.toEntries(commands), ([, declared]) => declared === command), {
+	onNone: () => Effect.die("Akter.schedule names a command this actor does not declare"),
+	onSome: ([name]) => Effect.succeed(name)
+});
+const ownJob = ({ actor, jobs }, { job: { _tag: name } }) => {
+	if (Array.some(Record.keys(jobs), (member) => jobTag({
+		actor,
+		member
+	}) === name)) return Effect.succeed(name);
+	return Effect.die(`Akter.start names ${name}, which is not a job of ${actor}`);
+};
+/** The payload as the job's journal keeps it: through the job's own codec, which adds the patches its contract declares. */
+const storedPayloadOf = ({ job, payload }) => {
+	const declared = Option.flatMapNullishOr(Context.get(job.annotations, JobCodecsOf), (codecs) => codecs.startedPayload);
+	const codec = Option.getOrElse(declared, () => jsonCodec(job.payloadSchema));
+	return Schema.encodeEffect(codec)(payload);
+};
+const startJob = (source, changes) => Effect.fnUntraced(function* start(starting) {
+	const { actor, environment } = source;
+	const job = yield* ownJob(source, starting);
+	const payload = yield* Effect.orDie(storedPayloadOf(starting));
+	const id = jobIdOf({
+		actor,
+		id: yield* environment.id,
+		key: environment.key
+	});
+	const started = {
+		id,
+		job,
+		payload
+	};
+	yield* Ref.update(changes, (current) => ({
+		...current,
+		jobs: Array.append(current.jobs, started)
+	}));
+	return id;
+});
+const ownExecution = ({ actor, environment }, job) => {
+	if (Option.exists(jobAddress(job), (address) => address.actor === actor && address.key === environment.key)) return Effect.void;
+	return Effect.die(`Akter.signal names ${job}, which is not a job of ${actor}/${environment.key}: signal another actor's job with a command sent to that actor`);
+};
+const signalJob = (source, changes) => Effect.fnUntraced(function* signal({ exit: schema, job, name, value }) {
+	yield* ownExecution(source, job);
+	const encoded = yield* Effect.orDie(Schema.encodeEffect(schema)(Exit.succeed(value)));
+	const signalled = {
+		deferred: name,
+		exit: yield* Effect.orDie(Schema.encodeEffect(StoredExit)(encoded)),
+		id: job
+	};
+	yield* Ref.update(changes, (current) => ({
+		...current,
+		signals: Array.append(current.signals, signalled)
+	}));
+});
+const pendingOf = (state) => ({
+	...noTimers,
+	jobs: noJobs,
+	messages: noMessages,
+	signals: noSignals,
+	state
+});
+const commandActorState = Effect.fnUntraced(function* commandActorState(source) {
+	const { commands, environment, state } = source;
+	const changes = yield* Ref.make(pendingOf(state));
+	const schedule = Effect.fnUntraced(function* schedule({ command, delay, payload }) {
+		const name = yield* commandName(commands, command);
+		const text = yield* Effect.orDie(Schema.encodeEffect(jsonCodec(command.payload))(payload));
+		const minted = yield* environment.id;
+		const id = TimerId.make(minted);
+		const timer = {
+			after: Duration.fromInputUnsafe(delay),
+			command: name,
+			id,
+			payload: text
+		};
+		yield* Ref.update(changes, (current) => ({
+			...current,
+			scheduled: Array.append(current.scheduled, timer)
+		}));
+		return id;
+	});
+	const send = Effect.fnUntraced(function* send({ command, key, payload }) {
+		const { actor, member } = command.address;
+		const encodedKey = yield* Effect.orDie(Schema.encodeEffect(command.address.key)(key));
+		const text = yield* Effect.orDie(Schema.encodeEffect(jsonCodec(command.payload))(payload));
+		const id = yield* environment.id;
+		const message = outboxMessage({
+			actor,
+			id,
+			key: encodedKey,
+			member,
+			payload: text
+		});
+		yield* Ref.update(changes, (current) => ({
+			...current,
+			messages: Array.append(current.messages, message)
+		}));
+	});
+	return {
+		changes,
+		service: {
+			attachFile: environment.files.attach,
+			cancel: (timerId) => Ref.update(changes, (current) => ({
+				...current,
+				cancelled: Array.append(current.cancelled, timerId),
+				scheduled: Array.filter(current.scheduled, (timer) => timer.id !== timerId)
+			})),
+			patch: (patch) => Ref.update(changes, (current) => ({
+				...current,
+				state: {
+					...current.state,
+					...patch
+				}
+			})),
+			removeFile: environment.files.remove,
+			schedule,
+			send,
+			signal: signalJob(source, changes),
+			start: startJob(source, changes)
+		}
+	};
+});
+export { commandActorState, noJobs, noMessages, noSignals, noTimers, refusedActorState, scopeOf };

package/dist/contract/state/actor-state.service.d.mts

@@ -0,0 +1,45 @@
+import { AddressedCommand, Decoded, StateFields } from "../actor/actor.contract.mjs";
+import { AnyCommand, StartableJob } from "../command/command.contract.mjs";
+import { TimerId } from "../command/timer.schema.mjs";
+import { ActorFiles, FileStorage } from "../file/actor-files.contract.mjs";
+import { Context, Duration, Effect, Exit, Schema } from "effect";
+interface Sending {
+  readonly command: AddressedCommand;
+  readonly key: Decoded;
+  readonly payload: Decoded;
+}
+interface Starting {
+  readonly job: StartableJob;
+  readonly payload: Decoded;
+}
+interface Signalling {
+  /** The deferred's exit schema, which encodes `value` as its success. */
+  readonly exit: Schema.Codec<Exit.Exit<unknown, unknown>, Exit.Exit<unknown, unknown>>;
+  readonly job: string;
+  /** The durable deferred's name. */
+  readonly name: string;
+  readonly value: unknown;
+}
+interface Scheduling {
+  readonly command: AnyCommand;
+  readonly delay: Duration.Input;
+  readonly payload: Decoded;
+}
+interface FileScope {
+  readonly files: FileStorage;
+  readonly now: Effect.Effect<number>;
+}
+declare const ActorState_base: Context.ServiceClass<ActorState, "@akterjs/effect/contract/state/actor-state.service/ActorState", {
+  readonly attachFile: FileStorage["attach"];
+  readonly cancel: (timerId: TimerId) => Effect.Effect<void>;
+  readonly patch: (patch: StateFields) => Effect.Effect<void>;
+  readonly removeFile: FileStorage["remove"];
+  readonly schedule: (scheduling: Scheduling) => Effect.Effect<TimerId>;
+  readonly send: (sending: Sending) => Effect.Effect<void>;
+  readonly signal: (signalling: Signalling) => Effect.Effect<void>;
+  readonly start: (starting: Starting) => Effect.Effect<string>;
+}>;
+export declare class ActorState extends ActorState_base {
+  static files({ files, now }: FileScope): ActorFiles;
+}
+export type { FileStorage, Scheduling, Sending, Signalling, Starting, TimerId };

package/dist/contract/state/actor-state.service.mjs

@@ -0,0 +1,18 @@
+import { Context, Effect } from "effect";
+// src/contract/state/actor-state.service.ts
+var ActorState = class ActorState extends Context.Service()("@akterjs/effect/contract/state/actor-state.service/ActorState") {
+	static files({ files, now }) {
+		return {
+			attach: (path, receipt) => ActorState.use((state) => Effect.flatMap(now, (at) => state.attachFile({
+				now: at,
+				path,
+				receipt
+			}))),
+			fileUsage: files.fileUsage,
+			list: files.list,
+			read: files.read,
+			remove: (path) => ActorState.use((state) => state.removeFile(path))
+		};
+	}
+};
+export { ActorState };

package/dist/contract/state/state-migration.pure.d.mts

@@ -0,0 +1,11 @@
+import { StateFields, StateMigration } from "../actor/actor.contract.mjs";
+import { PlainSchema } from "../command/command.contract.mjs";
+import { ErasedParts } from "../hosted/hosted-request.pure.mjs";
+import { StateUnreadableError } from "./state-unreadable.errors.mjs";
+import { Effect, Option } from "effect";
+declare const migrateState: {
+  <From extends PlainSchema, Current extends StateFields>(migrate: (old: From["Type"]) => Current): (from: From) => StateMigration<Current>;
+  <From extends PlainSchema, Current extends StateFields>(from: From, migrate: (old: From["Type"]) => Current): StateMigration<Current>;
+};
+declare const upgradeState: (parts: ErasedParts, stored: string) => Effect.Effect<Option.Option<string>, StateUnreadableError, never>;
+export { migrateState, upgradeState };

package/dist/contract/state/state-migration.pure.mjs

@@ -0,0 +1,23 @@
+import { jsonCodec } from "../json-codec.pure.mjs";
+import { StateUnreadableError } from "./state-unreadable.errors.mjs";
+import { Effect, Option, Result, Schema } from "effect";
+import { dual } from "effect/Function";
+// src/contract/state/state-migration.pure.ts
+const migrateState = dual(2, (from, migrate) => ({ upgrade: (stored) => Effect.map(Schema.decodeEffect(jsonCodec(from))(stored), migrate) }));
+const migrateStored = (parts, stored) => Option.match(Option.fromUndefinedOr(parts.implementation.state), {
+	onNone: () => Effect.fail(StateUnreadableError.make({
+		actor: parts.name,
+		message: "no Akter.migrateState"
+	})),
+	onSome: (migration) => Effect.flatMap(migration.upgrade(stored), Schema.encodeEffect(jsonCodec(parts.definition.state)))
+});
+const upgradeState = Effect.fnUntraced(function* upgradeState(parts, stored) {
+	const current = yield* Effect.result(Schema.decodeEffect(jsonCodec(parts.definition.state))(stored));
+	if (Result.isSuccess(current)) return Option.none();
+	const upgraded = yield* Effect.mapError(migrateStored(parts, stored), (issue) => StateUnreadableError.make({
+		actor: parts.name,
+		message: `${current.failure.message}\n${issue.message}`
+	}));
+	return Option.some(upgraded);
+});
+export { migrateState, upgradeState };

package/dist/contract/state/state-read.pure.d.mts

@@ -0,0 +1,12 @@
+import { HostedError } from "../hosted/hosted-error.contract.mjs";
+import { CallersSchemas, StateFields, StateSchema } from "../actor/actor.contract.mjs";
+import { Effect, Option } from "effect";
+interface StateSource {
+  readonly callers: CallersSchemas;
+  readonly initial: Option.Option<() => StateFields>;
+  readonly name: string;
+  readonly state: StateSchema;
+}
+type StateEncoder = (stored: Option.Option<string>) => Effect.Effect<string, HostedError>;
+declare const stateReader: (source: StateSource) => (principal: string) => Effect.Effect<StateEncoder, HostedError>;
+export { type StateEncoder, type StateSource, stateReader };

package/dist/contract/state/state-read.pure.mjs

@@ -0,0 +1,22 @@
+import { admit } from "../caller/caller-admission.pure.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { jsonCodec } from "../json-codec.pure.mjs";
+import { startingState } from "../hosted/hosted-request.pure.mjs";
+import { Effect, Option, Schema } from "effect";
+// src/contract/state/state-read.pure.ts
+const stateMember = "state";
+const stateReader = (source) => (principal) => {
+	const encode = Schema.encodeEffect(jsonCodec(source.state));
+	const encoder = (stored) => Effect.flatMap(startingState(source, stored), (state) => Effect.mapError(encode(state), (issue) => InvalidRequestError.make({
+		actor: source.name,
+		message: issue.message
+	})));
+	return Effect.as(admit({
+		actor: source.name,
+		allowed: Option.none(),
+		callers: source.callers,
+		member: stateMember,
+		principal
+	}), encoder);
+};
+export { stateReader };

package/dist/contract/state/state-unreadable.errors.d.mts

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

package/dist/contract/state/state-unreadable.errors.mjs

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

package/dist/host/actor/actor-database.service.d.mts

@@ -0,0 +1,46 @@
+import { HostedActor } from "../../contract/actor/actor.contract.mjs";
+import { FileStorage } from "../../contract/file/actor-files.contract.mjs";
+import { LocalActorFileOpener, LocalActorFiles } from "../file/local-blob-owner.sql.mjs";
+import { ActorMigrations, ActorOpenError as ActorOpenError$1 } from "../migration/actor-migrations.service.mjs";
+import { SqliteDriver } from "../sqlite/sqlite-driver.service.mjs";
+import { Context, Effect, Layer, Scope } from "effect";
+import { SqlClient } from "effect/sql";
+interface OpenOptions {
+  readonly actor: HostedActor;
+  readonly filename: string;
+  readonly identity?: string;
+}
+interface OpenedActor {
+  readonly actor: HostedActor;
+  readonly files: (sql: SqlClient.SqlClient) => FileStorage;
+  readonly filename: string;
+  readonly fileSession?: LocalActorFiles;
+  readonly reader: SqlClient.SqlClient;
+  readonly sql: SqlClient.SqlClient;
+}
+interface ReplayOptions {
+  readonly actor: HostedActor;
+  readonly source: SqlClient.SqlClient;
+}
+type ClientsFailure = Effect.Error<ReturnType<SqliteDriver["Service"]["openActor"]>>;
+type ActorOpenError = ActorOpenError$1 | ClientsFailure | Effect.Error<ReturnType<LocalActorFileOpener>>;
+declare const ActorDatabase_base: Context.ServiceClass<ActorDatabase, "@akterjs/effect/host/actor/actor-database.service/ActorDatabase", {
+  readonly blank: (actor: HostedActor) => Effect.Effect<OpenedActor, ActorOpenError$1, Scope.Scope>;
+  readonly open: (options: OpenOptions) => Effect.Effect<OpenedActor, ActorOpenError, Scope.Scope>;
+  /** Opens a database file that is no actor's yet, such as a fork's staged copy: no migrations, no files. */
+  readonly openCopy: (filename: string) => Effect.Effect<SqlClient.SqlClient, ClientsFailure, Scope.Scope>;
+  readonly replay: (options: ReplayOptions) => Effect.Effect<OpenedActor, ActorOpenError, Scope.Scope>;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly blank: (actor: HostedActor) => Effect.Effect<OpenedActor, ActorOpenError$1, Scope.Scope>;
+    readonly open: (options: OpenOptions) => Effect.Effect<OpenedActor, ActorOpenError, Scope.Scope>;
+    /** Opens a database file that is no actor's yet, such as a fork's staged copy: no migrations, no files. */
+    readonly openCopy: (filename: string) => Effect.Effect<SqlClient.SqlClient, ClientsFailure, Scope.Scope>;
+    readonly replay: (options: ReplayOptions) => Effect.Effect<OpenedActor, ActorOpenError, Scope.Scope>;
+  }, never, ActorMigrations | SqliteDriver>;
+};
+export declare class ActorDatabase extends ActorDatabase_base {
+  static readonly layer: Layer.Layer<ActorDatabase, never, SqliteDriver>;
+  static readonly layerNode: Layer.Layer<ActorDatabase, never, never>;
+}
+export type { ActorOpenError, OpenOptions, OpenedActor };

package/dist/host/actor/actor-database.service.mjs

@@ -0,0 +1,112 @@
+import { actorFileStorage, emptyFileStorage, unavailableFileStorage } from "../file/actor-file-storage.sql.mjs";
+import { LocalBlobHomes } from "../file/local-blob-home.service.mjs";
+import { localActorFiles } from "../file/local-blob-owner.sql.mjs";
+import { replayFileStorage } from "../file/replay-file-storage.sql.mjs";
+import { ActorMigrations } from "../migration/actor-migrations.service.mjs";
+import { SqliteDriver } from "../sqlite/sqlite-driver.service.mjs";
+import { Context, Effect, Layer, Option } from "effect";
+// src/host/actor/actor-database.service.ts
+const memory = ":memory:";
+const queryOnly = "PRAGMA query_only = ON";
+const unavailableFiles = () => unavailableFileStorage;
+const emptyFiles = () => emptyFileStorage;
+const clientsOf = (driver, { filename, identity }) => Option.match(Option.fromNullishOr(identity), {
+	onNone: () => Effect.map(driver.open(filename), (sql) => ({
+		reader: driver.openQueryOnly(filename),
+		sql
+	})),
+	onSome: (actor) => driver.openActor({
+		actor,
+		filename
+	})
+});
+const openedWith = Effect.fnUntraced(function* openedWith({ reader: opening, session }, { actor, filename, identity }, sql) {
+	if (filename === memory) return {
+		actor,
+		filename,
+		files: unavailableFiles,
+		reader: sql,
+		sql
+	};
+	const reader = yield* opening;
+	const prepared = yield* Option.match(Option.fromNullishOr(identity), {
+		onNone: () => Effect.succeedNone,
+		onSome: (owner) => session({
+			actor: owner,
+			sql
+		})
+	});
+	const files = (connection) => Option.match(prepared, {
+		onNone: () => unavailableFileStorage,
+		onSome: ({ home, owner }) => actorFileStorage({
+			actor: owner.actor,
+			open: home.transfers.open,
+			sql: connection
+		})
+	});
+	return {
+		actor,
+		filename,
+		files,
+		reader,
+		sql,
+		...Option.match(prepared, {
+			onNone: () => ({}),
+			onSome: (fileSession) => ({ fileSession })
+		})
+	};
+});
+var ActorDatabase = class extends Context.Service()("@akterjs/effect/host/actor/actor-database.service/ActorDatabase", { make: Effect.gen(function* makeActorDatabase() {
+	const driver = yield* SqliteDriver;
+	const migrations = yield* ActorMigrations;
+	const homes = yield* Effect.serviceOption(LocalBlobHomes);
+	const session = localActorFiles(homes);
+	const replayFiles = replayFileStorage(homes);
+	const open = Effect.fn("ActorDatabase.open")(function* open(options) {
+		const { reader, sql } = yield* clientsOf(driver, options);
+		yield* migrations.prepare({
+			actor: options.actor,
+			sql
+		});
+		return yield* openedWith({
+			reader,
+			session
+		}, options, sql);
+	});
+	const blank = Effect.fn("ActorDatabase.blank")(function* blank(actor) {
+		const { reader, sql } = yield* driver.openInMemory;
+		yield* migrations.prepare({
+			actor,
+			sql
+		});
+		yield* reader.unsafe(queryOnly);
+		const files = Option.match(homes, {
+			onNone: () => unavailableFiles,
+			onSome: () => emptyFiles
+		});
+		return {
+			actor,
+			filename: memory,
+			files,
+			reader,
+			sql: reader
+		};
+	});
+	const replay = Effect.fn("ActorDatabase.replay")(function* replay({ actor, source }) {
+		const initial = yield* open({
+			actor,
+			filename: memory
+		});
+		return yield* replayFiles(source, initial);
+	});
+	return {
+		blank,
+		open,
+		openCopy: driver.open,
+		replay
+	};
+}) }) {
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide(ActorMigrations.layer));
+	static layerNode = this.layer.pipe(Layer.provide(SqliteDriver.layerNode));
+};
+export { ActorDatabase };

package/dist/host/actor/actor-exclusive.pure.d.mts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+interface ActorExclusive {
+  readonly close: Effect.Effect<void>;
+  readonly run: <Success, Failure, Needs>(effect: Effect.Effect<Success, Failure, Needs>) => Effect.Effect<Success, Failure, Needs>;
+}
+declare const actorExclusive: Effect.Effect<ActorExclusive>;
+export { type ActorExclusive, actorExclusive };

package/dist/host/actor/actor-exclusive.pure.mjs

@@ -0,0 +1,16 @@
+import { Effect, Ref, Semaphore } from "effect";
+// src/host/actor/actor-exclusive.pure.ts
+const oneActorOperation = 1;
+const actorExclusive = Effect.gen(function* makeActorExclusive() {
+	const semaphore = yield* Semaphore.make(oneActorOperation);
+	const closed = yield* Ref.make(false);
+	const run = (effect) => semaphore.withPermits(oneActorOperation)(Effect.flatMap(Ref.get(closed), (disposed) => {
+		if (disposed) return Effect.die("the actor database scope is closed");
+		return effect;
+	}));
+	return {
+		close: semaphore.withPermits(oneActorOperation)(Ref.set(closed, true)),
+		run
+	};
+});
+export { actorExclusive };