@akterjs/conformance 0.0.0-stage → 0.1.1

package/src/guarantee-titles.pure.ts

@@ -0,0 +1,50 @@
+const guaranteeTitles = {
+  callersBeforeHandler: "caller checks run before the handler: a caller the command doesn't allow changes nothing",
+  engineTablesOwned:
+    "a handler may read akter_* tables but never write them: the write fails, names the table and changes nothing",
+  fileRuleDecides:
+    "a file call is decided by the actor's rule from the verified caller and state: a kind it doesn't declare is refused, and a payload naming another caller changes nothing",
+  liveAfterCommit:
+    "live queries update only after a commit: a subscriber sees each committed change and nothing from a rolled-back command",
+  migrationsOnOpen:
+    "migrations run when an actor opens, before its first call, and a migration added later runs on the next open",
+  patchedJobs:
+    "a job keeps the code its start declared: after a deploy adds a patch, a job started before it takes the old path and one started after takes the new",
+  queriesNeverWrite: "queries never write: a write inside a query fails and leaves the actor unchanged",
+  replyMeansCommitted:
+    "a reply means the command committed: an engine reopened on the same storage sees every replied command",
+  retriedCommandId: "a retried command id returns the recorded outcome and runs the handler once",
+  rollsBack: "a handler failure rolls back every write the command made",
+  sentAfterCommit:
+    "a message a command sends is delivered after the command commits, at least once, and a rolled-back command sends none",
+  signalAfterCommit:
+    "a command's signal reaches its own actor's job after the command commits, once: a rolled-back command signals nothing and a finished job ignores it",
+  timerFiresOnce: "a timer fires once at its due time, and not again after the engine restarts",
+} as const;
+
+/** The computer guarantees' titles, which `@akterjs/conformance/computers` registers. */
+const computerGuaranteeTitles = {
+  computerHeldStaysPaused:
+    "a held computer stays paused, or stopped if it was stopped: an ensure, a step, and a resume or pause without its hold are refused until its hold resumes it",
+  computerKeepsFiles: "a computer keeps its files across pause, resume, stop and an engine restart",
+  computerLimitHolds:
+    "a computer past the store's limit is refused with ComputerLimitError and makes nothing, and one fits again once another is removed",
+  computerRemovedIsGone:
+    "a removed computer is gone with its disk: calls to it fail with ComputerNotFoundError, and ensuring it again starts it empty",
+  computerStepJournaled:
+    "a durable computer step journals its start and outcome in the actor, and its steps read back newest first, one with its output",
+  computerStepRunsOnce:
+    "a computer step runs once by its key: sent again, even after the engine restarts, it reads back the outcome it recorded",
+  computerStepSurvivesRestart:
+    "a durable computer step cut off by an engine restart never runs again: its replayed job settles it with its recorded outcome or unknown",
+} as const;
+
+/** The fork guarantees' titles, which `@akterjs/conformance/fork` registers. */
+const forkGuaranteeTitles = {
+  forkCopiesComputers:
+    "a fork copies each of the actor's computers by its disk at the cut, stopped: the copy holds the files written before the cut, the original's computers go back to where they were, and the two change independently",
+  forkStartsQuiet:
+    "a fork copies an actor as committed at its cut and starts quiet: the copy keeps no pending timer, the two change independently, and a retried fork id makes one copy",
+} as const;
+
+export { computerGuaranteeTitles, forkGuaranteeTitles, guaranteeTitles };

package/src/ledger/ledger-calls.pure.ts

