@akterjs/effect 0.0.0-stage → 0.1.0

package/src/host/sqlite/actor-connections.pure.ts

@@ -0,0 +1,44 @@
+import { Context } from "effect";
+import type { Effect, Option } from "effect";
+import type { SqlError } from "effect/sql";
+
+import type { ActorErasedError } from "#src/contract/actor/actor-erased.errors";
+
+type SqliteValue = null | number | bigint | string | Uint8Array;
+
+type SqliteRow = Readonly<Record<string, SqliteValue>>;
+
+interface SqliteStatement {
+  readonly all: (...params: SqliteValue[]) => readonly SqliteRow[];
+}
+
+interface SqliteHandle {
+  readonly close: () => void;
+  readonly exec: (sql: string) => void;
+  readonly isTransaction: () => boolean;
+  readonly prepare: (sql: string) => SqliteStatement;
+  readonly queryOnly?: (enabled: boolean) => void;
+  /** Refuses writes to the engine-owned `akter_*` tables while handler SQL runs (`HandlerSql`). */
+  readonly handlerWrites?: (refused: boolean) => void;
+  /** The engine-owned table the last refused write named, cleared as it is read. */
+  readonly refusedTable?: () => Option.Option<string>;
+}
+
+interface ActorDatabaseTarget {
+  readonly actor: string;
+  readonly filename: string;
+}
+
+type ActorConnectionOpener = (
+  target: ActorDatabaseTarget,
+  plain: Effect.Effect<SqliteHandle, SqlError.SqlError>,
+) => Effect.Effect<SqliteHandle, ActorErasedError | SqlError.SqlError>;
+
+const ActorConnections = Context.Reference<ActorConnectionOpener>(
+  "@akterjs/effect/host/sqlite/actor-connections.pure/ActorConnections",
+  { defaultValue: (): ActorConnectionOpener => (_target, plain) => plain },
+);
+
+export { ActorConnections };
+
+export type { ActorConnectionOpener, ActorDatabaseTarget, SqliteHandle, SqliteRow, SqliteStatement, SqliteValue };

package/src/host/sqlite/sqlite-connection.adapter.ts

