@akterjs/effect 0.0.0-stage → 0.1.1

package/dist/serve/hosted/hosted-runtime.layer.mjs

@@ -0,0 +1,48 @@
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { withJobs } from "../engine/job-runtime.layer.mjs";
+import { providedHandlers } from "../engine/actor-engine.layer.mjs";
+import { HostedRuntime } from "./hosted-runtime.service.mjs";
+import { bundleWorkflows, isRefusedBuild, servedRegistry } from "./hosted-app-checks.layer.mjs";
+import { servedSecrets } from "./hosted-secrets.layer.mjs";
+import { ActorSecrets } from "../../contract/secret/actor-secrets.adapter.mjs";
+import { ExecutionAuthority } from "../../host/upkeep/execution-authority.pure.mjs";
+import { engineOwnedRefusal } from "../../contract/hosted/handler-failure.pure.mjs";
+import { HandlerSql, QueryReadOnly, engineOwned } from "../../host/query/query-policy.pure.mjs";
+import { CommandBatch, commandBatch, dropCommand, keepCommand } from "../../host/command/batch/command-batch.sql.mjs";
+import { ActorConnections } from "../../host/sqlite/actor-connections.pure.mjs";
+import { HostedAppBuildError } from "./hosted-app-build.errors.mjs";
+import { bundleHostInterface, hostInterface, hostInterfaceLine, hostInterfaceOf, oldestHostInterface, servesHostInterface } from "../../contract/actor/host-interface.pure.mjs";
+import { JobComputers } from "../../host/computer/job-computers.service.mjs";
+import { hostedActorFiles, hostedFileHome } from "./hosted-files.layer.mjs";
+import { ServeDurableSteps, hostedFileRpcs, hostedFileRpcsWith } from "./hosted-file-rpcs.layer.mjs";
+import { defaultUploadLimits } from "../rpc/file/upload-sessions.pure.mjs";
+import { heldExportFile, heldExportFiles, holdExportFiles } from "../../host/blob/export/blob-export-holds.sql.mjs";
+import { ArchivedActors } from "../archive/archived-actors.layer.mjs";
+import { ArchivedStore } from "../archive/archived-store.layer.mjs";
+import { BlobKeyring } from "../../host/blob/blob-keyring.service.mjs";
+import { BlobSealing } from "../../host/blob/blob-sealing.service.mjs";
+import { BlobTransferError } from "../../contract/file/blob-transfer.errors.mjs";
+import { blobHashing } from "../../runtime/blob-hashing.layer.mjs";
+import { BlobHashing } from "../../host/hash/blob-hashing.service.mjs";
+import { Cause, Effect, Layer } from "effect";
+import { layer } from "@effect/platform-node/NodeFileSystem";
+import { layer as layer$1 } from "@effect/platform-node/NodePath";
+// src/serve/hosted/hosted-runtime.layer.ts
+const runtime = HostedRuntime.layer.pipe(Layer.provide([
+	providedHandlers,
+	layer,
+	layer$1
+]));
+const hostedRuntime = withJobs(runtime);
+const hostedApp = (app) => {
+	const registered = app.pipe(Layer.provide([
+		bundleWorkflows,
+		servedRegistry,
+		servedSecrets
+	]));
+	return runtime.pipe(Layer.provide(registered), Layer.provide(ActorRegistry.layer), withJobs, Layer.catchCause((cause) => {
+		for (const reason of cause.reasons) if (Cause.isDieReason(reason) && isRefusedBuild(reason.defect)) return Layer.effectContext(Effect.fail(reason.defect));
+		return Layer.effectContext(Effect.failCause(cause));
+	}));
+};
+export { ActorConnections, ActorSecrets, ArchivedActors, ArchivedStore, BlobHashing, BlobKeyring, BlobSealing, BlobTransferError, CommandBatch, ExecutionAuthority, HandlerSql, HostedAppBuildError, HostedRuntime, JobComputers, QueryReadOnly, ServeDurableSteps, blobHashing, bundleHostInterface, commandBatch, defaultUploadLimits, dropCommand, engineOwned, engineOwnedRefusal, heldExportFile, heldExportFiles, holdExportFiles, hostInterface, hostInterfaceLine, hostInterfaceOf, hostedActorFiles, hostedApp, hostedFileHome, hostedFileRpcs, hostedFileRpcsWith, hostedRuntime, keepCommand, oldestHostInterface, servesHostInterface };

package/dist/serve/hosted/hosted-runtime.service.d.mts