@@ -0,0 +1,179 @@
+import type { ActorHost } from "@akterjs/effect";
+import { Array as Arr, Effect, Exit } from "effect";
+import type { Duration, Schema } from "effect";
+
+import { decodeReply } from "./ledger-checks.pure.js";
+import { Cents, Ledger, OverdrawnError } from "./ledger.contract.js";
+import type { Entry } from "./ledger.contract.js";
+
+/** The callers, keys, amounts and payloads the engine conformance suite sends the Ledger, as the JSON the wire carries. */
+interface Sent {
+  readonly account?: string;
+  readonly commandId: string;
+  readonly payload: string;
+  readonly principal?: string;
+}
+
+const ada = '{"kind":"user","principal":{"id":"ada"}}';
+
+const billing = '{"kind":"service","principal":{"id":"billing"}}';
+
+const bob = '{"kind":"user","principal":{"id":"bob"}}';
+
+/** The one user the Ledger's file rule lets write. */
+const fileWriter = "ada";
+
+/** `akter.files` payloads: a read, an upload, and an upload whose payload claims to be ada's. */
+const reading = '{"access":"read","path":"statements/may.pdf"}';
+
+const writing = '{"access":"write","path":""}';
+
+/** What the rule decides for bob's read, write and forged write, ada's write, billing's read, then ada's write once closed. */
+const fileDecisions = ["allowed", "denied", "denied", "allowed", "CallerNotAllowedError", "denied"];
+
+const forgedWriting = '{"access":"write","path":"","principal":{"kind":"user","principal":{"id":"ada"}}}';
+
+const robot = '{"kind":"robot","principal":{"id":"r2"}}';
+
+const key = "acct-1";
+
+const payee = "acct-2";
+
+/**
+ * The key a fork of `acct-1` goes into. Akter Cloud forks only into a key on the parent's own shard, and `acct-5` hashes
+ * to `acct-1`'s shard, so an engine that serves one serves the other.
+ */
+const forked = "acct-5";
+
+const nothing = "null";
+
+const opening = 5;
+
+const topUp = 7;
+
+/** `topUp` as the patched build releases it for a hold it started: twice over. */
+const topUpDoubled = 14;
+
+const overdraft = 9;
+
+const lostInCrash = 3;
+
+const refill = 1;
+
+const transferred = 2;
+
+const dueMinutes = 5;
+
+const beforeDue: Duration.Input = "4 minutes";
+
+const untilDue: Duration.Input = "1 minute";
+
+const longAfterDue: Duration.Input = "10 minutes";
+
+const amountLater = (value: number): string => `{"amount":${value},"minutes":${dueMinutes}}`;
+
+const amountTo = (value: number): string => `{"amount":${value},"to":"${payee}"}`;
+
+const amount = (value: number): string => `{"amount":${value}}`;
+
+const overdrawnBy = OverdrawnError.make({ balance: Cents.make(opening - overdraft) });
+
+const depositOpening: Sent = { commandId: "a", payload: amount(opening) };
+
+const withdrawOverdraft: Sent = { commandId: "w", payload: amount(overdraft) };
+
+const robotDeposit: Sent = { commandId: "d-robot", payload: amount(opening), principal: robot };
+
+interface Approving {
+  readonly amount: number;
+  readonly job: string;
+  readonly refuse: boolean;
+}
+
+const approving = ({ amount: value, job, refuse }: Approving): string =>
+  `{"amount":${value},"job":"${job}","refuse":${refuse}}`;
+
+/** How the engine conformance suite calls the Ledger on an engine: commands and queries as JSON, replies decoded. */
+type Host = ActorHost["Service"];
+
+type Reply = ReturnType<Host["command"]>;
+
+type Unexpected = Effect.Error<Reply> | Effect.Error<ReturnType<Host["fork"]>> | Schema.SchemaError;
+
+const send = (host: Host, member: string, { account = key, commandId, payload, principal = ada }: Sent): Reply =>
+  host.command({ actor: "Ledger", commandId, key: account, member, payload, principal });
+
+const ask = (host: Host, member: string, holder = key): Reply =>
+  host.query({ actor: "Ledger", key: holder, member, payload: nothing, principal: ada });
+
+const account = (
+  host: Host,
+  holder = key,
+): Effect.Effect<Exit.Exit<typeof Ledger.queries.account.success.Type>, Unexpected> =>
+  Effect.flatMap(ask(host, "account", holder), (reply) => decodeReply(Ledger.queries.account, reply));
+
+/** Forks `acct-1` into `into`, which is `forked` by default, and answers the parent's version at the cut. */
+const fork = (host: Host, commandId: string, into = forked): ReturnType<Host["fork"]> =>
+  host.fork({ actor: "Ledger", commandId, into, key });
+
+const amounts = (host: Host, holder = key): Effect.Effect<Exit.Exit<readonly number[]>, Unexpected> =>
+  Effect.map(
+    Effect.flatMap(ask(host, "entries", holder), (reply) => decodeReply(Ledger.queries.entries, reply)),
+    Exit.map(Arr.map((entry: Entry) => entry.amount)),
+  );
+
+const approve = (host: Host, commandId: string, payload: string): Reply =>
+  send(host, "approve", { commandId, payload });
+
+const drained = (host: Host): ReturnType<typeof amounts> =>
+  Effect.gen(function* drainThenRead() {
+    yield* account(host);
+    yield* host.drain;
+
+    return yield* amounts(host);
+  });
+
+/** Holds funds: starts a `release` job and returns its id. */
+const held = (host: Host, commandId: string): Effect.Effect<string, Unexpected> =>
+  Effect.flatMap(send(host, "hold", { commandId, payload: nothing }), (reply) =>
+    Effect.flatten(decodeReply(Ledger.commands.hold, reply)),
+  );
+
+/** The calls, as one namespace: `send`, `ask`, `approve` and `held` take the host first. */
+const ledgerHost = { account, amounts, approve, ask, drained, fork, held, send };
+
+export {
+  ada,
+  amount,
+  amountLater,
+  amountTo,
+  approving,
+  beforeDue,
+  billing,
+  bob,
+  depositOpening,
+  fileDecisions,
+  fileWriter,
+  forgedWriting,
+  forked,
+  key,
+  ledgerHost,
+  lostInCrash,
+  longAfterDue,
+  nothing,
+  opening,
+  overdraft,
+  overdrawnBy,
+  payee,
+  reading,
+  refill,
+  robotDeposit,
+  topUp,
+  topUpDoubled,
+  transferred,
+  untilDue,
+  withdrawOverdraft,
+  writing,
+};
+
+export type { Host, Reply, Sent, Unexpected };

