@akterjs/conformance 0.0.0-stage → 0.1.0

package/dist/tally-clients.layer.d.mts

@@ -0,0 +1,39 @@
+import { RejectedError } from "./rejected.errors.mjs";
+import { Effect, MutableRef, Scope, Stream } from "effect";
+type Headers = Readonly<Record<string, string>>;
+interface Update<Value> {
+  readonly value: Value;
+  readonly version: number;
+}
+interface Owned {
+  readonly owner: string;
+  readonly total: number;
+}
+interface TallyHandle {
+  readonly add: (amount: number) => Effect.Effect<number, RejectedError>;
+  readonly create: (owner: string) => Effect.Effect<void, RejectedError>;
+  readonly ensure: (owner: string) => Effect.Effect<void, RejectedError>;
+  readonly fork: (into: string) => Effect.Effect<TallyHandle, RejectedError>;
+  readonly owner: Effect.Effect<string, RejectedError>;
+  readonly state: Stream.Stream<Update<Owned>, RejectedError>;
+  readonly take: (amount: number) => Effect.Effect<number, RejectedError>;
+  readonly total: Effect.Effect<number, RejectedError>;
+  readonly totals: Stream.Stream<Update<number>, RejectedError>;
+  readonly warm: Effect.Effect<void, RejectedError>;
+}
+interface Wire {
+  readonly fetch: typeof globalThis.fetch;
+  readonly loseNextReply: Effect.Effect<void>;
+  readonly opened: MutableRef.MutableRef<number>;
+  readonly sockets: Set<globalThis.WebSocket>;
+  readonly webSocket: typeof globalThis.WebSocket;
+}
+interface Connection {
+  readonly headers: Headers;
+  readonly url: string;
+  readonly wire: Wire;
+}
+type Connect = (connection: Connection) => Effect.Effect<(key: string) => TallyHandle, never, Scope.Scope>;
+declare const clients: readonly (readonly [string, Connect])[];
+declare const wired: Effect.Effect<Wire>;
+export { type Connect, type Headers, type TallyHandle, type Update, type Wire, clients, wired };

package/dist/tally-clients.layer.mjs

