@akterjs/conformance 0.0.0-stage → 0.1.0

package/src/engine-conformance.suite.ts

@@ -0,0 +1,484 @@
+import { ActorHost } from "@akterjs/effect";
+import type { ActorRegistry } from "@akterjs/effect/contract/actor-registry";
+import { expect } from "@effect/vitest";
+import type { Vitest } from "@effect/vitest";
+import {
+  Array as Arr,
+  Cause,
+  Context,
+  Effect,
+  Exit,
+  Layer,
+  Option,
+  Predicate,
+  Queue,
+  Record as Rec,
+  Stream,
+  String as Str,
+} from "effect";
+import type { Duration, Schema, Scope } from "effect";
+import { TestClock } from "effect/testing";
+
+import { guaranteeTitles } from "./guarantee-titles.pure.js";
+import { effectLedgers } from "./ledger/ledger.actor.js";
+import type { LedgerLayer, Ledgers } from "./ledger/ledger.actor.js";
+import {
+  ada,
+  amount,
+  amountLater,
+  amountTo,
+  approving,
+  beforeDue,
+  billing,
+  bob,
+  depositOpening,
+  fileDecisions,
+  forgedWriting,
+  key,
+  ledgerHost,
+  lostInCrash,
+  longAfterDue,
+  nothing,
+  opening,
+  overdraft,
+  overdrawnBy,
+  payee,
+  reading,
+  refill,
+  robotDeposit,
+  topUp,
+  topUpDoubled,
+  transferred,
+  untilDue,
+  withdrawOverdraft,
+  writing,
+} from "./ledger/ledger-calls.pure.js";
+import type { Host, Unexpected } from "./ledger/ledger-calls.pure.js";
+import {
+  akterTables,
+  decodeReply,
+  fileDecision,
+  isHostTable,
+  isRefused,
+  refusedPrefix,
+} from "./ledger/ledger-checks.pure.js";
+import { Ledger } from "./ledger/ledger.contract.js";
+
+const { account, amounts, approve, ask, drained, held, send } = ledgerHost;
+
+type Storage<Failure> = Layer.Layer<ActorHost | ActorRegistry, Failure>;
+
+type Engine<Failure, Services> = Effect.Effect<Storage<Failure>, Failure, Scope.Scope | Services>;
+
+interface Declared {
+  readonly hostTables: Option.Option<string>;
+  readonly ledgers: Ledgers;
+}
+
+type Checked<Failure> = Effect.Effect<void, Failure | Unexpected>;
+
+type Guarantee<Failure> = (storage: Storage<Failure>, declared: Declared) => Checked<Failure>;
+
+type GuaranteeName = keyof typeof guaranteeTitles;
+
+const tables = (host: Host, declared: Declared): Effect.Effect<Exit.Exit<readonly string[]>, Unexpected> => {
+  const appTable = Predicate.not(isHostTable(declared));
+
+  return Effect.map(
+    Effect.flatMap(ask(host, "tables"), (reply) => decodeReply(Ledger.queries.tables, reply)),
+    Exit.map(Arr.filter(appTable)),
+  );
+};
+
+const onEngine = <Failure, Success, UseFailure>(
+  storage: Storage<Failure>,
+  handlers: LedgerLayer,
+  use: (host: Host) => Effect.Effect<Success, UseFailure>,
+): Effect.Effect<Success, Failure | UseFailure> => {
+  const engine = storage.pipe(Layer.provide(handlers));
+  const run = Effect.flatMap(Layer.build(engine), (services) => use(Context.get(services, ActorHost)));
+
+  return Effect.scoped(run);
+};
+
+const depositThenOverdraw = (host: Host): Effect.Effect<readonly [string, string], Unexpected> =>
+  Effect.all([send(host, "deposit", depositOpening), send(host, "withdraw", withdrawOverdraft)]);
+
+const replyMeansCommitted = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  Effect.gen(function* reopenAfterReplies() {
+    yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.all([
+        send(host, "deposit", depositOpening),
+        send(host, "deposit", { commandId: "b", payload: amount(topUp) }),
+      ]),
+    );
+
+    const seen = yield* onEngine(storage, declared.ledgers.live, (host) => Effect.all([account(host), amounts(host)]));
+
+    expect(seen).toStrictEqual([
+      Exit.succeed({ balance: opening + topUp, closed: false }),
+      Exit.succeed([opening, topUp]),
+    ]);
+  });
+
+const retriedCommandId = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  Effect.gen(function* retryAcrossReopens() {
+    const [first, retriedLive] = yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.all([depositThenOverdraw(host), depositThenOverdraw(host)]),
+    );
+
+    const retriedReopened = yield* onEngine(storage, declared.ledgers.live, depositThenOverdraw);
+    const after = yield* onEngine(storage, declared.ledgers.live, (host) => Effect.all([account(host), amounts(host)]));
+    const [, retriedWithdraw] = retriedReopened;
+    const overdrawn = yield* decodeReply(Ledger.commands.withdraw, retriedWithdraw);
+
+    expect([retriedLive, retriedReopened]).toStrictEqual([first, first]);
+    expect(overdrawn).toStrictEqual(Exit.fail(overdrawnBy));
+    expect(after).toStrictEqual([Exit.succeed({ balance: opening, closed: false }), Exit.succeed([opening])]);
+  });
+
+const rollsBack = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  onEngine(storage, declared.ledgers.live, (host) =>
+    Effect.gen(function* failThenDeposit() {
+      yield* send(host, "deposit", depositOpening);
+
+      const withdrawn = yield* send(host, "withdraw", withdrawOverdraft);
+      const crashed = yield* send(host, "crash", { commandId: "c", payload: amount(lostInCrash) });
+
+      const failures = yield* Effect.all([
+        decodeReply(Ledger.commands.withdraw, withdrawn),
+        decodeReply(Ledger.commands.crash, crashed),
+      ]);
+
+      const afterFailures = yield* Effect.all([account(host), amounts(host)]);
+
+      yield* send(host, "deposit", { commandId: "b", payload: amount(refill) });
+
+      const afterDeposit = yield* account(host);
+
+      expect(failures).toStrictEqual([
+        Exit.fail(overdrawnBy),
+        Exit.die(new Error("the handler crashed after writing")),
+      ]);
+      expect(afterFailures).toStrictEqual([Exit.succeed({ balance: opening, closed: false }), Exit.succeed([opening])]);
+      expect(afterDeposit).toStrictEqual(Exit.succeed({ balance: opening + refill, closed: false }));
+    }),
+  );
+
+const callersBeforeHandler = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  onEngine(storage, declared.ledgers.live, (host) =>
+    Effect.gen(function* refuseThenAllow() {
+      const refused = yield* Effect.all([
+        isRefused(send(host, "close", { commandId: "c-user", payload: nothing })),
+        isRefused(send(host, "deposit", robotDeposit)),
+      ]);
+
+      const untouched = yield* Effect.all([account(host), amounts(host)]);
+
+      yield* send(host, "close", { commandId: "c-service", payload: nothing, principal: billing });
+
+      const closed = yield* account(host);
+
+      expect(refused).toStrictEqual([true, true]);
+      expect(untouched).toStrictEqual([Exit.succeed({ balance: 0, closed: false }), Exit.succeed([])]);
+      expect(closed).toStrictEqual(Exit.succeed({ balance: 0, closed: true }));
+    }),
+  );
+
+const fileRuleDecides = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  onEngine(storage, declared.ledgers.live, (host) =>
+    Effect.gen(function* decideFiles() {
+      const asked = (payload: string, principal: string): Effect.Effect<string, Schema.SchemaError> =>
+        fileDecision(host.query({ actor: "Ledger", key, member: "akter.files", payload, principal }));
+
+      const bobs = [yield* asked(reading, bob), yield* asked(writing, bob), yield* asked(forgedWriting, bob)];
+      const others = [yield* asked(writing, ada), yield* asked(reading, billing)];
+
+      yield* send(host, "close", { commandId: "c-files", payload: nothing, principal: billing });
+
+      expect([...bobs, ...others, yield* asked(writing, ada)]).toStrictEqual(fileDecisions);
+    }),
+  );
+
+const migrationsOnOpen = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  Effect.gen(function* reopenWithNewMigration() {
+    const reserved = Option.getOrElse(declared.hostTables, () => akterTables);
+
+    const opened = yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.tap(tables(host, declared), () => send(host, "deposit", depositOpening)),
+    );
+
+    const reopened = yield* onEngine(storage, declared.ledgers.withNotes, (host) =>
+      Effect.all([tables(host, declared), amounts(host)]),
+    );
+
+    const intruded = yield* onEngine(storage, declared.ledgers.intruding(reserved), (host) =>
+      Effect.exit(ask(host, "account")),
+    );
+
+    const after = yield* onEngine(storage, declared.ledgers.withNotes, (host) => tables(host, declared));
+
+    expect(opened).toStrictEqual(Exit.succeed(["entries"]));
+    expect(reopened).toStrictEqual([Exit.succeed(["entries", "notes"]), Exit.succeed([opening])]);
+    expect(Exit.match(intruded, { onFailure: () => "refused", onSuccess: () => "opened" })).toBe("refused");
+    expect(after).toStrictEqual(Exit.succeed(["entries", "notes"]));
+  });
+
+const queriesNeverWrite = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  onEngine(storage, declared.ledgers.live, (host) =>
+    Effect.gen(function* writeInsideQuery() {
+      yield* send(host, "deposit", depositOpening);
+
+      const scribbled = yield* Effect.exit(
+        Effect.flatMap(ask(host, "scribble"), (reply) => decodeReply(Ledger.queries.scribble, reply)),
+      );
+
+      const after = yield* amounts(host);
+
+      expect([Exit.isSuccess(scribbled) && Exit.isSuccess(scribbled.value), after]).toStrictEqual([
+        false,
+        Exit.succeed([opening]),
+      ]);
+    }),
+  );
+
+const engineTablesOwned = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  onEngine(storage, declared.ledgers.live, (host) =>
+    Effect.gen(function* writeEngineTable() {
+      yield* send(host, "deposit", depositOpening);
+      const tampered = yield* Effect.exit(send(host, "tamper", { commandId: "t", payload: amount(topUp) }));
+      const refusal = Exit.match(tampered, { onFailure: Cause.pretty, onSuccess: Str.trim });
+      const after = yield* Effect.all([account(host), amounts(host)]);
+
+      expect([Str.includes("akter_state is engine-owned")(refusal), after]).toStrictEqual([
+        true,
+        [Exit.succeed({ balance: opening, closed: false }), Exit.succeed([opening])],
+      ]);
+    }),
+  );
+
+const liveAfterCommit = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  onEngine(storage, declared.ledgers.live, (host) =>
+    Effect.gen(function* watchCommits() {
+      const updates = yield* Queue.unbounded<string>();
+      const watched = host.subscribe({ actor: "Ledger", key, member: "account", payload: nothing, principal: ada });
+
+      yield* Effect.forkChild(Stream.runForEach(watched, (update) => Queue.offer(updates, update.value)));
+
+      const next = Effect.flatMap(Queue.take(updates), (value) => decodeReply(Ledger.queries.account, value));
+      const before = yield* next;
+
+      yield* Effect.all([
+        send(host, "deposit", depositOpening),
+        send(host, "withdraw", withdrawOverdraft),
+        send(host, "crash", { commandId: "c", payload: amount(lostInCrash) }),
+        send(host, "deposit", { commandId: "b", payload: amount(refill) }),
+      ]);
+
+      const seen = yield* Effect.all([next, next]);
+
+      expect([before, ...seen]).toStrictEqual([
+        Exit.succeed({ balance: 0, closed: false }),
+        Exit.succeed({ balance: opening, closed: false }),
+        Exit.succeed({ balance: opening + refill, closed: false }),
+      ]);
+    }),
+  );
+
+const sentAfterCommit = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  Effect.gen(function* deliverAcrossReopen() {
+    const overdrawn = yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.gen(function* transferTwice() {
+        yield* send(host, "deposit", depositOpening);
+
+        const refused = yield* send(host, "transfer", { commandId: "t-over", payload: amountTo(overdraft) });
+
+        yield* send(host, "transfer", { commandId: "t", payload: amountTo(transferred) });
+
+        return yield* decodeReply(Ledger.commands.transfer, refused);
+      }),
+    );
+
+    const delivered = yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.gen(function* drainTwice() {
+        yield* account(host);
+        yield* host.drain;
+
+        const firstDrain = yield* Effect.all([account(host), amounts(host, payee)]);
+
+        yield* host.drain;
+
+        const drainedAgain = yield* amounts(host, payee);
+
+        return [...firstDrain, drainedAgain];
+      }),
+    );
+
+    expect(overdrawn).toStrictEqual(Exit.fail(overdrawnBy));
+    expect(delivered).toStrictEqual([
+      Exit.succeed({ balance: opening - transferred, closed: false }),
+      Exit.succeed([transferred]),
+      Exit.succeed([transferred]),
+    ]);
+  });
+
+const signalAfterCommit = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  Effect.gen(function* approveAcrossReopen() {
+    const [job, live] = yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.gen(function* holdThenApprove() {
+        const id = yield* held(host, "h");
+
+        yield* approve(host, "refused", approving({ amount: lostInCrash, job: id, refuse: true }));
+        const afterRefusal = yield* drained(host);
+
+        yield* approve(host, "approved", approving({ amount: opening, job: id, refuse: false }));
+
+        return [id, [afterRefusal, yield* drained(host)]] as const;
+      }),
+    );
+
+    const reopened = yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.gen(function* retryThenApproveLate() {
+        yield* approve(host, "approved", approving({ amount: opening, job, refuse: false }));
+        const afterRetry = yield* drained(host);
+
+        yield* approve(host, "late", approving({ amount: topUp, job, refuse: false }));
+
+        return [afterRetry, yield* drained(host)];
+      }),
+    );
+
+    expect([...live, ...reopened]).toStrictEqual([
+      Exit.succeed([]),
+      Exit.succeed([opening]),
+      Exit.succeed([opening]),
+      Exit.succeed([opening]),
+    ]);
+  });
+
+const patchedJobs = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  Effect.gen(function* deployOverHeldJob() {
+    const before = yield* onEngine(storage, declared.ledgers.live, (host) => held(host, "h-before"));
+
+    const released = yield* onEngine(storage, declared.ledgers.patched, (host) =>
+      Effect.gen(function* approveBothHolds() {
+        yield* approve(host, "a-before", approving({ amount: opening, job: before, refuse: false }));
+        const afterOld = yield* drained(host);
+
+        const after = yield* held(host, "h-after");
+        yield* approve(host, "a-after", approving({ amount: topUp, job: after, refuse: false }));
+
+        return [afterOld, yield* drained(host)];
+      }),
+    );
+
+    expect(released).toStrictEqual([Exit.succeed([opening]), Exit.succeed([opening, topUpDoubled])]);
+  });
+
+const advance = (host: Host, elapsed: Duration.Input): ReturnType<typeof account> =>
+  Effect.gen(function* advanceAndDrain() {
+    yield* TestClock.adjust(elapsed);
+    yield* account(host);
+    yield* host.drain;
+
+    return yield* account(host);
+  });
+
+const timerFiresOnce = <Failure>(storage: Storage<Failure>, declared: Declared): Checked<Failure> =>
+  Effect.gen(function* fireAcrossReopen() {
+    const early = yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.andThen(
+        send(host, "depositLater", { commandId: "l", payload: amountLater(opening) }),
+        advance(host, beforeDue),
+      ),
+    );
+
+    const later = yield* onEngine(storage, declared.ledgers.live, (host) =>
+      Effect.all([advance(host, untilDue), advance(host, longAfterDue), amounts(host)]),
+    );
+
+    expect([early, ...later]).toStrictEqual([
+      Exit.succeed({ balance: 0, closed: false }),
+      Exit.succeed({ balance: opening, closed: false }),
+      Exit.succeed({ balance: opening, closed: false }),
+      Exit.succeed([opening]),
+    ]);
+  });
+
+const onFresh = <Failure, Services>(
+  engine: Engine<Failure, Services>,
+  guarantee: (storage: Storage<Failure>) => Effect.Effect<void, Failure | Unexpected>,
+): Effect.Effect<void, Failure | Unexpected, Services> => Effect.scoped(Effect.flatMap(engine, guarantee));
+
+const guarantees = {
+  callersBeforeHandler,
+  engineTablesOwned,
+  fileRuleDecides,
+  liveAfterCommit,
+  migrationsOnOpen,
+  patchedJobs,
+  queriesNeverWrite,
+  replyMeansCommitted,
+  retriedCommandId,
+  rollsBack,
+  sentAfterCommit,
+  signalAfterCommit,
+  timerFiresOnce,
+} as const satisfies Record<GuaranteeName, Guarantee<never>>;
+
+/** Every guarantee, by name. */
+const everyGuarantee: readonly GuaranteeName[] = Rec.keys(guarantees);
+
+interface Skipping<Failure, Services> {
+  readonly engine: Engine<Failure, Services>;
+  readonly hostTables?: string;
+  /** The Ledger implementation to run: the Effect SDK's by default, or the plain SDK's from `@akterjs/conformance/plain`. */
+  readonly ledgers?: Ledgers;
+  readonly skip: Readonly<Partial<Record<GuaranteeName, string>>>;
+}
+
+const conformanceOf =
+  <Failure, Services>({
+    engine,
+    hostTables,
+    ledgers = effectLedgers,
+    skip,
+  }: Skipping<Failure, Services>): ((test: Vitest.MethodsNonLive<Services>) => void) =>
+  (test) => {
+    const declared: Declared = { hostTables: Option.fromNullishOr(hostTables), ledgers };
+    const refused = Option.flatMap(declared.hostTables, refusedPrefix);
+
+    if (Option.isSome(refused)) {
+      test.effect(`the engine's host table prefix "${String(hostTables)}" is refused: ${refused.value}`, () =>
+        Effect.die(refused.value),
+      );
+
+      return;
+    }
+
+    for (const name of everyGuarantee) {
+      const title = guaranteeTitles[name];
+
+      const run = (): Effect.Effect<void, Failure | Unexpected, Services> =>
+        onFresh<Failure, Services>(engine, (storage) => guarantees[name](storage, declared));
+
+      Option.match(Option.fromNullishOr(skip[name]), {
+        onNone: () => {
+          test.effect(title, run);
+        },
+        onSome: (reason) => {
+          test.effect.skip(`${title} (skipped: ${reason})`, run);
+        },
+      });
+    }
+  };
+
+const conformance = <Failure, Services>(
+  engine: Engine<Failure, Services>,
+): ((test: Vitest.MethodsNonLive<Services>) => void) => conformanceOf({ engine, skip: {} });
+
+export { conformance, conformanceOf };
+
+export type { Engine, GuaranteeName, Storage };
+
+export type { Ledgers } from "./ledger/ledger.actor.js";