@@ -0,0 +1,77 @@
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { OpenedActor } from "../../host/actor/actor-database.service.mjs";
+import { CommandRunner } from "../../host/command/command-runner.service.mjs";
+import { ActorMigrations, ActorOpenError, PreparingActor } from "../../host/migration/actor-migrations.service.mjs";
+import { QueryRunner } from "../../host/query/query-runner.service.mjs";
+import { ActorUpkeep, Kept, Upkeep } from "../../host/upkeep/actor-upkeep.service.mjs";
+import { LiveReads } from "../live/live-reads.service.mjs";
+import { Context, Effect, Layer, Scope } from "effect";
+import { SqlClient } from "effect/sql";
+type DeclaredActor = Omit<PreparingActor, "sql">;
+interface HostedOpening {
+  readonly actor: DeclaredActor;
+  readonly filename: string;
+  readonly sql: SqlClient.SqlClient;
+}
+interface HostedUpkeep<Failure> {
+  readonly exclusive: Upkeep<Failure>["exclusive"];
+  readonly read: Upkeep<Failure>["read"];
+  readonly key: string;
+  readonly measured?: NonNullable<Upkeep<Failure>["measured"]>;
+  readonly opened: OpenedActor;
+  readonly send: Upkeep<Failure>["send"];
+}
+type HostedKept<Failure> = Kept<Failure>;
+type Declare = (actor: string) => Effect.Effect<DeclaredActor, Effect.Error<ReturnType<ActorRegistry["Service"]["lookup"]>> | ActorOpenError>;
+type Open = (opening: HostedOpening) => Effect.Effect<OpenedActor, ActorOpenError>;
+declare const HostedRuntime_base: Context.ServiceClass<HostedRuntime, "@akterjs/effect/serve/hosted/hosted-runtime.service/HostedRuntime", {
+  /** When a command id first committed, so a host can mark an answer it replays from the journal. */
+  readonly committedAt: LiveReads["Service"]["committedAt"];
+  readonly coveredSince: QueryRunner["Service"]["coveredSince"];
+  readonly create: CommandRunner["Service"]["create"];
+  readonly declare: Declare;
+  readonly files: QueryRunner["Service"]["files"];
+  readonly history: QueryRunner["Service"]["history"];
+  readonly live: LiveReads["Service"]["open"];
+  readonly locateJobs: ActorUpkeep["Service"]["locateJobs"];
+  readonly open: Open;
+  readonly query: QueryRunner["Service"]["run"];
+  readonly retainedJobs: ActorUpkeep["Service"]["retainedJobs"];
+  readonly run: CommandRunner["Service"]["run"];
+  /** One durable computer step of an opened actor, by its key, with its output. */
+  readonly step: QueryRunner["Service"]["step"];
+  /** An opened actor's durable computer steps, newest first. */
+  readonly steps: QueryRunner["Service"]["steps"];
+  readonly upkeep: <Failure>(hosted: HostedUpkeep<Failure>) => Effect.Effect<HostedKept<Failure>, never, Scope.Scope>;
+  readonly version: LiveReads["Service"]["version"];
+}> & {
+  readonly make: Effect.Effect<{
+    /** When a command id first committed, so a host can mark an answer it replays from the journal. */
+    readonly committedAt: LiveReads["Service"]["committedAt"];
+    readonly coveredSince: QueryRunner["Service"]["coveredSince"];
+    readonly create: CommandRunner["Service"]["create"];
+    readonly declare: Declare;
+    readonly files: QueryRunner["Service"]["files"];
+    readonly history: QueryRunner["Service"]["history"];
+    readonly live: LiveReads["Service"]["open"];
+    readonly locateJobs: ActorUpkeep["Service"]["locateJobs"];
+    readonly open: Open;
+    readonly query: QueryRunner["Service"]["run"];
+    readonly retainedJobs: ActorUpkeep["Service"]["retainedJobs"];
+    readonly run: CommandRunner["Service"]["run"];
+    /** One durable computer step of an opened actor, by its key, with its output. */
+    readonly step: QueryRunner["Service"]["step"];
+    /** An opened actor's durable computer steps, newest first. */
+    readonly steps: QueryRunner["Service"]["steps"];
+    readonly upkeep: <Failure>(hosted: HostedUpkeep<Failure>) => Effect.Effect<HostedKept<Failure>, never, Scope.Scope>;
+    readonly version: LiveReads["Service"]["version"];
+  }, never, ActorMigrations | ActorRegistry | ActorUpkeep | CommandRunner | LiveReads | QueryRunner>;
+};
+export declare class HostedRuntime extends HostedRuntime_base {
+  static readonly historyRetention: Context.Reference<import("effect/Duration").Duration>;
+  static readonly hostTables: Context.Reference<import("effect/Option").Option<string>>;
+  /** How long a timer the storage ceiling refused waits to fire again. */
+  static readonly refusedTimerRetry: Context.Reference<import("effect/Duration").Duration>;
+  static readonly layer: Layer.Layer<HostedRuntime, never, ActorRegistry>;
+}
+export type { DeclaredActor, HostedKept, HostedOpening, HostedUpkeep };