@@ -0,0 +1,97 @@
+import { RejectedError } from "./rejected.errors.mjs";
+import { Tally } from "./tally.contract.mjs";
+import { Cause, Effect, Layer, MutableRef, Option, Queue, Schema, Stream } from "effect";
+import { createClient } from "@akterjs/client";
+import { akterClient } from "@akterjs/client/effect";
+import { FetchHttpClient } from "effect/http";
+// src/tally-clients.layer.ts
+const noSockets = 0;
+const withoutPayload = (send, payload) => send(payload);
+const settle = (promise) => Effect.tryPromise({
+	catch: (reason) => RejectedError.make({ reason }),
+	try: promise
+});
+const effectClient = ({ headers, url, wire }) => Effect.map(Layer.build(akterClient({
+	fetch: wire.fetch,
+	headers: () => headers,
+	url,
+	webSocket: wire.webSocket
+})), (services) => function handleOf(key) {
+	const client = Tally.client(key);
+	const run = (use) => Effect.scoped(Effect.flatMap(client, use)).pipe(Effect.mapError((reason) => RejectedError.make({ reason })), Effect.provide(services));
+	const watch = (use) => Stream.unwrap(Effect.map(client, use)).pipe(Stream.mapError((reason) => RejectedError.make({ reason })), Stream.provide(services));
+	return {
+		add: (amount) => run((tally) => tally.add({ amount })),
+		create: (owner) => run((tally) => tally.create({ owner })),
+		ensure: (owner) => run((tally) => tally.ensure({ owner })),
+		fork: (into) => Effect.as(run((tally) => Effect.flatMap(tally.fork(into), (copy) => withoutPayload(copy.owner))), handleOf(into)),
+		owner: run((tally) => withoutPayload(tally.owner)),
+		state: watch((tally) => tally.state),
+		take: (amount) => run((tally) => tally.take({ amount })),
+		total: run((tally) => withoutPayload(tally.total)),
+		totals: watch((tally) => withoutPayload(tally.total.subscribe)),
+		warm: run((tally) => tally.warm)
+	};
+});
+const listened = (subscribe) => Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => subscribe((update) => {
+	Queue.offerUnsafe(queue, update);
+}, (failure) => {
+	Queue.failCauseUnsafe(queue, Cause.fail(RejectedError.make({ reason: failure })));
+})), (stop) => Effect.sync(stop)));
+const promiseClient = ({ headers, url, wire }) => Effect.map(Effect.acquireRelease(Effect.sync(() => createClient({
+	actors: [Tally],
+	fetch: wire.fetch,
+	headers: () => headers,
+	url,
+	webSocket: wire.webSocket
+})), (client) => Effect.promise(() => client.close())), (client) => function handleOf(key) {
+	const tally = client.Tally(key);
+	return {
+		add: (amount) => settle(() => tally.add({ amount })),
+		create: (owner) => settle(() => tally.create({ owner })),
+		ensure: (owner) => settle(() => tally.ensure({ owner })),
+		fork: (into) => Effect.as(Effect.flatMap(settle(() => tally.fork(into)), (copy) => settle(() => withoutPayload(copy.owner))), handleOf(into)),
+		owner: settle(() => withoutPayload(tally.owner)),
+		state: listened((onUpdate, onFailure) => tally.state.subscribe(onUpdate, onFailure)),
+		take: (amount) => settle(() => tally.take({ amount })),
+		total: settle(() => withoutPayload(tally.total)),
+		totals: listened((onUpdate, onFailure) => tally.total.subscribe(onUpdate, onFailure)),
+		warm: settle(() => tally.warm())
+	};
+});
+const clients = [["the Effect client", effectClient], ["the Promise client", promiseClient]];
+const isSocket = Schema.is(Schema.instanceOf(globalThis.WebSocket));
+const trackedSockets = (sockets, opened) => new Proxy(globalThis.WebSocket, { construct: (native, socket) => {
+	const constructed = Reflect.construct(native, socket);
+	const tracked = Option.getOrThrow(Option.liftPredicate(constructed, isSocket));
+	sockets.add(tracked);
+	MutableRef.increment(opened);
+	tracked.addEventListener("close", () => {
+		sockets.delete(tracked);
+	});
+	return tracked;
+} });
+const wired = Effect.gen(function* wired() {
+	const losing = MutableRef.make(false);
+	const sockets = /* @__PURE__ */ new Set();
+	const opened = MutableRef.make(noSockets);
+	const services = yield* Effect.context();
+	const send = yield* FetchHttpClient.Fetch;
+	const losingFetch = (input, init) => Effect.runPromiseWith(services)(Effect.gen(function* fetchOrLoseReply() {
+		const response = yield* Effect.promise(() => send(input, init));
+		if (MutableRef.get(losing)) {
+			MutableRef.set(losing, false);
+			yield* Effect.promise(() => response.arrayBuffer());
+			return yield* Effect.die("the fixture dropped the connection after the server replied");
+		}
+		return response;
+	}));
+	return {
+		fetch: Object.assign(losingFetch, send),
+		loseNextReply: Effect.sync(() => MutableRef.set(losing, true)),
+		opened,
+		sockets,
+		webSocket: trackedSockets(sockets, opened)
+	};
+});
+export { clients, wired };

package/dist/tally.actor.d.mts

