@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance/provider/advertise.js

@@ -0,0 +1,44 @@
+import { connect } from "node:net";
+import { Duration, Effect, Schema } from "effect";
+/** An advertised-address list that cannot be read. */
+export class BadAdvertised extends Schema.TaggedError()("BadAdvertised", {
+    reason: Schema.String,
+}) {
+}
+/**
+ * Parses a comma-separated list of `host:port`, where `host` may be a name,
+ * an IPv4 address, or a bracketed IPv6 address. A malformed entry fails
+ * instead of being dropped, so a typo cannot pass as "every address reached".
+ */
+export const parseAdvertised = (list) => Effect.forEach(list
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry !== ""), (entry) => {
+    const match = /^(\[[0-9a-fA-F:.]+\]|[^:\s[\]]+):(\d{1,5})$/.exec(entry);
+    const port = Number(match?.[2]);
+    return match === null || port < 1 || port > 65_535
+        ? Effect.fail(BadAdvertised.make({ reason: `"${entry}" is not host:port` }))
+        : Effect.succeed({ host: match[1].replace(/^\[|\]$/g, ""), port });
+}).pipe(Effect.filterOrFail((addresses) => addresses.length > 0, () => BadAdvertised.make({ reason: "No advertised address given" })));
+/**
+ * Opens a TCP connection to `address` and reports whether it was accepted
+ * within `timeout`. It proves the address routes to a listener from where this
+ * process runs; it says nothing about what listens there.
+ */
+const canConnect = (address, timeout) => Effect.callback((resume) => {
+    const socket = connect({ host: address.host, port: address.port });
+    const finish = (reached) => {
+        socket.destroy();
+        resume(Effect.succeed(reached));
+    };
+    socket.setTimeout(Duration.toMillis(Duration.fromInputUnsafe(timeout)));
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", () => finish(false));
+    return Effect.sync(() => socket.destroy());
+});
+/** The `host:port` of every address this process cannot connect to. */
+export const unreachable = Effect.fnUntraced(function* (addresses, timeout) {
+    const missed = yield* Effect.forEach(addresses, (address) => Effect.map(canConnect(address, timeout), (reached) => reached ? [] : [`${address.host}:${address.port}`]), { concurrency: 8 });
+    return missed.flat();
+});

package/dist/testing/conformance/read-your-writes.d.ts

@@ -0,0 +1,20 @@
+import { Effect, Redacted, type Scope } from "effect";
+import type { ConformanceCase, ConformanceConnection, ConformanceEnvironment, ConformanceServices, ConformanceSuite } from "../conformance.ts";
+/**
+ * Runs `body` on a runtime whose queries read `replica`, in place of the
+ * suite's runtime, which is restarted afterwards. Two runtimes never serve one
+ * database at once, since both would claim its shards.
+ */
+export declare const withReplica: {
+    <A>(replica: Redacted.Redacted<string>, body: Effect.Effect<A, never, ConformanceServices | Scope.Scope>): (environment: ConformanceEnvironment) => Promise<A>;
+    <A>(environment: ConformanceEnvironment, replica: Redacted.Redacted<string>, body: Effect.Effect<A, never, ConformanceServices | Scope.Scope>): Promise<A>;
+};
+/** Replay on the replica stays paused for the rest of the scope. */
+export declare const pauseReplay: (control: ConformanceConnection) => Effect.Effect<readonly unknown[], never, Scope.Scope>;
+export declare const resumeReplay: (control: ConformanceConnection) => Effect.Effect<void, never, never>;
+/** Waits until the replica has replayed through `version`. */
+export declare const replayedThrough: (control: ConformanceConnection, version: string) => Effect.Effect<void, never, never>;
+/** Read-your-writes cases: durable-version headers on replies and replays, rejection of malformed minimums, and replica reads only once it has replayed the caller's version. */
+export declare const readYourWritesConformance: ReadonlyArray<ConformanceCase>;
+/** Read-your-writes cases call the served HTTP actors. */
+export declare const readYourWritesSuite: ConformanceSuite;

package/dist/testing/conformance/read-your-writes.js

