@rikalabs/akter 0.1.0-alpha.0 → 0.1.0-alpha.3

package/dist/testing/conformance/retention.js

@@ -1,463 +0,0 @@
-import { Cause, Clock, Effect, Exit, Fiber, Layer, Option, Schema } from "effect";
-import { SqlClient } from "effect/sql";
-import { Actor, Intent, RetentionGap, UnknownCursor } from "../../index.js";
-import { ActorError, CommandExpired, Timeout } from "../../errors/actor.js";
-import { databaseTime } from "../../runtime/turn/admission.js";
-import { ActorTest } from "../actor-test.js";
-import { CLAIM_LEASE } from "./outbox.js";
-export const retentionFixture = () => ({ adds: 0, receives: 0 });
-const Noted = Actor.event("Noted", { body: Schema.String });
-const files = Actor.blob("files");
-const Note = Actor.command("Note", { payload: Schema.String, success: Schema.String });
-const NoteMany = Actor.command("NoteMany", {
-    payload: Schema.Struct({ count: Schema.Int, bytes: Schema.Int }),
-});
-const Add = Actor.command("Add", { payload: Schema.Int, success: Schema.Int });
-const Forward = Actor.command("Forward", { payload: Schema.String });
-const Receive = Actor.command("Receive", { payload: Schema.String });
-const Put = Actor.command("Put", {
-    payload: Schema.Struct({ name: Schema.String, bytes: Schema.Int }),
-});
-const Grow = Actor.command("Grow", {
-    payload: Schema.Struct({ name: Schema.String, bytes: Schema.Int }),
-});
-const Drop = Actor.command("Drop", { payload: Schema.String });
-/** Replaces an entry and swallows the defect, so the turn commits whatever the write left. */
-const PutCaught = Actor.command("PutCaught", {
-    payload: Schema.Struct({ name: Schema.String, bytes: Schema.Int }),
-    success: Schema.Boolean,
-});
-const Entry = Schema.Struct({ cursor: Schema.String, body: Schema.String });
-const History = Actor.query("History", {
-    payload: Schema.Struct({
-        after: Schema.optional(Schema.String),
-        limit: Schema.optional(Schema.Finite),
-    }),
-    success: Schema.Array(Entry),
-    error: Schema.Union([UnknownCursor, RetentionGap]),
-});
-const Size = Actor.query("Size", { payload: Schema.String, success: Schema.Int });
-const Total = Actor.query("Total", { success: Schema.Int });
-const Journal = Actor.make("Journal", {
-    key: Schema.String,
-    state: Actor.state({ total: Schema.Int.pipe(Schema.withDecodingDefault(Effect.succeed(0))) }),
-    events: [Noted],
-    blobs: [files],
-    api: { Note, NoteMany, Add, Forward, Put, Grow, PutCaught, Drop, History, Size, Total },
-    internal: { Receive },
-    policy: {
-        keepReceipts: "2 days",
-        keepEvents: "1 day",
-        maxBlobBytes: 1024,
-        maxBlobEntries: 3,
-        executionTimeout: "2 seconds",
-    },
-});
-/** The same events under a longer horizon, so one sweep applies each type's own policy. */
-const Tally = Actor.command("Tally", { payload: Schema.Int, success: Schema.Int });
-/** Keeps receipts for less than the retry window, so only the delivery-timeout grace holds them. */
-const Brief = Actor.make("Brief", {
-    key: Schema.String,
-    state: Actor.state({ total: Schema.Int.pipe(Schema.withDecodingDefault(Effect.succeed(0))) }),
-    api: { Tally },
-    policy: { keepReceipts: "1 second" },
-});
-const Chronicle = Actor.make("Chronicle", {
-    key: Schema.String,
-    events: [Noted],
-    api: { Note },
-    policy: { keepEvents: "90 days" },
-});
-export const retentionLayer = (fixture) => Layer.mergeAll(Journal.toLayer(Effect.succeed({
-    Forward: Effect.fnUntraced(function* (to) {
-        yield* Journal.Turn;
-        yield* (yield* Journal.intents(to)).Receive("forwarded").pipe(Intent.after("1 minute"));
-    }),
-    Note: Effect.fnUntraced(function* (body) {
-        const turn = yield* Journal.Turn;
-        yield* turn.emit(Noted.make({ body }));
-        return turn.commandId;
-    }),
-    NoteMany: Effect.fnUntraced(function* ({ count, bytes }) {
-        const turn = yield* Journal.Turn;
-        for (let index = 0; index < count; index++)
-            yield* turn.emit(Noted.make({ body: "x".repeat(bytes) }));
-    }),
-    Add: Effect.fnUntraced(function* (amount) {
-        const turn = yield* Journal.Turn;
-        fixture.adds += 1;
-        yield* turn.state.set({ total: turn.state.total + amount });
-        return turn.state.total;
-    }),
-    Receive: Effect.fnUntraced(function* () {
-        const turn = yield* Journal.Turn;
-        fixture.receives += 1;
-        yield* turn.state.set({ total: turn.state.total + 1 });
-    }),
-    Put: Effect.fnUntraced(function* ({ name, bytes }) {
-        yield* (yield* Journal.Turn).blob(files).set(name, new Uint8Array(bytes));
-    }),
-    Grow: Effect.fnUntraced(function* ({ name, bytes }) {
-        yield* (yield* Journal.Turn).blob(files).append(name, new Uint8Array(bytes));
-    }),
-    Drop: Effect.fnUntraced(function* (name) {
-        yield* (yield* Journal.Turn).blob(files).delete(name);
-    }),
-    PutCaught: Effect.fnUntraced(function* ({ name, bytes }) {
-        return yield* (yield* Journal.Turn)
-            .blob(files)
-            .set(name, new Uint8Array(bytes))
-            .pipe(Effect.as(true), Effect.catchDefect(() => Effect.succeed(false)));
-    }),
-})), Journal.toQueryLayer(Effect.succeed({
-    History: Effect.fnUntraced(function* ({ after, limit }) {
-        const read = yield* Journal.Read;
-        const entries = yield* read.events(Noted, { after, limit });
-        return entries.map(({ cursor, event }) => ({ cursor, body: event.body }));
-    }),
-    Size: Effect.fnUntraced(function* (name) {
-        const bytes = yield* (yield* Journal.Read).blob(files).get(name);
-        return Option.match(bytes, { onNone: () => -1, onSome: (value) => value.byteLength });
-    }),
-    Total: Effect.fnUntraced(function* () {
-        return (yield* Journal.Read).state.total;
-    }),
-})), Brief.toLayer(Effect.succeed({
-    Tally: Effect.fnUntraced(function* (amount) {
-        const turn = yield* Brief.Turn;
-        yield* turn.state.set({ total: turn.state.total + amount });
-        return turn.state.total;
-    }),
-})), Chronicle.toLayer(Effect.succeed({
-    Note: Effect.fnUntraced(function* (body) {
-        const turn = yield* Chronicle.Turn;
-        yield* turn.emit(Noted.make({ body }));
-        return turn.commandId;
-    }),
-})));
-const defect = (exit) => Exit.isFailure(exit) ? Cause.pretty(exit.cause) : "succeeded";
-const cursors = (entries) => entries.map(({ cursor }) => cursor);
-/**
- * Runs `effect` in a runtime of its own on a fresh database, for a case whose
- * pause points must not catch a turn the shared runtime's relay delivers. The
- * shared runtime stops meanwhile: two in-process runtimes at once can starve
- * Cluster's runner health checks.
- */
-const isolated = (environment, effect) => Effect.runPromise(Effect.gen(function* () {
-    yield* Effect.acquireRelease(environment.stop, () => environment.restart);
-    const database = yield* environment.freshDatabase;
-    const runtime = yield* Effect.acquireRelease(Effect.sync(() => environment.build({ database })), (built) => Effect.promise(() => built.dispose()));
-    return yield* Effect.promise(() => runtime.runPromise(Effect.scoped(effect)));
-}).pipe(Effect.scoped));
-const eventSequence = Effect.fnUntraced(function* (id) {
-    const sql = yield* SqlClient.SqlClient;
-    const test = yield* ActorTest;
-    const [row] = yield* sql `
-    SELECT event_sequence::text AS sequence FROM actor_generations
-    WHERE tenant_id = ${test.tenant} AND actor_type = 'Journal' AND actor_id = ${id}`;
-    return row?.sequence;
-}, Effect.orDie);
-/** Retention cases: pruning of receipts and events keeps expired ids rejected, outbox dedup intact, and sequences continuous. */
-export const retentionConformance = [
-    {
-        name: "prunes receipts past keepReceipts and still rejects the expired id after pruning and restart",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const journal = yield* Journal.get("receipts");
-            const before = fixture.adds;
-            const add = journal.Add(3);
-            expect(yield* add).toBe(3);
-            expect(yield* journal.Add(4)).toBe(7);
-            yield* test.advance("1 day");
-            yield* test.cleanup;
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ receipts: 2 });
-            expect((yield* add.pipe(Effect.flip)).reason).toBeInstanceOf(CommandExpired);
-            yield* test.advance("2 days");
-            yield* test.cleanup;
-            expect(yield* test.inspect(journal.ref)).toMatchObject({
-                receipts: 0,
-                state: { total: 7 },
-            });
-            expect((yield* add.pipe(Effect.flip)).reason).toBeInstanceOf(CommandExpired);
-            expect(fixture.adds - before).toBe(2);
-            expect(yield* journal.Total()).toBe(7);
-        })),
-    },
-    {
-        name: "rejects a pruned expired id after restart without running its handler",
-        run: ({ expect, environment, fixture }) => Effect.runPromise(Effect.gen(function* () {
-            yield* environment.stop;
-            const first = environment.build();
-            const saved = yield* Effect.promise(() => first
-                .runPromise(Effect.scoped(Effect.gen(function* () {
-                const test = yield* ActorTest;
-                const journal = yield* Journal.get("restart");
-                const now = yield* databaseTime;
-                const id = `v1.${now - 59_000}.${now + 1_000}.6f6f1e0a-3a42-4c1e-9d6b-2b1c1f1a9e01`;
-                expect(yield* journal.Add(5).pipe(Actor.commandId(id))).toBe(5);
-                yield* test.advance("3 days");
-                yield* test.cleanup;
-                expect(yield* test.inspect(journal.ref)).toMatchObject({ receipts: 0 });
-                return { id, tenant: test.tenant };
-            })))
-                .finally(() => first.dispose()));
-            const adds = fixture.adds;
-            const second = environment.build();
-            yield* Effect.promise(() => second
-                .runPromise(Effect.scoped(Effect.gen(function* () {
-                const journal = yield* Journal.get("restart").pipe(Actor.tenant(saved.tenant));
-                yield* Effect.sleep("1100 millis");
-                const failure = yield* journal
-                    .Add(5)
-                    .pipe(Actor.commandId(saved.id), Effect.flip);
-                expect(failure.reason).toBeInstanceOf(CommandExpired);
-                expect(yield* journal.Total()).toBe(5);
-            })))
-                .finally(() => second.dispose()));
-            expect(fixture.adds).toBe(adds);
-        }).pipe(Effect.ensuring(environment.restart))),
-    },
-    {
-        name: "prunes receipts past keepReceipts without breaking outbox dedup",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const sender = yield* Journal.get("sender");
-            const receiver = yield* Journal.get("receiver");
-            const bystander = yield* Journal.get("bystander");
-            const before = fixture.receives;
-            yield* sender.Forward("receiver");
-            const sql = yield* SqlClient.SqlClient;
-            yield* bystander.Add(1);
-            yield* sql `UPDATE actor_receipts SET command_id = o.intent_id FROM actor_outbox o
-            WHERE o.tenant_id = ${test.tenant} AND o.actor_id = 'sender'
-              AND actor_receipts.tenant_id = ${test.tenant} AND actor_receipts.actor_id = 'bystander'`;
-            yield* test.crashNext("beforeOutboxDelete");
-            yield* test.crashNext("beforeOutboxDelete");
-            yield* test.advance("10 days");
-            expect(yield* test.receiptsFor(receiver.ref, "Receive")).toBe(1);
-            expect(yield* test.inspect(sender.ref)).toMatchObject({ outbox: 1 });
-            yield* test.cleanup;
-            expect(yield* test.receiptsFor(receiver.ref, "Receive")).toBe(1);
-            expect(yield* test.receiptsFor(bystander.ref, "Add")).toBe(0);
-            yield* test.advance(CLAIM_LEASE);
-            yield* test.cleanup;
-            expect(yield* test.inspect(sender.ref)).toMatchObject({ outbox: 1 });
-            yield* test.advance(CLAIM_LEASE);
-            expect(fixture.receives - before).toBe(1);
-            expect(yield* receiver.Total()).toBe(1);
-            expect(yield* test.inspect(sender.ref)).toMatchObject({ outbox: 0 });
-            yield* test.cleanup;
-            expect(yield* test.receiptsFor(receiver.ref, "Receive")).toBe(0);
-        })),
-    },
-    {
-        name: "completes a command admitted before expiry when keepReceipts is shorter than the retry window",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const brief = yield* Brief.get("short-horizon");
-            const pause = yield* test.pauseNext("beforeHandler");
-            yield* test.crashNext("beforeCommit");
-            const now = yield* databaseTime;
-            const id = `v1.${now - 59_500}.${now + 500}.2d1f6a3e-7b9c-4e21-8f0a-5c6d7e8f9a01`;
-            const waiter = yield* brief
-                .Tally(9)
-                .pipe(Actor.commandId(id), Effect.flip, Effect.forkChild);
-            yield* pause.reached;
-            yield* Effect.sleep("550 millis");
-            yield* pause.release;
-            expect((yield* Fiber.join(waiter)).reason).toBeInstanceOf(CommandExpired);
-            expect(yield* test.inspect(brief.ref)).toMatchObject({ state: { total: 9 }, receipts: 1 });
-            yield* test.cleanup;
-            expect(yield* test.inspect(brief.ref)).toMatchObject({ receipts: 1 });
-        })),
-    },
-    {
-        name: "prunes only an actor's oldest events, never resets the sequence, and reports the gap",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const journal = yield* Journal.get("events");
-            const chronicle = yield* Chronicle.get("events");
-            yield* journal.Note("a");
-            yield* journal.Note("b");
-            yield* chronicle.Note("kept");
-            yield* test.advance("2 days");
-            yield* journal.Note("c");
-            yield* test.cleanup;
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ events: 1 });
-            expect(yield* test.inspect(chronicle.ref)).toMatchObject({ events: 1 });
-            expect(yield* eventSequence("events")).toBe("3");
-            expect(yield* journal.History({}).pipe(Effect.flip)).toEqual(RetentionGap.make({ cursor: "0" }));
-            expect(yield* journal.History({ after: "1" }).pipe(Effect.flip)).toEqual(RetentionGap.make({ cursor: "1" }));
-            expect(yield* journal.History({ after: "2" })).toEqual([{ cursor: "3", body: "c" }]);
-            yield* journal.Note("d");
-            expect(cursors(yield* journal.History({ after: "2" }))).toEqual(["3", "4"]);
-            expect(yield* eventSequence("events")).toBe("4");
-        })),
-    },
-    {
-        name: "prunes events as a prefix even when a later event carries an older timestamp",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const sql = yield* SqlClient.SqlClient;
-            const journal = yield* Journal.get("skewed");
-            for (const body of ["a", "b", "c", "d"])
-                yield* journal.Note(body);
-            yield* sql `UPDATE actor_events SET emitted_at_ms = emitted_at_ms - 172800000
-            WHERE tenant_id = ${test.tenant} AND actor_type = 'Journal' AND actor_id = 'skewed' AND sequence = 3`;
-            yield* test.cleanup;
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ events: 1 });
-            expect(yield* journal.History({ after: "3" })).toEqual([{ cursor: "4", body: "d" }]);
-            expect(yield* journal.History({ after: "2" }).pipe(Effect.flip)).toEqual(RetentionGap.make({ cursor: "2" }));
-        })),
-    },
-    {
-        name: "sweeps in batches that each leave a whole prefix",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const journal = yield* Journal.get("batched");
-            yield* journal.NoteMany({ count: 2_500, bytes: 1 });
-            yield* test.advance("2 days");
-            yield* journal.Note("fresh");
-            yield* test.cleanup;
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ events: 1 });
-            expect(yield* journal.History({ after: "2500" })).toEqual([
-                { cursor: "2501", body: "fresh" },
-            ]);
-            expect(yield* eventSequence("batched")).toBe("2501");
-        })),
-    },
-    {
-        name: "pages event replay by limit and continues after the last cursor",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const journal = yield* Journal.get("paged");
-            yield* journal.NoteMany({ count: 1_205, bytes: 1 });
-            const first = yield* journal.History({});
-            expect(first.length).toBe(1_000);
-            expect(first.at(-1).cursor).toBe("1000");
-            expect((yield* journal.History({ after: "1000" })).length).toBe(205);
-            const small = yield* journal.History({ after: "10", limit: 3 });
-            expect(cursors(small)).toEqual(["11", "12", "13"]);
-            expect(cursors(yield* journal.History({ after: "1203", limit: 3 }))).toEqual([
-                "1204",
-                "1205",
-            ]);
-            expect(yield* journal.History({ after: "1205", limit: 3 })).toEqual([]);
-            for (const limit of [0, 10_001, 1.5])
-                expect(defect(yield* journal.History({ limit }).pipe(Effect.exit))).toContain("read.events limit must be an integer from 1 to 10000");
-        })),
-    },
-    {
-        name: "fails a turn whose emits exceed the per-turn byte budget and commits none of them",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const journal = yield* Journal.get("budget");
-            yield* journal.NoteMany({ count: 2, bytes: 500_000 });
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ events: 2, receipts: 1 });
-            expect(defect(yield* journal.NoteMany({ count: 3, bytes: 500_000 }).pipe(Effect.exit))).toContain("Events emitted in one turn exceed 1048576 bytes");
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ events: 2, receipts: 1 });
-            expect(yield* eventSequence("budget")).toBe("2");
-        })),
-    },
-    {
-        name: "refuses blob writes past policy.maxBlobBytes and leaves the entry whole",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const journal = yield* Journal.get("quota");
-            yield* journal.Put({ name: "a", bytes: 600 });
-            yield* journal.Grow({ name: "b", bytes: 200 });
-            yield* journal.Grow({ name: "b", bytes: 200 });
-            expect(defect(yield* journal.Grow({ name: "b", bytes: 25 }).pipe(Effect.exit))).toContain("One actor's blobs hold at most 1024 bytes (policy.maxBlobBytes)");
-            expect(defect(yield* journal.Put({ name: "c", bytes: 25 }).pipe(Effect.exit))).toContain("policy.maxBlobBytes");
-            yield* journal.Put({ name: "a", bytes: 624 });
-            expect(yield* journal.Size("a")).toBe(624);
-            expect(yield* journal.PutCaught({ name: "b", bytes: 500 })).toBe(false);
-            expect(yield* journal.Size("b")).toBe(400);
-            expect(yield* journal.PutCaught({ name: "b", bytes: 100 })).toBe(true);
-            expect(yield* journal.Size("b")).toBe(100);
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ blobs: { files: 2 } });
-        })),
-    },
-    {
-        name: "refuses a new blob entry past policy.maxBlobEntries and frees one on delete",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const journal = yield* Journal.get("entries");
-            yield* journal.Put({ name: "a", bytes: 0 });
-            yield* journal.Put({ name: "b", bytes: 0 });
-            yield* journal.Grow({ name: "c", bytes: 0 });
-            expect(defect(yield* journal.Put({ name: "d", bytes: 0 }).pipe(Effect.exit))).toContain("One actor's blobs hold at most 3 entries (policy.maxBlobEntries)");
-            expect(defect(yield* journal.Grow({ name: "d", bytes: 1 }).pipe(Effect.exit))).toContain("policy.maxBlobEntries");
-            expect(yield* journal.PutCaught({ name: "d", bytes: 1 })).toBe(false);
-            expect(yield* journal.Size("d")).toBe(-1);
-            yield* journal.Put({ name: "a", bytes: 10 });
-            yield* journal.Grow({ name: "b", bytes: 5 });
-            yield* journal.Grow({ name: "b", bytes: 5 });
-            expect([yield* journal.Size("a"), yield* journal.Size("b")]).toEqual([10, 10]);
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ blobs: { files: 3 } });
-            yield* journal.Drop("b");
-            yield* journal.Drop("missing");
-            expect(yield* journal.Size("b")).toBe(-1);
-            yield* journal.Put({ name: "d", bytes: 4 });
-            expect(yield* journal.Size("d")).toBe(4);
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ blobs: { files: 3 } });
-        })),
-    },
-    {
-        name: "rejects a retry admitted before expiry when cleanup pruned the receipt before its turn",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 20_000,
-        run: ({ expect, environment, fixture }) => isolated(environment, Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const journal = yield* Journal.get("race");
-            const before = fixture.adds;
-            const now = yield* databaseTime;
-            const id = `v1.${now - 58_500}.${now + 1_500}.0c2f3a55-5b8e-4d53-9a51-1f7b3d9f0c11`;
-            const committing = yield* test.pauseNext("beforeCommit");
-            const first = yield* journal.Add(1).pipe(Actor.commandId(id), Effect.forkChild);
-            yield* committing.reached;
-            const delivering = yield* test.pauseNext("beforeDelivery");
-            const retry = yield* journal
-                .Add(1)
-                .pipe(Actor.commandId(id), Effect.flip, Effect.forkChild);
-            yield* delivering.reached;
-            yield* committing.release;
-            expect(yield* Fiber.join(first)).toBe(1);
-            yield* test.advance("3 days");
-            yield* test.cleanup;
-            expect(yield* test.inspect(journal.ref)).toMatchObject({ receipts: 0 });
-            yield* delivering.release;
-            const failure = yield* Fiber.join(retry);
-            expect(Schema.is(ActorError)(failure) && failure.reason).toBeInstanceOf(CommandExpired);
-            expect(fixture.adds - before).toBe(1);
-            expect(yield* journal.Total()).toBe(1);
-        })),
-    },
-    {
-        name: "cancels a query read past commandTimeout on the server",
-        requiresIndependentConnections: true,
-        timeoutMs: 20_000,
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const journal = yield* Journal.get("slow-read");
-            yield* journal.Add(1);
-            const connect = environment.connect;
-            const locker = yield* connect;
-            yield* locker.query("BEGIN");
-            yield* locker.query("LOCK TABLE actor_state IN ACCESS EXCLUSIVE MODE");
-            const started = yield* Clock.currentTimeMillis;
-            const failure = yield* journal.Total().pipe(Effect.flip);
-            expect(failure.reason).toBeInstanceOf(Timeout);
-            expect((yield* Clock.currentTimeMillis) - started < 10_000).toBe(true);
-            const waiting = yield* locker.query(`SELECT count(*)::int AS waiting FROM pg_stat_activity
-             WHERE datname = current_database() AND wait_event_type = 'Lock' AND pid <> pg_backend_pid()`);
-            expect(waiting).toEqual([{ waiting: 0 }]);
-            yield* locker.query("ROLLBACK");
-            expect(yield* journal.Total()).toBe(1);
-        })),
-    },
-];
-/** Retention actors. */
-export const retentionSuite = {
-    fixture: retentionFixture,
-    layer: retentionLayer,
-};

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

@@ -1,24 +0,0 @@
-import { PGlite } from "@electric-sql/pglite";
-import { Crypto, Effect, Redacted, Scope } from "effect";
-import type { ConformanceCase, ConformanceEnvironment } from "../conformance.ts";
-/**
- * The operator script of the row-level security guide: a tenant role the
- * runtime takes for tenant-scoped transactions, and a separate view-owner role
- * the policies bind, which the tenant role can't act as.
- */
-export declare const grants: ({ role, viewOwner, }: {
-    readonly role: string;
-    readonly viewOwner: string;
-}) => string[];
-type Target = Redacted.Redacted<string> | {
-    readonly liveClient: PGlite;
-};
-/** A fresh database for `environment`, migrated with the owned tables and a new tenant role, as row-level security cases need. */
-export declare const preparedForRowLevelSecurity: (environment: ConformanceEnvironment) => Effect.Effect<{
-    target: Target;
-    role: string;
-    viewOwner: string;
-}, never, Crypto.Crypto | Scope.Scope>;
-/** Row-level-security cases: every framework and owned table carries the tenant policy, and runners serving two tenants each see only their own rows. */
-export declare const rlsConformance: ReadonlyArray<ConformanceCase>;
-export {};