@akterjs/conformance 0.0.0-stage → 0.1.1

package/dist/engine-conformance.suite.mjs

@@ -0,0 +1,357 @@
+import { guaranteeTitles } from "./guarantee-titles.pure.mjs";
+import { effectLedgers } from "./ledger/ledger.actor.mjs";
+import { ada, amount, amountLater, amountTo, approving, beforeDue, billing, bob, depositOpening, fileDecisions, forgedWriting, key, ledgerHost, longAfterDue, nothing, overdrawnBy, payee, reading, robotDeposit, untilDue, withdrawOverdraft, writing } from "./ledger/ledger-calls.pure.mjs";
+import { akterTables, decodeReply, fileDecision, isHostTable, isRefused, refusedPrefix } from "./ledger/ledger-checks.pure.mjs";
+import { Ledger } from "./ledger/ledger.contract.mjs";
+import { expect } from "@effect/vitest";
+import { Array, Cause, Context, Effect, Exit, Layer, Option, Predicate, Queue, Record, Stream, String as String$1 } from "effect";
+import { ActorHost } from "@akterjs/effect";
+import { TestClock } from "effect/testing";
+// src/engine-conformance.suite.ts
+const { account, amounts, approve, ask, drained, held, send } = ledgerHost;
+const tables = (host, declared) => {
+	const appTable = Predicate.not(isHostTable(declared));
+	return Effect.map(Effect.flatMap(ask(host, "tables"), (reply) => decodeReply(Ledger.queries.tables, reply)), Exit.map(Array.filter(appTable)));
+};
+const onEngine = (storage, handlers, use) => {
+	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) => Effect.all([send(host, "deposit", depositOpening), send(host, "withdraw", withdrawOverdraft)]);
+const replyMeansCommitted = (storage, declared) => Effect.gen(function* reopenAfterReplies() {
+	yield* onEngine(storage, declared.ledgers.live, (host) => Effect.all([send(host, "deposit", depositOpening), send(host, "deposit", {
+		commandId: "b",
+		payload: amount(7)
+	})]));
+	const seen = yield* onEngine(storage, declared.ledgers.live, (host) => Effect.all([account(host), amounts(host)]));
+	expect(seen).toStrictEqual([Exit.succeed({
+		balance: 12,
+		closed: false
+	}), Exit.succeed([5, 7])]);
+});
+const retriedCommandId = (storage, declared) => 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: 5,
+		closed: false
+	}), Exit.succeed([5])]);
+});
+const rollsBack = (storage, declared) => 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(3)
+	});
+	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(1)
+	});
+	const afterDeposit = yield* account(host);
+	expect(failures).toStrictEqual([Exit.fail(overdrawnBy), Exit.die(/* @__PURE__ */ new Error("the handler crashed after writing"))]);
+	expect(afterFailures).toStrictEqual([Exit.succeed({
+		balance: 5,
+		closed: false
+	}), Exit.succeed([5])]);
+	expect(afterDeposit).toStrictEqual(Exit.succeed({
+		balance: 6,
+		closed: false
+	}));
+}));
+const callersBeforeHandler = (storage, declared) => 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 = (storage, declared) => onEngine(storage, declared.ledgers.live, (host) => Effect.gen(function* decideFiles() {
+	const asked = (payload, principal) => 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 = (storage, declared) => 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([5])]);
+	expect(Exit.match(intruded, {
+		onFailure: () => "refused",
+		onSuccess: () => "opened"
+	})).toBe("refused");
+	expect(after).toStrictEqual(Exit.succeed(["entries", "notes"]));
+});
+const queriesNeverWrite = (storage, declared) => 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([5])]);
+}));
+const engineTablesOwned = (storage, declared) => 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(7)
+	}));
+	const refusal = Exit.match(tampered, {
+		onFailure: Cause.pretty,
+		onSuccess: String$1.trim
+	});
+	const after = yield* Effect.all([account(host), amounts(host)]);
+	expect([String$1.includes("akter_state is engine-owned")(refusal), after]).toStrictEqual([true, [Exit.succeed({
+		balance: 5,
+		closed: false
+	}), Exit.succeed([5])]]);
+}));
+const liveAfterCommit = (storage, declared) => onEngine(storage, declared.ledgers.live, (host) => Effect.gen(function* watchCommits() {
+	const updates = yield* Queue.unbounded();
+	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(3)
+		}),
+		send(host, "deposit", {
+			commandId: "b",
+			payload: amount(1)
+		})
+	]);
+	const seen = yield* Effect.all([next, next]);
+	expect([before, ...seen]).toStrictEqual([
+		Exit.succeed({
+			balance: 0,
+			closed: false
+		}),
+		Exit.succeed({
+			balance: 5,
+			closed: false
+		}),
+		Exit.succeed({
+			balance: 6,
+			closed: false
+		})
+	]);
+}));
+const sentAfterCommit = (storage, declared) => 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(9)
+		});
+		yield* send(host, "transfer", {
+			commandId: "t",
+			payload: amountTo(2)
+		});
+		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: 3,
+			closed: false
+		}),
+		Exit.succeed([2]),
+		Exit.succeed([2])
+	]);
+});
+const signalAfterCommit = (storage, declared) => 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: 3,
+			job: id,
+			refuse: true
+		}));
+		const afterRefusal = yield* drained(host);
+		yield* approve(host, "approved", approving({
+			amount: 5,
+			job: id,
+			refuse: false
+		}));
+		return [id, [afterRefusal, yield* drained(host)]];
+	}));
+	const reopened = yield* onEngine(storage, declared.ledgers.live, (host) => Effect.gen(function* retryThenApproveLate() {
+		yield* approve(host, "approved", approving({
+			amount: 5,
+			job,
+			refuse: false
+		}));
+		const afterRetry = yield* drained(host);
+		yield* approve(host, "late", approving({
+			amount: 7,
+			job,
+			refuse: false
+		}));
+		return [afterRetry, yield* drained(host)];
+	}));
+	expect([...live, ...reopened]).toStrictEqual([
+		Exit.succeed([]),
+		Exit.succeed([5]),
+		Exit.succeed([5]),
+		Exit.succeed([5])
+	]);
+});
+const patchedJobs = (storage, declared) => 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: 5,
+			job: before,
+			refuse: false
+		}));
+		const afterOld = yield* drained(host);
+		const after = yield* held(host, "h-after");
+		yield* approve(host, "a-after", approving({
+			amount: 7,
+			job: after,
+			refuse: false
+		}));
+		return [afterOld, yield* drained(host)];
+	}));
+	expect(released).toStrictEqual([Exit.succeed([5]), Exit.succeed([5, 14])]);
+});
+const advance = (host, elapsed) => Effect.gen(function* advanceAndDrain() {
+	yield* TestClock.adjust(elapsed);
+	yield* account(host);
+	yield* host.drain;
+	return yield* account(host);
+});
+const timerFiresOnce = (storage, declared) => Effect.gen(function* fireAcrossReopen() {
+	const early = yield* onEngine(storage, declared.ledgers.live, (host) => Effect.andThen(send(host, "depositLater", {
+		commandId: "l",
+		payload: amountLater(5)
+	}), 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: 5,
+			closed: false
+		}),
+		Exit.succeed({
+			balance: 5,
+			closed: false
+		}),
+		Exit.succeed([5])
+	]);
+});
+const onFresh = (engine, guarantee) => Effect.scoped(Effect.flatMap(engine, guarantee));
+const guarantees = {
+	callersBeforeHandler,
+	engineTablesOwned,
+	fileRuleDecides,
+	liveAfterCommit,
+	migrationsOnOpen,
+	patchedJobs,
+	queriesNeverWrite,
+	replyMeansCommitted,
+	retriedCommandId,
+	rollsBack,
+	sentAfterCommit,
+	signalAfterCommit,
+	timerFiresOnce
+};
+/** Every guarantee, by name. */
+const everyGuarantee = Record.keys(guarantees);
+const conformanceOf = ({ engine, hostTables, ledgers = effectLedgers, skip }) => (test) => {
+	const 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 = () => onFresh(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 = (engine) => conformanceOf({
+	engine,
+	skip: {}
+});
+export { conformance, conformanceOf };

package/dist/fork/fork-conformance.suite.d.mts

@@ -0,0 +1,20 @@
+import { Engine } from "../engine-conformance.suite.mjs";
+import { forkGuaranteeTitles } from "../guarantee-titles.pure.mjs";
+import { Vitest } from "@effect/vitest";
+type ForkGuaranteeName = keyof typeof forkGuaranteeTitles;
+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.
+ */
+declare const forkConformanceOf: <Failure, Services>({ engine, skip }: ForkSkipping<Failure, Services>) => ((test: Vitest.MethodsNonLive<Services>) => void);
+export { type ForkGuaranteeName, forkConformanceOf };

package/dist/fork/fork-conformance.suite.mjs

@@ -0,0 +1,167 @@
+import { forkGuaranteeTitles } from "../guarantee-titles.pure.mjs";
+import { effectLedgers } from "../ledger/ledger.actor.mjs";
+import { amount, amountLater, depositOpening, forked, ledgerHost, longAfterDue } from "../ledger/ledger-calls.pure.mjs";
+import { WorkbenchLive } from "../workbench/workbench.actor.mjs";
+import { bench, ensure, forkedBench, get, list, stop, workbenchHost } from "../workbench/workbench-calls.pure.mjs";
+import { expect } from "@effect/vitest";
+import { Clock, Context, Effect, Exit, Layer, Option, Record } from "effect";
+import { ActorHost } from "@akterjs/effect";
+import { TestClock } from "effect/testing";
+// src/fork/fork-conformance.suite.ts
+const { account, amounts, fork, send } = ledgerHost;
+const onEngine = (storage, use) => {
+	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) => Effect.all([
+	account(host),
+	amounts(host),
+	account(host, forked),
+	amounts(host, forked)
+]);
+const startsQuiet = (storage) => 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(5)
+		});
+		const version = yield* fork(host, "f");
+		yield* send(host, "deposit", {
+			commandId: "b",
+			payload: amount(7)
+		});
+		yield* send(host, "deposit", {
+			account: forked,
+			commandId: "c",
+			payload: amount(1)
+		});
+		const again = yield* fork(host, "f");
+		yield* TestClock.adjust(longAfterDue);
+		yield* account(host);
+		yield* host.drain;
+		return [
+			version,
+			again,
+			yield* both(host)
+		];
+	}));
+	const reopened = yield* onEngine(storage, both);
+	const settled = [
+		Exit.succeed({
+			balance: 17,
+			closed: false
+		}),
+		Exit.succeed([
+			5,
+			7,
+			5
+		]),
+		Exit.succeed({
+			balance: 6,
+			closed: false
+		}),
+		Exit.succeed([5, 1])
+	];
+	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 = (storage, use) => {
+	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, commandId) => host.fork({
+	actor: "Workbench",
+	commandId,
+	into: forkedBench,
+	key: bench
+});
+const forkedWithComputers = (host) => 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")
+		]
+	});
+	return {
+		after: yield* ran(host, "fc-4", [exec("box", "reread", "cat notes")]),
+		copy,
+		cut,
+		made,
+		original,
+		retried
+	};
+});
+const copiesComputers = (storage) => 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: "
+		]
+	});
+});
+/** The fork guarantees, by name; each runs the Ledger on a fresh store. */
+const forkGuarantees = {
+	forkCopiesComputers: copiesComputers,
+	forkStartsQuiet: startsQuiet
+};
+const everyForkGuarantee = Record.keys(forkGuarantees);
+/**
+* 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 = ({ engine, skip }) => (test) => {
+	for (const name of everyForkGuarantee) {
+		const title = forkGuaranteeTitles[name];
+		const guarantee = forkGuarantees[name];
+		const run = () => 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 };

package/dist/guarantee-titles.pure.d.mts

@@ -0,0 +1,31 @@
+declare const guaranteeTitles: {
+  readonly callersBeforeHandler: "caller checks run before the handler: a caller the command doesn't allow changes nothing";
+  readonly engineTablesOwned: "a handler may read akter_* tables but never write them: the write fails, names the table and changes nothing";
+  readonly 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";
+  readonly liveAfterCommit: "live queries update only after a commit: a subscriber sees each committed change and nothing from a rolled-back command";
+  readonly migrationsOnOpen: "migrations run when an actor opens, before its first call, and a migration added later runs on the next open";
+  readonly 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";
+  readonly queriesNeverWrite: "queries never write: a write inside a query fails and leaves the actor unchanged";
+  readonly replyMeansCommitted: "a reply means the command committed: an engine reopened on the same storage sees every replied command";
+  readonly retriedCommandId: "a retried command id returns the recorded outcome and runs the handler once";
+  readonly rollsBack: "a handler failure rolls back every write the command made";
+  readonly sentAfterCommit: "a message a command sends is delivered after the command commits, at least once, and a rolled-back command sends none";
+  readonly 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";
+  readonly timerFiresOnce: "a timer fires once at its due time, and not again after the engine restarts";
+};
+/** The computer guarantees' titles, which `@akterjs/conformance/computers` registers. */
+declare const computerGuaranteeTitles: {
+  readonly 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";
+  readonly computerKeepsFiles: "a computer keeps its files across pause, resume, stop and an engine restart";
+  readonly computerLimitHolds: "a computer past the store's limit is refused with ComputerLimitError and makes nothing, and one fits again once another is removed";
+  readonly computerRemovedIsGone: "a removed computer is gone with its disk: calls to it fail with ComputerNotFoundError, and ensuring it again starts it empty";
+  readonly computerStepJournaled: "a durable computer step journals its start and outcome in the actor, and its steps read back newest first, one with its output";
+  readonly computerStepRunsOnce: "a computer step runs once by its key: sent again, even after the engine restarts, it reads back the outcome it recorded";
+  readonly 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";
+};
+/** The fork guarantees' titles, which `@akterjs/conformance/fork` registers. */
+declare const forkGuaranteeTitles: {
+  readonly 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";
+  readonly 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";
+};
+export { computerGuaranteeTitles, forkGuaranteeTitles, guaranteeTitles };

package/dist/guarantee-titles.pure.mjs

@@ -0,0 +1,32 @@
+// src/guarantee-titles.pure.ts
+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"
+};
+/** 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"
+};
+/** 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"
+};
+export { computerGuaranteeTitles, forkGuaranteeTitles, guaranteeTitles };