@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance/workflows/guards.js

@@ -0,0 +1,172 @@
+import { Cause, DateTime, Deferred, Effect, Exit } from "effect";
+import { SqlClient } from "effect/sql";
+import { InvalidExecutionKey } from "../../../index.js";
+import { ActorTest } from "../../actor-test.js";
+import { EngineProbe, Ledger, Shipper } from "./actors.js";
+import { eventually, reset, suspendedRow } from "./harness.js";
+/** Expiry bounds, fencing, deduplication, and body-shape guards of workflows. */
+export const workflowGuardConformance = [
+    {
+        name: "workflows: dies with ActivityOutcomeUnknown instead of calling past the expiry bound",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const gate = yield* Deferred.make();
+            fixture.blocked = gate;
+            const run = yield* (yield* Shipper.get("late")).Ship({ orderId: "late1", sku: "late" });
+            yield* eventually(Effect.sync(() => fixture.runs.get("reserve:late1") === 1), "the activity to start");
+            yield* test.advance("61 seconds");
+            yield* Deferred.succeed(gate, undefined);
+            const exit = yield* run.result.pipe(Effect.exit);
+            expect(Exit.isFailure(exit) && Cause.pretty(exit.cause).includes("ActivityOutcomeUnknown")).toBe(true);
+            const ledger = yield* Ledger.get("late1");
+            expect(yield* test.receiptsFor(ledger.ref, "Charge")).toBe(0);
+        })),
+    },
+    {
+        name: "workflows: interrupts once when interrupt races completion",
+        timeoutMs: 120_000,
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            const engine = fixture.engine;
+            const outcomes = new Set();
+            for (let round = 0; round < 8; round++) {
+                const key = `race-${round}`;
+                const gate = yield* Deferred.make();
+                engine.gates.set(key, gate);
+                const probe = yield* EngineProbe.get(key);
+                const run = yield* probe.Probe({ scenario: "compensate-last", key });
+                yield* eventually(Effect.sync(() => (engine.runs.get(`hold:${key}`) ?? 0) >= 1), "the activity to start");
+                yield* Effect.all([Deferred.succeed(gate, undefined), run.interrupt], {
+                    concurrency: 2,
+                });
+                const exit = yield* run.result.pipe(Effect.exit);
+                const interrupted = Exit.isFailure(exit) && Exit.hasInterrupts(exit);
+                if (!interrupted)
+                    expect(exit).toEqual(Exit.succeed("held"));
+                outcomes.add(interrupted ? "interrupted" : "completed");
+                expect(engine.runs.get(`compensate:${key}`) ?? 0).toBe(interrupted ? 1 : 0);
+                yield* run.interrupt;
+                const again = yield* run.result.pipe(Effect.exit);
+                expect(Exit.isFailure(again) && Exit.hasInterrupts(again)).toBe(interrupted);
+                const [left] = yield* sql `
+              SELECT (SELECT count(*)::int FROM actor_workflow_step WHERE execution_id = ${run.executionId}) AS steps,
+                (SELECT count(*)::int FROM actor_outbox WHERE timer_key = ${`wf:${run.executionId}`}) AS timers`;
+                expect(left).toEqual({ steps: 0, timers: 0 });
+                expect(engine.runs.get(`compensate:${key}`) ?? 0).toBe(interrupted ? 1 : 0);
+            }
+            expect(outcomes.size > 0).toBe(true);
+        })),
+    },
+    {
+        name: "workflows: rejects step writes from a stale generation",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const sql = yield* SqlClient.SqlClient;
+            const test = yield* ActorTest;
+            const gate = yield* Deferred.make();
+            fixture.blocked = gate;
+            const shipper = yield* Shipper.get("stale");
+            const run = yield* shipper.Ship({ orderId: "st1", sku: "block-stale" });
+            yield* eventually(Effect.sync(() => fixture.runs.get("reserve:st1") === 1), "the activity to start");
+            yield* sql `UPDATE actor_generations SET generation = generation + 1
+            WHERE tenant_id = ${shipper.ref.tenant} AND actor_type = 'Shipper' AND actor_id = 'stale'`;
+            yield* Deferred.succeed(gate, undefined);
+            yield* Effect.sleep("300 millis");
+            const pending = () => sql `SELECT exit IS NOT NULL AS exit FROM actor_workflow_step
+              WHERE execution_id = ${run.executionId} AND step = 'reserve'`;
+            expect(yield* pending()).toEqual([{ exit: false }]);
+            yield* test.invalidate(shipper.ref);
+            yield* test.advance("31 seconds");
+            expect(yield* run.result).toBe("r-block-stale:v2");
+            expect(fixture.runs.get("reserve:st1")).toBe(2);
+        })),
+    },
+    {
+        name: "workflows: deduplicates a rerun activity's actor calls by derived command id",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const gate = yield* Deferred.make();
+            fixture.blocked = gate;
+            const shipper = yield* Shipper.get("rerun-calls");
+            const run = yield* shipper.Ship({ orderId: "rc1", sku: "charge-block" });
+            const ledger = yield* Ledger.get("rc1");
+            yield* eventually(test.receiptsFor(ledger.ref, "Charge").pipe(Effect.map((count) => count === 1)), "the first call");
+            yield* test.invalidate(shipper.ref);
+            const sql = yield* SqlClient.SqlClient;
+            const now = DateTime.toEpochMillis(yield* test.now);
+            yield* sql `UPDATE actor_outbox SET due_at_ms = ${now}
+            WHERE timer_key = ${`wf:${run.executionId}`}`;
+            yield* test.advance("1 second");
+            expect(yield* run.result).toBe("r-charge-block-1-2:v2");
+            expect(fixture.runs.get("reserve:rc1")).toBe(2);
+            expect(yield* test.receiptsFor(ledger.ref, "Charge")).toBe(2);
+            yield* Deferred.succeed(gate, undefined);
+        })),
+    },
+    {
+        name: "workflows: replays the first result when a step is called twice",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const run = yield* (yield* Shipper.get("twice")).Ship({ orderId: "tw1", sku: "twice" });
+            expect(yield* run.result).toBe("r-twice|r-twice");
+            expect(fixture.runs.get("reserve:tw1")).toBe(1);
+        })),
+    },
+    {
+        name: "workflows: dies on an actor call outside an activity",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const run = yield* (yield* Shipper.get("outside")).Ship({
+                orderId: "out1",
+                sku: "outside",
+            });
+            const exit = yield* run.result.pipe(Effect.exit);
+            expect(Exit.isFailure(exit) && Cause.pretty(exit.cause).includes("outside a step")).toBe(true);
+            expect(yield* test.receiptsFor((yield* Ledger.get("out1")).ref, "Charge")).toBe(0);
+        })),
+    },
+    {
+        name: "workflows: dies on a constructor created inside a body with Unregistered workflow step",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const run = yield* (yield* Shipper.get("loose")).Loose({});
+            const exit = yield* run.result.pipe(Effect.exit);
+            expect(Exit.isFailure(exit) && Cause.pretty(exit.cause).includes("Unregistered workflow step")).toBe(true);
+        })),
+    },
+    {
+        name: "workflows: rejects an oversized key with InvalidExecutionKey",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const shipper = yield* Shipper.get("oversized");
+            const error = yield* shipper
+                .Ship({ orderId: "k".repeat(257), sku: "a" })
+                .pipe(Effect.flip);
+            expect(error).toBeInstanceOf(InvalidExecutionKey);
+            expect(error).toMatchObject({ bytes: 257 });
+        })),
+    },
+    {
+        name: "workflows: attaches a repeated start without rewriting its markers",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const sql = yield* SqlClient.SqlClient;
+            const test = yield* ActorTest;
+            const shipper = yield* Shipper.get("markers");
+            const run = yield* shipper.Ship({ orderId: "mk1", sku: "sleep-mk" });
+            yield* suspendedRow(run.executionId);
+            yield* sql `UPDATE actor_workflow_step SET version = 1
+            WHERE execution_id = ${run.executionId} AND kind = 'version'`;
+            const again = yield* shipper.Ship({ orderId: "mk1", sku: "sleep-mk" });
+            expect(again.executionId).toBe(run.executionId);
+            const markers = yield* sql `
+            SELECT step, version FROM actor_workflow_step
+            WHERE execution_id = ${run.executionId} AND kind = 'version'`;
+            expect(markers).toEqual([{ step: "label", version: 1 }]);
+            yield* test.advance("11 seconds");
+            expect(yield* again.result).toBe("r-sleep-mk:v1");
+            expect(fixture.runs.get("reserve:mk1")).toBe(1);
+        })),
+    },
+];