package/dist/serve/hosted/hosted-runtime.service.mjs

@@ -0,0 +1,74 @@
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { CommandRunner } from "../../host/command/command-runner.service.mjs";
+import { unavailableFileStorage } from "../../host/file/actor-file-storage.sql.mjs";
+import { ActorMigrations } from "../../host/migration/actor-migrations.service.mjs";
+import { QueryRunner } from "../../host/query/query-runner.service.mjs";
+import { ActorUpkeep } from "../../host/upkeep/actor-upkeep.service.mjs";
+import { LiveReads } from "../live/live-reads.service.mjs";
+import { Context, Effect, Layer } from "effect";
+// src/serve/hosted/hosted-runtime.service.ts
+/** In Akter Cloud a failed statement's message goes to the host's log, not to the caller (`CommandRunner.statementDetail`). */
+const logged = (effect) => Effect.provideService(effect, CommandRunner.statementDetail, "logged");
+const declaring = (registry, migrations) => Effect.fn("HostedRuntime.declare")(function* declare(name) {
+	const actor = yield* registry.lookup(name);
+	return {
+		actor,
+		declared: yield* migrations.declare(actor)
+	};
+});
+const opening = (migrations) => Effect.fn("HostedRuntime.open")(function* open({ actor, filename, sql }) {
+	yield* migrations.apply({
+		...actor,
+		sql
+	});
+	return {
+		actor: actor.actor,
+		filename,
+		files: () => unavailableFileStorage,
+		reader: sql,
+		sql
+	};
+});
+var HostedRuntime = class extends Context.Service()("@akterjs/effect/serve/hosted/hosted-runtime.service/HostedRuntime", { make: Effect.gen(function* makeHostedRuntime() {
+	const registry = yield* ActorRegistry;
+	const migrations = yield* ActorMigrations;
+	const runner = yield* CommandRunner;
+	const queries = yield* QueryRunner;
+	const upkeeps = yield* ActorUpkeep;
+	const reads = yield* LiveReads;
+	const upkeep = (hosted) => logged(upkeeps.start({
+		...hosted,
+		lock: hosted.exclusive
+	}));
+	return {
+		committedAt: reads.committedAt,
+		coveredSince: queries.coveredSince,
+		create: (...creating) => logged(runner.create(...creating)),
+		declare: declaring(registry, migrations),
+		files: queries.files,
+		history: queries.history,
+		live: reads.open,
+		locateJobs: upkeeps.locateJobs,
+		open: opening(migrations),
+		query: (...querying) => logged(queries.run(...querying)),
+		retainedJobs: upkeeps.retainedJobs,
+		run: (...running) => logged(runner.run(...running)),
+		step: queries.step,
+		steps: queries.steps,
+		upkeep,
+		version: reads.version
+	};
+}) }) {
+	static historyRetention = CommandRunner.historyRetention;
+	static hostTables = ActorMigrations.hostTables;
+	/** How long a timer the storage ceiling refused waits to fire again. */
+	static refusedTimerRetry = ActorUpkeep.refusedTimerRetry;
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide([
+		ActorMigrations.layer,
+		ActorUpkeep.layer,
+		CommandRunner.layer,
+		LiveReads.layer,
+		QueryRunner.layer
+	]));
+};
+export { HostedRuntime };

package/dist/serve/hosted/hosted-secrets.layer.d.mts

@@ -0,0 +1,10 @@
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { ActorSecrets } from "../../contract/secret/actor-secrets.adapter.mjs";
+import { Layer } from "effect";
+/**
+ * The secrets a bundle's job activities read. The host's own `ActorSecrets`, when it has one, is asked only for a
+ * secret the asking actor declares in this build's registry: a bundle can't read a secret by naming another actor or
+ * skipping its own `Actor.secret`, and a host that delivers no secrets answers `unavailable`.
+ */
+declare const servedSecrets: Layer.Layer<ActorSecrets, never, ActorRegistry>;
+export { servedSecrets };

package/dist/serve/hosted/hosted-secrets.layer.mjs