@@ -0,0 +1,49 @@
+import { ShortError } from "./tally.contract.mjs";
+declare const TallyLive: import("effect/Layer").Layer<import("@akterjs/effect/contract").ActorHandlers<"Tally">, never, never>;
+declare const app: {
+  readonly actors: readonly [import("@akterjs/effect/contract").Actor<"Tally", import("@akterjs/effect/contract").DefinitionOf<{
+    readonly commands: {
+      add: import("@akterjs/effect/contract").Command<import("effect/Schema").Struct<{
+        readonly amount: import("effect/Schema").Int;
+      }>, import("effect/Schema").Int, import("effect/Schema").Never, never>;
+      take: import("@akterjs/effect/contract").Command<import("effect/Schema").Struct<{
+        readonly amount: import("effect/Schema").Int;
+      }>, import("effect/Schema").Int, typeof ShortError, never>;
+    };
+    readonly create: {
+      owner: import("effect/Schema").String;
+    };
+    readonly key: import("effect/Schema").String;
+    readonly queries: {
+      owner: import("@akterjs/effect/contract").Query<import("effect/Schema").Void, import("effect/Schema").String, import("effect/Schema").Never, never>;
+      total: import("@akterjs/effect/contract").Query<import("effect/Schema").Void, import("effect/Schema").Int, import("effect/Schema").Never, never>;
+    };
+    readonly state: import("effect/Schema").Struct<{
+      readonly owner: import("effect/Schema").String;
+      readonly total: import("effect/Schema").Int;
+    }>;
+  }>> & import("@akterjs/effect/contract").ActorHistory<import("@akterjs/effect/contract").DefinitionOf<{
+    readonly commands: {
+      add: import("@akterjs/effect/contract").Command<import("effect/Schema").Struct<{
+        readonly amount: import("effect/Schema").Int;
+      }>, import("effect/Schema").Int, import("effect/Schema").Never, never>;
+      take: import("@akterjs/effect/contract").Command<import("effect/Schema").Struct<{
+        readonly amount: import("effect/Schema").Int;
+      }>, import("effect/Schema").Int, typeof ShortError, never>;
+    };
+    readonly create: {
+      owner: import("effect/Schema").String;
+    };
+    readonly key: import("effect/Schema").String;
+    readonly queries: {
+      owner: import("@akterjs/effect/contract").Query<import("effect/Schema").Void, import("effect/Schema").String, import("effect/Schema").Never, never>;
+      total: import("@akterjs/effect/contract").Query<import("effect/Schema").Void, import("effect/Schema").Int, import("effect/Schema").Never, never>;
+    };
+    readonly state: import("effect/Schema").Struct<{
+      readonly owner: import("effect/Schema").String;
+      readonly total: import("effect/Schema").Int;
+    }>;
+  }>>];
+  readonly layer: import("effect/Layer").Layer<import("@akterjs/effect/contract").ActorHandlers<"Tally">, never, never>;
+};
+export { TallyLive, app };

package/dist/tally.actor.mjs

@@ -0,0 +1,26 @@
+import { ShortError, Tally } from "./tally.contract.mjs";
+import { Effect } from "effect";
+// src/tally.actor.ts
+const empty = 0;
+const TallyLive = Tally.toLayer({
+	commands: {
+		add: (tally, { amount }) => Effect.as(Tally.update({ total: tally.total + amount }), tally.total + amount),
+		take: (tally, { amount }) => {
+			if (amount > tally.total) return ShortError.make({ total: tally.total });
+			return Effect.as(Tally.update({ total: tally.total - amount }), tally.total - amount);
+		}
+	},
+	create: ({ owner }) => Effect.succeed({
+		owner,
+		total: empty
+	}),
+	queries: {
+		owner: (tally) => Effect.succeed(tally.owner),
+		total: (tally) => Effect.succeed(tally.total)
+	}
+});
+const app = {
+	actors: [Tally],
+	layer: TallyLive
+};
+export { TallyLive, app };

package/dist/tally.contract.d.mts