package/src/ledger/ledger-checks.pure.ts

@@ -0,0 +1,84 @@
+import { FileAccessDeniedError } from "@akterjs/effect/contract/errors";
+import { Effect, Exit, Option, Predicate, Schema, String as Str } from "effect";
+import { dual } from "effect/Function";
+
+/** Checks the engine conformance suite applies to replies, table names and an engine's declared host table prefix. */
+const akterTables = "akter_";
+
+const isHostTable =
+  ({ hostTables }: { readonly hostTables: Option.Option<string> }) =>
+  (name: string): boolean => {
+    const lowered = Str.toLowerCase(name);
+    const prefix = Option.map(hostTables, Str.toLowerCase);
+
+    return Option.exists(prefix, (lower) => Str.startsWith(lower)(lowered));
+  };
+
+const isRefused = <Failure>(reply: Effect.Effect<string, Failure>): Effect.Effect<boolean> =>
+  Effect.match(reply, {
+    onFailure: (failure) => Predicate.isTagged(failure, "CallerNotAllowedError"),
+    onSuccess: () => false,
+  });
+
+interface Declaration<Success, SuccessEncoded, Failure, FailureEncoded> {
+  readonly error: Schema.Codec<Failure, FailureEncoded>;
+  readonly success: Schema.Codec<Success, SuccessEncoded>;
+}
+
+type Decoded<Success, Failure> = Effect.Effect<Exit.Exit<Success, Failure>, Schema.SchemaError>;
+
+const replyArity = 2;
+
+/** Decodes a member's reply, as the engine encodes it, to its exit. */
+const decodeReply: {
+  (
+    reply: string,
+  ): <Success, SuccessEncoded, Failure, FailureEncoded>(
+    declaration: Declaration<Success, SuccessEncoded, Failure, FailureEncoded>,
+  ) => Decoded<Success, Failure>;
+  <Success, SuccessEncoded, Failure, FailureEncoded>(
+    declaration: Declaration<Success, SuccessEncoded, Failure, FailureEncoded>,
+    reply: string,
+  ): Decoded<Success, Failure>;
+} = dual(
+  replyArity,
+  <Success, SuccessEncoded, Failure, FailureEncoded>(
+    declaration: Declaration<Success, SuccessEncoded, Failure, FailureEncoded>,
+    reply: string,
+  ): Decoded<Success, Failure> => {
+    const exit = Schema.Exit(declaration.success, declaration.error, Schema.Defect());
+
+    return Schema.decodeEffect(Schema.fromJsonString(Schema.toCodecJson(exit)))(reply);
+  },
+);
+
+/** What an actor's file rule decided for one `akter.files` query: `allowed`, `denied`, or the caller's refusal. */
+const fileDecision = <Failure>(reply: Effect.Effect<string, Failure>): Effect.Effect<string, Schema.SchemaError> =>
+  Effect.matchEffect(reply, {
+    // A refused call reads as the engine's caller refusal by its tag, anything else as `failed`.
+    onFailure: (failure) =>
+      Option.liftPredicate(failure, Predicate.isTagged("CallerNotAllowedError")).pipe(
+        Option.as("CallerNotAllowedError"),
+        Option.getOrElse(() => "failed"),
+        Effect.succeed,
+      ),
+    onSuccess: (text) =>
+      Effect.map(
+        decodeReply({ error: FileAccessDeniedError, success: Schema.Void }, text),
+        Exit.match({ onFailure: () => "denied", onSuccess: () => "allowed" }),
+      ),
+  });
+
+const refusedPrefix = (prefix: string): Option.Option<string> => {
+  if (Str.isEmpty(prefix)) {
+    return Option.some("an empty prefix would match every table");
+  }
+
+  if (Str.toLowerCase(prefix) === akterTables) {
+    return Option.some(`${akterTables} is Akter's own prefix`);
+  }
+
+  return Option.none();
+};
+
+export { akterTables, decodeReply, fileDecision, isHostTable, isRefused, refusedPrefix };