@@ -0,0 +1,28 @@
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { ActorSecrets } from "../../contract/secret/actor-secrets.adapter.mjs";
+import { SecretUnavailableError } from "../../contract/secret/secret-unavailable.errors.mjs";
+import { Array, Effect, Layer, Option } from "effect";
+// src/serve/hosted/hosted-secrets.layer.ts
+/**
+* The secrets a bundle's job activities read. The host's own `ActorSecrets`, when it has one, is asked only for a
+* secret the asking actor declares in this build's registry: a bundle can't read a secret by naming another actor or
+* skipping its own `Actor.secret`, and a host that delivers no secrets answers `unavailable`.
+*/
+const servedSecrets = Layer.effect(ActorSecrets, Effect.gen(function* serveSecrets() {
+	const registry = yield* ActorRegistry;
+	const source = yield* Effect.serviceOption(ActorSecrets);
+	const read = Effect.fn("ActorSecrets.read")(function* read(request) {
+		const actor = yield* Effect.option(registry.lookup(request.actor));
+		if (!Option.exists(actor, ({ secrets }) => Array.contains(secrets ?? [], request.secret))) return yield* SecretUnavailableError.make({
+			...request,
+			reason: "undeclared"
+		});
+		if (Option.isNone(source)) return yield* SecretUnavailableError.make({
+			...request,
+			reason: "unavailable"
+		});
+		return yield* source.value.read(request);
+	});
+	return ActorSecrets.of({ read });
+}));
+export { servedSecrets };

package/dist/serve/http/loopback-host.pure.d.mts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+type Response = HttpServerResponse.HttpServerResponse;
+type AllowedHosts = readonly string[] | true;
+type Middleware = <Failure, Services>(app: Effect.Effect<Response, Failure, Services>) => Effect.Effect<Response, Failure, Services | HttpServerRequest.HttpServerRequest>;
+declare const isLoopbackHost: (host: string) => boolean;
+declare const isAllowedHost: (allowed: AllowedHosts) => (host: string) => boolean;
+declare const isLoopbackOrigin: (origin: string) => boolean;
+declare const allowedHostsOnly: (allowed: AllowedHosts) => Middleware;
+declare const loopbackOriginOnly: Middleware;
+export { type AllowedHosts, allowedHostsOnly, isAllowedHost, isLoopbackHost, isLoopbackOrigin, loopbackOriginOnly };

package/dist/serve/http/loopback-host.pure.mjs

@@ -0,0 +1,29 @@
+import { Array, Effect, Option, String } from "effect";
+import { Headers, HttpServerRequest, HttpServerResponse } from "effect/http";
+// src/serve/http/loopback-host.pure.ts
+const forbidden = 403;
+const misdirected = 421;
+const originScheme = /^https?:\/\//iu;
+const portSuffix = /:\d{1,5}$/u;
+const loopbackHost = /^(?:localhost|127(?:\.(?:25[0-5]|2[0-4]\d|1?\d?\d)){3}|\[::1\])(?::\d{1,5})?$/iu;
+const refusal = "this listener only answers a loopback Host (localhost, 127.0.0.0/8 or [::1]) or a name in allowedHosts, so a page that rebinds its own name to this address gets nothing";
+const crossSite = "this listener only answers requests from a loopback page or from outside a browser, so another site's page can't call it with your development caller";
+const isLoopbackHost = (host) => loopbackHost.test(host);
+const isAllowedHost = (allowed) => (host) => {
+	if (allowed === true || isLoopbackHost(host)) return true;
+	const name = String.toLowerCase(String.replace(portSuffix, "")(host));
+	return Array.some(allowed, (listed) => String.toLowerCase(listed) === name);
+};
+const isLoopbackOrigin = (origin) => originScheme.test(origin) && isLoopbackHost(String.replace(originScheme, "")(origin));
+const allowedHostsOnly = (allowed) => (app) => HttpServerRequest.HttpServerRequest.use((request) => {
+	if (Option.exists(Headers.get(request.headers, "host"), isAllowedHost(allowed))) return app;
+	return Effect.succeed(HttpServerResponse.text(refusal, { status: misdirected }));
+});
+const loopbackOriginOnly = (app) => HttpServerRequest.HttpServerRequest.use((request) => {
+	if (Option.match(Headers.get(request.headers, "origin"), {
+		onNone: () => true,
+		onSome: isLoopbackOrigin
+	})) return app;
+	return Effect.succeed(HttpServerResponse.text(crossSite, { status: forbidden }));
+});
+export { allowedHostsOnly, isAllowedHost, isLoopbackHost, isLoopbackOrigin, loopbackOriginOnly };

package/dist/serve/inspect/actor-inspection.schema.d.mts