package/dist/testing/conformance/workflows/harness.d.ts

@@ -0,0 +1,14 @@
+import { Duration, Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { ActorTest } from "../../actor-test.ts";
+import { ActorCluster } from "../../cluster.ts";
+import type { ConformanceEnvironment } from "../../conformance.ts";
+import { type WorkflowsFixture } from "./actors.ts";
+export declare const reset: (fixture: WorkflowsFixture) => Effect.Effect<void, never, never>;
+export declare const withCluster: <A, E>(environment: ConformanceEnvironment, fixture: WorkflowsFixture, body: Effect.Effect<A, E, ActorCluster>) => Promise<A>;
+export declare const on: <A, E, R>(runner: number, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, ActorCluster | Exclude<R, ActorTest | import("../../../index.ts").Actors | import("../../../index.ts").ContentStore | import("../../../runtime/index.ts").DefectLog | import("../../index.ts").InternalActors | import("../../../runtime/operators/repair.ts").OperatorRuntime | import("@effect/sql-pglite/PgliteClient").PgliteClient | import("../../../runtime/drain.ts").RuntimeControl | SqlClient.SqlClient | import("../../../runtime/index.ts").TelemetrySampler>>;
+export declare const advance: (runner: number, duration: Duration.Input) => Effect.Effect<void, never, ActorCluster>;
+/** Kills the runner owning `id` and returns a survivor once it holds the shards. */
+export declare const killOwner: (id: string) => Effect.Effect<number, never, ActorCluster>;
+export declare const eventually: <E, R>(check: Effect.Effect<boolean, E, R>, what: string) => Effect.Effect<void, E, R>;
+export declare const suspendedRow: (executionId: string) => Effect.Effect<void, never, SqlClient.SqlClient>;

package/dist/testing/conformance/workflows/harness.js

@@ -0,0 +1,44 @@
+import { Duration, Effect, Layer, Schedule } from "effect";
+import { SqlClient } from "effect/sql";
+import { User } from "../../../index.js";
+import { ActorTest } from "../../actor-test.js";
+import { ActorCluster } from "../../cluster.js";
+import { Shipper, workflowsLayer } from "./actors.js";
+export const reset = (fixture) => Effect.sync(() => {
+    fixture.runs.clear();
+    fixture.blocked = undefined;
+});
+const EXPIRATION_SECONDS = 3;
+export const withCluster = (environment, fixture, body) => environment.run(Effect.gen(function* () {
+    yield* reset(fixture);
+    const database = yield* environment.freshDatabase;
+    const context = yield* Layer.build(ActorTest.cluster({
+        database,
+        runners: 3,
+        shardLockExpiration: `${EXPIRATION_SECONDS} seconds`,
+        actors: workflowsLayer(fixture),
+        as: User.make({ subject: "alice" }),
+        authorize: () => Effect.succeed(true),
+    }));
+    return yield* body.pipe(Effect.provideContext(context));
+}));
+export const on = (runner, effect) => ActorCluster.use((cluster) => cluster.on(runner)(effect));
+export const advance = (runner, duration) => on(runner, ActorTest.use((test) => test.advance(duration)));
+/** Kills the runner owning `id` and returns a survivor once it holds the shards. */
+export const killOwner = (id) => ActorCluster.use((cluster) => Effect.gen(function* () {
+    const ref = (yield* cluster.on(0)(Shipper.get(id))).ref;
+    const owner = (yield* cluster.owner(ref));
+    yield* cluster.kill(owner);
+    yield* cluster.ready;
+    return (owner + 1) % cluster.runners;
+}));
+export const eventually = (check, what) => check.pipe(Effect.repeat({ schedule: Schedule.spaced("25 millis"), until: (held) => held }), Effect.timeoutOrElse({
+    duration: "30 seconds",
+    orElse: () => Effect.die(new Error(`Timed out waiting for ${what}`)),
+}), Effect.asVoid);
+export const suspendedRow = (executionId) => eventually(Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const rows = yield* sql `SELECT status FROM actor_workflow_executions
+        WHERE execution_id = ${executionId}`;
+    return rows[0]?.status === "suspended";
+}).pipe(Effect.orDie), "the execution to suspend");

