@akterjs/effect 0.0.0-stage → 0.1.1

package/src/host/job/job-engine.adapter.ts

@@ -0,0 +1,420 @@
+import {
+  Array as Arr,
+  Cause,
+  Clock,
+  Context,
+  Deferred,
+  Effect,
+  Exit,
+  Fiber,
+  FiberMap,
+  Layer,
+  MutableHashMap,
+  Option,
+  Predicate,
+  Ref,
+} from "effect";
+import { Workflow, WorkflowEngine } from "effect/workflow";
+import type { Activity } from "effect/workflow";
+
+import { completedRun, decodePayload, openJobs, storeExit, storeResult, storedExit } from "./job-journal.sql.js";
+import { awaitRun, detachStore, lastExit, nameOf, parkedOn, resume, settled, startExecution } from "./job-runs.pure.js";
+import type { Execute, Execution, JobStore, Parked, Payload, RunResult } from "./job-runs.pure.js";
+import {
+  deferredResult,
+  doneDeferred,
+  executionOf,
+  scheduleClock,
+  storeOf,
+  wakeSignalled,
+} from "./job-durables.sql.js";
+import type { Encoded, Engine, Locate, Waiting } from "./job-durables.sql.js";
+
+type Instance = WorkflowEngine.WorkflowInstance["Service"];
+
+interface EncodedActivity {
+  readonly executeEncoded: Effect.Effect<unknown, unknown, WorkflowEngine.WorkflowInstance>;
+}
+
+interface Polling {
+  readonly executionId: string;
+  readonly store: JobStore;
+  readonly workflow: Workflow.Any;
+}
+
+const completed = (polling: Polling): Effect.Effect<Option.Option<RunResult>> =>
+  polling.store.authority(completedRun(polling));
+
+interface Executing<Discard extends boolean> {
+  readonly discard: Discard;
+  readonly executionId: string;
+  readonly parent?: unknown;
+  readonly payload: object;
+}
+
+interface JobEngineService {
+  readonly bind: (locate: Locate) => Effect.Effect<void>;
+  /**
+   * When the oldest activity executing now in this session's jobs started; none while every job is waiting, suspended
+   * or between steps.
+   */
+  readonly busySince: (store: JobStore) => Effect.Effect<Option.Option<number>>;
+  /** Stops and forgets the jobs running on a closing session; the next session's start replays them from the journal. */
+  readonly detach: (store: JobStore) => Effect.Effect<void>;
+  readonly drain: (store: JobStore) => Effect.Effect<boolean>;
+  readonly engine: WorkflowEngine.WorkflowEngine["Service"];
+  /**
+   * This session's jobs with nothing to run now: those that wait on a signal or a clock, until one is stored, and those
+   * whose activity executes, with no waits, until it ends. The session is busy while an activity executes.
+   */
+  readonly parked: (store: JobStore) => Effect.Effect<readonly Parked[]>;
+  /** Jobs held in memory: those running or suspended on an open session. Finished jobs answer from the journal. */
+  readonly retained: Effect.Effect<number>;
+  readonly start: (store: JobStore) => Effect.Effect<void>;
+}
+
+const startStored = (engine: Engine, { job, store }: Waiting): Effect.Effect<void> =>
+  Effect.suspend(() => {
+    const entry = MutableHashMap.get(engine.registered, job.job);
+
+    if (Option.isNone(entry)) {
+      MutableHashMap.set(engine.waiting, job.id, { job, store });
+
+      return Effect.void;
+    }
+
+    const { workflow } = entry.value;
+
+    MutableHashMap.remove(engine.waiting, job.id);
+
+    return Effect.flatMap(decodePayload({ text: job.payload, workflow }), (payload) =>
+      startExecution({ executionId: job.id, payload, runs: engine, store, workflow }),
+    );
+  });
+
+const startOpen = (engine: Engine, store: JobStore): Effect.Effect<void> =>
+  Effect.suspend(() => {
+    if (engine.detached.has(store)) {
+      return Effect.void;
+    }
+
+    return Clock.currentTimeMillis.pipe(
+      Effect.flatMap((now) => store.withSql((sql) => store.exclusive(openJobs({ now, sql })))),
+      Effect.orDie,
+      Effect.flatMap((jobs) =>
+        Effect.forEach(
+          Arr.filter(jobs, (job) => !MutableHashMap.has(engine.executions, job.id)),
+          (job) => startStored(engine, { job, store }),
+          { discard: true },
+        ),
+      ),
+      Effect.andThen(wakeSignalled({ engine, store })),
+    );
+  });
+
+const register = (engine: Engine): Encoded["register"] =>
+  Effect.fnUntraced(function* registering(workflow: Workflow.Any, execute: Execute) {
+    const name = nameOf(workflow);
+
+    MutableHashMap.set(engine.registered, name, { execute, scope: yield* Effect.scope, workflow });
+
+    const waiting = Arr.filter(Arr.fromIterable(MutableHashMap.values(engine.waiting)), ({ job }) => job.job === name);
+
+    yield* Effect.forEach(waiting, (found) => startStored(engine, found), { discard: true });
+  });
+
+const oneActivity = 1;
+
+const isInterruptOnly = (result: RunResult): boolean =>
+  Predicate.isTagged(result, "Suspended") ||
+  (Exit.isFailure(result.exit) && Cause.hasInterruptsOnly(result.exit.cause));
+
+const runActivity = ({ executeEncoded }: EncodedActivity, instance: Instance): Effect.Effect<RunResult> => {
+  const running = WorkflowEngine.WorkflowInstance.initial(instance.workflow, instance.executionId);
+
+  running.interrupted = instance.interrupted;
+
+  return executeEncoded.pipe(Workflow.intoResult, Effect.provideService(WorkflowEngine.WorkflowInstance, running));
+};
+
+const recordActivity = (activity: Activity.Any, attempt: number, execution: Execution): Effect.Effect<RunResult> =>
+  Effect.gen(function* recording() {
+    const stored = {
+      entry: `activity/${activity.name}/${attempt}`,
+      executionId: execution.executionId,
+      store: execution.store,
+    };
+
+    const result = yield* runActivity(activity, execution.instance);
+
+    if (!isInterruptOnly(result) && Predicate.isTagged(result, "Complete")) {
+      yield* storeExit({ ...stored, exit: result.exit });
+    }
+
+    return result;
+  });
+
+/** Records an activity's start on its run while it executes, so the session's `busySince` reads it. */
+const inFlight =
+  (execution: Execution) =>
+  <Success, Failure, Needs>(effect: Effect.Effect<Success, Failure, Needs>): Effect.Effect<Success, Failure, Needs> =>
+    Effect.acquireUseRelease(
+      Effect.tap(Clock.currentTimeMillis, (started) => Effect.sync(() => execution.activities.push(started))),
+      () => effect,
+      (started) =>
+        Effect.sync(() => {
+          execution.activities.splice(execution.activities.indexOf(started), oneActivity);
+        }),
+    );
+
+/** When the oldest activity executing in the session's jobs started, if any is. */
+const busySince =
+  (engine: Engine) =>
+  (store: JobStore): Effect.Effect<Option.Option<number>> =>
+    Effect.sync(() => {
+      const runs = Arr.fromIterable(engine.owned.get(store) ?? []);
+
+      return Arr.reduce(
+        Arr.flatMap(runs, (run) => run.activities),
+        Option.none<number>(),
+        (oldest, started) =>
+          Option.some(Option.match(oldest, { onNone: () => started, onSome: (at) => Math.min(at, started) })),
+      );
+    });
+
+const noWaits: readonly string[] = [];
+
+/**
+ * A run whose activity executes now has nothing to run until the activity ends, and its end continues the run in
+ * memory. Counting it as due would report it due now on every kick for as long as the activity runs.
+ */
+const activityRunning = (run: Execution): Option.Option<readonly string[]> =>
+  Option.liftPredicate(noWaits, () => Arr.isReadonlyArrayNonEmpty(run.activities));
+
+const parked =
+  (engine: Engine) =>
+  (store: JobStore): Effect.Effect<readonly Parked[]> =>
+    Effect.sync(() => {
+      const runs = Arr.fromIterable(engine.owned.get(store) ?? []);
+
+      return Arr.getSomes(
+        Arr.map(runs, (run) =>
+          Option.map(
+            Option.orElse(parkedOn(run), () => activityRunning(run)),
+            (waits) => ({ id: run.executionId, waits }),
+          ),
+        ),
+      );
+    });
+
+const activityExecute =
+  (engine: Engine): Encoded["activityExecute"] =>
+  (activity, attempt) =>
+    Effect.gen(function* executingActivity() {
+      const instance = yield* WorkflowEngine.WorkflowInstance;
+      const execution = yield* executionOf(engine);
+
+      return yield* execution.store.authority(
+        Effect.gen(function* activityWhileOwned() {
+          const entry = `activity/${activity.name}/${attempt}`;
+          const found = yield* storedExit({ entry, executionId: instance.executionId, store: execution.store });
+
+          if (Option.isSome(found)) {
+            return new Workflow.Complete({ exit: found.value });
+          }
+
+          if (execution.interrupted && !instance.interrupted) {
+            return Workflow.Suspended.make({});
+          }
+
+          return yield* recordActivity(activity, attempt, { ...execution, instance }).pipe(inFlight(execution));
+        }),
+      );
+    });
+
+/** A finished job is no longer in memory, so starting it again answers from its journaled result instead of rerunning it. */
+const startUnfinished = (engine: Engine, starting: Polling & { readonly payload: Payload }): Effect.Effect<void> =>
+  Effect.suspend(() => {
+    if (MutableHashMap.has(engine.executions, starting.executionId)) {
+      return Effect.void;
+    }
+
+    return Effect.flatMap(
+      completed(starting),
+      Option.match({
+        onNone: () => starting.store.authority(startExecution({ ...starting, runs: engine })),
+        onSome: () => Effect.void,
+      }),
+    );
+  });
+
+const poll =
+  (engine: Engine): Encoded["poll"] =>
+  (workflow, executionId) =>
+    Effect.suspend(() =>
+      Option.match(Option.flatMap(MutableHashMap.get(engine.executions, executionId), lastExit), {
+        onNone: () =>
+          Effect.flatMap(storeOf({ engine, executionId }), (store) => completed({ executionId, store, workflow })),
+        onSome: (exit) =>
+          Effect.flatMap(storeOf({ engine, executionId }), (store) => store.authority(Effect.asSome(exit))),
+      }),
+    ).pipe(Effect.scoped);
+
+function executeWith<Discard extends boolean>(
+  engine: Engine,
+  workflow: Workflow.Any,
+  options: Executing<Discard>,
+): Effect.Effect<Discard extends true ? undefined : RunResult>;
+function executeWith(engine: Engine, workflow: Workflow.Any, options: Executing<boolean>): Effect.Effect<unknown> {
+  return Effect.gen(function* executing() {
+    const { discard, executionId, parent, payload } = options;
+
+    if (Predicate.isNotUndefined(parent)) {
+      return yield* Effect.die(
+        `${nameOf(workflow)}: a job can't start another job; start it from a command with Akter.start`,
+      );
+    }
+
+    const store = yield* storeOf({ engine, executionId });
+    const journaled = completed({ executionId, store, workflow });
+
+    yield* startUnfinished(engine, { executionId, payload, store, workflow });
+
+    if (discard) {
+      return yield* Effect.void;
+    }
+
+    return yield* Option.match(MutableHashMap.get(engine.executions, executionId), {
+      onNone: () =>
+        Effect.map(
+          journaled,
+          Option.getOrElse((): RunResult => Workflow.Suspended.make({})),
+        ),
+      onSome: (found) => store.authority(awaitRun(found)),
+    });
+  }).pipe(Effect.scoped);
+}
+
+const interruptRun = (engine: Engine, execution: Execution, unsafe: boolean): Effect.Effect<void> => {
+  execution.interrupted = true;
+  execution.interruptedUnsafe ||= unsafe;
+
+  const wake = resume({ executionId: execution.executionId, mode: "explicit", runs: engine });
+
+  if (unsafe && Option.isSome(execution.fiber)) {
+    return Effect.andThen(Fiber.interrupt(execution.fiber.value), wake);
+  }
+
+  return wake;
+};
+
+const interrupt =
+  (engine: Engine, unsafe: boolean): Encoded["interrupt"] =>
+  (_workflow, executionId) =>
+    Effect.suspend(() =>
+      Option.match(MutableHashMap.get(engine.executions, executionId), {
+        onNone: () => Effect.void,
+        onSome: (execution) => interruptRun(engine, execution, unsafe),
+      }),
+    );
+
+const awaitComplete =
+  (engine: Engine): NonNullable<Encoded["awaitComplete"]> =>
+  (_workflow, executionId) =>
+    Effect.suspend(() =>
+      Option.match(MutableHashMap.get(engine.executions, executionId), {
+        onNone: () => Effect.never,
+        onSome: (found) => found.store.authority(Deferred.await(found.done)),
+      }),
+    );
+
+const drain =
+  (engine: Engine) =>
+  (store: JobStore): Effect.Effect<boolean> =>
+    Effect.gen(function* draining() {
+      yield* startOpen(engine, store);
+
+      const mine = Arr.fromIterable(engine.owned.get(store) ?? []);
+
+      const waited = yield* Effect.forEach(mine, settled);
+
+      return Arr.some(waited, Boolean);
+    });
+
+const encodedOf = (engine: Engine): Encoded => ({
+  activityExecute: activityExecute(engine),
+  awaitComplete: awaitComplete(engine),
+  deferredDone: doneDeferred(engine),
+  deferredResult: deferredResult(engine),
+  execute: (workflow, options) => executeWith(engine, workflow, options),
+  interrupt: interrupt(engine, false),
+  interruptUnsafe: interrupt(engine, true),
+  poll: poll(engine),
+  register: register(engine),
+  resume: (_workflow, executionId) => resume({ executionId, mode: "explicit", runs: engine }),
+  scheduleClock: scheduleClock(engine),
+});
+
+// The latest host's locator resolves every job id: a host that replaces another on this engine, as a promoted local
+// Environment's does, binds its own.
+const rebinding = Effect.fnUntraced(function* rebinding(locator: Deferred.Deferred<Locate>) {
+  const latest = yield* Ref.make<Locate>(() => Effect.die("no host has bound a job locator"));
+  const current: Locate = (address) => Effect.flatMap(Ref.get(latest), (locate) => locate(address));
+
+  return (locate: Locate): Effect.Effect<void> =>
+    Effect.andThen(Ref.set(latest, locate), Effect.asVoid(Deferred.succeed(locator, current)));
+});
+
+const makeEngine = Effect.gen(function* makeEngine() {
+  const engine: Engine = {
+    clocks: yield* FiberMap.make<string>(),
+    deferreds: WorkflowEngine.makeDeferredState(),
+    detached: new WeakSet(),
+    executions: MutableHashMap.empty(),
+    locator: yield* Deferred.make<Locate>(),
+    owned: new Map(),
+    record: ({ executionId, store, workflow }, exit) =>
+      store.authority(storeResult({ executionId, exit, store, workflow })),
+    registered: MutableHashMap.empty(),
+    scope: yield* Effect.scope,
+    waiting: MutableHashMap.empty(),
+    workflowEngine: yield* Deferred.make<WorkflowEngine.WorkflowEngine["Service"]>(),
+  };
+
+  const workflowEngine = WorkflowEngine.makeUnsafe(encodedOf(engine));
+  const bind = yield* rebinding(engine.locator);
+
+  yield* Deferred.succeed(engine.workflowEngine, workflowEngine);
+
+  const service: JobEngineService = {
+    bind,
+    busySince: busySince(engine),
+    detach: (store) => detachStore({ runs: engine, store }),
+    drain: drain(engine),
+    engine: workflowEngine,
+    parked: parked(engine),
+    retained: Effect.sync(() => MutableHashMap.size(engine.executions)),
+    start: (store) => startOpen(engine, store),
+  };
+
+  return service;
+});
+
+export class JobEngine extends Context.Service<JobEngine, JobEngineService>()(
+  "@akterjs/effect/host/job/job-engine.adapter/JobEngine",
+  { make: makeEngine },
+) {
+  public static readonly layer = Layer.effect(this, this.make);
+
+  public static readonly layerShared = Layer.effect(
+    this,
+    Effect.flatMap(Effect.serviceOption(this), Option.match({ onNone: () => this.make, onSome: Effect.succeed })),
+  );
+
+  public static readonly layerWorkflow = Layer.effect(
+    WorkflowEngine.WorkflowEngine,
+    JobEngine.use((jobs) => Effect.succeed(jobs.engine)),
+  ).pipe(Layer.provideMerge(JobEngine.layer));
+}
+
+export type { JobStore, Parked } from "./job-runs.pure.js";