@@ -0,0 +1,119 @@
+import { Schema } from "effect";
+declare const Rows: Schema.$Array<Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Null]>>>;
+declare const DeveloperTable: Schema.Struct<{
+  readonly columns: Schema.$Array<Schema.String>;
+  readonly name: Schema.String;
+  readonly rows: Schema.$Array<Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Null]>>>;
+  readonly total: Schema.Int;
+}>;
+declare const JournaledCommand: Schema.Struct<{
+  readonly at: Schema.Int;
+  readonly command: Schema.String;
+  readonly commandId: Schema.String;
+  readonly exit: Schema.String;
+  readonly payload: Schema.String;
+  readonly principal: Schema.String;
+  readonly seq: Schema.Int;
+}>;
+declare const PendingTimer: Schema.Struct<{
+  readonly command: Schema.String;
+  readonly dueAt: Schema.Int;
+  readonly id: Schema.String;
+  readonly payload: Schema.String;
+  readonly principal: Schema.String;
+}>;
+declare const OutboxEntry: Schema.Struct<{
+  readonly actor: Schema.String;
+  readonly commandId: Schema.String;
+  readonly key: Schema.String;
+  readonly member: Schema.String;
+  readonly payload: Schema.String;
+  readonly seq: Schema.Int;
+}>;
+declare const FailedDelivery: Schema.Struct<{
+  readonly actor: Schema.String;
+  readonly at: Schema.Int;
+  readonly commandId: Schema.String;
+  readonly error: Schema.String;
+  readonly key: Schema.String;
+  readonly member: Schema.String;
+}>;
+declare const JobRun: Schema.Struct<{
+  readonly entries: Schema.$Array<Schema.Struct<{
+    readonly entry: Schema.String;
+    readonly value: Schema.String;
+  }>>;
+  readonly executionId: Schema.String;
+}>;
+declare const ActorFile: Schema.Struct<{
+  readonly bytes: Schema.Int;
+  readonly name: Schema.String;
+}>;
+declare const ActorInspection: Schema.Struct<{
+  readonly actor: Schema.String;
+  readonly commands: Schema.$Array<Schema.Struct<{
+    readonly at: Schema.Int;
+    readonly command: Schema.String;
+    readonly commandId: Schema.String;
+    readonly exit: Schema.String;
+    readonly payload: Schema.String;
+    readonly principal: Schema.String;
+    readonly seq: Schema.Int;
+  }>>;
+  readonly failedDeliveries: Schema.$Array<Schema.Struct<{
+    readonly actor: Schema.String;
+    readonly at: Schema.Int;
+    readonly commandId: Schema.String;
+    readonly error: Schema.String;
+    readonly key: Schema.String;
+    readonly member: Schema.String;
+  }>>;
+  readonly files: Schema.$Array<Schema.Struct<{
+    readonly bytes: Schema.Int;
+    readonly name: Schema.String;
+  }>>;
+  readonly jobs: Schema.$Array<Schema.Struct<{
+    readonly entries: Schema.$Array<Schema.Struct<{
+      readonly entry: Schema.String;
+      readonly value: Schema.String;
+    }>>;
+    readonly executionId: Schema.String;
+  }>>;
+  readonly key: Schema.String;
+  readonly outbox: Schema.$Array<Schema.Struct<{
+    readonly actor: Schema.String;
+    readonly commandId: Schema.String;
+    readonly key: Schema.String;
+    readonly member: Schema.String;
+    readonly payload: Schema.String;
+    readonly seq: Schema.Int;
+  }>>;
+  readonly state: Schema.NullOr<Schema.String>;
+  readonly tables: Schema.$Array<Schema.Struct<{
+    readonly columns: Schema.$Array<Schema.String>;
+    readonly name: Schema.String;
+    readonly rows: Schema.$Array<Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Null]>>>;
+    readonly total: Schema.Int;
+  }>>;
+  readonly timers: Schema.$Array<Schema.Struct<{
+    readonly command: Schema.String;
+    readonly dueAt: Schema.Int;
+    readonly id: Schema.String;
+    readonly payload: Schema.String;
+    readonly principal: Schema.String;
+  }>>;
+}>;
+type ActorInspection = typeof ActorInspection.Type;
+declare const ActorTypes: Schema.$Array<Schema.Struct<{
+  readonly actor: Schema.String;
+  readonly keys: Schema.$Array<Schema.String>;
+}>>;
+type ActorTypes = typeof ActorTypes.Type;
+type DeveloperTable = typeof DeveloperTable.Type;
+type JournaledCommand = typeof JournaledCommand.Type;
+type PendingTimer = typeof PendingTimer.Type;
+type OutboxEntry = typeof OutboxEntry.Type;
+type FailedDelivery = typeof FailedDelivery.Type;
+type JobRun = typeof JobRun.Type;
+type ActorFile = typeof ActorFile.Type;
+export { type ActorFile, ActorInspection, ActorTypes, type DeveloperTable, type FailedDelivery, type JobRun, type JournaledCommand, type OutboxEntry, type PendingTimer, Rows };

package/dist/serve/inspect/actor-inspection.schema.mjs