package/src/ledger/ledger.actor.ts

@@ -0,0 +1,196 @@
+import { Akter as Engine } from "@akterjs/effect";
+import { Akter } from "@akterjs/effect/contract";
+import { FileAccessDeniedError } from "@akterjs/effect/contract/errors";
+import type { Migrations } from "@akterjs/effect/contract";
+import { Array as Arr, Duration, Effect, Exit, Layer } from "effect";
+import { DurableDeferred } from "effect/workflow";
+
+import { fileWriter } from "./ledger-calls.pure.js";
+import { Cents, EntryId, Ledger, OverdrawnError, PatchedLedger, doubled } from "./ledger.contract.js";
+import type { Account, Entry } from "./ledger.contract.js";
+
+interface TableName {
+  readonly name: string;
+}
+
+const lowestBalance = 0;
+
+const entriesVersion = 1;
+
+const notesVersion = 2;
+
+const reservedVersion = 3;
+
+const record = Effect.fnUntraced(function* record(balance: Cents, amount: Cents) {
+  const minted = yield* Akter.id;
+  const id = EntryId.make(minted);
+  const sql = yield* Akter.sql;
+
+  yield* sql`INSERT INTO entries ${sql.insert({ amount, id })}`;
+  yield* Ledger.update({ balance });
+
+  return id;
+});
+
+const withdrawal = Effect.fnUntraced(function* withdrawal(ledger: Account, amount: Cents) {
+  const balance = Cents.make(ledger.balance - amount);
+  const id = yield* record(balance, amount);
+
+  if (balance < lowestBalance) {
+    return yield* OverdrawnError.make({ balance });
+  }
+
+  return id;
+});
+
+/** Writes an entry, reads the engine's journal, then writes the engine's state table, which no handler may do. */
+const tamper = Effect.fnUntraced(function* tamper(balance: Cents, amount: Cents) {
+  yield* record(balance, amount);
+  const sql = yield* Akter.sql;
+
+  yield* sql`SELECT count(*) AS commands FROM akter_commands`;
+  yield* sql`UPDATE akter_state SET value = value`;
+});
+
+/** The amount a person approves for release: `hold` starts a job that waits for it, and `approve` signals it. */
+const approval = DurableDeferred.make("approval", { success: Cents });
+
+/** Signals the held job, then fails after the signal when `refuse` is set, so the command rolls back with it. */
+const refusal = Effect.die(new Error("the approval was refused after signalling"));
+
+const approve = (amount: Cents, job: string, refuse: boolean): ReturnType<typeof Akter.signal> => {
+  const signalled = Akter.signal(approval, { job, value: amount });
+
+  if (refuse) {
+    return Effect.andThen(signalled, refusal);
+  }
+
+  return signalled;
+};
+
+/** Any user reads the ledger's files; only ada writes them, and no one once the account is closed. */
+const fileRule = (
+  ledger: { readonly closed: boolean },
+  { access, path }: { readonly access: "read" | "write"; readonly path: string },
+): Effect.Effect<void, FileAccessDeniedError, Akter> =>
+  Ledger.principal.pipe(
+    Effect.filterOrFail(
+      (caller) => access === "read" || (caller.id === fileWriter && !ledger.closed),
+      () => FileAccessDeniedError.make({ access, message: "only ada writes, while the account is open", path }),
+    ),
+    Effect.asVoid,
+  );
+
+/** The `release` job a build's `hold` starts: the Ledger's, or the patched build's. */
+type Release = typeof Ledger.jobs.release | typeof PatchedLedger.jobs.release;
+
+const ledgerLayer = (
+  migrations: Migrations,
+  holding: Release = Ledger.jobs.release,
+): ReturnType<typeof Ledger.toLayer> =>
+  Ledger.toLayer({
+    commands: {
+      approve: (_ledger, { amount, job, refuse }) => approve(amount, job, refuse),
+      close: () => Ledger.update({ closed: true }),
+      crash: (ledger, { amount }) =>
+        Effect.andThen(
+          record(Cents.make(ledger.balance + amount), amount),
+          Effect.die(new Error("the handler crashed after writing")),
+        ),
+      credit: (ledger, { amount }) => record(Cents.make(ledger.balance + amount), amount),
+      deposit: (ledger, { amount }) => record(Cents.make(ledger.balance + amount), amount),
+      depositLater: (_ledger, { amount, minutes }) =>
+        Effect.asVoid(Akter.schedule(Duration.minutes(minutes), Ledger.commands.deposit, { amount })),
+      hold: () => Akter.start(holding, {}),
+      tamper: (ledger, { amount }) => tamper(Cents.make(ledger.balance + amount), amount),
+      transfer: (ledger, { amount, to }) =>
+        Effect.andThen(Akter.send(Ledger.commands.credit, to, { amount }), withdrawal(ledger, amount)),
+      withdraw: (ledger, { amount }) => withdrawal(ledger, amount),
+    },
+    files: { authorize: fileRule },
+    migrations,
+    queries: {
+      account: (ledger) => Effect.succeed({ balance: ledger.balance, closed: ledger.closed }),
+      entries: () => Effect.flatMap(Akter.sql, (sql) => sql<Entry>`SELECT id, amount FROM entries ORDER BY rowid`),
+      scribble: () =>
+        Effect.asVoid(
+          Effect.flatMap(Akter.sql, (sql) => sql`INSERT INTO entries ${sql.insert({ amount: 1, id: "query" })}`),
+        ),
+      tables: () =>
+        Effect.flatMap(Akter.sql, (sql) =>
+          Effect.map(
+            sql<TableName>`SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'akter_%' AND name NOT LIKE 'sqlite_%' ORDER BY name`,
+            Arr.map((row) => row.name),
+          ),
+        ),
+    },
+    results: {
+      release: (ledger, result) =>
+        Exit.match(result, {
+          onFailure: () => Effect.void,
+          onSuccess: (amount) => Effect.asVoid(record(Cents.make(ledger.balance + amount), amount)),
+        }),
+    },
+  });
+
+const releaseLive = Ledger.jobs.release.toLayer(() => DurableDeferred.await(approval));
+
+const twice = 2;
+
+/** The later build's release: twice the approved amount, but only for a hold this build started. */
+const doublingReleaseLive = PatchedLedger.jobs.release.toLayer(() =>
+  Effect.gen(function* doublingRelease() {
+    const amount = yield* DurableDeferred.await(approval);
+
+    if (yield* PatchedLedger.jobs.release.patched(doubled)) {
+      return Cents.make(amount * twice);
+    }
+
+    return amount;
+  }),
+);
+
+/** Serves the Ledger with its job on the engine's job runtime, as an app does. */
+const withJobs = (ledger: ReturnType<typeof Ledger.toLayer>, release = releaseLive): LedgerLayer =>
+  Layer.merge(ledger, release).pipe(Layer.provide(Engine.jobs));
+
+const createEntries: Migrations[number] = (sql) =>
+  sql`CREATE TABLE entries (id TEXT PRIMARY KEY, amount INTEGER NOT NULL)`;
+
+const createNotes: Migrations[number] = (sql) => sql`CREATE TABLE notes (id TEXT PRIMARY KEY, text TEXT NOT NULL)`;
+
+const LedgerLive = withJobs(ledgerLayer({ [entriesVersion]: createEntries }));
+
+const LedgerWithNotesLive = withJobs(ledgerLayer({ [entriesVersion]: createEntries, [notesVersion]: createNotes }));
+
+const ledgerIntruding = (prefix: string): LedgerLayer =>
+  withJobs(
+    ledgerLayer({
+      [entriesVersion]: createEntries,
+      [notesVersion]: createNotes,
+      [reservedVersion]: (sql) => sql`CREATE TABLE ${sql(`${prefix}intruder`)} (id TEXT PRIMARY KEY)`,
+    }),
+  );
+
+/** A Ledger implementation the suite serves on the engine, from either SDK. */
+type LedgerLayer = Layer.Layer<never>;
+
+/** The Ledger at each migration step the suite opens: entries only, entries and notes, and one that creates a table under the engine's prefix. */
+interface Ledgers {
+  readonly intruding: (prefix: string) => LedgerLayer;
+  readonly live: LedgerLayer;
+  /** `live` deployed again with its `release` job patched (`doubled`), over holds the earlier build started. */
+  readonly patched: LedgerLayer;
+  readonly withNotes: LedgerLayer;
+}
+
+const effectLedgers: Ledgers = {
+  intruding: ledgerIntruding,
+  live: LedgerLive,
+  patched: withJobs(ledgerLayer({ [entriesVersion]: createEntries }, PatchedLedger.jobs.release), doublingReleaseLive),
+  withNotes: LedgerWithNotesLive,
+};
+
+export { effectLedgers };
+
+export type { LedgerLayer, Ledgers };