package/src/host/job/job-journal.sql.ts

@@ -0,0 +1,257 @@
+import { Array as Arr, Context, Effect, Exit, Option, Predicate, Schema } from "effect";
+import type { SqlClient, SqlError } from "effect/sql";
+import { Workflow } from "effect/workflow";
+
+import { JobCodecsOf } from "#src/contract/command/command.contract";
+import type { JobCodecs } from "#src/contract/command/command.contract";
+import type { StartedJob } from "#src/contract/job/started-job.schema";
+import { StoredExit } from "#src/contract/job/job-signal.schema";
+import type { JobSignal } from "#src/contract/job/job-signal.schema";
+import { nameOf } from "./job-runs.pure.js";
+import type { JobStore, Payload, RunResult } from "./job-runs.pure.js";
+
+type JournalStore = Pick<JobStore, "exclusive" | "finish" | "withSql">;
+
+interface EntryAddress {
+  readonly entry: string;
+  readonly executionId: string;
+  readonly sql: SqlClient.SqlClient;
+}
+
+interface EntryWrite extends EntryAddress {
+  readonly value: string;
+}
+
+interface JobsWrite {
+  readonly jobs: readonly StartedJob[];
+  readonly sql: SqlClient.SqlClient;
+}
+
+interface SignalsWrite {
+  /** Absent from the outcome of an app built before Akter.signal, which signals nothing. */
+  readonly signals: readonly JobSignal[] | undefined;
+  readonly sql: SqlClient.SqlClient;
+}
+
+interface StoredEntry {
+  readonly entry: string;
+  readonly executionId: string;
+  readonly store: JournalStore;
+}
+
+interface WritingEntry extends StoredEntry {
+  readonly value: string;
+}
+
+interface StoringEntry extends StoredEntry {
+  readonly exit: AnyExit;
+}
+
+interface StoredResult {
+  readonly executionId: string;
+  readonly store: JournalStore;
+  readonly workflow: Workflow.Any;
+}
+
+interface StoringResult extends StoredResult {
+  readonly exit: AnyExit;
+}
+
+interface StoredPayload {
+  readonly text: string;
+  readonly workflow: Workflow.Any;
+}
+
+type Sql<Value> = Effect.Effect<Value, SqlError.SqlError>;
+
+type AnyExit = Exit.Exit<unknown, unknown>;
+
+type ExitCodec = Schema.Codec<AnyExit, string>;
+
+const insertEntry = ({ entry, executionId, sql, value }: EntryWrite): Sql<void> =>
+  Effect.asVoid(
+    sql`INSERT INTO akter_workflow (execution_id, entry, value) VALUES (${executionId}, ${entry}, ${value}) ON CONFLICT (execution_id, entry) DO NOTHING`,
+  );
+
+/**
+ * A job's 'open' entry lives from the command that starts it to the transaction that saves its result. The partial
+ * index holds only those entries, so finding the open jobs costs the jobs still open, not every job the actor ran.
+ */
+const openIndex = "akter_workflow_open";
+
+const saveJobs = ({ jobs, sql }: JobsWrite): Sql<void> =>
+  Effect.forEach(
+    jobs,
+    ({ id, job, payload }) =>
+      Effect.all(
+        [
+          insertEntry({ entry: "job", executionId: id, sql, value: job }),
+          insertEntry({ entry: "payload", executionId: id, sql, value: payload }),
+          insertEntry({ entry: "open", executionId: id, sql, value: "" }),
+        ],
+        { discard: true },
+      ),
+    { discard: true },
+  );
+
+/**
+ * Stores each signal as its job's deferred result, in the command's transaction, only while the job is open and the
+ * deferred has none yet. A signal for a job that finished, never started or already has that result does nothing.
+ */
+const saveSignals = ({ signals, sql }: SignalsWrite): Sql<void> =>
+  Effect.forEach(
+    signals ?? [],
+    ({ deferred, exit, id }) =>
+      sql`INSERT INTO akter_workflow (execution_id, entry, value) SELECT ${id}, ${`deferred/${deferred}`}, ${exit} WHERE EXISTS (SELECT 1 FROM akter_workflow WHERE execution_id = ${id} AND entry = 'open') AND NOT EXISTS (SELECT 1 FROM akter_workflow WHERE execution_id = ${id} AND entry = 'result') ON CONFLICT (execution_id, entry) DO NOTHING`,
+    { discard: true },
+  );
+
+/**
+ * Its result check ignores an 'open' entry an older engine left behind when it saved the result. A job whose result
+ * spent a round of retries waits for its next round (its 'undelivered' entry's `next`), so it isn't run before then.
+ */
+const openJobs = ({
+  now,
+  sql,
+}: {
+  readonly now: number;
+  readonly sql: SqlClient.SqlClient;
+}): Sql<readonly StartedJob[]> =>
+  sql<StartedJob>`SELECT open.execution_id AS id, started.value AS job, payload.value AS payload FROM akter_workflow open INDEXED BY akter_workflow_open JOIN akter_workflow started ON started.execution_id = open.execution_id AND started.entry = 'job' JOIN akter_workflow payload ON payload.execution_id = open.execution_id AND payload.entry = 'payload' WHERE open.entry = 'open' AND NOT EXISTS (SELECT 1 FROM akter_workflow result WHERE result.execution_id = open.execution_id AND result.entry = 'result') AND NOT EXISTS (SELECT 1 FROM akter_workflow stalled WHERE stalled.execution_id = open.execution_id AND stalled.entry = 'undelivered' AND json_extract(stalled.value, '$.next') > ${now}) ORDER BY started.rowid`;
+
+const hasOpenIndex = (sql: SqlClient.SqlClient): Sql<boolean> =>
+  Effect.map(
+    sql`SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ${openIndex}`,
+    Arr.isReadonlyArrayNonEmpty,
+  );
+
+const indexOpenJobs = (sql: SqlClient.SqlClient): Sql<void> =>
+  sql.withTransaction(
+    Effect.andThen(
+      sql`CREATE INDEX akter_workflow_open ON akter_workflow (execution_id) WHERE entry = 'open'`,
+      sql`INSERT OR IGNORE INTO akter_workflow (execution_id, entry, value) SELECT started.execution_id, 'open', '' FROM akter_workflow started WHERE started.entry = 'job' AND NOT EXISTS (SELECT 1 FROM akter_workflow result WHERE result.execution_id = started.execution_id AND result.entry = 'result')`,
+    ),
+  );
+
+/** Creates the open-jobs index once, marking the jobs a journal from before it still has open. */
+const prepareOpenJobs = (sql: SqlClient.SqlClient): Sql<void> =>
+  Effect.flatMap(hasOpenIndex(sql), (indexed) => {
+    if (indexed) {
+      return Effect.void;
+    }
+
+    return indexOpenJobs(sql);
+  });
+
+const readEntry = ({ entry, executionId, sql }: EntryAddress): Sql<Option.Option<string>> =>
+  Effect.map(
+    sql<{
+      readonly value: string;
+    }>`SELECT value FROM akter_workflow WHERE execution_id = ${executionId} AND entry = ${entry}`,
+    (rows) => Option.map(Arr.head(rows), (row) => row.value),
+  );
+
+const encodedExit: ExitCodec = StoredExit;
+
+const codecsOf = (workflow: Workflow.Any): Effect.Effect<JobCodecs> =>
+  Option.match(Context.get(workflow.annotations, JobCodecsOf), {
+    onNone: () => Effect.die(`${nameOf(workflow)} is not an Akter job: declare it in Akter.make's jobs`),
+    onSome: Effect.succeed,
+  });
+
+const decodePayload = ({ text, workflow }: StoredPayload): Effect.Effect<Payload> =>
+  Effect.flatMap(codecsOf(workflow), (codecs) =>
+    codecs.decodePayload(text).pipe(
+      Effect.filterOrFail(Predicate.isObject, () => `${nameOf(workflow)} has a payload that is not a struct`),
+      Effect.orDie,
+    ),
+  );
+
+const readStored = ({ entry, executionId, store }: StoredEntry): Effect.Effect<Option.Option<string>> =>
+  Effect.orDie(store.withSql((sql) => store.exclusive(readEntry({ entry, executionId, sql }))));
+
+const writeStored = ({ store, ...written }: WritingEntry): Effect.Effect<void> =>
+  Effect.orDie(store.withSql((sql) => store.exclusive(insertEntry({ ...written, sql }))));
+
+const decodedWith =
+  (decode: JobCodecs["decodeResult"]) =>
+  (found: Option.Option<string>): Effect.Effect<Option.Option<AnyExit>> =>
+    Option.map(found, decode).pipe(Effect.transposeOption, Effect.orDie);
+
+const storedExit = (stored: StoredEntry): Effect.Effect<Option.Option<AnyExit>> =>
+  Effect.flatMap(readStored(stored), decodedWith(Schema.decodeEffect(encodedExit)));
+
+const storeExit = ({ exit, ...stored }: StoringEntry): Effect.Effect<void> =>
+  Schema.encodeEffect(encodedExit)(exit).pipe(
+    Effect.orDie,
+    Effect.flatMap((value) => writeStored({ ...stored, value })),
+  );
+
+const storeResult = ({ executionId, exit, store, workflow }: StoringResult): Effect.Effect<void> =>
+  Effect.gen(function* storingResult() {
+    const codecs = yield* codecsOf(workflow);
+    const result = yield* Effect.orDie(codecs.encodeResult(exit));
+
+    yield* store.finish({ executionId, job: nameOf(workflow), result });
+  });
+
+const saveResult = ({ executionId, sql, value }: Omit<EntryWrite, "entry">): Sql<void> =>
+  Effect.andThen(
+    insertEntry({ entry: "result", executionId, sql, value }),
+    sql`DELETE FROM akter_workflow WHERE execution_id = ${executionId} AND entry IN ('open', 'undelivered')`,
+  );
+
+/**
+ * While a job's result can't be stored, its journal says so in an 'undelivered' entry (`undelivered-result.pure.ts`).
+ * The inspector shows it with the job's other entries, and saving the result removes it.
+ */
+const markUndelivered = ({ executionId, sql, value }: Omit<EntryWrite, "entry">): Sql<void> =>
+  Effect.asVoid(
+    sql`INSERT INTO akter_workflow (execution_id, entry, value) VALUES (${executionId}, 'undelivered', ${value}) ON CONFLICT (execution_id, entry) DO UPDATE SET value = excluded.value`,
+  );
+
+const storedResult = (stored: StoredResult): Effect.Effect<Option.Option<AnyExit>> =>
+  Effect.gen(function* readingResult() {
+    const codecs = yield* codecsOf(stored.workflow);
+    const found = yield* readStored({ ...stored, entry: "result" });
+
+    return yield* decodedWith(codecs.decodeResult)(found);
+  });
+
+const completedRun = (stored: StoredResult): Effect.Effect<Option.Option<RunResult>> =>
+  Effect.map(
+    storedResult(stored),
+    Option.map((exit) => new Workflow.Complete({ exit })),
+  );
+
+/**
+ * Closes every job still open in a copied database, such as a fork's (ADR 0017): each gets an interrupted result, so
+ * the copy never runs work it inherited. Its parent keeps running its own.
+ */
+const cancelOpenJobs = (sql: SqlClient.SqlClient): Sql<void> =>
+  Effect.gen(function* cancelInheritedJobs() {
+    const interrupted = yield* Effect.orDie(Schema.encodeEffect(encodedExit)(Exit.interrupt()));
+
+    yield* sql`INSERT INTO akter_workflow (execution_id, entry, value) SELECT execution_id, 'result', ${interrupted} FROM akter_workflow WHERE entry = 'open' ON CONFLICT (execution_id, entry) DO NOTHING`;
+    yield* sql`DELETE FROM akter_workflow WHERE entry = 'open'`;
+  });
+
+export {
+  cancelOpenJobs,
+  completedRun,
+  decodePayload,
+  markUndelivered,
+  openJobs,
+  prepareOpenJobs,
+  readEntry,
+  readStored,
+  saveJobs,
+  saveResult,
+  saveSignals,
+  storeExit,
+  storeResult,
+  storedExit,
+  writeStored,
+};
+
+export type { AnyExit, StoredEntry };