@@ -0,0 +1,75 @@
+import { Schema } from "effect";
+// src/serve/inspect/actor-inspection.schema.ts
+const Cell = Schema.Union([
+	Schema.String,
+	Schema.Finite,
+	Schema.Null
+]);
+const Rows = Schema.Array(Schema.Array(Cell));
+const DeveloperTable = Schema.Struct({
+	columns: Schema.Array(Schema.String),
+	name: Schema.String,
+	rows: Rows,
+	total: Schema.Int
+});
+const JournaledCommand = Schema.Struct({
+	at: Schema.Int,
+	command: Schema.String,
+	commandId: Schema.String,
+	exit: Schema.String,
+	payload: Schema.String,
+	principal: Schema.String,
+	seq: Schema.Int
+});
+const PendingTimer = Schema.Struct({
+	command: Schema.String,
+	dueAt: Schema.Int,
+	id: Schema.String,
+	payload: Schema.String,
+	principal: Schema.String
+});
+const OutboxEntry = Schema.Struct({
+	actor: Schema.String,
+	commandId: Schema.String,
+	key: Schema.String,
+	member: Schema.String,
+	payload: Schema.String,
+	seq: Schema.Int
+});
+const FailedDelivery = Schema.Struct({
+	actor: Schema.String,
+	at: Schema.Int,
+	commandId: Schema.String,
+	error: Schema.String,
+	key: Schema.String,
+	member: Schema.String
+});
+const JobRun = Schema.Struct({
+	entries: Schema.Array(Schema.Struct({
+		entry: Schema.String,
+		value: Schema.String
+	})),
+	executionId: Schema.String
+});
+const ActorFile = Schema.Struct({
+	bytes: Schema.Int,
+	name: Schema.String
+});
+const ActorInspection = Schema.Struct({
+	actor: Schema.String,
+	commands: Schema.Array(JournaledCommand),
+	failedDeliveries: Schema.Array(FailedDelivery),
+	files: Schema.Array(ActorFile),
+	jobs: Schema.Array(JobRun),
+	key: Schema.String,
+	outbox: Schema.Array(OutboxEntry),
+	state: Schema.NullOr(Schema.String),
+	tables: Schema.Array(DeveloperTable),
+	timers: Schema.Array(PendingTimer)
+});
+const ActorType = Schema.Struct({
+	actor: Schema.String,
+	keys: Schema.Array(Schema.String)
+});
+const ActorTypes = Schema.Array(ActorType);
+export { ActorInspection, ActorTypes, Rows };

package/dist/serve/inspect/actor-inspection.sql.d.mts

@@ -0,0 +1,12 @@
+import { DeveloperTable, FailedDelivery, JobRun, JournaledCommand, OutboxEntry, PendingTimer } from "./actor-inspection.schema.mjs";
+import { Effect, Option, Schema } from "effect";
+import { SqlClient, SqlError } from "effect/sql";
+type Sql<Value> = Effect.Effect<Value, SqlError.SqlError | Schema.SchemaError>;
+declare const stateOf: (sql: SqlClient.SqlClient) => Sql<Option.Option<string>>;
+declare const developerTables: (sql: SqlClient.SqlClient) => Sql<readonly DeveloperTable[]>;
+declare const commandsOf: (sql: SqlClient.SqlClient) => Sql<readonly JournaledCommand[]>;
+declare const timersOf: (sql: SqlClient.SqlClient) => Sql<readonly PendingTimer[]>;
+declare const outboxOf: (sql: SqlClient.SqlClient) => Sql<readonly OutboxEntry[]>;
+declare const failedDeliveriesOf: (sql: SqlClient.SqlClient) => Sql<readonly FailedDelivery[]>;
+declare const jobsOf: (sql: SqlClient.SqlClient) => Sql<readonly JobRun[]>;
+export { commandsOf, developerTables, failedDeliveriesOf, jobsOf, outboxOf, stateOf, timersOf };

package/dist/serve/inspect/actor-inspection.sql.mjs