@@ -0,0 +1,192 @@
+import { Effect, Redacted, Schedule } from "effect";
+import { dual } from "effect/Function";
+import { ActorError, InvalidInput } from "../../errors/actor.js";
+import { actorErrorBody } from "../../protocol/wire.js";
+import { HttpRoom, serveHttp, tenantOf, httpSuite } from "./http.js";
+const VERSION = /^(0|[1-9]\d*)$/;
+const baseFetch = globalThis.fetch.bind(globalThis);
+/**
+ * Runs `body` on a runtime whose queries read `replica`, in place of the
+ * suite's runtime, which is restarted afterwards. Two runtimes never serve one
+ * database at once, since both would claim its shards.
+ */
+export const withReplica = dual(3, (environment, replica, body) => Effect.runPromise(Effect.gen(function* () {
+    yield* environment.stop;
+    const runtime = environment.build({ replica });
+    return yield* Effect.promise(() => runtime.runPromise(Effect.scoped(body))).pipe(Effect.ensuring(Effect.promise(() => runtime.dispose()).pipe(Effect.andThen(environment.restart))));
+})));
+/** Replay on the replica stays paused for the rest of the scope. */
+export const pauseReplay = (control) => Effect.acquireRelease(control.query("SELECT pg_wal_replay_pause()"), () => Effect.asVoid(control.query("SELECT pg_wal_replay_resume()")));
+export const resumeReplay = (control) => Effect.asVoid(control.query("SELECT pg_wal_replay_resume()"));
+/** Waits until the replica has replayed through `version`. */
+export const replayedThrough = Effect.fnUntraced(function* (control, version) {
+    yield* control
+        .query("SELECT coalesce(pg_last_wal_replay_lsn() - '0/0' >= $1::numeric, false) AS ready", [
+        version,
+    ])
+        .pipe(Effect.map((rows) => rows[0].ready), Effect.repeat({ schedule: Schedule.spaced("50 millis"), until: (ready) => ready }), Effect.timeoutOrElse({
+        duration: "10 seconds",
+        orElse: () => Effect.die(`The replica did not replay through ${version}`),
+    }));
+});
+const post = (server, token, key) => Effect.gen(function* () {
+    const reply = yield* server.send(`/actors/HttpRoom/${key}/Post`, {
+        token,
+        key: yield* server.mint(),
+        body: { text: "a" },
+    });
+    return reply;
+});
+const count = (server, token, key, minVersion) => server.send(`/actors/HttpRoom/${key}/Count`, {
+    token,
+    headers: minVersion === undefined ? {} : { "durable-min-version": minVersion },
+});
+/** Read-your-writes cases: durable-version headers on replies and replays, rejection of malformed minimums, and replica reads only once it has replayed the caller's version. */
+export const readYourWritesConformance = [
+    {
+        name: "answers every committed command with durable-version, and a replay with one at least as high",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const server = yield* serveHttp();
+            const token = `${yield* tenantOf}:alice`;
+            const key = yield* server.mint();
+            const first = yield* server.send("/actors/HttpRoom/versioned/Post", {
+                token,
+                key,
+                body: { text: "a" },
+            });
+            const second = yield* post(server, token, "versioned");
+            const replayed = yield* server.send("/actors/HttpRoom/versioned/Post", {
+                token,
+                key,
+                body: { text: "a" },
+            });
+            const versions = [first, second, replayed].map((reply) => reply.headers.get("durable-version"));
+            expect([first.status, second.status, replayed.status]).toEqual([200, 200, 200]);
+            expect(versions.every((version) => version !== null && VERSION.test(version))).toBe(true);
+            expect(BigInt(versions[1]) > BigInt(versions[0])).toBe(true);
+            expect(BigInt(versions[2]) >= BigInt(versions[0])).toBe(true);
+            expect(replayed.body).toEqual(first.body);
+        })),
+    },
+    {
+        name: "refuses a malformed durable-min-version with InvalidInput",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const server = yield* serveHttp();
+            const token = `${yield* tenantOf}:alice`;
+            for (const malformed of ["", "01", "-1", "1.5", "0x10"]) {
+                const reply = yield* count(server, token, "malformed", malformed);
+                expect(reply.status).toBe(400);
+                expect(reply.body).toEqual(yield* actorErrorBody(ActorError.make({
+                    reason: InvalidInput.make({
+                        code: "decode",
+                        issues: [
+                            {
+                                path: "durable-min-version",
+                                message: "Expected a non-negative decimal integer without leading zeros",
+                            },
+                        ],
+                    }),
+                })));
+            }
+        })),
+    },
+    {
+        name: "reads the replica once it has replayed the caller's version, falls through to the primary while it lags, and serves tokenless reads there",
+        requiresReplica: true,
+        timeoutMs: 60_000,
+        run: ({ expect, environment }) => {
+            const replica = environment.replica;
+            return withReplica(environment, replica.database, Effect.gen(function* () {
+                const control = yield* replica.connect;
+                const server = yield* serveHttp();
+                const token = `${yield* tenantOf}:alice`;
+                const own = (yield* post(server, token, "lag")).headers.get("durable-version");
+                yield* replayedThrough(control, own);
+                yield* pauseReplay(control);
+                const other = (yield* post(server, token, "lag")).headers.get("durable-version");
+                expect(yield* count(server, token, "lag", own)).toMatchObject({ status: 200, body: 1 });
+                expect(yield* count(server, token, "lag")).toMatchObject({ status: 200, body: 1 });
+                expect(yield* count(server, token, "lag", other)).toMatchObject({ status: 200, body: 2 });
+                yield* resumeReplay(control);
+                yield* replayedThrough(control, other);
+                expect(yield* count(server, token, "lag", other)).toMatchObject({ status: 200, body: 2 });
+                expect(yield* count(server, token, "lag")).toMatchObject({ status: 200, body: 2 });
+            }));
+        },
+    },
+    {
+        name: "falls through to the primary when the replica cannot be reached",
+        requiresReplica: true,
+        run: ({ expect, environment }) => {
+            const url = new URL(Redacted.value(environment.replica.database));
+            url.port = "1";
+            return withReplica(environment, Redacted.make(url.href), Effect.gen(function* () {
+                const server = yield* serveHttp();
+                const token = `${yield* tenantOf}:alice`;
+                const version = (yield* post(server, token, "down")).headers.get("durable-version");
+                expect(yield* count(server, token, "down", version)).toMatchObject({
+                    status: 200,
+                    body: 1,
+                });
+                expect(yield* count(server, token, "down")).toMatchObject({ status: 200, body: 1 });
+            }));
+        },
+    },
+    {
+        name: "the Promise client reads its own writes while the replica lags, sending the greatest version it was issued",
+        requiresReplica: true,
+        timeoutMs: 60_000,
+        run: ({ expect, environment }) => {
+            const replica = environment.replica;
+            return withReplica(environment, replica.database, Effect.gen(function* () {
+                const control = yield* replica.connect;
+                const server = yield* serveHttp();
+                const tenant = yield* tenantOf;
+                const sent = [];
+                const issued = [];
+                const fetch = (input, init) => {
+                    sent.push(new Headers(init?.headers));
+                    return baseFetch(input, init).then((response) => {
+                        issued.push(response.headers.get("durable-version"));
+                        return response;
+                    });
+                };
+                const rooms = HttpRoom.client({
+                    baseUrl: server.url,
+                    headers: { authorization: `Bearer ${tenant}:alice` },
+                    fetch,
+                });
+                const room = rooms.get("client");
+                yield* Effect.promise(() => room.Post({ text: "a" }));
+                yield* replayedThrough(control, issued.at(-1));
+                yield* pauseReplay(control);
+                yield* Effect.promise(() => room.Post({ text: "b" }));
+                const latest = issued.at(-1);
+                expect(yield* count(server, `${tenant}:alice`, "client")).toMatchObject({ body: 1 });
+                expect(yield* Effect.promise(() => room.Count())).toBe(2);
+                expect(sent.at(-1).get("durable-min-version")).toBe(latest);
+                expect(VERSION.test(latest)).toBe(true);
+            }));
+        },
+    },
+    {
+        name: "an in-process handle's query reads the commands its runtime sent while the replica lags",
+        requiresReplica: true,
+        timeoutMs: 60_000,
+        run: ({ expect, environment }) => {
+            const replica = environment.replica;
+            return withReplica(environment, replica.database, Effect.gen(function* () {
+                const control = yield* replica.connect;
+                const room = yield* HttpRoom.get("in-process");
+                yield* room.Post({ text: "a" }).pipe(Effect.orDie);
+                yield* pauseReplay(control);
+                yield* room.Post({ text: "b" }).pipe(Effect.orDie);
+                expect(yield* room.Count().pipe(Effect.orDie)).toBe(2);
+            }));
+        },
+    },
+];
+/** Read-your-writes cases call the served HTTP actors. */
+export const readYourWritesSuite = {
+    uses: [httpSuite],
+};