@@ -0,0 +1,260 @@
+import { constants, DatabaseSync } from "node:sqlite";
+
+import { Array as Arr, Context, Effect, Exit, Layer, Option, Predicate, Record as Rec, Stream, identity } from "effect";
+import type { Scope } from "effect";
+import { SqlError } from "effect/sql";
+import type { SqlConnection } from "effect/sql";
+
+import type { ActorErasedError } from "#src/contract/actor/actor-erased.errors";
+
+import { engineOwnedRefusal } from "#src/contract/hosted/handler-failure.pure";
+import { engineOwned, HandlerSql } from "#src/host/query/query-policy.pure";
+import { ActorConnections } from "./actor-connections.pure.js";
+import type { ActorDatabaseTarget, SqliteHandle } from "./actor-connections.pure.js";
+import { bindParameters, sqliteFailure } from "./sqlite-parameters.pure.js";
+
+interface OpenConnection {
+  readonly connection: SqlConnection.Connection;
+  readonly isTransaction: () => boolean;
+}
+
+interface ActorConnection extends OpenConnection {
+  readonly reads: Option.Option<SqlConnection.Connection>;
+}
+
+interface OpenOptions {
+  readonly readOnly: boolean;
+}
+
+const busyTimeoutMillis = 5000;
+
+const writable: OpenOptions = { readOnly: false };
+
+const checkpointSql = "PRAGMA wal_checkpoint(TRUNCATE)";
+
+const busyTimeoutSql = `PRAGMA busy_timeout = ${busyTimeoutMillis}`;
+
+const schemaVersionSql = "PRAGMA schema_version";
+
+const rollbackSql = "ROLLBACK";
+
+const openFailure = sqliteFailure("open database");
+
+const checkpointFailure = sqliteFailure("checkpoint the WAL at close");
+
+const refusedWrite = (database: SqliteHandle, cause: unknown): SqlError.SqlError =>
+  Option.match(
+    Option.flatMap(Option.fromNullishOr(database.refusedTable), (taken) => taken()),
+    {
+      onNone: () => sqliteFailure("execute statement")(cause),
+      onSome: (table) =>
+        SqlError.SqlError.make({
+          reason: SqlError.classifySqliteError(cause, {
+            message: engineOwnedRefusal(table),
+            operation: "execute statement",
+          }),
+        }),
+    },
+  );
+
+const connect = (database: SqliteHandle, queryOnly: boolean): SqlConnection.Connection => {
+  const rows = (
+    ...[sql, params]: Parameters<SqlConnection.Connection["executeRaw"]>
+  ): Effect.Effect<readonly object[], SqlError.SqlError> =>
+    Effect.flatMap(Effect.all([HandlerSql, bindParameters(params)]), ([handler, inputs]) =>
+      Effect.try({
+        catch: (cause) => refusedWrite(database, cause),
+        try: () => {
+          database.queryOnly?.(queryOnly);
+          database.handlerWrites?.(handler && !queryOnly);
+
+          return Arr.map(database.prepare(sql).all(...inputs), Rec.map(identity));
+        },
+      }),
+    );
+
+  const execute: SqlConnection.Connection["execute"] = (sql, params, transformRows) =>
+    Effect.map(rows(sql, params), transformRows ?? identity);
+
+  const executeValues: SqlConnection.Connection["executeValues"] = (sql, params) =>
+    Effect.map(rows(sql, params), Arr.map(Rec.values));
+
+  return {
+    execute,
+    executeRaw: rows,
+    executeStream: () => Stream.die("node:sqlite does not stream"),
+    executeUnprepared: execute,
+    executeValues,
+    executeValuesUnprepared: executeValues,
+  };
+};
+
+const readable = (opened: SqliteHandle): Effect.Effect<SqliteHandle, SqlError.SqlError> =>
+  Effect.as(
+    Effect.tapError(
+      Effect.try({
+        catch: openFailure,
+        try: () => {
+          opened.exec(busyTimeoutSql);
+          opened.exec(schemaVersionSql);
+        },
+      }),
+      () =>
+        Effect.sync(() => {
+          opened.close();
+        }),
+    ),
+    opened,
+  );
+
+const checkpoint = (database: SqliteHandle): Effect.Effect<void, SqlError.SqlError> =>
+  Effect.try({
+    catch: checkpointFailure,
+    try: () => {
+      database.queryOnly?.(false);
+      database.exec(checkpointSql);
+    },
+  });
+
+const releaseDatabase = (database: SqliteHandle): Effect.Effect<void> =>
+  Effect.sync(() => {
+    database.queryOnly?.(false);
+
+    if (database.isTransaction()) {
+      database.exec(rollbackSql);
+    }
+
+    database.close();
+  });
+
+const closeDatabase = (
+  database: SqliteHandle,
+  exit: Exit.Exit<unknown, unknown>,
+  readOnly: boolean,
+): Effect.Effect<void> => {
+  if (readOnly) {
+    return releaseDatabase(database);
+  }
+
+  return Effect.ensuring(
+    checkpoint(database).pipe(
+      Effect.tapError((failure) => Effect.logError(failure.message)),
+      Effect.catchTag("SqlError", (failure) =>
+        Exit.match(exit, { onFailure: () => Effect.void, onSuccess: () => Effect.die(failure) }),
+      ),
+    ),
+    releaseDatabase(database),
+  );
+};
+
+const engineWrites = new Set([constants.SQLITE_INSERT, constants.SQLITE_UPDATE, constants.SQLITE_DELETE]);
+
+/** An authorizer, installed only while handler SQL runs, that refuses writes to the main database's `akter_*` tables. */
+const handlerGuard = (database: DatabaseSync): Pick<SqliteHandle, "handlerWrites" | "refusedTable"> => {
+  const guard = { denied: Option.none<string>(), refusing: false };
+
+  /** SQLite passes the table second and the database fourth for INSERT, UPDATE and DELETE. */
+  const authorize = (action: number, ...names: readonly (string | null)[]): number => {
+    const [table, , schema] = names;
+
+    if (engineWrites.has(action) && schema === "main" && Predicate.isString(table) && engineOwned(table)) {
+      guard.denied = Option.some(table);
+
+      return constants.SQLITE_DENY;
+    }
+
+    return constants.SQLITE_OK;
+  };
+
+  return {
+    handlerWrites: (refused) => {
+      if (refused !== guard.refusing) {
+        guard.refusing = refused;
+        database.setAuthorizer(Option.getOrNull(Option.liftPredicate(authorize, () => refused)));
+      }
+    },
+    refusedTable: () => {
+      const { denied } = guard;
+      guard.denied = Option.none();
+
+      return denied;
+    },
+  };
+};
+
+const openPlain = (
+  filename: string,
+  { readOnly }: OpenOptions = writable,
+): Effect.Effect<SqliteHandle, SqlError.SqlError> =>
+  Effect.try({
+    catch: openFailure,
+    try: (): SqliteHandle => {
+      const database = new DatabaseSync(filename, { readOnly, timeout: busyTimeoutMillis });
+
+      return {
+        close: () => {
+          database.close();
+        },
+        exec: (sql) => {
+          database.exec(sql);
+        },
+        isTransaction: () => database.isTransaction,
+        prepare: (sql) => database.prepare(sql),
+        ...handlerGuard(database),
+      };
+    },
+  });
+
+const held = <Failure>(
+  opening: Effect.Effect<SqliteHandle, Failure>,
+  { readOnly }: OpenOptions = writable,
+): Effect.Effect<SqliteHandle, Failure | SqlError.SqlError, Scope.Scope> =>
+  Effect.acquireRelease(Effect.flatMap(opening, readable), (opened, exit) => closeDatabase(opened, exit, readOnly));
+
+const openNode = Effect.fn("SqliteConnection.openNode")(function* openNode(
+  filename: string,
+  options: OpenOptions = writable,
+) {
+  const database = yield* held(openPlain(filename, options), options);
+
+  return { connection: connect(database, false), isTransaction: database.isTransaction };
+});
+
+const actorConnectionOf = (database: SqliteHandle): ActorConnection => ({
+  connection: connect(database, false),
+  isTransaction: database.isTransaction,
+  reads: Option.map(Option.fromNullishOr(database.queryOnly), () => connect(database, true)),
+});
+
+export class SqliteConnection extends Context.Service<
+  SqliteConnection,
+  {
+    readonly open: (
+      filename: string,
+      options?: OpenOptions,
+    ) => Effect.Effect<OpenConnection, SqlError.SqlError, Scope.Scope>;
+    readonly openActor: (
+      target: ActorDatabaseTarget,
+    ) => Effect.Effect<ActorConnection, ActorErasedError | SqlError.SqlError, Scope.Scope>;
+  }
+>()("@akterjs/effect/host/sqlite/sqlite-connection.adapter/SqliteConnection") {
+  public static readonly layerNode = Layer.effect(
+    this,
+    Effect.gen(function* makeSqliteConnection() {
+      const opener = yield* ActorConnections;
+
+      return {
+        open: openNode,
+        openActor: (
+          target: ActorDatabaseTarget,
+        ): Effect.Effect<ActorConnection, ActorErasedError | SqlError.SqlError, Scope.Scope> => {
+          const opening = opener(target, openPlain(target.filename));
+
+          return Effect.map(held(opening), actorConnectionOf);
+        },
+      };
+    }),
+  );
+}
+
+export type { ActorConnection, OpenConnection, OpenOptions };