package/src/fork/fork-conformance.suite.ts

@@ -0,0 +1,204 @@
+import { ActorHost } from "@akterjs/effect";
+import { expect } from "@effect/vitest";
+import type { Vitest } from "@effect/vitest";
+import { Clock, Context, Effect, Exit, Layer, Option, Record as Rec } from "effect";
+import { TestClock } from "effect/testing";
+
+import type { Engine, Storage } from "#src/engine-conformance.suite.js";
+import { forkGuaranteeTitles } from "#src/guarantee-titles.pure.js";
+import { effectLedgers } from "#src/ledger/ledger.actor.js";
+import {
+  amount,
+  amountLater,
+  depositOpening,
+  forked,
+  ledgerHost,
+  longAfterDue,
+  opening,
+  refill,
+  topUp,
+} from "#src/ledger/ledger-calls.pure.js";
+import type { Host, Unexpected } from "#src/ledger/ledger-calls.pure.js";
+import { WorkbenchLive } from "#src/workbench/workbench.actor.js";
+import { bench, ensure, forkedBench, get, list, stop, workbenchHost } from "#src/workbench/workbench-calls.pure.js";
+
+const { account, amounts, fork, send } = ledgerHost;
+
+type Checked<Failure> = Effect.Effect<void, Failure | Unexpected>;
+
+const onEngine = <Failure, Success>(
+  storage: Storage<Failure>,
+  use: (host: Host) => Effect.Effect<Success, Unexpected>,
+): Effect.Effect<Success, Failure | Unexpected> => {
+  const engine = storage.pipe(Layer.provide(effectLedgers.live));
+  const run = Effect.flatMap(Layer.build(engine), (services) => use(Context.get(services, ActorHost)));
+
+  return Effect.scoped(run);
+};
+
+/** Both accounts: the parent `acct-1`, then the fork `acct-5`, each with its balance and its entries. */
+const both = (host: Host): Effect.Effect<readonly unknown[], Unexpected> =>
+  Effect.all([account(host), amounts(host), account(host, forked), amounts(host, forked)]);
+
+const startsQuiet = <Failure>(storage: Storage<Failure>): Checked<Failure> =>
+  Effect.gen(function* forkThenDiverge() {
+    const [cut, retried, apart] = yield* onEngine(storage, (host) =>
+      Effect.gen(function* forkWithATimerPending() {
+        yield* send(host, "deposit", depositOpening);
+        yield* send(host, "depositLater", { commandId: "l", payload: amountLater(opening) });
+
+        const version = yield* fork(host, "f");
+
+        yield* send(host, "deposit", { commandId: "b", payload: amount(topUp) });
+        yield* send(host, "deposit", { account: forked, commandId: "c", payload: amount(refill) });
+
+        const again = yield* fork(host, "f");
+
+        yield* TestClock.adjust(longAfterDue);
+        yield* account(host);
+        yield* host.drain;
+
+        return [version, again, yield* both(host)] as const;
+      }),
+    );
+
+    const reopened = yield* onEngine(storage, both);
+
+    const settled = [
+      Exit.succeed({ balance: opening + topUp + opening, closed: false }),
+      Exit.succeed([opening, topUp, opening]),
+      Exit.succeed({ balance: opening + refill, closed: false }),
+      Exit.succeed([opening, refill]),
+    ];
+
+    expect(retried).toBe(cut);
+    expect([apart, reopened]).toStrictEqual([settled, settled]);
+  });
+
+const { exec, ran, ranAt } = workbenchHost;
+
+/** Runs `use` on the Workbench on the real clock: a computer's calls wait on real processes and machines. */
+const onBench = <Failure, Success>(
+  storage: Storage<Failure>,
+  use: (host: Host) => Effect.Effect<Success, Unexpected>,
+): Effect.Effect<Success, Failure | Unexpected> => {
+  const engine = storage.pipe(Layer.provide(WorkbenchLive));
+  const run = Effect.flatMap(Layer.build(engine), (services) => use(Context.get(services, ActorHost)));
+
+  return Effect.provideService(Effect.scoped(run), Clock.Clock, Clock.Clock.defaultValue());
+};
+
+const forkBench = (host: Host, commandId: string): ReturnType<Host["fork"]> =>
+  host.fork({ actor: "Workbench", commandId, into: forkedBench, key: bench });
+
+/**
+ * The Workbench with a running `box` that wrote `notes` and a stopped `idle`, forked twice under one fork id; then the
+ * original writes again, and the copy reads its `notes` and writes to them. Each exec has its own key, since a copy
+ * holds the original's recorded steps too.
+ */
+/** What each step of the computers guarantee answered: the runs' outcomes and the fork's version, twice. */
+interface ForkedComputers {
+  readonly after: readonly string[];
+  readonly copy: readonly string[];
+  readonly cut: number;
+  readonly made: readonly string[];
+  readonly original: readonly string[];
+  readonly retried: number;
+}
+
+const forkedWithComputers = (host: Host): Effect.Effect<ForkedComputers, Unexpected> =>
+  Effect.gen(function* forkTwiceThenDiverge() {
+    const made = yield* ran(host, "fc-1", [
+      ensure("box"),
+      exec("box", "write", "echo at-cut > notes"),
+      ensure("idle"),
+      stop("idle"),
+    ]);
+
+    const cut = yield* forkBench(host, "fc");
+    const retried = yield* forkBench(host, "fc");
+    const original = yield* ran(host, "fc-2", [get("box"), get("idle"), exec("box", "later", "echo later >> notes")]);
+
+    const copy = yield* ranAt(host, forkedBench, {
+      commandId: "fc-3",
+      ops: [
+        list,
+        get("box"),
+        get("idle"),
+        exec("box", "copy-read", "cat notes"),
+        exec("box", "copy-write", "echo copy >> notes"),
+      ],
+    });
+
+    const after = yield* ran(host, "fc-4", [exec("box", "reread", "cat notes")]);
+
+    return { after, copy, cut, made, original, retried };
+  });
+
+const copiesComputers = <Failure>(storage: Storage<Failure>): Checked<Failure> =>
+  Effect.gen(function* forkWithComputers() {
+    const { cut, retried, ...outcomes } = yield* onBench(storage, forkedWithComputers);
+
+    expect(retried).toBe(cut);
+    expect(outcomes).toStrictEqual({
+      after: ["exit 0: at-cut\nlater\n"],
+      copy: ["[box,idle]", "stopped", "stopped", "exit 0: at-cut\n", "exit 0: "],
+      made: ["up", "exit 0: ", "up", "stopped"],
+      original: ["up", "stopped", "exit 0: "],
+    });
+  });
+
+type ForkGuaranteeName = keyof typeof forkGuaranteeTitles;
+
+type Guarantee = <Failure>(storage: Storage<Failure>) => Checked<Failure>;
+
+/** The fork guarantees, by name; each runs the Ledger on a fresh store. */
+const forkGuarantees = {
+  forkCopiesComputers: copiesComputers,
+  forkStartsQuiet: startsQuiet,
+} as const satisfies Record<ForkGuaranteeName, Guarantee>;
+
+const everyForkGuarantee: readonly ForkGuaranteeName[] = Rec.keys(forkGuarantees);
+
+interface ForkSkipping<Failure, Services> {
+  /**
+   * An engine that serves `Ledger/acct-1` and `Ledger/acct-5`, a key the suite forks it into, and `Workbench/bench-1`
+   * and `Workbench/bench-250`, with their computers bound to the job runtime's `Actor.computer(key)` and reached by the
+   * engine's fork. An engine that places an actor by its key must place each fork's key on its parent's shard: Akter
+   * Cloud forks only within a shard.
+   */
+  readonly engine: Engine<Failure, Services>;
+  readonly skip: Readonly<Partial<Record<ForkGuaranteeName, string>>>;
+}
+
+/**
+ * Registers every fork guarantee against `engine`, each on fresh storage, skipping only those `skip` names with a
+ * reason. A guarantee added later runs on every engine that registers the suite.
+ */
+const forkConformanceOf =
+  <Failure, Services>({
+    engine,
+    skip,
+  }: ForkSkipping<Failure, Services>): ((test: Vitest.MethodsNonLive<Services>) => void) =>
+  (test) => {
+    for (const name of everyForkGuarantee) {
+      const title = forkGuaranteeTitles[name];
+      const guarantee: Guarantee = forkGuarantees[name];
+
+      const run = (): Effect.Effect<void, Failure | Unexpected, Services> =>
+        Effect.scoped(Effect.flatMap(engine, (storage) => guarantee(storage)));
+
+      Option.match(Option.fromNullishOr(skip[name]), {
+        onNone: () => {
+          test.effect(title, run);
+        },
+        onSome: (reason) => {
+          test.effect.skip(`${title} (skipped: ${reason})`, run);
+        },
+      });
+    }
+  };
+
+export { forkConformanceOf };
+
+export type { ForkGuaranteeName };