package/dist/testing/conformance/workflows/recovery.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type WorkflowsFixture } from "./actors.ts";
+/** Redelivery, execution-id validation, eviction, owner death, and drain recovery of workflows. */
+export declare const workflowRecoveryConformance: ReadonlyArray<ConformanceCase<WorkflowsFixture>>;

package/dist/testing/conformance/workflows/recovery.js

@@ -0,0 +1,181 @@
+import { Deferred, Effect, Exit, Option, Predicate } from "effect";
+import { InvalidExecutionId } from "../../../index.js";
+import { ActorTest } from "../../actor-test.js";
+import { ActorCluster } from "../../cluster.js";
+import { RuntimeControl } from "../../../runtime/drain.js";
+import { EngineProbe, Probe, Ship, Shipper } from "./actors.js";
+import { advance, eventually, killOwner, on, reset, suspendedRow, withCluster } from "./harness.js";
+import { SqlClient } from "effect/sql";
+/** Redelivery, execution-id validation, eviction, owner death, and drain recovery of workflows. */
+export const workflowRecoveryConformance = [
+    {
+        name: "workflows: a resume whose reply is lost after commit still wakes the execution on redelivery",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const shipper = yield* Shipper.get("resume-replay");
+            const run = yield* shipper.Ship({ orderId: "rr1", sku: "sleep-rr" });
+            yield* suspendedRow(run.executionId);
+            yield* test.crashNext("afterCommit");
+            yield* test.advance("11 seconds");
+            expect(yield* run.result).toBe("r-sleep-rr:v2");
+            expect(fixture.runs.get("reserve:rr1")).toBe(1);
+            expect(yield* test.receiptsFor(shipper.ref, "$workflow/resume")).toBe(1);
+        })),
+    },
+    {
+        name: "workflows: a malformed, foreign, or wrong-member execution id is InvalidExecutionId",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const bad = yield* Shipper.run(Ship, "w1.nope").pipe(Effect.flip);
+            expect(bad).toBeInstanceOf(InvalidExecutionId);
+            const other = yield* Shipper.run(Ship, "x1.abc").pipe(Effect.flip);
+            expect(other).toBeInstanceOf(InvalidExecutionId);
+        })),
+    },
+    {
+        name: "workflows: an evicted activation resumes its suspended execution without rerunning the activity",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const shipper = yield* Shipper.get("evicted");
+            const run = yield* shipper.Ship({ orderId: "o8", sku: "sleep-e" });
+            yield* suspendedRow(run.executionId);
+            yield* test.invalidate(shipper.ref);
+            yield* test.advance("11 seconds");
+            const reattached = yield* Shipper.run(Ship, run.executionId);
+            expect(yield* reattached.result).toBe("r-sleep-e:v2");
+            expect(fixture.runs.get("reserve:o8")).toBe(1);
+        })),
+    },
+    {
+        name: "workflows: a killed owner's suspended execution resumes on a survivor via its relay timer",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        timeoutMs: 90_000,
+        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, Effect.gen(function* () {
+            const id = yield* on(0, Effect.gen(function* () {
+                const run = yield* (yield* Shipper.get("killed-sleep")).Ship({
+                    orderId: "k1",
+                    sku: "sleep-k",
+                });
+                return run.executionId;
+            }));
+            yield* on(0, eventually(Effect.gen(function* () {
+                const polled = yield* (yield* Shipper.run(Ship, id)).poll;
+                return Option.isSome(polled) && Predicate.isTagged(polled.value, "Suspended");
+            }), "the sleep to suspend"));
+            const survivor = yield* killOwner("killed-sleep");
+            yield* advance(survivor, "11 seconds");
+            const result = yield* on(survivor, Effect.gen(function* () {
+                return yield* (yield* Shipper.run(Ship, id)).result;
+            }));
+            expect(result).toBe("r-sleep-k:v2");
+            expect(fixture.runs.get("reserve:k1")).toBe(1);
+        })),
+    },
+    {
+        name: "workflows: abandons a running execution on drain and resumes it on another runner",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        timeoutMs: 120_000,
+        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, Effect.gen(function* () {
+            const gate = yield* Deferred.make();
+            fixture.blocked = gate;
+            const id = yield* on(0, Effect.gen(function* () {
+                const run = yield* (yield* Shipper.get("drained-activity")).Ship({
+                    orderId: "d1",
+                    sku: "block",
+                });
+                return run.executionId;
+            }));
+            yield* eventually(Effect.sync(() => fixture.runs.get("reserve:d1") === 1), "the activity to start");
+            const cluster = yield* ActorCluster;
+            const ref = (yield* cluster.on(0)(Shipper.get("drained-activity"))).ref;
+            const owner = (yield* cluster.owner(ref));
+            const survivor = (owner + 1) % cluster.runners;
+            expect(yield* on(owner, RuntimeControl.use((control) => control.drain({ deadline: "5 seconds" })))).toEqual({ outcome: "clean", interruptedTurns: 0, interruptedJobs: 0 });
+            yield* cluster.shutdown(owner);
+            yield* cluster.ready;
+            yield* advance(survivor, "31 seconds");
+            const result = yield* on(survivor, Effect.gen(function* () {
+                return yield* (yield* Shipper.run(Ship, id)).result;
+            }));
+            expect(result).toBe("r-block:v2");
+            expect(fixture.runs.get("reserve:d1")).toBe(2);
+            yield* Deferred.succeed(gate, undefined);
+        })),
+    },
+    {
+        name: "workflows: replays an interrupted execution's compensation on a survivor when its runner dies mid-compensation, and records the interrupt once",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        timeoutMs: 120_000,
+        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, Effect.gen(function* () {
+            const engine = fixture.engine;
+            const key = "compensation-kill";
+            const hold = yield* Deferred.make();
+            const compensating = yield* Deferred.make();
+            engine.gates.set(key, hold);
+            engine.gates.set(`compensate:${key}`, compensating);
+            engine.runs.clear();
+            const executionId = yield* on(0, Effect.gen(function* () {
+                const run = yield* (yield* EngineProbe.get(key)).Probe({
+                    scenario: "compensate-block",
+                    key,
+                });
+                return run.executionId;
+            }));
+            yield* eventually(Effect.sync(() => (engine.runs.get(`hold:${key}`) ?? 0) >= 1), "the activity to start");
+            yield* on(0, Effect.flatMap(EngineProbe.run(Probe, executionId), (run) => run.interrupt));
+            yield* eventually(Effect.sync(() => (engine.runs.get(`compensate:${key}`) ?? 0) >= 1), "the compensation to start");
+            const survivor = yield* ActorCluster.use((cluster) => Effect.gen(function* () {
+                const ref = (yield* cluster.on(0)(EngineProbe.get(key))).ref;
+                const owner = (yield* cluster.owner(ref));
+                yield* cluster.kill(owner);
+                yield* cluster.ready;
+                return (owner + 1) % cluster.runners;
+            }));
+            yield* advance(survivor, "31 seconds");
+            yield* eventually(Effect.sync(() => (engine.runs.get(`compensate:${key}`) ?? 0) >= 2), "the survivor to run the compensation again");
+            yield* Deferred.succeed(compensating, undefined);
+            const exit = yield* on(survivor, Effect.flatMap(EngineProbe.run(Probe, executionId), (run) => run.result).pipe(Effect.exit));
+            expect(Exit.isFailure(exit) && Exit.hasInterrupts(exit)).toBe(true);
+            expect((engine.runs.get(`compensate:${key}`) ?? 0) >= 2).toBe(true);
+            const rows = yield* on(survivor, Effect.gen(function* () {
+                const sql = yield* SqlClient.SqlClient;
+                return yield* sql `SELECT status,
+                  (SELECT count(*)::int FROM actor_workflow_step
+                    WHERE execution_id = ${executionId}) AS steps
+                FROM actor_workflow_executions WHERE execution_id = ${executionId}`;
+            }).pipe(Effect.orDie));
+            expect(rows).toEqual([{ status: "finished", steps: 0 }]);
+            yield* Deferred.succeed(hold, undefined);
+        })),
+    },
+    {
+        name: "workflows: an activity whose runner is killed mid-run is rerun on a survivor with the same identity",
+        requiresFreshDatabase: true,
+        requiresIndependentConnections: true,
+        timeoutMs: 120_000,
+        run: ({ expect, environment, fixture }) => withCluster(environment, fixture, Effect.gen(function* () {
+            const gate = yield* Deferred.make();
+            fixture.blocked = gate;
+            const id = yield* on(0, Effect.gen(function* () {
+                const run = yield* (yield* Shipper.get("killed-activity")).Ship({
+                    orderId: "k2",
+                    sku: "block",
+                });
+                return run.executionId;
+            }));
+            yield* eventually(Effect.sync(() => fixture.runs.get("reserve:k2") === 1), "the activity to start");
+            const survivor = yield* killOwner("killed-activity");
+            yield* advance(survivor, "31 seconds");
+            const result = yield* on(survivor, Effect.gen(function* () {
+                return yield* (yield* Shipper.run(Ship, id)).result;
+            }));
+            expect(result).toBe("r-block:v2");
+            expect(fixture.runs.get("reserve:k2")).toBe(2);
+            yield* Deferred.succeed(gate, undefined);
+        })),
+    },
+];