package/src/host/sqlite/sqlite-driver.service.ts

@@ -0,0 +1,151 @@
+import { Context, Effect, Layer, Option, Semaphore } from "effect";
+import type { Scope } from "effect";
+import { Reactivity } from "effect/reactivity";
+import { SqlClient, Statement } from "effect/sql";
+import type { SqlError } from "effect/sql";
+
+import type { ActorErasedError } from "#src/contract/actor/actor-erased.errors";
+
+import type { ActorDatabaseTarget } from "./actor-connections.pure.js";
+import { SqliteConnection } from "./sqlite-connection.adapter.js";
+import type { OpenConnection, OpenOptions } from "./sqlite-connection.adapter.js";
+
+interface ClientMode {
+  readonly beginTransaction: string;
+  readonly pragmas: readonly string[];
+}
+
+type Open = (
+  filename: string,
+  options?: OpenOptions,
+) => Effect.Effect<SqlClient.SqlClient, SqlError.SqlError, Scope.Scope>;
+
+type ActorFailure = ActorErasedError | SqlError.SqlError;
+
+interface ActorClients {
+  readonly reader: Effect.Effect<SqlClient.SqlClient, ActorFailure, Scope.Scope>;
+  readonly sql: SqlClient.SqlClient;
+}
+
+interface InMemory {
+  readonly reader: SqlClient.SqlClient;
+  readonly sql: SqlClient.SqlClient;
+}
+
+const holders = 1;
+
+const writerMode: ClientMode = {
+  beginTransaction: "BEGIN IMMEDIATE",
+  pragmas: ["PRAGMA journal_mode = WAL", "PRAGMA synchronous = FULL"],
+};
+
+const queryOnlyMode: ClientMode = { beginTransaction: "BEGIN DEFERRED", pragmas: ["PRAGMA query_only = ON"] };
+
+const inMemory = ":memory:";
+
+const clientOf = Effect.fnUntraced(function* clientOf(
+  { connection, isTransaction }: OpenConnection,
+  beginTransaction: string,
+  semaphore: Semaphore.Semaphore,
+) {
+  const reactivity = yield* Reactivity.make;
+
+  const acquirers = SqlClient.makeSqliteAcquirers({
+    connection: Effect.succeed(connection),
+    isTransaction,
+    semaphore,
+  });
+
+  return yield* Effect.provideService(
+    SqlClient.make({
+      acquirer: acquirers.acquirer,
+      beginTransaction,
+      borrower: acquirers.borrower,
+      compiler: Statement.makeCompilerSqlite(),
+      driver: "sqlite",
+      isTransaction: acquirers.isTransaction,
+      onCommitFailure: acquirers.onCommitFailure,
+      releaseSavepoint: (name) => `RELEASE SAVEPOINT ${name}`,
+      spanAttributes: [["db.system.name", "sqlite"]],
+      transactionAcquirer: acquirers.transactionAcquirer,
+    }),
+    Reactivity.Reactivity,
+    reactivity,
+  );
+});
+
+const prepared = Effect.fnUntraced(function* prepared(
+  { beginTransaction, pragmas }: ClientMode,
+  opened: OpenConnection,
+  semaphore: Semaphore.Semaphore,
+) {
+  const client = yield* clientOf(opened, beginTransaction, semaphore);
+
+  yield* Effect.forEach(pragmas, (pragma) => client.unsafe(pragma), { discard: true });
+
+  return client;
+});
+
+export class SqliteDriver extends Context.Service<
+  SqliteDriver,
+  {
+    readonly open: Open;
+    readonly openActor: (target: ActorDatabaseTarget) => Effect.Effect<ActorClients, ActorFailure, Scope.Scope>;
+    readonly openInMemory: Effect.Effect<InMemory, SqlError.SqlError, Scope.Scope>;
+    readonly openQueryOnly: Open;
+  }
+>()("@akterjs/effect/host/sqlite/sqlite-driver.service/SqliteDriver", {
+  make: Effect.gen(function* makeSqliteDriver() {
+    const connections = yield* SqliteConnection;
+
+    const openIn = (mode: ClientMode): Open =>
+      Effect.fn("SqliteDriver.open")(function* open(filename: string, options?: OpenOptions) {
+        const opened = yield* connections.open(filename, options);
+        const semaphore = yield* Semaphore.make(holders);
+
+        return yield* prepared(mode, opened, semaphore);
+      });
+
+    const ownReader = Effect.fnUntraced(function* ownReader(target: ActorDatabaseTarget) {
+      const opened = yield* connections.openActor(target);
+      const semaphore = yield* Semaphore.make(holders);
+
+      return yield* prepared(queryOnlyMode, opened, semaphore);
+    });
+
+    const openActor = Effect.fn("SqliteDriver.openActor")(function* openActor(target: ActorDatabaseTarget) {
+      const opened = yield* connections.openActor(target);
+      const semaphore = yield* Semaphore.make(holders);
+      const sql = yield* prepared(writerMode, opened, semaphore);
+
+      const reader = Option.match(opened.reads, {
+        onNone: () => ownReader(target),
+        onSome: (connection) =>
+          clientOf({ connection, isTransaction: opened.isTransaction }, queryOnlyMode.beginTransaction, semaphore),
+      });
+
+      return { reader, sql };
+    });
+
+    const openInMemory = Effect.gen(function* openInMemory() {
+      const opened = yield* connections.open(inMemory);
+      const writes = yield* Semaphore.make(holders);
+      const reads = yield* Semaphore.make(holders);
+      const sql = yield* clientOf(opened, writerMode.beginTransaction, writes);
+      const reader = yield* clientOf(opened, queryOnlyMode.beginTransaction, reads);
+
+      return { reader, sql };
+    });
+
+    return {
+      open: openIn(writerMode),
+      openActor,
+      openInMemory,
+      openQueryOnly: openIn(queryOnlyMode),
+    } as const;
+  }),
+}) {
+  public static readonly layer = Layer.effect(this, this.make);
+
+  public static readonly layerNode = this.layer.pipe(Layer.provide(SqliteConnection.layerNode));
+}