@@ -0,0 +1,51 @@
+import { Schema } from "effect";
+declare const ShortError_base: Schema.Class<ShortError, Schema.TaggedStruct<"ShortError", {
+  readonly total: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+declare class ShortError extends ShortError_base {}
+declare const Tally: import("@akterjs/effect/contract").Actor<"Tally", import("@akterjs/effect/contract").DefinitionOf<{
+  readonly commands: {
+    add: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.Int;
+    }>, Schema.Int, Schema.Never, never>;
+    take: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.Int;
+    }>, Schema.Int, typeof ShortError, never>;
+  };
+  readonly create: {
+    owner: Schema.String;
+  };
+  readonly key: Schema.String;
+  readonly queries: {
+    owner: import("@akterjs/effect/contract").Query<Schema.Void, Schema.String, Schema.Never, never>;
+    total: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Int, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly owner: Schema.String;
+    readonly total: Schema.Int;
+  }>;
+}>> & import("@akterjs/effect/contract").ActorHistory<import("@akterjs/effect/contract").DefinitionOf<{
+  readonly commands: {
+    add: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.Int;
+    }>, Schema.Int, Schema.Never, never>;
+    take: import("@akterjs/effect/contract").Command<Schema.Struct<{
+      readonly amount: Schema.Int;
+    }>, Schema.Int, typeof ShortError, never>;
+  };
+  readonly create: {
+    owner: Schema.String;
+  };
+  readonly key: Schema.String;
+  readonly queries: {
+    owner: import("@akterjs/effect/contract").Query<Schema.Void, Schema.String, Schema.Never, never>;
+    total: import("@akterjs/effect/contract").Query<Schema.Void, Schema.Int, Schema.Never, never>;
+  };
+  readonly state: Schema.Struct<{
+    readonly owner: Schema.String;
+    readonly total: Schema.Int;
+  }>;
+}>>;
+export { ShortError, Tally };

package/dist/tally.contract.mjs

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import { Akter } from "@akterjs/effect/contract";
+// src/tally.contract.ts
+var ShortError = class extends Schema.TaggedError()("ShortError", { total: Schema.Int }) {};
+const Tally = Akter.make("Tally", {
+	commands: {
+		add: Akter.command({
+			payload: { amount: Schema.Int },
+			success: Schema.Int
+		}),
+		take: Akter.command({
+			error: ShortError,
+			payload: { amount: Schema.Int },
+			success: Schema.Int
+		})
+	},
+	create: { owner: Schema.String },
+	key: Schema.String,
+	queries: {
+		owner: Akter.query({ success: Schema.String }),
+		total: Akter.query({ success: Schema.Int })
+	},
+	state: Schema.Struct({
+		owner: Schema.String,
+		total: Schema.Int
+	})
+});
+export { ShortError, Tally };

package/dist/workbench/computer-conformance.suite.d.mts

