@akterjs/effect 0.0.0-stage → 0.1.1

package/src/serve/hosted/hosted-runtime.service.ts

@@ -0,0 +1,128 @@
+import { Context, Effect, Layer } from "effect";
+import type { Scope } from "effect";
+import type { SqlClient } from "effect/sql";
+
+import { ActorRegistry } from "#src/contract/actor/actor-registry.service";
+import type { OpenedActor } from "#src/host/actor/actor-database.service";
+import { CommandRunner } from "#src/host/command/command-runner.service";
+import { unavailableFileStorage } from "#src/host/file/actor-file-storage.sql";
+import { ActorMigrations } from "#src/host/migration/actor-migrations.service";
+import type { ActorOpenError, PreparingActor } from "#src/host/migration/actor-migrations.service";
+import { QueryRunner } from "#src/host/query/query-runner.service";
+import { ActorUpkeep } from "#src/host/upkeep/actor-upkeep.service";
+import type { Kept, Upkeep } from "#src/host/upkeep/actor-upkeep.service";
+import { LiveReads } from "#src/serve/live/live-reads.service";
+
+type DeclaredActor = Omit<PreparingActor, "sql">;
+
+/** In Akter Cloud a failed statement's message goes to the host's log, not to the caller (`CommandRunner.statementDetail`). */
+const logged = <Value, Failure, Services>(
+  effect: Effect.Effect<Value, Failure, Services>,
+): Effect.Effect<Value, Failure, Services> => Effect.provideService(effect, CommandRunner.statementDetail, "logged");
+
+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>;
+
+const declaring = (registry: ActorRegistry["Service"], migrations: ActorMigrations["Service"]): Declare =>
+  Effect.fn("HostedRuntime.declare")(function* declare(name: string) {
+    const actor = yield* registry.lookup(name);
+    const declared = yield* migrations.declare(actor);
+
+    return { actor, declared };
+  });
+
+const opening = (migrations: ActorMigrations["Service"]): Open =>
+  Effect.fn("HostedRuntime.open")(function* open({ actor, filename, sql }: HostedOpening) {
+    yield* migrations.apply({ ...actor, sql });
+
+    return { actor: actor.actor, filename, files: () => unavailableFileStorage, reader: sql, sql };
+  });
+
+export class HostedRuntime extends Context.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"];
+  }
+>()("@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 = <Failure>(hosted: HostedUpkeep<Failure>): Effect.Effect<HostedKept<Failure>, never, Scope.Scope> =>
+      logged(upkeeps.start({ ...hosted, lock: hosted.exclusive }));
+
+    return {
+      committedAt: reads.committedAt,
+      coveredSince: queries.coveredSince,
+      create: (...creating: Parameters<typeof runner.create>) => 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: Parameters<typeof queries.run>) => logged(queries.run(...querying)),
+      retainedJobs: upkeeps.retainedJobs,
+      run: (...running: Parameters<typeof runner.run>) => logged(runner.run(...running)),
+      step: queries.step,
+      steps: queries.steps,
+      upkeep,
+      version: reads.version,
+    } as const;
+  }),
+}) {
+  public static readonly historyRetention = CommandRunner.historyRetention;
+
+  public static readonly hostTables = ActorMigrations.hostTables;
+
+  /** How long a timer the storage ceiling refused waits to fire again. */
+  public static readonly refusedTimerRetry = ActorUpkeep.refusedTimerRetry;
+
+  public static readonly layer = Layer.effect(this, this.make).pipe(
+    Layer.provide([ActorMigrations.layer, ActorUpkeep.layer, CommandRunner.layer, LiveReads.layer, QueryRunner.layer]),
+  );
+}
+
+export type { DeclaredActor, HostedKept, HostedOpening, HostedUpkeep };

package/src/serve/hosted/hosted-secrets.layer.ts