package/src/host/sqlite/sqlite-parameters.pure.ts

@@ -0,0 +1,28 @@
+import { Effect, Option, Schema, flow } from "effect";
+import { SqlError } from "effect/sql";
+
+import { reasonText, sqliteReason } from "./sqlite-reason.pure.js";
+
+const SqliteParameters = Schema.Array(
+  Schema.Union([Schema.Null, Schema.Finite, Schema.BigInt, Schema.String, Schema.Uint8Array]),
+);
+
+const failureMessage = (operation: string, cause: unknown): string =>
+  Option.match(sqliteReason(cause), {
+    onNone: () => `Failed to ${operation}`,
+    onSome: (reason) => `Failed to ${operation}: ${reasonText(reason)}`,
+  });
+
+const sqliteFailure =
+  (operation: string): ((cause: unknown) => SqlError.SqlError) =>
+  (cause) =>
+    SqlError.SqlError.make({
+      reason: SqlError.classifySqliteError(cause, { message: failureMessage(operation, cause), operation }),
+    });
+
+const bindParameters = flow(
+  Schema.decodeUnknownEffect(SqliteParameters),
+  Effect.mapError(sqliteFailure("bind parameters")),
+);
+
+export { bindParameters, sqliteFailure };

package/src/host/sqlite/sqlite-reason.pure.ts