package/dist/testing/conformance/reducers.d.ts

@@ -0,0 +1,8 @@
+import { Layer } from "effect";
+import type { ConformanceCase, ConformanceSuite } from "../conformance.ts";
+/** Registers the reducer actor: a reducer-only actor still registers through `toLayer`, with no handlers. */
+export declare const reducerLayer: Layer.Layer<never, never, import("../index.ts").InternalActors>;
+/** Reducer cases: one receipt per committed change, replay without reducing, and rejection of changed input under a reused command id. */
+export declare const reducerConformance: ReadonlyArray<ConformanceCase>;
+/** The reducer actors. */
+export declare const reducerSuite: ConformanceSuite;

package/dist/testing/conformance/reducers.js

@@ -0,0 +1,258 @@
+import { Cause, Effect, Exit, Layer, Result, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { Actor, Actors, CommandConflict } from "../../index.js";
+import { decompress } from "../../runtime/storage/codec.js";
+import { VERSION_KEY } from "../../state/migration.js";
+import { ActorTest } from "../actor-test.js";
+class Overflow extends Schema.TaggedError()("Overflow", { max: Schema.Int }) {
+}
+const TallyV0 = { total: Schema.Int };
+const TallyFields = {
+    count: Schema.Int.pipe(Schema.withDecodingDefault(Effect.succeed(0))),
+    label: Schema.String.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
+};
+const TallyState = Actor.state(TallyFields, {
+    migrations: [
+        Actor.migration(TallyV0, TallyFields, ({ total }) => ({ count: total, label: "migrated" })),
+    ],
+});
+const reductions = { count: 0 };
+const Add = Actor.reducer("Add", {
+    state: TallyState,
+    payload: Schema.Int,
+    error: Overflow,
+    reduce: (state, amount) => {
+        reductions.count += 1;
+        return state.count + amount > 1_000
+            ? Result.fail(Overflow.make({ max: 1_000 }))
+            : Result.succeed({ ...state, count: state.count + amount });
+    },
+});
+const Label = Actor.reducer("Label", {
+    state: TallyState,
+    payload: Schema.String,
+    reduce: (state, label) => Result.succeed({ ...state, label }),
+});
+const Tick = Actor.reducer("Tick", {
+    state: TallyState,
+    payload: Schema.Int,
+    reduce: (state, amount) => Result.succeed({ ...state, count: state.count + amount }),
+    batch: { combine: (first, second) => first + second },
+});
+const Corrupt = Actor.reducer("Corrupt", {
+    state: TallyState,
+    payload: Schema.Boolean,
+    reduce: (state, raise) => {
+        if (raise)
+            throw new Error("Reducer bug");
+        return Result.succeed({ ...state, count: 0.5 });
+    },
+});
+const BasketState = Actor.state({
+    items: Schema.mutable(Schema.Array(Schema.String)).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
+});
+const Put = Actor.reducer("Put", {
+    state: BasketState,
+    payload: Schema.String,
+    reduce: (state, item) => {
+        state.items.push(item);
+        return Result.succeed(state);
+    },
+});
+const Basket = Actor.make("Basket", { key: Schema.String, state: BasketState, api: { Put } });
+const Tally = Actor.make("Tally", {
+    key: Schema.String,
+    state: TallyState,
+    api: { Add, Label, Tick, Corrupt },
+});
+/** Registers the reducer actor: a reducer-only actor still registers through `toLayer`, with no handlers. */
+export const reducerLayer = Layer.mergeAll(Tally.toLayer(Effect.succeed({})), Basket.toLayer(Effect.succeed({})));
+const storedVersion = Effect.fnUntraced(function* (ref) {
+    const sql = yield* SqlClient.SqlClient;
+    const [row] = yield* sql `SELECT value FROM actor_state
+    WHERE tenant_id = ${ref.tenant} AND actor_type = ${ref.actor} AND actor_id = ${ref.id}
+      AND key = ${VERSION_KEY}`;
+    return row === undefined ? undefined : decompress(row.value);
+}, Effect.orDie);
+/** Reducer cases: one receipt per committed change, replay without reducing, and rejection of changed input under a reused command id. */
+export const reducerConformance = [
+    {
+        name: "reducer commits changed state and one receipt, and replays without reducing again",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const tally = yield* Tally.get("reducer-commit");
+            const label = tally.Label("first");
+            expect(yield* label).toEqual({ count: 0, label: "first" });
+            expect(yield* test.inspect(tally.ref)).toEqual({
+                generation: "1",
+                state: { label: "first" },
+                receipts: 1,
+                outbox: 0,
+                events: 0,
+                jobs: 0,
+            });
+            const add = tally.Add(7);
+            const before = reductions.count;
+            expect(yield* add).toEqual({ count: 7, label: "first" });
+            expect(yield* add).toEqual({ count: 7, label: "first" });
+            expect(yield* label).toEqual({ count: 0, label: "first" });
+            expect(reductions.count - before).toBe(1);
+            expect(yield* test.inspect(tally.ref)).toEqual({
+                generation: "1",
+                state: { count: 7, label: "first" },
+                receipts: 2,
+                outbox: 0,
+                events: 0,
+                jobs: 0,
+            });
+            expect(yield* storedVersion(tally.ref)).toBe("1");
+        })),
+    },
+    {
+        name: "reducer rejects changed input or another member under the same command id",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const tally = yield* Tally.get("reducer-conflict");
+            const id = yield* (yield* Actors).mintCommandId;
+            expect(yield* tally.Add(3).pipe(Actor.commandId(id))).toEqual({ count: 3, label: "" });
+            expect(yield* tally.Add(4).pipe(Actor.commandId(id), Effect.flip)).toMatchObject({
+                reason: CommandConflict.make({ commandId: id }),
+            });
+            expect(yield* tally.Tick(3).pipe(Actor.commandId(id), Effect.flip)).toMatchObject({
+                reason: CommandConflict.make({ commandId: id }),
+            });
+            expect(yield* test.inspect(tally.ref)).toMatchObject({
+                state: { count: 3 },
+                receipts: 1,
+            });
+        })),
+    },
+    {
+        name: "failing reduce rolls back state and upcast writes and replays its declared error after conditions change",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const tally = yield* Tally.get("reducer-failure");
+            yield* test.seed(tally.ref, { total: 998 }, 0);
+            const overflow = tally.Add(5);
+            const before = reductions.count;
+            expect(yield* overflow.pipe(Effect.flip)).toEqual(Overflow.make({ max: 1_000 }));
+            expect(yield* test.inspect(tally.ref)).toEqual({
+                generation: "1",
+                state: { total: 998 },
+                receipts: 1,
+                outbox: 0,
+                events: 0,
+                jobs: 0,
+            });
+            expect(yield* storedVersion(tally.ref)).toBe(undefined);
+            expect(yield* tally.Add(-998)).toEqual({ count: 0, label: "migrated" });
+            expect(yield* overflow.pipe(Effect.flip)).toEqual(Overflow.make({ max: 1_000 }));
+            expect(reductions.count - before).toBe(2);
+            expect(yield* test.inspect(tally.ref)).toEqual({
+                generation: "1",
+                state: { count: 0, label: "migrated" },
+                receipts: 2,
+                outbox: 0,
+                events: 0,
+                jobs: 0,
+            });
+            expect(yield* storedVersion(tally.ref)).toBe("1");
+        })),
+    },
+    {
+        name: "recovers reducer turns crashed beforeCommit and afterCommit with one transition each",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const tally = yield* Tally.get("reducer-crash");
+            const before = reductions.count;
+            yield* test.crashNext("beforeCommit");
+            expect(yield* tally.Add(23)).toEqual({ count: 23, label: "" });
+            expect(reductions.count - before).toBe(2);
+            yield* test.crashNext("afterCommit");
+            expect(yield* tally.Add(4)).toEqual({ count: 27, label: "" });
+            expect(reductions.count - before).toBe(3);
+            expect(yield* test.inspect(tally.ref)).toMatchObject({
+                state: { count: 27 },
+                receipts: 2,
+            });
+        })),
+    },
+    {
+        name: "recovers failing reducer turns crashed beforeCommit and afterCommit with one terminal receipt each",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const tally = yield* Tally.get("reducer-failure-crash");
+            yield* tally.Add(999);
+            const before = reductions.count;
+            const beforeCommit = tally.Add(2);
+            yield* test.crashNext("beforeCommit");
+            expect(yield* beforeCommit.pipe(Effect.flip)).toEqual(Overflow.make({ max: 1_000 }));
+            expect(reductions.count - before).toBe(2);
+            const afterCommit = tally.Add(3);
+            yield* test.crashNext("afterCommit");
+            expect(yield* afterCommit.pipe(Effect.flip)).toEqual(Overflow.make({ max: 1_000 }));
+            expect(reductions.count - before).toBe(3);
+            expect(yield* test.inspect(tally.ref)).toMatchObject({
+                state: { count: 999 },
+                receipts: 3,
+            });
+            yield* tally.Add(-999);
+            expect(yield* beforeCommit.pipe(Effect.flip)).toEqual(Overflow.make({ max: 1_000 }));
+            expect(yield* afterCommit.pipe(Effect.flip)).toEqual(Overflow.make({ max: 1_000 }));
+            expect(reductions.count - before).toBe(4);
+            expect(yield* test.inspect(tally.ref)).toMatchObject({
+                state: { count: 0 },
+                receipts: 4,
+            });
+        })),
+    },
+    {
+        name: "commutative reducer runs as one receipted turn per call and replies void",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const tally = yield* Tally.get("reducer-commutative");
+            const tick = tally.Tick(2);
+            expect(yield* tick).toBe(undefined);
+            expect(yield* tick).toBe(undefined);
+            expect(yield* tally.Tick(5)).toBe(undefined);
+            expect(yield* test.inspect(tally.ref)).toMatchObject({
+                state: { count: 7 },
+                receipts: 2,
+            });
+        })),
+    },
+    {
+        name: "a throwing reduce or an invalid returned state is a defect with no receipt",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const tally = yield* Tally.get("reducer-defect");
+            yield* tally.Add(1);
+            for (const raise of [true, false]) {
+                const exit = yield* tally.Corrupt(raise).pipe(Effect.exit);
+                expect(Exit.isFailure(exit) && Cause.hasDies(exit.cause)).toBe(true);
+            }
+            expect(yield* test.inspect(tally.ref)).toMatchObject({
+                state: { count: 1 },
+                receipts: 1,
+            });
+            expect(yield* tally.Add(1)).toEqual({ count: 2, label: "" });
+        })),
+    },
+    {
+        name: "reducer that mutates its state argument still commits the change",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const basket = yield* Basket.get("reducer-mutation");
+            expect(yield* basket.Put("a")).toEqual({ items: ["a"] });
+            expect(yield* basket.Put("b")).toEqual({ items: ["a", "b"] });
+            expect(yield* test.inspect(basket.ref)).toMatchObject({
+                state: { items: ["a", "b"] },
+                receipts: 2,
+            });
+        })),
+    },
+];
+/** The reducer actors. */
+export const reducerSuite = {
+    layer: () => reducerLayer,
+};