package/dist/testing/conformance/workflows/starts.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type WorkflowsFixture } from "./actors.ts";
+/** Turn-staged starts, activity actor calls, and wait registration races of workflows. */
+export declare const workflowStartConformance: ReadonlyArray<ConformanceCase<WorkflowsFixture>>;

package/dist/testing/conformance/workflows/starts.js

@@ -0,0 +1,57 @@
+import { Effect } from "effect";
+import { ActorTest } from "../../actor-test.js";
+import { Ledger, Ship, Shipper } from "./actors.js";
+import { reset } from "./harness.js";
+/** Turn-staged starts, activity actor calls, and wait registration races of workflows. */
+export const workflowStartConformance = [
+    {
+        name: "workflows: a turn stages a start whose wait sees that turn's own event",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const shipper = yield* Shipper.get("staged");
+            const id = yield* shipper.Begin({ orderId: "s1", sku: "wait-s" });
+            expect(yield* (yield* Shipper.run(Ship, id)).result).toBe("r-wait-s:paid-3");
+            const again = yield* shipper.Ship({ orderId: "s1", sku: "wait-s" });
+            expect(again.executionId).toBe(id);
+            expect(yield* again.result).toBe("r-wait-s:paid-3");
+        })),
+    },
+    {
+        name: "workflows: a start staged by a turn that emits nothing sees an owner event committed before the start is delivered",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const shipper = yield* Shipper.get("deferred");
+            const id = yield* shipper.Defer({ orderId: "d1", sku: "wait-d" });
+            yield* shipper.Pay({ orderId: "d1", amount: 5 });
+            expect(yield* (yield* Shipper.run(Ship, id)).result).toBe("r-wait-d:paid-5");
+        })),
+    },
+    {
+        name: "workflows: activity actor calls get distinct ids per call and reach the receiver once each",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const shipper = yield* Shipper.get("charging");
+            const run = yield* shipper.Ship({ orderId: "c1", sku: "charge" });
+            expect(yield* run.result).toBe("r-charge-1-2:v2");
+            const ledger = yield* Ledger.get("c1");
+            expect(yield* test.receiptsFor(ledger.ref, "Charge")).toBe(2);
+        })),
+    },
+    {
+        name: "workflows: an event appended while a wait is registering is never lost",
+        requiresIndependentConnections: true,
+        timeoutMs: 60_000,
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const results = yield* Effect.forEach(Array.from({ length: 20 }, (_, index) => index), (index) => Effect.gen(function* () {
+                const shipper = yield* Shipper.get(`race-${index}`);
+                const orderId = `race-${index}`;
+                const run = yield* shipper.Ship({ orderId, sku: "wait-race" });
+                yield* shipper.Pay({ orderId, amount: index });
+                return yield* run.result;
+            }), { concurrency: 5 });
+            expect(results).toEqual(Array.from({ length: 20 }, (_, index) => `r-wait-race:paid-${index}`));
+        })),
+    },
+];