@@ -0,0 +1,19 @@
+import { Option, Schema } from "effect";
+
+interface SqliteReason {
+  readonly code: number;
+  readonly message: string;
+}
+
+const NativeSqliteError = Schema.Struct({ errcode: Schema.Int, message: Schema.String });
+
+const decodeNative = Schema.decodeUnknownOption(NativeSqliteError);
+
+const sqliteReason = (cause: unknown): Option.Option<SqliteReason> =>
+  Option.map(decodeNative(cause), ({ errcode, message }) => ({ code: errcode, message }));
+
+const reasonText = ({ code, message }: SqliteReason): string => `${message} (SQLite error ${code})`;
+
+export { reasonText, sqliteReason };
+
+export type { SqliteReason };

package/src/host/timer/actor-timers.sql.ts

@@ -0,0 +1,67 @@
+import { Array as Arr, Duration, Effect, Option } from "effect";
+import type { SqlClient, SqlError } from "effect/sql";
+
+import type { TimerChanges, TimerId } from "#src/contract/command/timer.schema";
+
+interface TimerWrite {
+  readonly at: number;
+  readonly principal: string;
+  readonly sql: SqlClient.SqlClient;
+  readonly timers: TimerChanges;
+}
+
+interface TimerLookup {
+  readonly id: TimerId;
+  readonly sql: SqlClient.SqlClient;
+}
+
+interface DueLookup {
+  readonly now: number;
+  readonly sql: SqlClient.SqlClient;
+}
+
+interface ClaimedTimer {
+  readonly command: string;
+  readonly payload: string;
+  readonly principal: string;
+}
+
+type Sql<Value> = Effect.Effect<Value, SqlError.SqlError>;
+
+const saveTimers = ({ at, principal, sql, timers }: TimerWrite): Sql<void> =>
+  Effect.andThen(
+    Effect.forEach(timers.cancelled, (id) => sql`DELETE FROM akter_timers WHERE id = ${id}`, { discard: true }),
+    Effect.forEach(
+      timers.scheduled,
+      (timer) =>
+        sql`INSERT INTO akter_timers (id, due_at, command, payload, principal) VALUES (${timer.id}, ${at + Duration.toMillis(timer.after)}, ${timer.command}, ${timer.payload}, ${principal})`,
+      { discard: true },
+    ),
+  );
+
+const dueTimers = ({ now, sql }: DueLookup): Sql<readonly TimerId[]> =>
+  Effect.map(
+    sql<{ readonly id: TimerId }>`SELECT id FROM akter_timers WHERE due_at <= ${now} ORDER BY due_at, id`,
+    Arr.map((row) => row.id),
+  );
+
+const claimTimer = ({ id, sql }: TimerLookup): Sql<Option.Option<ClaimedTimer>> =>
+  Effect.map(
+    sql<ClaimedTimer>`DELETE FROM akter_timers WHERE id = ${id} RETURNING command, payload, principal`,
+    Arr.head,
+  );
+
+interface Deferral extends TimerLookup {
+  readonly at: number;
+}
+
+// Moves a timer that is still due to a later time, as when its command was refused, so it fires again then.
+const deferTimer = ({ at, id, sql }: Deferral): Sql<void> =>
+  Effect.asVoid(sql`UPDATE akter_timers SET due_at = ${at} WHERE id = ${id}`);
+
+const earliestDue = (sql: SqlClient.SqlClient): Sql<Option.Option<number>> =>
+  Effect.map(sql<{ readonly due: number }>`SELECT due_at AS due FROM akter_timers ORDER BY due_at LIMIT 1`, (rows) =>
+    Option.map(Arr.head(rows), (row) => row.due),
+  );
+
+export { claimTimer, deferTimer, dueTimers, earliestDue, saveTimers };

