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

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

@@ -1,7 +0,0 @@
-import type { ConformanceCase } from "../conformance.ts";
-/**
- * Group commit cases: warm turns of different actors share one transaction,
- * and each keeps its own fence, receipt, failure, interruption and statement
- * outcome.
- */
-export declare const groupsConformance: ReadonlyArray<ConformanceCase>;

package/dist/testing/conformance/groups.js

@@ -1,353 +0,0 @@
-import { Cause, Clock, Crypto, Deferred, Duration, Option, Effect, Exit, Fiber, Layer, Redacted, Schedule, Schema, } from "effect";
-import { SqlClient } from "effect/sql";
-import { Actor, Actors } from "../../index.js";
-import { TurnGroupSettings } from "../../runtime/turn/group.js";
-import { ActorTest } from "../actor-test.js";
-import { transactions } from "./batches.js";
-class Refused extends Schema.TaggedError()("GroupRefused", {}) {
-}
-const Add = Actor.command("Add", { payload: Schema.Finite, success: Schema.Finite });
-const Refuse = Actor.command("Refuse", { payload: Schema.Finite, error: Refused });
-const Explode = Actor.command("Explode", { payload: Schema.Finite });
-/**
- * Warm actors without owned tables, so concurrent turns of different ones
- * share a group. A short execution timeout lets a case interrupt one member.
- */
-const Tally = Actor.make("GroupTally", {
-    key: Schema.String,
-    state: Actor.state({ count: Schema.Finite.pipe(Schema.withDecodingDefault(Effect.succeed(0))) }),
-    api: { Add, Refuse, Explode },
-    policy: { executionTimeout: "2 seconds" },
-});
-/** Handler runs per actor id. */
-const runs = new Map();
-const ran = Effect.gen(function* () {
-    const turn = yield* Tally.Turn;
-    runs.set(turn.id, (runs.get(turn.id) ?? 0) + 1);
-    return turn;
-});
-const tallyLive = Tally.toLayer(Effect.succeed({
-    Add: Effect.fnUntraced(function* (amount) {
-        const turn = yield* ran;
-        yield* turn.state.set({ count: turn.state.count + amount });
-        return turn.state.count;
-    }),
-    Refuse: Effect.fnUntraced(function* (amount) {
-        const turn = yield* ran;
-        yield* turn.state.set({ count: turn.state.count + amount });
-        return yield* Refused.make({});
-    }),
-    Explode: Effect.fnUntraced(function* (amount) {
-        const turn = yield* ran;
-        yield* turn.state.set({ count: turn.state.count + amount });
-        return yield* Effect.die(new Error("Group member defect"));
-    }),
-}));
-/** Runs `body` on a runner over a fresh database whose closed groups wait `wait` for members. */
-const withGroups = (environment, wait, body) => environment.run(Effect.service(Crypto.Crypto)).then((crypto) => Effect.runPromise(Effect.gen(function* () {
-    yield* Effect.acquireRelease(environment.stop, () => environment.restart);
-    const database = yield* environment.freshDatabase;
-    if (!Redacted.isRedacted(database))
-        return yield* Effect.die(new Error("The group cases need a Postgres database"));
-    const context = yield* Layer.build(tallyLive.pipe(Layer.provideMerge(ActorTest.layer({ database })), Layer.provide(Layer.succeed(TurnGroupSettings, { wait: Duration.fromInputUnsafe(wait) }))));
-    return yield* body.pipe(Effect.provideContext(context));
-}).pipe(Effect.scoped, Effect.provideService(Crypto.Crypto, crypto))));
-/**
- * Warms each actor with one `Add(1)`, then sends every call at once and holds
- * each turn before its handler until all of them reached it, so they joined
- * one group before any member handed over its writes.
- */
-const together = Effect.fnUntraced(function* (calls) {
-    const test = yield* ActorTest;
-    for (const { id } of calls) {
-        const warm = yield* (yield* Tally.get(id)).Add(1);
-        if (warm !== 1)
-            return yield* Effect.die(new Error(`Warming ${id} returned ${warm}`));
-    }
-    const pauses = yield* Effect.forEach(calls, ({ commandId }) => test.pauseNext("beforeHandler", { commandId }));
-    const fibers = yield* Effect.forEach(calls, ({ id, commandId, call }) => Effect.flatMap(Tally.get(id), (tally) => Effect.forkChild(call(tally).pipe(Actor.commandId(commandId), Effect.exit))));
-    yield* Effect.forEach(pauses, ({ reached }) => reached, { concurrency: "unbounded" });
-    return { fibers, release: Effect.forEach(pauses, ({ release }) => release, { discard: true }) };
-});
-const mintAll = Effect.fnUntraced(function* (count) {
-    const actors = yield* Actors;
-    return yield* Effect.forEach(Array.from({ length: count }), () => actors.mintCommandId);
-});
-/** The transaction that committed `commandId` on actor `id`, if it committed. */
-const committedIn = Effect.fnUntraced(function* (id, commandId) {
-    return (yield* transactions((yield* Tally.get(id)).ref)).get(commandId);
-});
-/**
- * Waits until a turn waits for a generation row lock, which only a group
- * still holding a departed member's fenced read can hold here.
- */
-const lockWaiter = Effect.gen(function* () {
-    const sql = yield* SqlClient.SqlClient;
-    const [row] = yield* sql `SELECT count(*)::int AS waiting
-    FROM pg_stat_activity WHERE wait_event_type = 'Lock' AND datname = current_database()`;
-    if (row.waiting === 0)
-        return yield* Effect.fail("no lock waiter yet");
-}).pipe(Effect.retry(Schedule.spaced("20 millis")), Effect.orDie);
-const stateOf = Effect.fnUntraced(function* (id) {
-    const test = yield* ActorTest;
-    return (yield* test.inspect((yield* Tally.get(id)).ref)).state;
-});
-/**
- * Group commit cases: warm turns of different actors share one transaction,
- * and each keeps its own fence, receipt, failure, interruption and statement
- * outcome.
- */
-export const groupsConformance = [
-    {
-        name: "group commit: concurrent warm turns commit in one transaction; a declared failure keeps only its receipt and a defect leaves only itself out",
-        requiresIndependentConnections: true,
-        requiresFreshDatabase: true,
-        timeoutMs: 60_000,
-        run: ({ expect, environment }) => withGroups(environment, "10 seconds", Effect.gen(function* () {
-            const [a, b, refused, exploded, e] = yield* mintAll(5);
-            const ids = ["one", "two", "refused", "exploded", "five"].map((id) => `group-${id}`);
-            const { fibers, release } = yield* together([
-                { id: ids[0], commandId: a, call: (tally) => tally.Add(10) },
-                { id: ids[1], commandId: b, call: (tally) => tally.Add(20) },
-                { id: ids[2], commandId: refused, call: (tally) => tally.Refuse(30) },
-                { id: ids[3], commandId: exploded, call: (tally) => tally.Explode(40) },
-                { id: ids[4], commandId: e, call: (tally) => tally.Add(50) },
-            ]);
-            runs.clear();
-            yield* release;
-            const [one, two, refusal, defect, five] = yield* Effect.forEach(fibers, Fiber.join);
-            expect([one, two, five]).toEqual([Exit.succeed(11), Exit.succeed(21), Exit.succeed(51)]);
-            expect(Exit.isFailure(refusal) && Cause.squash(refusal.cause)).toBeInstanceOf(Refused);
-            expect(Exit.isFailure(defect) && Cause.hasDies(defect.cause)).toBe(true);
-            const shared = yield* committedIn(ids[0], a);
-            expect(shared).not.toBe(undefined);
-            expect(yield* committedIn(ids[1], b)).toBe(shared);
-            expect(yield* committedIn(ids[2], refused)).toBe(shared);
-            expect(yield* committedIn(ids[4], e)).toBe(shared);
-            expect(yield* committedIn(ids[3], exploded)).toBe(undefined);
-            expect(yield* stateOf(ids[2])).toEqual({ count: 1 });
-            expect(yield* stateOf(ids[3])).toEqual({ count: 1 });
-            expect(ids.map((id) => runs.get(id))).toEqual([1, 1, 1, 1, 1]);
-        })),
-    },
-    {
-        name: "group commit: a member fenced by a newer generation leaves its group before its handler runs, runs again alone, and its neighbours commit together",
-        requiresIndependentConnections: true,
-        requiresFreshDatabase: true,
-        timeoutMs: 60_000,
-        run: ({ expect, environment }) => withGroups(environment, "10 seconds", Effect.gen(function* () {
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            const [a, fenced, c] = yield* mintAll(3);
-            const ids = ["group-left", "group-fenced", "group-right"];
-            for (const id of ids)
-                expect(yield* (yield* Tally.get(id)).Add(1)).toBe(1);
-            yield* sql `UPDATE actor_generations SET generation = generation + 1
-            WHERE actor_type = 'GroupTally' AND actor_id = ${ids[1]}`;
-            const pauses = yield* Effect.forEach([a, c], (commandId) => test.pauseNext("beforeHandler", { commandId }));
-            runs.clear();
-            const fibers = yield* Effect.forEach([
-                [ids[0], a],
-                [ids[1], fenced],
-                [ids[2], c],
-            ], ([id, commandId]) => Effect.flatMap(Tally.get(id), (tally) => Effect.forkChild(tally.Add(1).pipe(Actor.commandId(commandId)))));
-            yield* Effect.forEach(pauses, ({ reached }) => reached, { concurrency: "unbounded" });
-            yield* lockWaiter;
-            expect(runs.size).toBe(0);
-            yield* Effect.forEach(pauses, ({ release }) => release, { discard: true });
-            expect(yield* Effect.forEach(fibers, Fiber.join)).toEqual([2, 2, 2]);
-            const shared = yield* committedIn(ids[0], a);
-            expect(yield* committedIn(ids[2], c)).toBe(shared);
-            expect(yield* committedIn(ids[1], fenced)).not.toBe(shared);
-            expect(ids.map((id) => runs.get(id))).toEqual([1, 1, 1]);
-            expect(yield* test.receiptsFor((yield* Tally.get(ids[1])).ref, "Add")).toBe(2);
-        })),
-    },
-    {
-        name: "group commit: a member interrupted after handing over its writes is withdrawn, and the group commits its neighbour",
-        requiresIndependentConnections: true,
-        requiresFreshDatabase: true,
-        timeoutMs: 60_000,
-        run: ({ expect, environment }) => withGroups(environment, "30 seconds", Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const [early, late] = yield* mintAll(2);
-            const ids = ["group-early", "group-late"];
-            for (const id of ids)
-                expect(yield* (yield* Tally.get(id)).Add(1)).toBe(1);
-            const lateHeld = yield* test.pauseNext("beforeHandler", { commandId: late });
-            const earlyHeld = yield* test.pauseNext("beforeHandler", { commandId: early });
-            runs.clear();
-            const earlyCall = yield* Effect.forkChild((yield* Tally.get(ids[0])).Add(10).pipe(Actor.commandId(early)));
-            yield* earlyHeld.reached;
-            yield* Effect.sleep("1 second");
-            const lateCall = yield* Effect.forkChild((yield* Tally.get(ids[1])).Add(20).pipe(Actor.commandId(late)));
-            yield* lateHeld.reached;
-            yield* earlyHeld.release;
-            yield* lockWaiter;
-            expect(runs.get(ids[0])).toBe(1);
-            expect(yield* committedIn(ids[0], early)).toBe(undefined);
-            expect(yield* stateOf(ids[0])).toEqual({ count: 1 });
-            yield* lateHeld.release;
-            expect(yield* Fiber.join(lateCall)).toBe(21);
-            expect(yield* Fiber.join(earlyCall)).toBe(11);
-            expect(runs.get(ids[0])).toBe(2);
-            expect(runs.get(ids[1])).toBe(1);
-            expect(yield* committedIn(ids[0], early)).not.toBe(yield* committedIn(ids[1], late));
-            expect(yield* stateOf(ids[0])).toEqual({ count: 11 });
-        })),
-    },
-    {
-        name: "group commit: a member still running when the group's wait ends is evicted, runs again alone, and commits once",
-        requiresIndependentConnections: true,
-        requiresFreshDatabase: true,
-        timeoutMs: 60_000,
-        run: ({ expect, environment }) => withGroups(environment, "50 millis", Effect.gen(function* () {
-            const test = yield* ActorTest;
-            const [quick, slow] = yield* mintAll(2);
-            const ids = ["group-quick", "group-slow"];
-            const { fibers, release } = yield* together([
-                { id: ids[0], commandId: quick, call: (tally) => tally.Add(10) },
-                { id: ids[1], commandId: slow, call: (tally) => tally.Add(20) },
-            ]);
-            const slowHeld = yield* test.pauseNext("beforeCommit", { commandId: slow });
-            runs.clear();
-            yield* release;
-            yield* slowHeld.reached;
-            expect(yield* Fiber.join(fibers[0])).toEqual(Exit.succeed(11));
-            expect(yield* committedIn(ids[1], slow)).toBe(undefined);
-            yield* Effect.sleep("200 millis");
-            yield* slowHeld.release;
-            expect(yield* Fiber.join(fibers[1])).toEqual(Exit.succeed(21));
-            expect(runs.get(ids[0])).toBe(1);
-            expect(runs.get(ids[1])).toBe(2);
-            expect(yield* committedIn(ids[1], slow)).not.toBe(yield* committedIn(ids[0], quick));
-            expect(yield* test.receiptsFor((yield* Tally.get(ids[1])).ref, "Add")).toBe(2);
-            expect(yield* stateOf(ids[1])).toEqual({ count: 21 });
-        })),
-    },
-    {
-        name: "group commit: a statement error in one member's writes rolls the group back; that member fails and its neighbours commit alone, once each",
-        requiresIndependentConnections: true,
-        requiresFreshDatabase: true,
-        timeoutMs: 60_000,
-        run: ({ expect, environment }) => withGroups(environment, "10 seconds", Effect.gen(function* () {
-            const sql = yield* SqlClient.SqlClient;
-            const [poisoned, b, c] = yield* mintAll(3);
-            const ids = ["group-poisoned", "group-b", "group-c"];
-            yield* sql.unsafe(`CREATE FUNCTION group_poison() RETURNS trigger LANGUAGE plpgsql AS $$
-            BEGIN
-              IF NEW.command_id = '${poisoned}' THEN RAISE EXCEPTION 'poisoned receipt'; END IF;
-              RETURN NEW;
-            END $$`);
-            yield* sql.unsafe(`CREATE TRIGGER group_poison BEFORE INSERT ON actor_receipts
-            FOR EACH ROW EXECUTE FUNCTION group_poison()`);
-            const { fibers, release } = yield* together([
-                { id: ids[0], commandId: poisoned, call: (tally) => tally.Add(10) },
-                { id: ids[1], commandId: b, call: (tally) => tally.Add(20) },
-                { id: ids[2], commandId: c, call: (tally) => tally.Add(30) },
-            ]);
-            runs.clear();
-            yield* release;
-            const [failed, second, third] = yield* Effect.forEach(fibers, Fiber.join);
-            expect(Exit.isFailure(failed) && Cause.hasDies(failed.cause)).toBe(true);
-            expect([second, third]).toEqual([Exit.succeed(21), Exit.succeed(31)]);
-            expect(runs.get(ids[1])).toBe(2);
-            expect(runs.get(ids[2])).toBe(2);
-            expect(yield* committedIn(ids[0], poisoned)).toBe(undefined);
-            expect(yield* committedIn(ids[1], b)).not.toBe(yield* committedIn(ids[2], c));
-            expect(yield* stateOf(ids[0])).toEqual({ count: 1 });
-            expect(yield* stateOf(ids[1])).toEqual({ count: 21 });
-        })),
-    },
-    {
-        name: "group commit: a member whose next batch rides behind the COMMIT, interrupted while that COMMIT runs, never gets the session back with its chained transaction open",
-        requiresIndependentConnections: true,
-        requiresFreshDatabase: true,
-        timeoutMs: 60_000,
-        run: ({ expect, environment }) => withGroups(environment, "30 seconds", Effect.gen(function* () {
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            const [a1, a2, b1] = yield* mintAll(3);
-            const ids = ["group-handoff", "group-neighbour"];
-            for (const id of ids)
-                expect(yield* (yield* Tally.get(id)).Add(1)).toBe(1);
-            yield* sql.unsafe(`CREATE FUNCTION group_slow_commit() RETURNS trigger LANGUAGE plpgsql AS $$
-            BEGIN PERFORM pg_sleep(1.4); RETURN NULL; END $$`);
-            yield* sql.unsafe(`CREATE CONSTRAINT TRIGGER group_slow_commit AFTER INSERT ON actor_receipts
-            DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN (NEW.command_id = '${a1}')
-            EXECUTE FUNCTION group_slow_commit()`);
-            const a1Held = yield* test.pauseNext("beforeHandler", { commandId: a1 });
-            const b1Held = yield* test.pauseNext("beforeHandler", { commandId: b1 });
-            const handoff = yield* Tally.get(ids[0]);
-            const first = yield* Effect.forkChild(handoff.Add(10).pipe(Actor.commandId(a1), Effect.exit));
-            yield* a1Held.reached;
-            const second = yield* Effect.forkChild(handoff.Add(100).pipe(Actor.commandId(a2), Effect.exit));
-            yield* Effect.sleep("900 millis");
-            const neighbour = yield* Effect.forkChild((yield* Tally.get(ids[1])).Add(20).pipe(Actor.commandId(b1), Effect.exit));
-            yield* b1Held.reached;
-            yield* a1Held.release;
-            yield* b1Held.release;
-            expect(yield* Fiber.join(neighbour)).toEqual(Exit.succeed(21));
-            const seen = [];
-            const deadline = (yield* Clock.currentTimeMillis) + 4_000;
-            while ((yield* Clock.currentTimeMillis) < deadline) {
-                const rows = yield* sql `
-              SELECT pid, state, wait_event_type AS waiting FROM pg_stat_activity
-              WHERE datname = current_database() AND pid <> pg_backend_pid()
-                AND clock_timestamp() - state_change > interval '300 milliseconds'
-                AND (state = 'idle in transaction' OR wait_event_type = 'Lock')`;
-                for (const row of rows)
-                    seen.push(`${row.pid}:${row.state}:${row.waiting}`);
-                yield* Effect.sleep("25 millis");
-            }
-            expect([...new Set(seen)]).toEqual([]);
-            expect(yield* Fiber.join(first)).toEqual(Exit.succeed(11));
-            expect(yield* Fiber.join(second)).toEqual(Exit.succeed(111));
-            expect(yield* stateOf(ids[0])).toEqual({ count: 111 });
-            expect(yield* test.receiptsFor(handoff.ref, "Add")).toBe(3);
-        })),
-    },
-    {
-        name: "group commit: a member whose generation row another transaction holds is skipped, and its neighbours commit together without waiting for that lock",
-        requiresIndependentConnections: true,
-        requiresFreshDatabase: true,
-        timeoutMs: 60_000,
-        run: ({ expect, environment }) => withGroups(environment, "10 seconds", Effect.gen(function* () {
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            const [l, x, y] = yield* mintAll(3);
-            const ids = ["group-locked", "group-x", "group-y"];
-            for (const id of ids)
-                expect(yield* (yield* Tally.get(id)).Add(1)).toBe(1);
-            const locked = Deferred.makeUnsafe();
-            const unlock = Deferred.makeUnsafe();
-            const holder = yield* Effect.forkChild(sql.withTransaction(Effect.gen(function* () {
-                yield* sql `SELECT 1 FROM actor_generations
-                  WHERE actor_type = 'GroupTally' AND actor_id = ${ids[0]} FOR UPDATE`;
-                yield* Deferred.succeed(locked, undefined);
-                yield* Deferred.await(unlock);
-            })));
-            yield* Deferred.await(locked);
-            const pauses = yield* Effect.forEach([x, y], (commandId) => test.pauseNext("beforeHandler", { commandId }));
-            runs.clear();
-            const lockedCall = yield* Effect.forkChild((yield* Tally.get(ids[0])).Add(5).pipe(Actor.commandId(l), Effect.exit));
-            yield* Effect.sleep("20 millis");
-            const others = yield* Effect.forEach([
-                [ids[1], x],
-                [ids[2], y],
-            ], ([id, commandId]) => Effect.flatMap(Tally.get(id), (tally) => Effect.forkChild(tally.Add(5).pipe(Actor.commandId(commandId), Effect.exit))));
-            const reached = yield* Effect.forEach(pauses, ({ reached }) => reached, {
-                concurrency: "unbounded",
-            }).pipe(Effect.timeoutOption("1500 millis"));
-            expect(reached._tag).toBe("Some");
-            yield* Effect.forEach(pauses, ({ release }) => release, { discard: true });
-            const answered = yield* Effect.forEach(others, Fiber.join).pipe(Effect.timeoutOption("1500 millis"));
-            expect(answered).toEqual(Option.some([Exit.succeed(6), Exit.succeed(6)]));
-            expect(yield* committedIn(ids[1], x)).toBe(yield* committedIn(ids[2], y));
-            yield* Deferred.succeed(unlock, undefined);
-            yield* Fiber.join(holder);
-            expect(yield* Fiber.join(lockedCall)).toEqual(Exit.succeed(6));
-            expect(yield* committedIn(ids[0], l)).not.toBe(yield* committedIn(ids[1], x));
-        })),
-    },
-];

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

