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

package/dist/testing/conformance/effect-control.js

@@ -1,1059 +0,0 @@
-import { Cause, Clock, Deferred, Duration, Effect, Exit, Fiber, Layer, Schedule, Schema, } from "effect";
-import { SqlClient } from "effect/sql";
-import { Actor, Intent } from "../../index.js";
-import { TurnHooks } from "../../runtime/turn/hooks.js";
-import { wakeWaiting } from "../../runtime/jobs/attempt.js";
-import { claimCapped } from "../../runtime/turn/relay.js";
-import { ActorTest } from "../actor-test.js";
-import { ActorCluster } from "../cluster.js";
-export const effectControlFixture = () => ({
-    attempts: [],
-    provider: (attempt) => Effect.succeed(attempt.label),
-    hook: () => Effect.void,
-});
-const reset = (fixture) => Effect.sync(() => {
-    fixture.attempts.length = 0;
-    fixture.provider = (attempt) => Effect.succeed(attempt.label);
-    fixture.hook = () => Effect.void;
-});
-class ControlDown extends Schema.TaggedError()("ControlDown", {}) {
-}
-const Job = Actor.job("Job", {
-    payload: { label: Schema.String },
-    success: Schema.String,
-});
-const Capped = Actor.job("Capped", {
-    payload: { label: Schema.String },
-    success: Schema.String,
-});
-const Serial = Actor.job("Serial", {
-    payload: { label: Schema.String },
-    success: Schema.String,
-});
-const Picky = Actor.job("Picky", {
-    payload: { label: Schema.String },
-    success: Schema.String,
-});
-const EffectName = Schema.Literals(["Job", "Capped", "Serial", "Picky"]);
-const Perform = Actor.command("Perform", {
-    payload: Schema.Struct({
-        effect: EffectName,
-        labels: Schema.Array(Schema.String),
-        keyed: Schema.optional(Schema.Boolean),
-        afterMs: Schema.optional(Schema.Int),
-    }),
-});
-const CancelEffect = Actor.command("CancelEffect", { payload: Schema.Array(Schema.String) });
-const PerformThenCancel = Actor.command("PerformThenCancel", { payload: Schema.String });
-const CancelThenRefuse = Actor.command("CancelThenRefuse", {
-    payload: Schema.String,
-    error: ControlDown,
-});
-const CancelThenDie = Actor.command("CancelThenDie", { payload: Schema.String });
-const CaptureCancel = Actor.command("CaptureCancel", {});
-const UseCaptured = Actor.command("UseCaptured", { payload: Schema.String });
-const Done = Actor.command("Done", { payload: Schema.String });
-const JobCancelled = Actor.command("JobCancelled", { payload: Actor.Cancelled(Job) });
-const CappedCancelled = Actor.command("CappedCancelled", { payload: Actor.Cancelled(Capped) });
-const SerialFailed = Actor.command("SerialFailed", { payload: Actor.DeadLetter(Serial) });
-const PickyDone = Actor.command("PickyDone", {
-    payload: Schema.String.check(Schema.isPattern(/^accepted$/u)),
-});
-const PickyCancelled = Actor.command("PickyCancelled", { payload: Actor.Cancelled(Picky) });
-const Report = Schema.Struct({
-    label: Schema.String,
-    effectId: Schema.String,
-    outcome: Schema.String,
-    ambiguous: Schema.Boolean,
-    value: Schema.optional(Schema.String),
-    cause: Schema.optional(Schema.String),
-});
-const Controlled = Actor.make("Controlled", {
-    key: Schema.String,
-    state: Actor.state({
-        done: Schema.Array(Schema.String).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
-        cancelled: Schema.Array(Report).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
-        letters: Schema.Array(Report).pipe(Schema.withDecodingDefault(Effect.succeed([]))),
-    }),
-    jobs: {
-        Job: {
-            job: Job,
-            retry: { times: 2, backoff: { base: "1 second", max: "1 second" } },
-            onSuccess: Done,
-            onCancelled: JobCancelled,
-        },
-        Capped: {
-            job: Capped,
-            retry: { times: 1, backoff: { base: "1 second", max: "1 second" } },
-            concurrency: { perActor: 2 },
-            onSuccess: Done,
-            onCancelled: CappedCancelled,
-        },
-        Serial: {
-            job: Serial,
-            retry: { times: 1, backoff: { base: "1 second", max: "1 second" } },
-            concurrency: { perActor: 1 },
-            onSuccess: Done,
-            onDeadLetter: SerialFailed,
-        },
-        Picky: { job: Picky, retry: { times: 0 }, onSuccess: PickyDone, onCancelled: PickyCancelled },
-    },
-    api: {
-        Perform,
-        CancelEffect,
-        PerformThenCancel,
-        CancelThenRefuse,
-        CancelThenDie,
-        CaptureCancel,
-        UseCaptured,
-    },
-    internal: { Done, JobCancelled, CappedCancelled, SerialFailed, PickyDone, PickyCancelled },
-});
-const reportCancelled = (cancelled) => Effect.gen(function* () {
-    const turn = yield* Controlled.Turn;
-    const { outcome } = cancelled;
-    yield* turn.state.set({
-        cancelled: [
-            ...turn.state.cancelled,
-            {
-                label: cancelled.job.label,
-                effectId: cancelled.jobId,
-                outcome: outcome._tag,
-                ambiguous: cancelled.ambiguous,
-                ...("value" in outcome ? { value: String(outcome.value) } : { cause: outcome.cause }),
-            },
-        ],
-    });
-});
-let captured;
-/** The effect-control actors' command layers, which every runner builds. */
-export const effectControlLayer = Controlled.toLayer(Effect.succeed({
-    Perform: Effect.fnUntraced(function* ({ effect, labels, keyed, afterMs }) {
-        const turn = yield* Controlled.Turn;
-        for (const label of labels) {
-            const instance = { Job, Capped, Serial, Picky }[effect].make({ label });
-            const options = {};
-            if (keyed === true)
-                options.key = label;
-            if (afterMs !== undefined)
-                options.after = Duration.millis(afterMs);
-            yield* turn.enqueue(instance, options);
-        }
-    }),
-    CancelEffect: Effect.fnUntraced(function* (keys) {
-        const turn = yield* Controlled.Turn;
-        for (const key of keys)
-            yield* turn.cancelJob(key);
-    }),
-    PerformThenCancel: Effect.fnUntraced(function* (label) {
-        const turn = yield* Controlled.Turn;
-        yield* turn.enqueue(Job.make({ label }), { key: label });
-        yield* turn.cancelJob(label);
-    }),
-    CancelThenRefuse: Effect.fnUntraced(function* (key) {
-        yield* (yield* Controlled.Turn).cancelJob(key);
-        return yield* ControlDown.make({});
-    }),
-    CancelThenDie: Effect.fnUntraced(function* (key) {
-        yield* (yield* Controlled.Turn).cancelJob(key);
-        return yield* Effect.die(new Error("Canceller defect"));
-    }),
-    CaptureCancel: Effect.fnUntraced(function* () {
-        captured = (yield* Controlled.Turn).cancelJob;
-    }),
-    UseCaptured: Effect.fnUntraced(function* (key) {
-        if (captured !== undefined)
-            yield* captured(key);
-    }),
-    Done: Effect.fnUntraced(function* (value) {
-        const turn = yield* Controlled.Turn;
-        yield* turn.state.set({ done: [...turn.state.done, value] });
-    }),
-    JobCancelled: reportCancelled,
-    CappedCancelled: (cancelled) => reportCancelled(cancelled),
-    PickyDone: Effect.fnUntraced(function* (value) {
-        const turn = yield* Controlled.Turn;
-        yield* turn.state.set({ done: [...turn.state.done, value] });
-    }),
-    PickyCancelled: (cancelled) => reportCancelled(cancelled),
-    SerialFailed: Effect.fnUntraced(function* (letter) {
-        const turn = yield* Controlled.Turn;
-        yield* turn.state.set({
-            letters: [
-                ...turn.state.letters,
-                {
-                    label: letter.job.label,
-                    effectId: letter.jobId,
-                    outcome: "DeadLetter",
-                    ambiguous: letter.ambiguous,
-                    cause: letter.cause,
-                },
-            ],
-        });
-    }),
-}));
-/** The executors of `runner`. */
-const runnerEffects = (fixture, runner) => {
-    const execute = (effect, label) => Effect.gen(function* () {
-        const exec = yield* Controlled.Executor;
-        const attempt = {
-            label,
-            actor: exec.ref.id,
-            effect,
-            jobId: exec.jobId,
-            attempt: exec.attempt,
-            runner,
-            startedAt: yield* Clock.currentTimeMillis,
-            endedAt: undefined,
-            interrupted: false,
-        };
-        fixture.attempts.push(attempt);
-        return yield* Effect.suspend(() => fixture.provider(attempt)).pipe(Effect.onExit((exit) => Effect.map(Clock.currentTimeMillis, (now) => {
-            attempt.endedAt = now;
-            attempt.interrupted = Exit.hasInterrupts(exit);
-        })));
-    });
-    return Controlled.toJobLayer(Effect.succeed({
-        Job: ({ label }) => execute("Job", label),
-        Capped: ({ label }) => execute("Capped", label),
-        Serial: ({ label }) => execute("Serial", label),
-        Picky: ({ label }) => execute("Picky", label),
-    }));
-};
-/** The executors of the conformance environment's single runtime. */
-export const effectControlEffects = (fixture) => runnerEffects(fixture, 0);
-/** A poll far longer than any case, so only wakes after commit and `advance` claim rows. */
-const NO_POLL = { poll: "1 hour" };
-const SHORT_LEASE = { lease: "3 seconds" };
-/** Builds a fresh database and `runners` runners on it for one case. */
-const withCluster = (environment, fixture, runners, settings, body) => environment.run(Effect.gen(function* () {
-    yield* reset(fixture);
-    const database = yield* environment.freshDatabase;
-    const context = yield* Layer.build(ActorTest.cluster({
-        database,
-        runners,
-        shardLockExpiration: "3 seconds",
-        actors: effectControlLayer,
-        runnerActors: (runner) => runnerEffects(fixture, runner),
-        relay: settings.relay,
-        executors: settings.executors,
-    })).pipe(Effect.provideService(TurnHooks, {
-        at: (point, request) => Effect.suspend(() => fixture.hook(point, request)),
-    }));
-    return yield* body.pipe(Effect.provideContext(context));
-}));
-const on = (runner, effect) => ActorCluster.use((cluster) => cluster.on(runner)(effect));
-const perform = (id, effect, labels, options = {}) => Controlled.get(id).pipe(Effect.flatMap((actor) => actor.Perform({ effect, labels, ...options })), Effect.orDie);
-const cancel = (id, keys) => Controlled.get(id).pipe(Effect.flatMap((actor) => actor.CancelEffect(keys)), Effect.orDie);
-const stateOf = (id) => Effect.gen(function* () {
-    const actor = yield* Controlled.get(id);
-    const { state } = yield* (yield* ActorTest).inspect(actor.ref);
-    return state;
-});
-const effectRows = (sql) => sql `SELECT command, kind, attempts, running, cancelled_at_ms IS NOT NULL AS cancelled,
-      waiting, timer_key
-    FROM actor_outbox WHERE actor_type = 'Controlled' ORDER BY ready_at_ms, intent_id`;
-const deadLetters = (sql) => sql `SELECT attempts, ambiguous, cause
-    FROM actor_dead_letters WHERE actor_type = 'Controlled'`;
-/** Runs a query on `runner`'s database pool. */
-const query = (runner, statement) => on(runner, Effect.gen(function* () {
-    return yield* statement(yield* SqlClient.SqlClient);
-})).pipe(Effect.orDie);
-/** Polls `check` until it holds, dying after `timeout`. */
-const eventually = (check, timeout = "20 seconds", what = "a condition") => check.pipe(Effect.repeat({ schedule: Schedule.spaced("25 millis"), until: (held) => held }), Effect.timeoutOrElse({
-    duration: timeout,
-    orElse: () => Effect.die(new Error(`Timed out waiting for ${what}`)),
-}), Effect.asVoid);
-/**
- * Waits until no outbox row is left. The relay commits a route's turn before
- * it deletes the route's row, so a route can show in state while its row
- * still exists.
- */
-const drained = (rows) => eventually(rows.pipe(Effect.map((left) => left.length === 0)), "5 seconds", "the delivered route's outbox row to be deleted");
-const advance = (runner, duration) => on(runner, ActorTest.use((test) => test.advance(duration)));
-/** The runner that owns `ref`'s shard, and another one. */
-const ownerAndOther = (ref) => Effect.gen(function* () {
-    const cluster = yield* ActorCluster;
-    const owner = (yield* cluster.owner(ref));
-    return { owner, other: (owner + 1) % cluster.runners };
-});
-const refOf = (id) => on(0, Controlled.get(id).pipe(Effect.map((actor) => actor.ref)));
-/** The most attempts of one actor's `effect` whose runs overlapped in time. */
-const maxInFlight = (attempts, actor, effect) => {
-    const mine = attempts.filter((attempt) => attempt.actor === actor && attempt.effect === effect);
-    return Math.max(0, ...mine.map((attempt) => 1 +
-        mine.filter((other) => other !== attempt &&
-            other.startedAt <= attempt.startedAt &&
-            (other.endedAt ?? Number.POSITIVE_INFINITY) > attempt.startedAt).length));
-};
-const thrown = (build) => {
-    try {
-        build();
-        return "";
-    }
-    catch (error) {
-        return error instanceof Error ? error.message : String(error);
-    }
-};
-/** Single-runtime cases, on every backend. */
-export const effectControlConformance = [
-    {
-        name: "never runs a pending keyed effect cancelled by a later turn or in its own turn",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            yield* perform("pending", "Job", ["later"], { keyed: true, afterMs: 60_000 });
-            expect(yield* effectRows(sql)).toMatchObject([
-                { command: "Job", timer_key: "$job:later", attempts: 0 },
-            ]);
-            yield* cancel("pending", ["later", "never-performed"]);
-            const actor = yield* Controlled.get("pending");
-            yield* actor.PerformThenCancel("same-turn").pipe(Effect.orDie);
-            yield* test.advance("2 minutes");
-            expect(fixture.attempts).toEqual([]);
-            expect(yield* effectRows(sql)).toEqual([]);
-            const pending = yield* stateOf("pending");
-            expect([...(pending.done ?? []), ...(pending.cancelled ?? [])]).toEqual([]);
-        })),
-    },
-    {
-        name: "replaces a pending keyed effect performed again under its key",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const test = yield* ActorTest;
-            fixture.provider = (attempt) => Effect.succeed(`${attempt.label}@${attempt.attempt}`);
-            const actor = yield* Controlled.get("replaced");
-            yield* actor
-                .Perform({ effect: "Job", labels: ["k"], keyed: true, afterMs: 60_000 })
-                .pipe(Effect.orDie);
-            yield* actor
-                .Perform({ effect: "Job", labels: ["k"], keyed: true, afterMs: 30_000 })
-                .pipe(Effect.orDie);
-            yield* test.advance("2 minutes");
-            expect(fixture.attempts.map(({ label }) => label)).toEqual(["k"]);
-            expect((yield* stateOf("replaced")).done).toEqual(["k@1"]);
-        })),
-    },
-    {
-        name: "reports Failed when cancelled while backing off after a typed failure, and never retries",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            fixture.provider = () => Effect.fail(ControlDown.make({}));
-            yield* perform("typed", "Job", ["typed"], { keyed: true });
-            yield* eventually(Effect.sync(() => fixture.attempts[0]?.endedAt !== undefined));
-            yield* eventually(effectRows(sql).pipe(Effect.map((rows) => rows[0]?.running === false)), "5 seconds", "the failure's backoff");
-            yield* cancel("typed", ["typed"]);
-            yield* test.advance("5 seconds");
-            expect(fixture.attempts.length).toBe(1);
-            expect((yield* stateOf("typed")).cancelled).toMatchObject([
-                { label: "typed", outcome: "Failed", ambiguous: false },
-            ]);
-            expect(yield* effectRows(sql)).toEqual([]);
-        })),
-    },
-    {
-        name: "reports Unknown when cancelled while backing off after an attempt that may have applied",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            fixture.provider = () => Effect.die(new Error("provider connection reset"));
-            yield* perform("maybe", "Job", ["maybe"], { keyed: true });
-            yield* eventually(effectRows(sql).pipe(Effect.map((rows) => rows[0]?.attempts === 1 && rows[0].running === false)), "5 seconds", "the defect's backoff");
-            yield* cancel("maybe", ["maybe"]);
-            yield* test.advance("5 seconds");
-            expect(fixture.attempts.length).toBe(1);
-            expect((yield* stateOf("maybe")).cancelled).toMatchObject([
-                { label: "maybe", outcome: "Unknown", ambiguous: true },
-            ]);
-        })),
-    },
-    {
-        name: "interrupts a running attempt its own runner cancels and reports Unknown, never Failed",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            fixture.provider = () => Effect.never;
-            yield* perform("running", "Job", ["running"], { keyed: true });
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            const cancelledAt = yield* Clock.currentTimeMillis;
-            yield* cancel("running", ["running"]);
-            yield* eventually(Effect.sync(() => fixture.attempts[0]?.interrupted === true), "5 seconds", "the interruption");
-            expect(fixture.attempts[0].endedAt - cancelledAt < 5000).toBe(true);
-            yield* eventually(stateOf("running").pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)), "5 seconds", "the cancellation report");
-            yield* test.advance("5 minutes");
-            expect(fixture.attempts.length).toBe(1);
-            expect((yield* stateOf("running")).cancelled).toMatchObject([
-                { label: "running", outcome: "Unknown", ambiguous: true },
-            ]);
-            expect(yield* effectRows(sql)).toEqual([]);
-        })),
-    },
-    {
-        name: "interrupts at once an attempt its own runner cancels between its claim and its call",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            fixture.provider = () => Effect.never;
-            const paused = yield* test.pauseNext("beforeExecute");
-            yield* perform("claimed", "Job", ["claimed"], { keyed: true });
-            yield* paused.reached;
-            const cancelledAt = yield* Clock.currentTimeMillis;
-            yield* cancel("claimed", ["claimed"]);
-            yield* paused.release;
-            yield* eventually(Effect.sync(() => fixture.attempts[0]?.interrupted === true), "5 seconds", "the interruption");
-            expect(fixture.attempts[0].endedAt - cancelledAt < 5000).toBe(true);
-            yield* eventually(stateOf("claimed").pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)), "5 seconds", "the cancellation report");
-            expect(fixture.attempts.length).toBe(1);
-            expect((yield* stateOf("claimed")).cancelled).toMatchObject([
-                { label: "claimed", outcome: "Unknown", ambiguous: true },
-            ]);
-            yield* drained(effectRows(sql));
-        })),
-    },
-    {
-        name: "dead-letters an ambiguous cancellation as ambiguous and drops a failed one without onCancelled",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            fixture.provider = (attempt) => attempt.label === "hung" ? Effect.never : Effect.fail(ControlDown.make({}));
-            yield* perform("unrouted", "Serial", ["hung"], { keyed: true });
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            yield* cancel("unrouted", ["hung"]);
-            yield* eventually(stateOf("unrouted").pipe(Effect.map((state) => (state.letters ?? []).length === 1)), "5 seconds", "the dead letter");
-            expect(yield* deadLetters(sql)).toMatchObject([{ attempts: 1, ambiguous: true }]);
-            yield* perform("unrouted", "Serial", ["refused"], { keyed: true });
-            yield* eventually(effectRows(sql).pipe(Effect.map((rows) => rows[0]?.attempts === 1 && rows[0].running === false)), "5 seconds", "the typed failure's backoff");
-            yield* cancel("unrouted", ["refused"]);
-            yield* test.advance("5 seconds");
-            expect(fixture.attempts.map(({ label }) => label)).toEqual(["hung", "refused"]);
-            expect((yield* stateOf("unrouted")).letters?.length).toBe(1);
-            expect((yield* deadLetters(sql)).length).toBe(1);
-            expect(yield* effectRows(sql)).toEqual([]);
-        })),
-    },
-    {
-        name: "runs one capped attempt at a time per actor, in perform order, without holding other actors back",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            fixture.provider = (attempt) => Effect.sleep("20 millis").pipe(Effect.as(attempt.label));
-            const labels = Array.from({ length: 6 }, (_, index) => `hot-${index}`);
-            yield* perform("hot", "Serial", labels.slice(0, 3));
-            for (const label of labels.slice(3))
-                yield* perform("hot", "Serial", [label]);
-            yield* perform("cold", "Serial", ["cold-0"]);
-            yield* eventually(stateOf("hot").pipe(Effect.map((state) => (state.done ?? []).length === 6)), "20 seconds", "the hot actor's effects");
-            yield* eventually(stateOf("cold").pipe(Effect.map((state) => (state.done ?? []).length === 1)));
-            expect(maxInFlight(fixture.attempts, "hot", "Serial")).toBe(1);
-            expect(fixture.attempts.filter(({ actor }) => actor === "hot").map(({ label }) => label)).toEqual(labels);
-            const cold = fixture.attempts.find(({ actor }) => actor === "cold");
-            const lastHot = fixture.attempts.filter(({ actor }) => actor === "hot").at(-1);
-            expect(cold.startedAt <= lastHot.startedAt).toBe(true);
-        })),
-    },
-    {
-        name: "rejects effect keys, intent keys in the effect namespace, and caps out of range",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const actor = yield* Controlled.get("keys");
-            const failure = yield* actor
-                .Perform({ effect: "Job", labels: ["x".repeat(201)], keyed: true })
-                .pipe(Effect.exit);
-            expect(Exit.isFailure(failure)).toBe(true);
-            for (const perActor of [0, 65, 1.5])
-                expect(thrown(() => Actor.make("BadCap", {
-                    jobs: { Job: { job: Job, concurrency: { perActor } } },
-                    api: { Done },
-                }))).toContain("perActor");
-        })),
-    },
-    {
-        name: "cancels nothing when the cancelling turn rolls back",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const test = yield* ActorTest;
-            const actor = yield* Controlled.get("rollback");
-            yield* perform("rollback", "Job", ["kept"], { keyed: true, afterMs: 60_000 });
-            expect(yield* actor.CancelThenRefuse("kept").pipe(Effect.flip)).toBeInstanceOf(ControlDown);
-            const died = yield* actor.CancelThenDie("kept").pipe(Effect.exit);
-            expect(Exit.isFailure(died) && Cause.pretty(died.cause)).toContain("Canceller defect");
-            yield* perform("rollback", "Job", ["retried"], { keyed: true, afterMs: 60_000 });
-            yield* test.crashNext("beforeCommit");
-            yield* actor.CancelEffect(["retried"]).pipe(Effect.orDie);
-            yield* test.advance("2 minutes");
-            expect(fixture.attempts.map(({ label }) => label)).toEqual(["kept"]);
-            const state = yield* stateOf("rollback");
-            expect(state.done).toEqual(["kept"]);
-            expect(state.cancelled ?? []).toEqual([]);
-        })),
-    },
-    {
-        name: "does nothing when cancelling an effect that already completed",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            const sql = yield* SqlClient.SqlClient;
-            const test = yield* ActorTest;
-            yield* perform("completed", "Job", ["done"], { keyed: true });
-            yield* eventually(stateOf("completed").pipe(Effect.map((state) => (state.done ?? []).length === 1)));
-            yield* cancel("completed", ["done"]);
-            yield* test.advance("1 minute");
-            expect(fixture.attempts.length).toBe(1);
-            const state = yield* stateOf("completed");
-            expect(state.done).toEqual(["done"]);
-            expect(state.cancelled ?? []).toEqual([]);
-            expect(yield* effectRows(sql)).toEqual([]);
-            yield* perform("completed", "Job", ["done"], { keyed: true });
-            yield* eventually(stateOf("completed").pipe(Effect.map((state) => (state.done ?? []).length === 2)));
-        })),
-    },
-    {
-        name: "replaces a running keyed effect: reports the old one and runs the new one under a new id",
-        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
-            yield* reset(fixture);
-            fixture.provider = (attempt) => fixture.attempts.indexOf(attempt) === 0 ? Effect.never : Effect.succeed("second");
-            yield* perform("rerun", "Job", ["k"], { keyed: true });
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            yield* perform("rerun", "Job", ["k"], { keyed: true });
-            yield* eventually(stateOf("rerun").pipe(Effect.map((state) => (state.done ?? []).length === 1 && (state.cancelled ?? []).length === 1)));
-            const [first, second] = fixture.attempts;
-            expect(first.interrupted).toBe(true);
-            expect(second.jobId === first.jobId).toBe(false);
-            const state = yield* stateOf("rerun");
-            expect(state.done).toEqual(["second"]);
-            expect(state.cancelled).toMatchObject([
-                { effectId: first.jobId, outcome: "Unknown", ambiguous: true },
-            ]);
-        })),
-    },
-    {
-        name: "rejects reserved intent keys and a captured cancelJob",
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            expect(thrown(() => Intent.key("$job:x"))).toContain('Intent key "$job:x" is reserved for jobs');
-            const inTurn = yield* Intent.cancel("$job:x").pipe(Effect.provideService(Actor.InTurn, Actor.InTurn.of({ turn: Symbol() })), Effect.exit);
-            expect(Exit.isFailure(inTurn) && Cause.pretty(inTurn.cause)).toContain("is reserved for jobs");
-            const actor = yield* Controlled.get("escape");
-            yield* actor.CaptureCancel().pipe(Effect.orDie);
-            const stolen = yield* actor.UseCaptured("k").pipe(Effect.exit);
-            expect(Exit.isFailure(stolen) && Cause.pretty(stolen.cause)).toContain("Job capability escaped its turn");
-        })),
-    },
-];
-/** Multi-runner cases: real Postgres only, each on a fresh database and cluster. */
-export const effectControlClusterConformance = [
-    {
-        name: "never shortens the lease of a waiting row a claim takes while a settle wakes it",
-        requiresIndependentConnections: true,
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const sql = yield* SqlClient.SqlClient;
-            const group = {
-                routing_key: "7",
-                tenant_id: "wake-race",
-                actor_type: "Controlled",
-                actor_id: "raced",
-                command: "Serial",
-            };
-            const now = yield* Clock.currentTimeMillis;
-            const leaseEnd = now + 60_000;
-            yield* sql `INSERT INTO actor_generations (routing_key, tenant_id, actor_type, actor_id)
-            VALUES (7, 'wake-race', 'Controlled', 'raced')`;
-            yield* sql `INSERT INTO actor_outbox ${sql.insert(["oldest", "next"].map((intentId, index) => ({
-                routing_key: 7,
-                intent_id: intentId,
-                kind: "job",
-                bucket: 0,
-                due_at_ms: leaseEnd,
-                scheduled_at_ms: now + index,
-                ready_at_ms: now + index,
-                waiting: true,
-                tenant_id: "wake-race",
-                actor_type: "Controlled",
-                actor_id: "raced",
-                target_type: "Controlled",
-                target_id: "raced",
-                command: "Serial",
-                payload: "{}",
-                caller: "{}",
-            })))}`;
-            const locked = yield* Deferred.make();
-            const release = yield* Deferred.make();
-            const claim = yield* sql
-                .withTransaction(Effect.gen(function* () {
-                yield* sql `SELECT 1 FROM actor_outbox
-                  WHERE routing_key = 7 AND intent_id = 'oldest' FOR UPDATE`;
-                yield* sql `UPDATE actor_outbox SET running = true, waiting = false,
-                    attempts = 1, due_at_ms = ${leaseEnd}
-                  WHERE routing_key = 7 AND intent_id = 'oldest'`;
-                yield* Deferred.succeed(locked, undefined);
-                yield* Deferred.await(release);
-            }))
-                .pipe(Effect.forkChild);
-            yield* Deferred.await(locked);
-            const wake = yield* wakeWaiting({ sql, group, at: now }).pipe(Effect.forkChild);
-            yield* eventually(Effect.gen(function* () {
-                if (wake.pollUnsafe() !== undefined)
-                    return true;
-                const [blocked] = yield* sql `SELECT count(*)::int AS n
-                FROM pg_stat_activity
-                WHERE datname = current_database()
-                  AND wait_event_type = 'Lock' AND query LIKE 'UPDATE actor_outbox SET due_at_ms%'`;
-                return blocked.n > 0;
-            }).pipe(Effect.orDie), "10 seconds", "the wake to finish or wait on the claim's row lock");
-            yield* Deferred.succeed(release, undefined);
-            yield* Fiber.join(claim);
-            yield* Fiber.join(wake);
-            const rows = yield* sql `SELECT intent_id AS id, running, waiting, due_at_ms::text AS due FROM actor_outbox
-            WHERE routing_key = 7 ORDER BY intent_id`;
-            expect(rows).toEqual([
-                { id: "next", running: false, waiting: false, due: String(now) },
-                { id: "oldest", running: true, waiting: false, due: String(leaseEnd) },
-            ]);
-        })),
-    },
-    {
-        name: "wakes the oldest waiting row only after a claim of its group has committed",
-        requiresIndependentConnections: true,
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const sql = yield* SqlClient.SqlClient;
-            const group = {
-                routing_key: "8",
-                tenant_id: "wake-order",
-                actor_type: "Controlled",
-                actor_id: "ordered",
-                command: "Serial",
-            };
-            const now = yield* Clock.currentTimeMillis;
-            yield* sql `INSERT INTO actor_generations (routing_key, tenant_id, actor_type, actor_id)
-            VALUES (8, 'wake-order', 'Controlled', 'ordered')`;
-            yield* sql `INSERT INTO actor_outbox ${sql.insert({
-                routing_key: 8,
-                intent_id: "oldest",
-                kind: "job",
-                bucket: 0,
-                due_at_ms: now + 60_000,
-                scheduled_at_ms: now,
-                ready_at_ms: now,
-                waiting: true,
-                tenant_id: "wake-order",
-                actor_type: "Controlled",
-                actor_id: "ordered",
-                target_type: "Controlled",
-                target_id: "ordered",
-                command: "Serial",
-                payload: "{}",
-                caller: "{}",
-            })}`;
-            const locked = yield* Deferred.make();
-            const release = yield* Deferred.make();
-            const claim = yield* sql
-                .withTransaction(Effect.gen(function* () {
-                yield* sql `SELECT 1 FROM actor_generations
-                    WHERE routing_key = 8 AND tenant_id = 'wake-order'
-                      AND actor_type = 'Controlled' AND actor_id = 'ordered' FOR UPDATE`;
-                yield* Deferred.succeed(locked, undefined);
-                yield* Deferred.await(release);
-            }))
-                .pipe(Effect.forkChild);
-            yield* Deferred.await(locked);
-            const wake = yield* wakeWaiting({ sql, group, at: now }).pipe(Effect.forkChild);
-            yield* eventually(Effect.gen(function* () {
-                const [blocked] = yield* sql `SELECT count(*)::int AS n
-                FROM pg_stat_activity
-                WHERE datname = current_database()
-                  AND wait_event_type = 'Lock' AND wait_event IN ('tuple', 'transactionid')`;
-                return blocked.n > 0;
-            }).pipe(Effect.orDie), "10 seconds", "the wake to wait on the group's lock");
-            expect(wake.pollUnsafe()).toBe(undefined);
-            yield* Deferred.succeed(release, undefined);
-            yield* Fiber.join(claim);
-            yield* Fiber.join(wake);
-            const [row] = yield* sql `SELECT waiting,
-            due_at_ms::text AS due FROM actor_outbox WHERE routing_key = 8 AND intent_id = 'oldest'`;
-            expect(row).toEqual({ waiting: false, due: String(now) });
-        })),
-    },
-    {
-        name: "never starts a younger capped row while an older attempt's lost lease is being renewed",
-        requiresIndependentConnections: true,
-        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
-            const sql = yield* SqlClient.SqlClient;
-            const group = {
-                routing_key: "9",
-                tenant_id: "claim-renew",
-                actor_type: "Controlled",
-                actor_id: "renewed",
-                command: "Serial",
-            };
-            const now = yield* Clock.currentTimeMillis;
-            const renewedUntil = now + 60_000;
-            yield* sql `INSERT INTO actor_generations (routing_key, tenant_id, actor_type, actor_id)
-            VALUES (9, 'claim-renew', 'Controlled', 'renewed')`;
-            yield* sql `INSERT INTO actor_outbox ${sql.insert([
-                { intent_id: "oldest", running: true, waiting: false, attempts: 1, due: now - 1 },
-                {
-                    intent_id: "next",
-                    running: false,
-                    waiting: true,
-                    attempts: 0,
-                    due: now + 60_000,
-                },
-            ].map(({ due, ...row }, index) => ({
-                ...row,
-                routing_key: 9,
-                kind: "job",
-                bucket: 0,
-                due_at_ms: due,
-                scheduled_at_ms: now + index,
-                ready_at_ms: now + index,
-                tenant_id: "claim-renew",
-                actor_type: "Controlled",
-                actor_id: "renewed",
-                target_type: "Controlled",
-                target_id: "renewed",
-                command: "Serial",
-                payload: "{}",
-                caller: "{}",
-            })))}`;
-            const locked = yield* Deferred.make();
-            const release = yield* Deferred.make();
-            const renewal = yield* sql
-                .withTransaction(Effect.gen(function* () {
-                yield* sql `UPDATE actor_outbox SET due_at_ms = ${renewedUntil}
-                  WHERE routing_key = 9 AND intent_id = 'oldest' AND attempts = 1`;
-                yield* Deferred.succeed(locked, undefined);
-                yield* Deferred.await(release);
-            }))
-                .pipe(Effect.forkChild);
-            yield* Deferred.await(locked);
-            const claim = yield* claimCapped({
-                sql,
-                now: sql `${now}::bigint`,
-                group,
-                cap: 1,
-                maxAttempts: 3,
-                permits: 1,
-                leaseMs: 60_000,
-            }).pipe(Effect.forkChild);
-            yield* eventually(Effect.gen(function* () {
-                if (claim.pollUnsafe() !== undefined)
-                    return true;
-                const [blocked] = yield* sql `SELECT count(*)::int AS n
-                FROM pg_stat_activity
-                WHERE datname = current_database() AND wait_event_type = 'Lock'`;
-                return blocked.n > 0;
-            }).pipe(Effect.orDie), "10 seconds", "the claim to finish or wait on the renewal's row lock");
-            yield* Deferred.succeed(release, undefined);
-            yield* Fiber.join(renewal);
-            expect((yield* Fiber.join(claim)).map(({ intent_id }) => intent_id)).toEqual([]);
-            const rows = yield* sql `
-            SELECT intent_id AS id, running, due_at_ms::text AS due FROM actor_outbox
-            WHERE routing_key = 9 ORDER BY intent_id`;
-            expect(rows).toEqual([
-                { id: "next", running: false, due: String(now + 60_000) },
-                { id: "oldest", running: true, due: String(renewedUntil) },
-            ]);
-        })),
-    },
-    {
-        name: "caps one actor's running attempts across three runners while other actors proceed",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 120_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 3, {}, Effect.gen(function* () {
-            fixture.provider = (attempt) => Effect.sleep("100 millis").pipe(Effect.as(attempt.label));
-            const labels = Array.from({ length: 12 }, (_, index) => `capped-${index}`);
-            yield* on(1, perform("capped", "Capped", labels));
-            yield* on(2, Effect.forEach(Array.from({ length: 6 }, (_, index) => `other-${index}`), (id) => perform(id, "Capped", [id]), { concurrency: 6, discard: true }));
-            yield* eventually(on(0, stateOf("capped")).pipe(Effect.map((state) => (state.done ?? []).length === 12)), "60 seconds", "every capped effect");
-            expect(maxInFlight(fixture.attempts, "capped", "Capped") <= 2).toBe(true);
-            expect(new Set(fixture.attempts.map(({ jobId }) => jobId)).size).toBe(18);
-            expect(fixture.attempts.every(({ attempt }) => attempt === 1)).toBe(true);
-        })),
-    },
-    {
-        name: "keeps a killed runner's capped attempt counted until its lease ends, then retries it first",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 120_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 3, { executors: { lease: "9 seconds" } }, Effect.gen(function* () {
-            fixture.provider = (attempt) => attempt.label === "first" && attempt.attempt === 1
-                ? Effect.never
-                : Effect.succeed(`${attempt.label}@${attempt.attempt}`);
-            const { owner, other } = yield* ownerAndOther(yield* refOf("killed"));
-            yield* on(other, perform("killed", "Serial", ["first"]));
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            yield* on(other, perform("killed", "Serial", ["second"]));
-            const holder = fixture.attempts[0].runner;
-            const cluster = yield* ActorCluster;
-            yield* cluster.kill(holder);
-            const killedAt = yield* Clock.currentTimeMillis;
-            yield* cluster.ready;
-            const survivor = [owner, other, (owner + 2) % 3].find((runner) => runner !== holder);
-            yield* eventually(on(survivor, stateOf("killed")).pipe(Effect.map((state) => (state.done ?? []).length === 2)), "60 seconds", "both effects");
-            const later = fixture.attempts.slice(1);
-            expect(later.map(({ label, attempt }) => `${label}@${attempt}`)).toEqual([
-                "first@2",
-                "second@1",
-            ]);
-            expect(later.every(({ startedAt }) => startedAt >= killedAt)).toBe(true);
-            expect(maxInFlight(later, "killed", "Serial")).toBe(1);
-            expect((yield* on(survivor, stateOf("killed"))).done).toEqual(["first@2", "second@1"]);
-        })),
-    },
-    {
-        name: "frees a capped slot when an attempt loses its lease, interrupting it before the takeover starts",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 90_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 2, { executors: SHORT_LEASE }, Effect.gen(function* () {
-            fixture.provider = (attempt) => attempt.attempt === 1 ? Effect.never : Effect.succeed(attempt.label);
-            fixture.hook = (point) => point === "beforeRenew" && fixture.attempts.length === 1
-                ? Effect.die(new Error("Database unreachable"))
-                : Effect.void;
-            yield* on(0, perform("lost", "Serial", ["lost"]));
-            yield* eventually(on(0, stateOf("lost")).pipe(Effect.map((state) => (state.done ?? []).length === 1)), "30 seconds", "the takeover");
-            const [first, second] = fixture.attempts;
-            expect(first.interrupted).toBe(true);
-            expect(first.endedAt <= second.startedAt).toBe(true);
-            expect(maxInFlight(fixture.attempts, "lost", "Serial")).toBe(1);
-        })),
-    },
-    {
-        name: "keeps a newer capped attempt's slot when an attempt that lost its lease settles late",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 90_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 2, { relay: NO_POLL, executors: SHORT_LEASE }, Effect.gen(function* () {
-            const held = yield* Deferred.make();
-            const newer = yield* Deferred.make();
-            const settling = yield* Deferred.make();
-            fixture.provider = (attempt) => attempt.label === "slow" && attempt.attempt === 2
-                ? Deferred.await(newer).pipe(Effect.as("slow@2"))
-                : Effect.succeed(`${attempt.label}@${attempt.attempt}`);
-            fixture.hook = (point) => point === "afterExecute" && fixture.attempts.length === 1
-                ? Deferred.succeed(settling, undefined).pipe(Effect.andThen(Deferred.await(held)))
-                : Effect.void;
-            const { owner, other } = yield* ownerAndOther(yield* refOf("overlap"));
-            yield* on(owner, perform("overlap", "Serial", ["slow"]));
-            yield* Deferred.await(settling);
-            expect(fixture.attempts[0].runner).toBe(owner);
-            yield* advance(other, "4 seconds").pipe(Effect.forkChild);
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 2), "10 seconds");
-            expect(fixture.attempts[1]).toMatchObject({ runner: other, attempt: 2 });
-            yield* Deferred.succeed(held, undefined);
-            yield* Effect.sleep("1 second");
-            yield* on(owner, perform("overlap", "Serial", ["next"]));
-            yield* Effect.sleep("2 seconds");
-            expect(fixture.attempts.map(({ label }) => label)).toEqual(["slow", "slow"]);
-            expect((yield* query(other, effectRows)).find((row) => row.command === "Serial" && row.running)).toMatchObject({ attempts: 2 });
-            yield* Deferred.succeed(newer, undefined);
-            yield* eventually(on(other, stateOf("overlap")).pipe(Effect.map((state) => (state.done ?? []).length === 2)), "20 seconds", "both effects");
-            expect(maxInFlight(fixture.attempts, "overlap", "Serial")).toBe(1);
-            const { done } = yield* on(other, stateOf("overlap"));
-            expect(done.filter((label) => label.startsWith("slow")).length).toBe(1);
-            expect(done).toContain("next@1");
-        })),
-    },
-    {
-        name: "reaches a running attempt on another runner within cancelCheck and reports Unknown",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 90_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 2, { relay: NO_POLL, executors: { lease: "3 seconds", cancelCheck: "1 second" } }, Effect.gen(function* () {
-            fixture.provider = () => Effect.never;
-            const { owner, other } = yield* ownerAndOther(yield* refOf("remote"));
-            yield* on(owner, perform("remote", "Job", ["remote"], { keyed: true, afterMs: 60_000 }));
-            yield* advance(other, "1 minute");
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            expect(fixture.attempts[0].runner).toBe(other);
-            const cancelledAt = yield* Clock.currentTimeMillis;
-            yield* on(owner, cancel("remote", ["remote"]));
-            yield* eventually(Effect.sync(() => fixture.attempts[0].interrupted), "5 seconds", "the remote interruption");
-            expect(fixture.attempts[0].endedAt - cancelledAt <= 2500).toBe(true);
-            yield* eventually(on(owner, stateOf("remote")).pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)));
-            expect((yield* on(owner, stateOf("remote"))).cancelled).toMatchObject([
-                { outcome: "Unknown", ambiguous: true },
-            ]);
-            expect(fixture.attempts.length).toBe(1);
-        })),
-    },
-    {
-        name: "routes a success that finishes before the cancellation is seen to onCancelled as Succeeded",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 90_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 2, { relay: NO_POLL }, Effect.gen(function* () {
-            const gate = yield* Deferred.make();
-            fixture.provider = (attempt) => Deferred.await(gate).pipe(Effect.as(attempt.label));
-            const { owner, other } = yield* ownerAndOther(yield* refOf("raced"));
-            yield* on(owner, perform("raced", "Job", ["raced"], { keyed: true, afterMs: 60_000 }));
-            yield* advance(other, "1 minute").pipe(Effect.forkChild);
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            yield* on(owner, cancel("raced", ["raced"]));
-            yield* Deferred.succeed(gate, undefined);
-            yield* eventually(on(owner, stateOf("raced")).pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)));
-            const state = yield* on(owner, stateOf("raced"));
-            expect(state.cancelled).toMatchObject([
-                { outcome: "Succeeded", value: "raced", ambiguous: false },
-            ]);
-            expect(state.done ?? []).toEqual([]);
-        })),
-    },
-    {
-        name: "routes a capped success that finishes before the cancellation is seen to onCancelled",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 90_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 2, { relay: NO_POLL }, Effect.gen(function* () {
-            const gate = yield* Deferred.make();
-            fixture.provider = (attempt) => Deferred.await(gate).pipe(Effect.as(attempt.label));
-            const { owner, other } = yield* ownerAndOther(yield* refOf("capped-raced"));
-            yield* on(owner, perform("capped-raced", "Capped", ["capped"], { keyed: true, afterMs: 60_000 }));
-            yield* advance(other, "1 minute").pipe(Effect.forkChild);
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            yield* on(owner, cancel("capped-raced", ["capped"]));
-            yield* Deferred.succeed(gate, undefined);
-            yield* eventually(on(owner, stateOf("capped-raced")).pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)));
-            const state = yield* on(owner, stateOf("capped-raced"));
-            expect(state.cancelled).toMatchObject([
-                { outcome: "Succeeded", value: "capped", ambiguous: false },
-            ]);
-            expect(state.done ?? []).toEqual([]);
-            yield* drained(query(owner, effectRows));
-        })),
-    },
-    {
-        name: "routes a cancelled success that onSuccess cannot accept to onCancelled as Succeeded",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 90_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 2, { relay: NO_POLL }, Effect.gen(function* () {
-            const gate = yield* Deferred.make();
-            fixture.provider = (attempt) => Deferred.await(gate).pipe(Effect.as(attempt.label));
-            const { owner, other } = yield* ownerAndOther(yield* refOf("picky"));
-            yield* on(owner, perform("picky", "Picky", ["rejected"], { keyed: true, afterMs: 60_000 }));
-            yield* advance(other, "1 minute").pipe(Effect.forkChild);
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            yield* on(owner, cancel("picky", ["rejected"]));
-            yield* Deferred.succeed(gate, undefined);
-            yield* eventually(on(owner, stateOf("picky")).pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)));
-            const state = yield* on(owner, stateOf("picky"));
-            expect(state.cancelled).toMatchObject([
-                { outcome: "Succeeded", value: "rejected", ambiguous: false },
-            ]);
-            expect(state.done ?? []).toEqual([]);
-            yield* drained(query(owner, effectRows));
-            expect(fixture.attempts.length).toBe(1);
-        })),
-    },
-    {
-        name: "records a late success after its cancellation settled as ambiguous and routes it once",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 90_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 2, { relay: NO_POLL, executors: SHORT_LEASE }, Effect.gen(function* () {
-            const gate = yield* Deferred.make();
-            fixture.provider = (attempt) => Deferred.await(gate).pipe(Effect.as(attempt.label));
-            const { owner, other } = yield* ownerAndOther(yield* refOf("late"));
-            const renewal = yield* on(owner, ActorTest.use((test) => test.pauseNext("beforeRenew")));
-            yield* on(owner, perform("late", "Job", ["late"], { keyed: true }));
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            expect(fixture.attempts[0].runner).toBe(owner);
-            yield* renewal.reached;
-            yield* on(other, cancel("late", ["late"]));
-            yield* advance(other, "4 seconds");
-            yield* eventually(on(other, stateOf("late")).pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)));
-            yield* Deferred.succeed(gate, undefined);
-            yield* eventually(query(other, deadLetters).pipe(Effect.map((letters) => letters.length === 1)), "10 seconds", "the late success's record");
-            yield* renewal.release;
-            expect(yield* query(other, deadLetters)).toMatchObject([
-                { ambiguous: true, cause: "Succeeded after it was cancelled" },
-            ]);
-            const state = yield* on(other, stateOf("late"));
-            expect(state.cancelled).toMatchObject([{ outcome: "Unknown", ambiguous: true }]);
-            expect(state.done ?? []).toEqual([]);
-        })),
-    },
-    {
-        name: "records a late success onSuccess cannot accept after its cancellation settled",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 90_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 2, { relay: NO_POLL, executors: SHORT_LEASE }, Effect.gen(function* () {
-            const gate = yield* Deferred.make();
-            fixture.provider = (attempt) => Deferred.await(gate).pipe(Effect.as(attempt.label));
-            const { owner, other } = yield* ownerAndOther(yield* refOf("late-picky"));
-            const renewal = yield* on(owner, ActorTest.use((test) => test.pauseNext("beforeRenew")));
-            yield* on(owner, perform("late-picky", "Picky", ["rejected"], { keyed: true }));
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            expect(fixture.attempts[0].runner).toBe(owner);
-            yield* renewal.reached;
-            yield* on(other, cancel("late-picky", ["rejected"]));
-            yield* advance(other, "4 seconds");
-            yield* eventually(on(other, stateOf("late-picky")).pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)));
-            yield* Deferred.succeed(gate, undefined);
-            yield* eventually(query(other, deadLetters).pipe(Effect.map((letters) => letters.length === 1)), "10 seconds", "the late success's record");
-            yield* renewal.release;
-            expect(yield* query(other, deadLetters)).toMatchObject([
-                { ambiguous: true, cause: "Succeeded after it was cancelled" },
-            ]);
-            const state = yield* on(other, stateOf("late-picky"));
-            expect(state.cancelled).toMatchObject([{ outcome: "Unknown", ambiguous: true }]);
-            expect(state.done ?? []).toEqual([]);
-        })),
-    },
-    {
-        name: "gives each effect exactly one fate when cancellation races its claim",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 120_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 3, {}, Effect.gen(function* () {
-            fixture.provider = (attempt) => Effect.sleep("5 millis").pipe(Effect.as(attempt.label));
-            const ids = Array.from({ length: 40 }, (_, index) => `race-${index}`);
-            yield* Effect.forEach(ids, (id, index) => on(index % 3, perform(id, "Job", [id], { keyed: true }).pipe(Effect.andThen(cancel(id, [id])))), { concurrency: 8, discard: true });
-            yield* eventually(query(0, (sql) => sql `SELECT count(*)::int AS n FROM actor_outbox
-                WHERE actor_type = 'Controlled'`.pipe(Effect.map((rows) => rows[0].n === 0))), "30 seconds", "the outbox to settle");
-            for (const id of ids) {
-                const state = yield* on(0, stateOf(id));
-                const ran = fixture.attempts.filter(({ actor }) => actor === id);
-                const fates = (state.done ?? []).length + (state.cancelled ?? []).length;
-                expect(ran.length <= 1).toBe(true);
-                expect(fates).toBe(ran.length === 0 ? 0 : 1);
-                expect((state.cancelled ?? []).every(({ outcome }) => outcome !== "Failed")).toBe(true);
-            }
-        })),
-    },
-    {
-        name: "settles a cancelled effect whose runner was killed as ambiguous without running it",
-        requiresFreshDatabase: true,
-        requiresIndependentConnections: true,
-        timeoutMs: 120_000,
-        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, 3, { executors: { lease: "9 seconds" } }, Effect.gen(function* () {
-            fixture.provider = () => Effect.never;
-            const { owner, other } = yield* ownerAndOther(yield* refOf("orphan"));
-            yield* on(other, perform("orphan", "Job", ["orphan"], { keyed: true }));
-            yield* eventually(Effect.sync(() => fixture.attempts.length === 1));
-            const holder = fixture.attempts[0].runner;
-            const cluster = yield* ActorCluster;
-            yield* cluster.kill(holder);
-            yield* cluster.ready;
-            const survivor = [owner, other, (owner + 2) % 3].find((runner) => runner !== holder);
-            yield* on(survivor, cancel("orphan", ["orphan"]));
-            yield* eventually(on(survivor, stateOf("orphan")).pipe(Effect.map((state) => (state.cancelled ?? []).length === 1)), "60 seconds", "the orphan's cancellation report");
-            expect(fixture.attempts.length).toBe(1);
-            expect((yield* on(survivor, stateOf("orphan"))).cancelled).toMatchObject([
-                { outcome: "Unknown", ambiguous: true },
-            ]);
-            yield* eventually(query(survivor, effectRows).pipe(Effect.map((rows) => rows.length === 0)), "20 seconds", "the delivered route's row to be deleted");
-        })),
-    },
-];
-/** Effect-control actors and the executors of runner 0. */
-export const effectControlSuite = {
-    fixture: effectControlFixture,
-    layer: (fixture) => Layer.merge(effectControlLayer, effectControlEffects(fixture)),
-};