package/src/host/timer/timer-runner.service.ts

@@ -0,0 +1,117 @@
+import { Array as Arr, Clock, Context, Duration, Effect, identity, Layer, Option } from "effect";
+import { SqlError } from "effect/sql";
+
+import type { TimerId } from "#src/contract/command/timer.schema";
+import type { StorageLimitError } from "#src/contract/client/storage-limit.errors";
+
+import type { OpenedActor } from "#src/host/actor/actor-database.service";
+import { claimTimer, deferTimer, dueTimers, earliestDue } from "./actor-timers.sql.js";
+import { CommandRunner } from "#src/host/command/command-runner.service";
+import { timerCommandId } from "#src/host/command/command-id-reuse.pure";
+import type { CeilingGuard } from "#src/host/upkeep/execution-authority.pure";
+
+interface Firing {
+  readonly key: string;
+  /** Runs each timer's command against the store's storage ceiling, when it has one. */
+  readonly measured?: CeilingGuard;
+  readonly opened: OpenedActor;
+}
+
+interface FiringOne extends Firing {
+  readonly id: TimerId;
+}
+
+type Fired = Effect.Effect<Option.Option<TimerId>, SqlError.SqlError>;
+
+const refusedRetrySeconds = 30;
+
+/**
+ * How long a timer whose command the storage ceiling refused waits to fire again. A refusal lasts at least until the
+ * store's size is read again, so retrying sooner would mostly be refused again.
+ */
+const RefusedTimerRetry = Context.Reference<Duration.Duration>(
+  "@akterjs/effect/host/timer/timer-runner.service/RefusedTimerRetry",
+  { defaultValue: () => Duration.seconds(refusedRetrySeconds) },
+);
+
+interface Refused {
+  readonly id: TimerId;
+  readonly opened: OpenedActor;
+  readonly retry: Duration.Duration;
+}
+
+// The claim rolled back with the refused command, so the timer is still there: it moves later and fires again then.
+const refusedTimer =
+  ({ id, opened, retry }: Refused) =>
+  (refused: StorageLimitError): Effect.Effect<Option.Option<TimerId>, SqlError.SqlError> =>
+    Effect.gen(function* deferRefused() {
+      const now = yield* Clock.currentTimeMillis;
+
+      yield* deferTimer({ at: now + Duration.toMillis(retry), id, sql: opened.sql });
+      yield* Effect.logWarning(
+        `timer ${id} would grow its store past its storage ceiling and fires again later`,
+        refused,
+      );
+
+      return Option.none<TimerId>();
+    });
+
+export class TimerRunner extends Context.Service<
+  TimerRunner,
+  {
+    readonly fireDue: (firing: Firing) => Effect.Effect<readonly TimerId[], SqlError.SqlError>;
+    readonly nextDue: (opened: OpenedActor) => Effect.Effect<Option.Option<number>, SqlError.SqlError>;
+  }
+>()("@akterjs/effect/host/timer/timer-runner.service/TimerRunner", {
+  make: Effect.gen(function* makeTimerRunner() {
+    const runner = yield* CommandRunner;
+    const retry = yield* RefusedTimerRetry;
+
+    const fireOne = ({ id, key, measured = identity, opened }: FiringOne): Fired =>
+      opened.sql
+        .withTransaction(
+          Effect.gen(function* claimAndRun() {
+            const claimed = yield* claimTimer({ id, sql: opened.sql });
+
+            if (Option.isNone(claimed)) {
+              return Option.none();
+            }
+
+            const ran = runner
+              .runOwn({
+                opened,
+                request: { ...claimed.value, commandId: timerCommandId(id), key, member: claimed.value.command },
+              })
+              .pipe(
+                Effect.catchIf(
+                  (failure) => !SqlError.isSqlError(failure),
+                  (failure) => Effect.logWarning(`timer ${id} ended with a failure the journal does not keep`, failure),
+                ),
+              );
+
+            yield* measured(ran);
+
+            return Option.some(id);
+          }),
+        )
+        .pipe(Effect.catchTag("StorageLimitError", refusedTimer({ id, opened, retry })));
+
+    const fireDue = Effect.fn("TimerRunner.fireDue")(function* fireDue(firing: Firing) {
+      const now = yield* Clock.currentTimeMillis;
+      const due = yield* dueTimers({ now, sql: firing.opened.sql });
+      const fired = yield* Effect.forEach(due, (id) => fireOne({ ...firing, id }));
+
+      return Arr.getSomes(fired);
+    });
+
+    const nextDue = Effect.fn("TimerRunner.nextDue")(function* nextDue(opened: OpenedActor) {
+      return yield* earliestDue(opened.sql);
+    });
+
+    return { fireDue, nextDue } as const;
+  }),
+}) {
+  public static readonly layer = Layer.effect(this, this.make).pipe(Layer.provide(CommandRunner.layer));
+
+  public static readonly refusedRetry = RefusedTimerRetry;
+}