@@ -0,0 +1,15 @@
+import { Engine } from "../engine-conformance.suite.mjs";
+import { computerGuaranteeTitles } from "../guarantee-titles.pure.mjs";
+import { Vitest } from "@effect/vitest";
+type ComputerGuaranteeName = keyof typeof computerGuaranteeTitles;
+interface ComputerSkipping<Failure, Services> {
+  /** An engine that serves `Workbench/bench-1`, with its computers bound to the job runtime's `Actor.computer(key)`. */
+  readonly engine: Engine<Failure, Services>;
+  readonly skip: Readonly<Partial<Record<ComputerGuaranteeName, string>>>;
+}
+/**
+ * Registers every computer 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 computerConformanceOf: <Failure, Services>({ engine, skip }: ComputerSkipping<Failure, Services>) => ((test: Vitest.MethodsNonLive<Services>) => void);
+export { type ComputerGuaranteeName, computerConformanceOf };

package/dist/workbench/computer-conformance.suite.mjs

@@ -0,0 +1,330 @@
+import { computerGuaranteeTitles } from "../guarantee-titles.pure.mjs";
+import { WorkbenchLive } from "./workbench.actor.mjs";
+import { ComputerOp } from "./workbench.contract.mjs";
+import { bench, ensure, get, list, remove, stop, unfinished, workbenchHost } from "./workbench-calls.pure.mjs";
+import { expect } from "@effect/vitest";
+import { Array, Clock, Context, Effect, Layer, Option, Predicate, Record, Schedule, String as String$1 } from "effect";
+import { ActorHost } from "@akterjs/effect";
+// src/workbench/computer-conformance.suite.ts
+const { Pause, Resume, Step } = ComputerOp.cases;
+const { exec, outcomesOf, ran, startedRun } = workbenchHost;
+const holding = (hold) => Record.getSomes({ hold: Option.fromUndefinedOr(hold) });
+const pause = (computer, hold) => Pause.make({
+	computer,
+	...holding(hold)
+});
+const resume = (computer, hold) => Resume.make({
+	computer,
+	...holding(hold)
+});
+/** A durable step on `box`, named `name`, with an optional limit in seconds. */
+const step = (name, command, timeoutSeconds) => {
+	const limit = Record.getSomes({ timeoutSeconds: Option.fromUndefinedOr(timeoutSeconds) });
+	return Step.make({
+		command,
+		computer: "box",
+		name,
+		...limit
+	});
+};
+/** 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());
+};
+/** A step that counts how many times it ran, in a file on the computer. */
+const counting = "echo ran >> runs; grep -c ran runs";
+const stepRunsOnce = (storage) => Effect.gen(function* resendAcrossRestart() {
+	const live = yield* onBench(storage, (host) => ran(host, "r-1", [
+		ensure("box"),
+		exec("box", "count", counting),
+		exec("box", "count", counting)
+	]));
+	const restarted = yield* onBench(storage, (host) => ran(host, "r-2", [exec("box", "count", counting), exec("box", "read", "grep -c ran runs")]));
+	expect([live, restarted]).toStrictEqual([[
+		"up",
+		"exit 0: 1\n",
+		"exit 0: 1\n"
+	], ["exit 0: 1\n", "exit 0: 1\n"]]);
+});
+const keepsFiles = (storage) => Effect.gen(function* writePauseStopRestart() {
+	const live = yield* onBench(storage, (host) => ran(host, "k-1", [
+		ensure("box"),
+		exec("box", "write", "echo kept > notes"),
+		pause("box"),
+		resume("box"),
+		stop("box")
+	]));
+	const restarted = yield* onBench(storage, (host) => ran(host, "k-2", [
+		get("box"),
+		exec("box", "read", "cat notes"),
+		get("box")
+	]));
+	expect([live, restarted]).toStrictEqual([[
+		"up",
+		"exit 0: ",
+		"paused",
+		"up",
+		"stopped"
+	], [
+		"stopped",
+		"exit 0: kept\n",
+		"up"
+	]]);
+});
+/** Neither a plain pause nor a held pause starts a stopped computer; a plain pause cannot interfere with its hold. */
+const stoppedStaysStopped = (host) => Effect.gen(function* pauseStopped() {
+	const asked = yield* ran(host, "h-2", [
+		ensure("idle"),
+		stop("idle"),
+		pause("idle"),
+		pause("idle", "fork-3"),
+		pause("idle"),
+		exec("idle", "step", "true"),
+		get("idle"),
+		resume("idle", "fork-3"),
+		exec("idle", "step", "echo again")
+	]);
+	expect(asked).toStrictEqual([
+		"up",
+		"stopped",
+		"stopped",
+		"stopped",
+		"ComputerHeldError",
+		"ComputerHeldError",
+		"stopped",
+		"stopped",
+		"exit 0: again\n"
+	]);
+});
+const heldStaysPaused = (storage) => onBench(storage, (host) => Effect.gen(function* holdThenRelease() {
+	const outcomes = yield* ran(host, "h-1", [
+		ensure("box"),
+		pause("box", "fork-1"),
+		exec("box", "step", "true"),
+		ensure("box"),
+		resume("box"),
+		resume("box", "fork-2"),
+		pause("box"),
+		pause("box", "fork-2"),
+		pause("box", "fork-1"),
+		get("box"),
+		resume("box", "fork-1"),
+		resume("box", "fork-1"),
+		exec("box", "step", "echo once")
+	]);
+	const held = "ComputerHeldError";
+	expect(outcomes).toStrictEqual([
+		"up",
+		"paused",
+		held,
+		held,
+		held,
+		held,
+		held,
+		held,
+		"paused",
+		"paused",
+		"up",
+		"up",
+		"exit 0: once\n"
+	]);
+	yield* stoppedStaysStopped(host);
+}));
+const tried = 8;
+const none = 0;
+const first = 1;
+/** `value` `count` times, for a count from none to `tried`. */
+const times = (value, count) => Array.take(Array.replicate(value, tried), count);
+const listed = (names) => `[${Array.join(Array.sort(names, String$1.Order), ",")}]`;
+const limitHolds = (storage) => onBench(storage, (host) => Effect.gen(function* fillThenFree() {
+	const names = Array.makeBy(tried, (index) => `c${String(index)}`);
+	const filled = yield* ran(host, "l-1", [...Array.map(names, ensure), list]);
+	const made = Array.takeWhile(filled, (outcome) => outcome === "up").length;
+	const refused = `ComputerLimitError store ${String(made)}`;
+	const kept = Array.take(names, made);
+	const freed = yield* ran(host, "l-2", [
+		remove("c0"),
+		ensure("again"),
+		ensure("more"),
+		list
+	]);
+	expect({
+		filled,
+		freed,
+		made: made > none && made < tried
+	}).toStrictEqual({
+		filled: [
+			...times("up", made),
+			...times(refused, tried - made),
+			listed(kept)
+		],
+		freed: [
+			"removed",
+			"up",
+			refused,
+			listed([...Array.drop(kept, first), "again"])
+		],
+		made: true
+	});
+}));
+const removedIsGone = (storage) => onBench(storage, (host) => Effect.gen(function* removeThenEnsure() {
+	const outcomes = yield* ran(host, "g-1", [
+		ensure("box"),
+		exec("box", "write", "echo x > left"),
+		remove("box"),
+		get("box"),
+		exec("box", "after", "true"),
+		remove("box"),
+		list,
+		ensure("box"),
+		exec("box", "look", "ls")
+	]);
+	const missing = "ComputerNotFoundError";
+	expect(outcomes).toStrictEqual([
+		"up",
+		"exit 0: ",
+		"removed",
+		missing,
+		missing,
+		"removed",
+		"[]",
+		"up",
+		"exit 0: "
+	]);
+}));
+/** Each journaled step as `akter steps list` reads it, newest first: its name, its state and its exit code once it ran. */
+const journaled = (host) => Effect.map(host.steps({
+	actor: "Workbench",
+	key: bench
+}), (steps) => Array.map(steps, ({ exitCode, name, state }) => {
+	const exit = Option.map(Option.fromUndefinedOr(exitCode), String);
+	return Array.join([
+		name,
+		state,
+		...Option.toArray(exit)
+	], " ");
+}));
+const stepJournaled = (storage) => onBench(storage, (host) => Effect.gen(function* stepThenRead() {
+	const outcomes = yield* ran(host, "j-1", [
+		ensure("box"),
+		step("hello", "echo hi"),
+		step("no", "exit 3")
+	]);
+	const steps = yield* host.steps({
+		actor: "Workbench",
+		key: bench
+	});
+	const hello = Array.filter(steps, ({ name }) => name === "hello");
+	const read = yield* Effect.forEach(hello, ({ step: id }) => host.step({
+		actor: "Workbench",
+		key: bench,
+		step: id
+	}));
+	const missing = yield* host.step({
+		actor: "Workbench",
+		key: bench,
+		step: "no-such-step"
+	});
+	const journal = yield* journaled(host);
+	expect({
+		journal,
+		missing: Option.isNone(missing),
+		outcomes,
+		output: Array.map(Array.getSomes(read), ({ computer, stdout }) => [computer, stdout]),
+		quiet: Array.every(steps, ({ stdout }) => Predicate.isUndefined(stdout))
+	}).toStrictEqual({
+		journal: ["no ran 3", "hello ran 0"],
+		missing: true,
+		outcomes: [
+			"up",
+			"exit 0: hi\n",
+			"exit 3: "
+		],
+		output: [["box", "hi\n"]],
+		quiet: true
+	});
+}));
+/** How long a cut-off guarantee waits for the step to be journaled before the engine under it stops. */
+const journalPolls = 200;
+const pollEvery = "100 millis";
+/** How long it waits for the replayed job to settle the step: past the step's limit and grace, with room under load. */
+const settlePolls = 400;
+/** A step that counts its runs, then outlives the moment the engine stops under it, within its 3 s limit. */
+const slow = "echo ran >> runs; sleep 2";
+const slowLimit = 3;
+/**
+* Starts a job whose durable step is cut off by the engine stopping once the step is journaled, then restarts it.
+* Wherever the stop fell, the step ran at most once and its job settles it: with the outcome the computer recorded
+* when the command finished before the stop reached it, or `unknown` once its limit has passed without one.
+*/
+const stepSurvivesRestart = (storage) => Effect.gen(function* cutThenReplay() {
+	const job = yield* onBench(storage, (host) => Effect.gen(function* startThenStop() {
+		const started = yield* startedRun(host, {
+			commandId: "c-1",
+			key: bench,
+			ops: [ensure("box"), step("slow", slow, slowLimit)]
+		});
+		yield* Effect.repeat(journaled(host), {
+			schedule: Schedule.spaced(pollEvery),
+			times: journalPolls,
+			until: Array.isReadonlyArrayNonEmpty
+		});
+		return started;
+	}));
+	const settled = yield* onBench(storage, (host) => Effect.gen(function* replayThenCount() {
+		const outcomes = yield* Effect.repeat(outcomesOf(host, bench, job), {
+			schedule: Schedule.spaced(pollEvery),
+			times: settlePolls,
+			until: (found) => !Array.contains(found, unfinished)
+		});
+		return {
+			counted: yield* ran(host, "c-2", [exec("box", "count", "grep -c ran runs")]),
+			journal: yield* journaled(host),
+			outcomes
+		};
+	}));
+	const recorded = {
+		journal: ["slow ran 0"],
+		outcomes: ["up", "exit 0: "]
+	};
+	const unknown = {
+		journal: ["slow unknown"],
+		outcomes: ["up", "unknown"]
+	};
+	const { counted, ...settledAs } = settled;
+	expect(counted).toStrictEqual(["exit 0: 1\n"]);
+	expect([recorded, unknown]).toContainEqual(settledAs);
+});
+/** The computer guarantees, by name; each runs the Workbench on a fresh store. */
+const computerGuarantees = {
+	computerHeldStaysPaused: heldStaysPaused,
+	computerKeepsFiles: keepsFiles,
+	computerLimitHolds: limitHolds,
+	computerRemovedIsGone: removedIsGone,
+	computerStepJournaled: stepJournaled,
+	computerStepRunsOnce: stepRunsOnce,
+	computerStepSurvivesRestart: stepSurvivesRestart
+};
+const everyComputerGuarantee = Record.keys(computerGuarantees);
+/**
+* Registers every computer 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 computerConformanceOf = ({ engine, skip }) => (test) => {
+	for (const name of everyComputerGuarantee) {
+		const title = computerGuaranteeTitles[name];
+		const guarantee = computerGuarantees[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 { computerConformanceOf };