package/src/ledger/ledger.contract.ts

@@ -0,0 +1,76 @@
+import { Akter } from "@akterjs/effect/contract";
+import { Schema } from "effect";
+
+const AccountId = Schema.String.pipe(Schema.brand("AccountId"));
+
+const EntryId = Schema.String.pipe(Schema.brand("EntryId"));
+
+const Cents = Schema.Int.pipe(Schema.brand("Cents"));
+
+type Cents = typeof Cents.Type;
+
+const openingCents = 0;
+
+const Entry = Schema.Struct({ amount: Cents, id: EntryId });
+
+type Entry = typeof Entry.Type;
+
+type Account = typeof Account.Type;
+
+const Account = Schema.Struct({ balance: Cents, closed: Schema.Boolean });
+
+const Service = Schema.Struct({ id: Akter.PrincipalId });
+
+class OverdrawnError extends Schema.TaggedError<OverdrawnError, { readonly brand: unique symbol }>()("OverdrawnError", {
+  balance: Cents,
+}) {}
+
+/** Everything the Ledger declares but its `release` job, which the two builds below declare with different patches. */
+const ledgerOptions = {
+  callers: { actor: Akter.ActorPrincipal, service: Service, user: Akter.Principal },
+  commands: {
+    approve: Akter.command({
+      payload: { amount: Cents, job: Schema.String, refuse: Schema.Boolean },
+      success: Schema.Void,
+    }),
+    close: Akter.command({ callers: ["service"], success: Schema.Void }),
+    crash: Akter.command({ payload: { amount: Cents }, success: Schema.Void }),
+    credit: Akter.command({ callers: ["actor"], payload: { amount: Cents }, success: EntryId }),
+    deposit: Akter.command({ payload: { amount: Cents }, success: EntryId }),
+    depositLater: Akter.command({ payload: { amount: Cents, minutes: Schema.Int }, success: Schema.Void }),
+    hold: Akter.command({ success: Schema.String }),
+    tamper: Akter.command({ payload: { amount: Cents }, success: Schema.Void }),
+    transfer: Akter.command({ error: OverdrawnError, payload: { amount: Cents, to: AccountId }, success: EntryId }),
+    withdraw: Akter.command({ error: OverdrawnError, payload: { amount: Cents }, success: EntryId }),
+  },
+  files: Akter.fileAccess({ callers: ["user"] }),
+  initial: () => ({ balance: Cents.make(openingCents), closed: false }),
+  key: AccountId,
+  queries: {
+    account: Akter.query({ success: Account }),
+    entries: Akter.query({ success: Schema.Array(Entry) }),
+    scribble: Akter.query({ success: Schema.Void }),
+    tables: Akter.query({ success: Schema.Array(Schema.String) }),
+  },
+  state: Account,
+} as const;
+
+/** The patch the later build's `release` declares: it releases twice the approved amount, for holds it started. */
+const doubled = "double";
+
+const noPatches: readonly string[] = [];
+
+const doubling: readonly string[] = [doubled];
+
+const Ledger = Akter.make("Ledger", {
+  ...ledgerOptions,
+  jobs: { release: Akter.job({ patches: noPatches, payload: {}, success: Cents }) },
+});
+
+/** The Ledger deployed again with its `release` job patched, over holds the earlier build started. */
+const PatchedLedger = Akter.make("Ledger", {
+  ...ledgerOptions,
+  jobs: { release: Akter.job({ patches: doubling, payload: {}, success: Cents }) },
+});
+
+export { Account, Cents, Entry, EntryId, Ledger, OverdrawnError, PatchedLedger, doubled };