package/dist/testing/conformance/relay.d.ts

@@ -0,0 +1,42 @@
+import { Effect, Layer, Schema } from "effect";
+import type { Request } from "../../runtime/request.ts";
+import type { ConformanceCase, ConformanceSuite } from "../conformance.ts";
+/** One executor attempt as the fake provider saw it; times are this process's clock. */
+interface Attempt {
+    readonly key: string;
+    readonly effectId: string;
+    readonly attempt: number;
+    readonly runner: number;
+    readonly startedAt: number;
+    endedAt: number | undefined;
+    interrupted: boolean;
+}
+/** Shared by the relay actors and every relay case; each case resets it first. */
+export interface RelayFixture {
+    /** Receiver handler runs by intent payload; a rolled-back run counts too. */
+    readonly taken: Map<string, number>;
+    /** Claims seen at the `afterClaim` fault point, by command id, on any cluster runner. */
+    readonly claims: Map<string, number>;
+    readonly attempts: Array<Attempt>;
+    /** What the receiver does after counting a run. */
+    onTake: (id: string) => Effect.Effect<void>;
+    /** What the provider does on one attempt; the default succeeds with the key. */
+    provider: (attempt: Attempt) => Effect.Effect<string, ProviderDown>;
+    /** Behaviour at a fault point on every cluster runner, after its `ActorTest` faults. */
+    hook: (point: string, request: Request) => Effect.Effect<void>;
+}
+export declare const relayFixture: () => RelayFixture;
+declare const ProviderDown_base: Schema.Class<ProviderDown, Schema.TaggedStruct<"ProviderDown", {}>, import("effect/Cause").YieldableError>;
+declare class ProviderDown extends ProviderDown_base {
+}
+/** The relay actors' command layers, which every runner builds. */
+export declare const relayLayer: (fixture: RelayFixture) => Layer.Layer<never, never, import("../index.ts").InternalActors>;
+/** The executors of the conformance environment's single runtime. */
+export declare const relayEffects: (fixture: RelayFixture) => Layer.Layer<never, never, import("../index.ts").InternalActors>;
+/** Multi-runner cases: real Postgres only, each on a fresh database and cluster. */
+export declare const relayClusterConformance: ReadonlyArray<ConformanceCase<RelayFixture>>;
+/** Single-runner cases on the conformance environment, shared by PGlite and Postgres. */
+export declare const relayConformance: ReadonlyArray<ConformanceCase<RelayFixture>>;
+/** Relay actors and the executors of runner 0. */
+export declare const relaySuite: ConformanceSuite<RelayFixture>;
+export {};