@@ -0,0 +1,43 @@
+import { Rows } from "./actor-inspection.schema.mjs";
+import { Array, Effect, Option, Schema, String } from "effect";
+// src/serve/inspect/actor-inspection.sql.ts
+const shownRows = 100;
+const shownCommands = 100;
+const noRows = 0;
+const decodeRows = Schema.decodeUnknownEffect(Rows);
+const identifier = (name) => `"${String.replaceAll("\"", "\"\"")(name)}"`;
+const shownColumn = (column) => `CASE typeof(${identifier(column)}) WHEN 'blob' THEN '<' || length(${identifier(column)}) || ' bytes>' ELSE ${identifier(column)} END`;
+const stateOf = (sql) => Effect.map(sql`SELECT value FROM akter_state WHERE id = 1`, (rows) => Option.map(Array.head(rows), (row) => row.value));
+const rowsOf = (sql, name, columns) => {
+	const selected = Array.join(Array.map(columns, shownColumn), ", ");
+	return Effect.flatMap(sql.unsafe(`SELECT ${selected} FROM ${identifier(name)} LIMIT ${shownRows}`).values, decodeRows);
+};
+const developerTable = (sql, name) => Effect.gen(function* describeTable() {
+	const described = yield* sql.unsafe(`PRAGMA table_info(${identifier(name)})`);
+	const columns = Array.map(described, (column) => column.name);
+	const rows = yield* rowsOf(sql, name, columns);
+	const counted = yield* sql.unsafe(`SELECT count(*) AS total FROM ${identifier(name)}`);
+	return {
+		columns,
+		name,
+		rows,
+		total: Option.getOrElse(Option.map(Array.head(counted), (row) => row.total), () => noRows)
+	};
+});
+const developerTables = (sql) => Effect.flatMap(sql`SELECT name FROM sqlite_schema WHERE type = 'table' AND substr(name, 1, 7) <> 'sqlite_' AND substr(name, 1, 6) <> 'akter_' ORDER BY name`, (tables) => Effect.forEach(tables, (table) => developerTable(sql, table.name)));
+const commandsOf = (sql) => sql`SELECT seq, command_id AS "commandId", command, payload, principal, exit, at FROM akter_commands ORDER BY seq DESC LIMIT ${shownCommands}`;
+const timersOf = (sql) => sql`SELECT id, due_at AS "dueAt", command, payload, principal FROM akter_timers ORDER BY due_at, id`;
+const outboxOf = (sql) => sql`SELECT seq, command_id AS "commandId", actor, key, member, payload FROM akter_outbox ORDER BY seq`;
+const failedDeliveriesOf = (sql) => sql`SELECT command_id AS "commandId", actor, key, member, error, at FROM akter_failed_deliveries ORDER BY at, command_id`;
+const runsOf = (rows) => Array.match(rows, {
+	onEmpty: () => [],
+	onNonEmpty: (some) => Array.map(Array.groupWith(some, (left, right) => left.execution_id === right.execution_id), (group) => ({
+		entries: Array.map(group, ({ entry, value }) => ({
+			entry,
+			value
+		})),
+		executionId: Array.headNonEmpty(group).execution_id
+	}))
+});
+const jobsOf = (sql) => Effect.map(sql`SELECT execution_id, entry, value FROM akter_workflow ORDER BY execution_id, entry`, runsOf);
+export { commandsOf, developerTables, failedDeliveriesOf, jobsOf, outboxOf, stateOf, timersOf };

package/dist/serve/inspect/inspect.service.d.mts

@@ -0,0 +1,24 @@
+import { ActorNotCreatedError } from "../../contract/actor/actor-not-created.errors.mjs";
+import { SqliteDriver } from "../../host/sqlite/sqlite-driver.service.mjs";
+import { ActorAddress } from "../engine/actor-location.service.mjs";
+import { StoreUnreadableError } from "../store/store-unreadable.errors.mjs";
+import { ActorInspection, ActorTypes } from "./actor-inspection.schema.mjs";
+import { Context, Duration, Effect, FileSystem, Layer, Path, Stream } from "effect";
+type InspectFailure = ActorNotCreatedError | StoreUnreadableError;
+interface Inspected extends ActorAddress {
+  readonly directory: string;
+}
+interface Watched extends Inspected {
+  readonly every: Duration.Input;
+}
+interface InspectOperations {
+  readonly actor: (inspected: Inspected) => Effect.Effect<ActorInspection, InspectFailure>;
+  readonly actors: (directory: string) => Effect.Effect<ActorTypes, StoreUnreadableError>;
+  readonly watch: (watched: Watched) => Stream.Stream<ActorInspection, InspectFailure>;
+}
+type Inspecting = FileSystem.FileSystem | Path.Path | SqliteDriver;
+declare const Inspect_base: Context.ServiceClass<Inspect, "@akterjs/effect/serve/inspect/inspect.service/Inspect", InspectOperations>;
+export declare class Inspect extends Inspect_base {
+  static readonly layer: Layer.Layer<Inspect, never, Inspecting>;
+}
+export type { InspectFailure, Inspecting };

package/dist/serve/inspect/inspect.service.mjs

