@rikalabs/akter 0.1.0-alpha.0

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

@@ -0,0 +1,1059 @@
+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)),
+};