@@ -1,3 +0,0 @@
-import type { ConformanceCase } from "../conformance.ts";
-/** Heap cases: bounded retained heap once activations hibernate and once Cluster forgets processed request ids. */
-export declare const heapConformance: ReadonlyArray<ConformanceCase>;

package/dist/testing/conformance/heap.js

@@ -1,149 +0,0 @@
-import { Crypto, Effect, Layer, ManagedRuntime, Schedule, Schema } from "effect";
-import { Actor, Actors } from "../../index.js";
-import { ActorTest } from "../actor-test.js";
-import { onBun } from "./platform.js";
-const Touch = Actor.command("Touch", { success: Schema.Finite });
-const Sleeper = Actor.make("HeapSleeper", {
-    key: Schema.String,
-    state: Actor.state({ count: Schema.Finite.pipe(Schema.withDecodingDefault(Effect.succeed(0))) }),
-    api: { Touch },
-    policy: { hibernateAfter: "250 millis" },
-});
-const SleeperLive = Sleeper.toLayer(Effect.succeed({
-    Touch: Effect.fnUntraced(function* () {
-        const turn = yield* Sleeper.Turn;
-        yield* turn.state.set({ count: turn.state.count + 1 });
-        return turn.state.count;
-    }),
-}));
-const ACTORS = 1000;
-const COMMANDS = 4_096;
-const HOT_ACTORS = 32;
-let cachedGc;
-/**
- * Node's collector, made reachable once: building its vm realm allocates, so
- * doing that for each sample would charge the realm to the heap it measures.
- */
-const nodeGc = Effect.gen(function* () {
-    if (cachedGc !== undefined)
-        return cachedGc;
-    const v8 = yield* Effect.promise(() => import("node:v8"));
-    const vm = yield* Effect.promise(() => import("node:vm"));
-    v8.setFlagsFromString("--expose-gc");
-    cachedGc = vm.runInNewContext("gc");
-    return cachedGc;
-});
-/**
- * Live JavaScript heap after a full collection. ArrayBuffer memory is left
- * out: an in-process database keeps its pages there, and they grow with
- * stored rows rather than with anything the runtime retains. Bun counts every
- * live cell; V8 counts the objects that inherit `Object.prototype`, which is
- * every object but a null-prototype one, so the two counts differ in scale
- * but each rises with each object the runtime retains. The count is taken
- * before the byte size so counting is not charged to the sample. `bun:jsc` and `node:v8`
- * are loaded only when the case runs, so importing the testing entry needs
- * neither runtime's helpers.
- */
-const retained = Effect.gen(function* () {
-    if (!onBun) {
-        const v8 = yield* Effect.promise(() => import("node:v8"));
-        const gc = yield* nodeGc;
-        gc({ type: "major" });
-        gc({ type: "major" });
-        const objects = v8.queryObjects(Object, { format: "count" });
-        return { bytes: v8.getHeapStatistics().used_heap_size, objects };
-    }
-    const { heapStats } = yield* Effect.promise(() => import("bun:jsc"));
-    Bun.gc(true);
-    const stats = heapStats();
-    return { bytes: stats.heapSize - stats.extraMemorySize, objects: stats.objectCount };
-});
-/**
- * Samples the heap once a second until two samples agree to within one object
- * per actor, or 60 seconds pass. Cluster's reaper sweeps every 5 seconds and
- * releases a whole sweep's activations at once, so a settled heap means the
- * sweeps have run.
- */
-const settled = Effect.gen(function* () {
-    let previous = yield* retained;
-    return yield* Effect.gen(function* () {
-        const next = yield* retained;
-        const done = Math.abs(previous.objects - next.objects) < ACTORS;
-        previous = next;
-        return done ? next : yield* Effect.fail("unsettled");
-    }).pipe(Effect.delay("1 second"), Effect.retry({ schedule: Schedule.recurs(60) }), Effect.orElseSucceed(() => previous));
-});
-const perActor = (before, after) => ({
-    objects: (after.objects - before.objects) / ACTORS,
-    bytes: (after.bytes - before.bytes) / ACTORS,
-});
-/** Heap cases: bounded retained heap once activations hibernate and once Cluster forgets processed request ids. */
-export const heapConformance = [
-    {
-        name: "retains bounded heap for touched actors once every activation hibernates",
-        timeoutMs: 120_000,
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const database = yield* environment.freshDatabase;
-            const runtime = yield* Effect.acquireRelease(Effect.map(Crypto.Crypto, (crypto) => ManagedRuntime.make(SleeperLive.pipe(Layer.provideMerge(ActorTest.layer({ database })), Layer.provide(Layer.succeed(Crypto.Crypto, crypto)), Layer.orDie))), (runtime) => Effect.promise(() => runtime.dispose()));
-            const touch = (id) => Sleeper.get(id).pipe(Effect.flatMap((sleeper) => sleeper.Touch()));
-            const touchAll = (prefix) => Effect.forEach(Array.from({ length: ACTORS }, (_, index) => `${prefix}-${index}`), touch, { concurrency: 32, discard: true });
-            const hibernate = Effect.andThen(Effect.sleep("6 seconds"), settled);
-            const { growth, generations } = yield* Effect.promise(() => runtime.runPromise(Effect.gen(function* () {
-                yield* touchAll("warm");
-                const before = yield* hibernate;
-                yield* touchAll("actor");
-                const growth = perActor(before, yield* hibernate);
-                const test = yield* ActorTest;
-                const generations = yield* Effect.forEach([0, 250, 500, 750, 999], (index) => Effect.gen(function* () {
-                    const sample = yield* Sleeper.get(`actor-${index}`);
-                    yield* sample.Touch();
-                    return (yield* test.inspect(sample.ref)).generation;
-                }));
-                return { growth, generations };
-            })));
-            expect(generations).toEqual(["2", "2", "2", "2", "2"]);
-            expect({ ...growth, bounded: growth.objects < 10 && growth.bytes < 1024 }).toMatchObject({
-                bounded: true,
-            });
-        })),
-    },
-    {
-        name: "retains bounded heap per command once Cluster forgets processed request ids",
-        requiresIndependentConnections: true,
-        timeoutMs: 120_000,
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const database = yield* environment.freshDatabase;
-            const runtime = yield* Effect.acquireRelease(Effect.map(Crypto.Crypto, (crypto) => ManagedRuntime.make(SleeperLive.pipe(Layer.provideMerge(ActorTest.layer({ database })), Layer.provide(Layer.succeed(Crypto.Crypto, crypto)), Layer.orDie))), (runtime) => Effect.promise(() => runtime.dispose()));
-            const touch = (id) => Sleeper.get(id).pipe(Effect.flatMap((sleeper) => sleeper.Touch()));
-            const touchMany = Effect.forEach(Array.from({ length: COMMANDS }, (_, index) => `hot-${index % HOT_ACTORS}`), touch, { concurrency: HOT_ACTORS, discard: true });
-            const forget = Effect.andThen(Effect.sleep("11 seconds"), retained);
-            const { growth, first, replayed, count } = yield* Effect.promise(() => runtime.runPromise(Effect.gen(function* () {
-                const id = yield* (yield* Actors).mintCommandId;
-                const saved = Sleeper.get("hot-0").pipe(Effect.flatMap((sleeper) => sleeper.Touch().pipe(Actor.commandId(id))));
-                const first = yield* saved;
-                yield* touchMany;
-                yield* forget;
-                yield* touchMany;
-                const before = yield* forget;
-                yield* touchMany;
-                const after = yield* forget;
-                const replayed = yield* saved;
-                const count = yield* touch("hot-0");
-                return {
-                    growth: {
-                        objects: (after.objects - before.objects) / COMMANDS,
-                        bytes: (after.bytes - before.bytes) / COMMANDS,
-                    },
-                    first,
-                    replayed,
-                    count,
-                };
-            })));
-            expect({ first, replayed }).toEqual({ first: 1, replayed: 1 });
-            expect(count).toBe((3 * COMMANDS) / HOT_ACTORS + 2);
-            expect({ ...growth, bounded: growth.objects < 0.5 && growth.bytes < 64 }).toMatchObject({
-                bounded: true,
-            });
-        })),
-    },
-];