@@ -0,0 +1,92 @@
+import { ActorNotCreatedError } from "../../contract/actor/actor-not-created.errors.mjs";
+import { SqliteDriver } from "../../host/sqlite/sqlite-driver.service.mjs";
+import { ActorLocation } from "../engine/actor-location.service.mjs";
+import { StoreUnreadableError } from "../store/store-unreadable.errors.mjs";
+import { filePage } from "../../host/blob/reference/blob-file-page.sql.mjs";
+import { ActorInspection } from "./actor-inspection.schema.mjs";
+import { prepareInspectionWal } from "./inspector-wal.pure.mjs";
+import { commandsOf, developerTables, failedDeliveriesOf, jobsOf, outboxOf, stateOf, timersOf } from "./actor-inspection.sql.mjs";
+import { Array, Context, Effect, FileSystem, Layer, Option, Schema, Stream } from "effect";
+// src/serve/inspect/inspect.service.ts
+const locationIn = (directory) => Effect.map(Layer.build(ActorLocation.directory(directory)), (services) => Context.get(services, ActorLocation));
+const encodeInspection = Schema.encodeEffect(Schema.fromJsonString(ActorInspection));
+const unreadable = (directory) => (failure) => StoreUnreadableError.make({
+	directory,
+	message: failure.message
+});
+const filesIn = Effect.fn("Inspect.filesIn")(function* filesIn(sql) {
+	const owners = yield* sql`SELECT actor FROM akter_blob_owners WHERE id = 1 AND state = 'active'`;
+	const owner = Array.head(owners);
+	if (Option.isNone(owner)) return [];
+	const page = yield* filePage({
+		actor: owner.value.actor,
+		listing: {},
+		sql
+	});
+	return Array.map(page.entries, ({ bytes, path }) => ({
+		bytes,
+		name: path
+	}));
+});
+const sidecarsUnlinked = Effect.fn("Inspect.sidecarsUnlinked")(function* sidecarsUnlinked(fileSystem, database) {
+	const unlinked = yield* Effect.forEach(["-wal", "-shm"], (suffix) => fileSystem.lstat(`${database}${suffix}`).pipe(Effect.map((stats) => stats.type !== "SymbolicLink"), Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(true))));
+	return Array.every(unlinked, (safe) => safe);
+});
+const inspectionOf = (sql, address, files) => Effect.all({
+	commands: commandsOf(sql),
+	failedDeliveries: failedDeliveriesOf(sql),
+	files,
+	jobs: jobsOf(sql),
+	outbox: outboxOf(sql),
+	state: Effect.map(stateOf(sql), Option.getOrNull),
+	tables: developerTables(sql),
+	timers: timersOf(sql)
+}).pipe(Effect.map((parts) => ({
+	...parts,
+	actor: address.actor,
+	key: address.key
+})));
+const readerOf = Effect.fn("Inspect.readerOf")(function* readerOf({ actor, directory, key }) {
+	const location = yield* locationIn(directory);
+	const { driver, fileSystem } = yield* Effect.all({
+		driver: SqliteDriver,
+		fileSystem: FileSystem.FileSystem
+	});
+	const { database } = location.locate({
+		actor,
+		key
+	});
+	const listed = yield* location.list;
+	if (!Array.some(listed, (stored) => stored.actor === actor && stored.key === key) || !(yield* Effect.mapError(sidecarsUnlinked(fileSystem, database), unreadable(directory)))) return yield* ActorNotCreatedError.make({ actor: `${actor}/${key}` });
+	yield* Effect.mapError(prepareInspectionWal(fileSystem, database), unreadable(directory));
+	const sql = yield* Effect.mapError(driver.openQueryOnly(database, { readOnly: true }), unreadable(directory));
+	const files = filesIn(sql);
+	return { read: Effect.mapError(sql.withTransaction(inspectionOf(sql, {
+		actor,
+		key
+	}, files)), unreadable(directory)) };
+});
+const byType = (listed) => Array.match(listed, {
+	onEmpty: () => [],
+	onNonEmpty: (some) => Array.map(Array.groupWith(some, (left, right) => left.actor === right.actor), (group) => ({
+		actor: Array.headNonEmpty(group).actor,
+		keys: Array.map(group, (address) => address.key)
+	}))
+});
+const actors = (directory) => Effect.scoped(Effect.flatMap(locationIn(directory), (location) => Effect.map(location.list, byType)));
+const actor = (inspected) => Effect.scoped(Effect.flatMap(readerOf(inspected), (reader) => reader.read));
+const watch = ({ every, ...inspected }) => Stream.unwrap(Effect.map(readerOf(inspected), ({ read }) => {
+	const encoded = Effect.flatMap(read, (inspection) => Effect.map(Effect.orDie(encodeInspection(inspection)), (text) => ({
+		inspection,
+		text
+	})));
+	return Stream.tick(every).pipe(Stream.mapEffect(() => encoded), Stream.changesWith((before, after) => before.text === after.text), Stream.map(({ inspection }) => inspection));
+}));
+var Inspect = class extends Context.Service()("@akterjs/effect/serve/inspect/inspect.service/Inspect") {
+	static layer = Layer.effect(this, Effect.map(Effect.context(), (services) => ({
+		actor: (inspected) => Effect.provideContext(actor(inspected), services),
+		actors: (directory) => Effect.provideContext(actors(directory), services),
+		watch: (watched) => Stream.provideContext(watch(watched), services)
+	})));
+};
+export { Inspect };