@@ -0,0 +1,38 @@
+import { Array as Arr, Effect, Layer, Option } from "effect";
+
+import { ActorRegistry } from "#src/contract/actor/actor-registry.service";
+import { ActorSecrets } from "#src/contract/secret/actor-secrets.adapter";
+import type { SecretRequest } from "#src/contract/secret/actor-secrets.adapter";
+import { SecretUnavailableError } from "#src/contract/secret/secret-unavailable.errors";
+
+/**
+ * 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.Layer<ActorSecrets, never, ActorRegistry> = 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: SecretRequest) {
+      const actor = yield* Effect.option(registry.lookup(request.actor));
+      const declared = Option.exists(actor, ({ secrets }) => Arr.contains(secrets ?? [], request.secret));
+
+      if (!declared) {
+        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/src/serve/http/loopback-host.pure.ts

@@ -0,0 +1,67 @@
+import { Array as Arr, Effect, Option, String as Str } from "effect";
+import { Headers, 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>;
+
+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: string): boolean => loopbackHost.test(host);
+
+const isAllowedHost =
+  (allowed: AllowedHosts) =>
+  (host: string): boolean => {
+    if (allowed === true || isLoopbackHost(host)) {
+      return true;
+    }
+
+    const name = Str.toLowerCase(Str.replace(portSuffix, "")(host));
+
+    return Arr.some(allowed, (listed) => Str.toLowerCase(listed) === name);
+  };
+
+const isLoopbackOrigin = (origin: string): boolean =>
+  originScheme.test(origin) && isLoopbackHost(Str.replace(originScheme, "")(origin));
+
+const allowedHostsOnly =
+  (allowed: AllowedHosts): Middleware =>
+  (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: Middleware = (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 };
+
+export type { AllowedHosts };

package/src/serve/inspect/actor-inspection.schema.ts

@@ -0,0 +1,94 @@
+import { Schema } from "effect";
+
+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),
+});
+
+type ActorInspection = typeof ActorInspection.Type;
+
+const ActorType = Schema.Struct({ actor: Schema.String, keys: Schema.Array(Schema.String) });
+
+const ActorTypes = Schema.Array(ActorType);
+
+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 { ActorInspection, ActorTypes, Rows };
+
+export type { ActorFile, DeveloperTable, FailedDelivery, JobRun, JournaledCommand, OutboxEntry, PendingTimer };

package/src/serve/inspect/actor-inspection.sql.ts

@@ -0,0 +1,112 @@
+import { Array as Arr, Effect, Option, Schema, String as Str } from "effect";
+import type { SqlClient, SqlError } from "effect/sql";
+
+import { Rows } from "./actor-inspection.schema.js";
+import type {
+  DeveloperTable,
+  FailedDelivery,
+  JobRun,
+  JournaledCommand,
+  OutboxEntry,
+  PendingTimer,
+} from "./actor-inspection.schema.js";
+
+type Sql<Value> = Effect.Effect<Value, SqlError.SqlError | Schema.SchemaError>;
+
+interface NameRow {
+  readonly name: string;
+}
+
+interface CountRow {
+  readonly total: number;
+}
+
+interface WorkflowRow {
+  readonly entry: string;
+  readonly execution_id: string;
+  readonly value: string;
+}
+
+const shownRows = 100;
+
+const shownCommands = 100;
+
+const noRows = 0;
+
+const decodeRows = Schema.decodeUnknownEffect(Rows);
+
+const identifier = (name: string): string => `"${Str.replaceAll('"', '""')(name)}"`;
+
+const shownColumn = (column: string): string =>
+  `CASE typeof(${identifier(column)}) WHEN 'blob' THEN '<' || length(${identifier(column)}) || ' bytes>' ELSE ${identifier(column)} END`;
+
+const stateOf = (sql: SqlClient.SqlClient): Sql<Option.Option<string>> =>
+  Effect.map(sql<{ readonly value: string }>`SELECT value FROM akter_state WHERE id = 1`, (rows) =>
+    Option.map(Arr.head(rows), (row) => row.value),
+  );
+
+const rowsOf = (sql: SqlClient.SqlClient, name: string, columns: readonly string[]): Sql<typeof Rows.Type> => {
+  const selected = Arr.join(Arr.map(columns, shownColumn), ", ");
+
+  return Effect.flatMap(
+    sql.unsafe(`SELECT ${selected} FROM ${identifier(name)} LIMIT ${shownRows}`).values,
+    decodeRows,
+  );
+};
+
+const developerTable = (sql: SqlClient.SqlClient, name: string): Sql<DeveloperTable> =>
+  Effect.gen(function* describeTable() {
+    const described = yield* sql.unsafe<NameRow>(`PRAGMA table_info(${identifier(name)})`);
+    const columns = Arr.map(described, (column) => column.name);
+    const rows = yield* rowsOf(sql, name, columns);
+    const counted = yield* sql.unsafe<CountRow>(`SELECT count(*) AS total FROM ${identifier(name)}`);
+
+    return {
+      columns,
+      name,
+      rows,
+      total: Option.getOrElse(
+        Option.map(Arr.head(counted), (row) => row.total),
+        () => noRows,
+      ),
+    };
+  });
+
+const developerTables = (sql: SqlClient.SqlClient): Sql<readonly DeveloperTable[]> =>
+  Effect.flatMap(
+    sql<NameRow>`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: SqlClient.SqlClient): Sql<readonly JournaledCommand[]> =>
+  sql<JournaledCommand>`SELECT seq, command_id AS "commandId", command, payload, principal, exit, at FROM akter_commands ORDER BY seq DESC LIMIT ${shownCommands}`;
+
+const timersOf = (sql: SqlClient.SqlClient): Sql<readonly PendingTimer[]> =>
+  sql<PendingTimer>`SELECT id, due_at AS "dueAt", command, payload, principal FROM akter_timers ORDER BY due_at, id`;
+
+const outboxOf = (sql: SqlClient.SqlClient): Sql<readonly OutboxEntry[]> =>
+  sql<OutboxEntry>`SELECT seq, command_id AS "commandId", actor, key, member, payload FROM akter_outbox ORDER BY seq`;
+
+const failedDeliveriesOf = (sql: SqlClient.SqlClient): Sql<readonly FailedDelivery[]> =>
+  sql<FailedDelivery>`SELECT command_id AS "commandId", actor, key, member, error, at FROM akter_failed_deliveries ORDER BY at, command_id`;
+
+const runsOf = (rows: readonly WorkflowRow[]): readonly JobRun[] =>
+  Arr.match(rows, {
+    onEmpty: () => [],
+    onNonEmpty: (some) =>
+      Arr.map(
+        Arr.groupWith(some, (left, right) => left.execution_id === right.execution_id),
+        (group) => ({
+          entries: Arr.map(group, ({ entry, value }) => ({ entry, value })),
+          executionId: Arr.headNonEmpty(group).execution_id,
+        }),
+      ),
+  });
+
+const jobsOf = (sql: SqlClient.SqlClient): Sql<readonly JobRun[]> =>
+  Effect.map(
+    sql<WorkflowRow>`SELECT execution_id, entry, value FROM akter_workflow ORDER BY execution_id, entry`,
+    runsOf,
+  );
+
+export { commandsOf, developerTables, failedDeliveriesOf, jobsOf, outboxOf, stateOf, timersOf };

package/src/serve/inspect/inspect.service.ts

@@ -0,0 +1,173 @@
+import { Array as Arr, Context, Effect, FileSystem, Layer, Option, Schema, Stream } from "effect";
+import type { Duration, Scope, Path } from "effect";
+import type { SqlClient } from "effect/sql";
+
+import { ActorNotCreatedError } from "#src/contract/actor/actor-not-created.errors";
+import { SqliteDriver } from "#src/host/sqlite/sqlite-driver.service";
+import { ActorLocation } from "#src/serve/engine/actor-location.service";
+import type { ActorAddress } from "#src/serve/engine/actor-location.service";
+import { StoreUnreadableError } from "#src/serve/store/store-unreadable.errors";
+import { filePage } from "#src/host/blob/reference/blob-file-page.sql";
+
+import { ActorInspection } from "./actor-inspection.schema.js";
+import type { ActorFile, ActorTypes } from "./actor-inspection.schema.js";
+import { prepareInspectionWal } from "./inspector-wal.pure.js";
+import {
+  commandsOf,
+  developerTables,
+  failedDeliveriesOf,
+  jobsOf,
+  outboxOf,
+  stateOf,
+  timersOf,
+} from "./actor-inspection.sql.js";
+
+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>;
+}
+
+interface Reader {
+  readonly read: Effect.Effect<ActorInspection, StoreUnreadableError>;
+}
+
+type Inspecting = FileSystem.FileSystem | Path.Path | SqliteDriver;
+
+const locationIn = (
+  directory: string,
+): Effect.Effect<ActorLocation["Service"], never, FileSystem.FileSystem | Path.Path | Scope.Scope> =>
+  Effect.map(Layer.build(ActorLocation.directory(directory)), (services) => Context.get(services, ActorLocation));
+
+const encodeInspection = Schema.encodeEffect(Schema.fromJsonString(ActorInspection));
+
+const unreadable =
+  (directory: string) =>
+  (failure: { readonly message: string }): StoreUnreadableError =>
+    StoreUnreadableError.make({ directory, message: failure.message });
+
+const filesIn = Effect.fn("Inspect.filesIn")(function* filesIn(sql: SqlClient.SqlClient) {
+  const owners = yield* sql<{
+    readonly actor: string;
+  }>`SELECT actor FROM akter_blob_owners WHERE id = 1 AND state = 'active'`;
+
+  const owner = Arr.head(owners);
+
+  if (Option.isNone(owner)) {
+    return [];
+  }
+
+  const page = yield* filePage({ actor: owner.value.actor, listing: {}, sql });
+
+  return Arr.map(page.entries, ({ bytes, path }): ActorFile => ({ bytes, name: path }));
+});
+
+type Files = ReturnType<typeof filesIn>;
+
+const sidecarsUnlinked = Effect.fn("Inspect.sidecarsUnlinked")(function* sidecarsUnlinked(
+  fileSystem: FileSystem.FileSystem,
+  database: string,
+) {
+  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 Arr.every(unlinked, (safe) => safe);
+});
+
+const inspectionOf = (
+  sql: SqlClient.SqlClient,
+  address: ActorAddress,
+  files: Files,
+): Effect.Effect<ActorInspection, Effect.Error<ReturnType<typeof commandsOf>> | Effect.Error<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 }: Inspected) {
+  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 (
+    !Arr.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)),
+  } satisfies Reader;
+});
+
+const byType = (listed: readonly ActorAddress[]): ActorTypes =>
+  Arr.match(listed, {
+    onEmpty: () => [],
+    onNonEmpty: (some) =>
+      Arr.map(
+        Arr.groupWith(some, (left, right) => left.actor === right.actor),
+        (group) => ({ actor: Arr.headNonEmpty(group).actor, keys: Arr.map(group, (address) => address.key) }),
+      ),
+  });
+
+const actors = (directory: string): Effect.Effect<ActorTypes, StoreUnreadableError, Inspecting> =>
+  Effect.scoped(Effect.flatMap(locationIn(directory), (location) => Effect.map(location.list, byType)));
+
+const actor = (inspected: Inspected): Effect.Effect<ActorInspection, InspectFailure, Inspecting> =>
+  Effect.scoped(Effect.flatMap(readerOf(inspected), (reader) => reader.read));
+
+const watch = ({ every, ...inspected }: Watched): Stream.Stream<ActorInspection, InspectFailure, Inspecting> =>
+  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),
+      );
+    }),
+  );
+
+export class Inspect extends Context.Service<Inspect, InspectOperations>()(
+  "@akterjs/effect/serve/inspect/inspect.service/Inspect",
+) {
+  public static readonly layer: Layer.Layer<Inspect, never, Inspecting> = Layer.effect(
+    this,
+    Effect.map(Effect.context<Inspecting>(), (services) => ({
+      actor: (inspected: Inspected) => Effect.provideContext(actor(inspected), services),
+      actors: (directory: string) => Effect.provideContext(actors(directory), services),
+      watch: (watched: Watched) => Stream.provideContext(watch(watched), services),
+    })),
+  );
+}
+
+export type { Inspecting, InspectFailure };