package/dist/testing/conformance/workflows/suspension.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type WorkflowsFixture } from "./actors.ts";
+/** Waits, races, interrupts, and keyless restarts of suspended workflows. */
+export declare const workflowSuspensionConformance: ReadonlyArray<ConformanceCase<WorkflowsFixture>>;

package/dist/testing/conformance/workflows/suspension.js

@@ -0,0 +1,106 @@
+import { Effect, Exit } from "effect";
+import { SqlClient } from "effect/sql";
+import { Unauthorized } from "../../../index.js";
+import { ActorTest } from "../../actor-test.js";
+import { Ship, Shipper } from "./actors.js";
+import { reset, suspendedRow } from "./harness.js";
+/** Waits, races, interrupts, and keyless restarts of suspended workflows. */
+export const workflowSuspensionConformance = [
+    {
+        name: "workflows: a wait sees a matching owner event appended after it registered",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const shipper = yield* Shipper.get("waiting");
+            const run = yield* shipper.Ship({ orderId: "o4", sku: "wait" });
+            yield* suspendedRow(run.executionId);
+            yield* shipper.Pay({ orderId: "other", amount: 1 });
+            yield* shipper.Pay({ orderId: "o4", amount: 7 });
+            expect(yield* run.result).toBe("r-wait:paid-7");
+        })),
+    },
+    {
+        name: "workflows: a wait times out on the framework clock",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const shipper = yield* Shipper.get("timeout");
+            const run = yield* shipper.Ship({ orderId: "o5", sku: "wait" });
+            yield* suspendedRow(run.executionId);
+            yield* test.advance("61 seconds");
+            expect(yield* run.result).toBe("r-wait:unpaid");
+        })),
+    },
+    {
+        name: "workflows: interrupt finishes a suspended execution as interrupted",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const sql = yield* SqlClient.SqlClient;
+            const shipper = yield* Shipper.get("interrupt");
+            const run = yield* shipper.Ship({ orderId: "o6", sku: "wait" });
+            yield* suspendedRow(run.executionId);
+            yield* run.interrupt;
+            yield* run.interrupt;
+            const exit = yield* run.result.pipe(Effect.exit);
+            expect(Exit.isFailure(exit) && Exit.hasInterrupts(exit)).toBe(true);
+            const steps = yield* sql `SELECT count(*)::int AS count
+            FROM actor_workflow_step WHERE execution_id = ${run.executionId}`;
+            expect(steps[0].count).toBe(0);
+        })),
+    },
+    {
+        name: "workflows: a race whose branches all suspend resumes and records the event winner",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const shipper = yield* Shipper.get("race-event");
+            const run = yield* shipper.Ship({ orderId: "r1", sku: "race" });
+            yield* suspendedRow(run.executionId);
+            yield* shipper.Pay({ orderId: "r1", amount: 5 });
+            expect(yield* run.result).toBe("r-race:paid-5");
+            expect(fixture.runs.get("reserve:r1")).toBe(1);
+        })),
+    },
+    {
+        name: "workflows: a race whose branches all suspend resumes and records the clock winner",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const shipper = yield* Shipper.get("race-clock");
+            const run = yield* shipper.Ship({ orderId: "r2", sku: "race" });
+            yield* suspendedRow(run.executionId);
+            yield* test.advance("11 seconds");
+            expect(yield* run.result).toBe("r-race:grace");
+            const again = yield* Shipper.run(Ship, run.executionId);
+            expect(yield* again.result).toBe("r-race:grace");
+        })),
+    },
+    {
+        name: "workflows: rerunning one keyless start effect attaches to its execution",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const shipper = yield* Shipper.get("keyless");
+            const start = shipper.Quote({ n: 1 });
+            const first = yield* start;
+            const retried = yield* start;
+            expect(retried.executionId).toBe(first.executionId);
+            expect(yield* retried.result).toBe("q-1");
+            const fresh = yield* shipper.Quote({ n: 1 });
+            expect(fresh.executionId).not.toBe(first.executionId);
+        })),
+    },
+    {
+        name: "workflows: interrupt is authorized as the execution's workflow member",
+        run: ({ expect, environment, fixture, access }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const shipper = yield* Shipper.get("interrupt-authz");
+            const run = yield* shipper.Ship({ orderId: "a1", sku: "wait" });
+            yield* suspendedRow(run.executionId);
+            access.denied.add("Ship");
+            expect(yield* run.interrupt.pipe(Effect.flip)).toMatchObject({
+                reason: Unauthorized.make({ code: "access_denied" }),
+            });
+            access.denied.delete("Ship");
+            yield* run.interrupt;
+            const exit = yield* run.result.pipe(Effect.exit);
+            expect(Exit.isFailure(exit) && Exit.hasInterrupts(exit)).toBe(true);
+        }).pipe(Effect.ensuring(Effect.sync(() => access.denied.delete("Ship"))))),
+    },
+];

package/dist/testing/conformance/workflows/waits.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type WorkflowsFixture } from "./actors.ts";
+/** Owner-event waits, clocks, and retention pins of workflows. */
+export declare const workflowWaitConformance: ReadonlyArray<ConformanceCase<WorkflowsFixture>>;