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

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

@@ -1,172 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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>>;