@rikalabs/akter 0.1.0-alpha.0

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

@@ -0,0 +1,305 @@
+import { Deferred, Effect, Layer, Option, Schema } from "effect";
+import { WorkflowEngine } from "effect/workflow";
+import { Actor, Intent } from "../../../index.js";
+import { engineFixture, Flake, probeBody, ProbeInput, } from "../workflow-engine.js";
+export const workflowsFixture = () => ({
+    runs: new Map(),
+    blocked: undefined,
+    engine: engineFixture(),
+    audits: new Map(),
+    gates: new Map(),
+});
+const Paid = Actor.event("Paid", { orderId: Schema.String, amount: Schema.Int });
+export class OutOfStock extends Schema.TaggedError()("OutOfStock", {
+    sku: Schema.String,
+}) {
+}
+export const Ship = Actor.workflow("Ship", {
+    payload: { orderId: Schema.String, sku: Schema.String },
+    success: Schema.String,
+    error: OutOfStock,
+    key: ({ orderId }) => orderId,
+    versions: { label: { current: 2, min: 0 } },
+});
+const Reserve = Ship.step("reserve", {
+    payload: Schema.String,
+    success: Schema.String,
+    error: OutOfStock,
+});
+const CoolOff = Ship.sleep("cool-off");
+const AwaitPaid = Ship.wait("paid", Paid);
+const Grace = Ship.sleep("grace");
+const FirstSignal = Ship.race("first-signal", { success: Schema.String });
+export const Quote = Actor.workflow("Quote", {
+    payload: { n: Schema.Int },
+    success: Schema.String,
+});
+const Pay = Actor.command("Pay", {
+    payload: { orderId: Schema.String, amount: Schema.Int },
+});
+const Charge = Actor.command("Charge", { payload: Schema.String, success: Schema.Int });
+const Record = Actor.command("Record", { payload: Schema.String });
+/** Records the tenant and caller of each call it receives. */
+const Audit = Actor.make("Audit", { key: Schema.String, api: { Record } });
+/** Sleeps, then calls `Audit` from an activity, so the call runs after a resume. */
+export const Attributed = Actor.workflow("Attributed", {
+    payload: { key: Schema.String },
+    success: Schema.String,
+    key: ({ key }) => key,
+});
+const AttributedNap = Attributed.sleep("nap");
+const Report = Attributed.step("report", { payload: Schema.String, success: Schema.String });
+/** Owner-event waits and clocks in the shapes the W2 and clock cases need, by `mode`. */
+export const Watch = Actor.workflow("Watch", {
+    payload: { mode: Schema.String, orderId: Schema.String },
+    success: Schema.String,
+    key: ({ mode, orderId }) => `${mode}/${orderId}`,
+});
+const WatchHold = Watch.step("hold", { payload: Schema.String, success: Schema.String });
+const WatchSlow = Watch.step("slow", { payload: Schema.String, success: Schema.String });
+const WatchFirst = Watch.wait("first", Paid);
+const WatchSecond = Watch.wait("second", Paid);
+const WatchPick = Watch.race("pick", { success: Schema.String });
+const WatchNapA = Watch.sleep("nap-a");
+const WatchNapB = Watch.sleep("nap-b");
+const WatchMarkA = Watch.step("mark-a", { payload: Schema.String, success: Schema.String });
+const WatchMarkB = Watch.step("mark-b", { payload: Schema.String, success: Schema.String });
+const WatchLong = Watch.sleep("long");
+const WatchEmit = Watch.step("emit", { payload: Schema.String, success: Schema.String });
+const Emit = Actor.command("Emit", {
+    payload: { orderId: Schema.String, amount: Schema.Int },
+});
+/** Waits for a `Paid` event for order `k`, with no timeout. */
+const Held = Actor.workflow("Held", { success: Schema.String });
+const HeldPaid = Held.wait("paid", Paid);
+/** Prunes events after an hour, so a case can see which ones a pending wait pins. */
+export const Keeper = Actor.make("Keeper", {
+    key: Schema.String,
+    events: [Paid],
+    api: { Emit, Held },
+    policy: { keepEvents: "1 hour" },
+});
+/** Creates a step constructor inside its body, which the engine must refuse. */
+const Loose = Actor.workflow("Loose", { success: Schema.String });
+let looseSteps = 0;
+export const Ledger = Actor.make("Ledger", {
+    key: Schema.String,
+    state: Actor.state({ count: Schema.Int.pipe(Schema.withDecodingDefault(Effect.succeed(0))) }),
+    api: { Charge },
+});
+const Begin = Actor.command("Begin", {
+    payload: { orderId: Schema.String, sku: Schema.String },
+    success: Schema.String,
+});
+const Defer = Actor.command("Defer", {
+    payload: { orderId: Schema.String, sku: Schema.String },
+    success: Schema.String,
+});
+export const Shipper = Actor.make("Shipper", {
+    key: Schema.String,
+    events: [Paid],
+    api: { Ship, Quote, Pay, Begin, Attributed, Loose, Watch, Defer },
+});
+export const Probe = Actor.workflow("Probe", {
+    payload: ProbeInput,
+    success: Schema.String,
+    error: Flake,
+    key: ({ scenario, key }) => `${scenario}/${key}`,
+});
+const probeSteps = {
+    once: Probe.step("once", { success: Schema.String, error: Flake }),
+    fast: Probe.step("fast", { success: Schema.String, error: Flake }),
+    hold: Probe.step("hold", { success: Schema.String, error: Flake }),
+    flaky: Probe.step("flaky", { success: Schema.String, error: Flake }),
+};
+const Nap = Probe.sleep("nap");
+const Pick = Probe.race("pick", { success: Schema.String });
+/** Reports whether a body can reach an Effect `WorkflowEngine`, as `DurableDeferred.done` needs. */
+const Inspect = Actor.workflow("Inspect", { success: Schema.String });
+export const EngineProbe = Actor.make("EngineProbe", {
+    key: Schema.String,
+    api: { Probe, Inspect },
+});
+const probePrimitives = {
+    activity: (name, execute) => probeSteps[name].run(undefined, () => execute),
+    sleep: (_, duration) => Nap(duration),
+    race: (_, effects) => Pick.run(effects),
+};
+const bump = (fixture, key) => Effect.sync(() => fixture.runs.set(key, (fixture.runs.get(key) ?? 0) + 1));
+const LedgerLive = Ledger.toLayer(Effect.succeed({
+    Charge: Effect.fnUntraced(function* () {
+        const turn = yield* Ledger.Turn;
+        yield* turn.state.set({ count: turn.state.count + 1 });
+        return turn.state.count;
+    }),
+}));
+export const workflowsLayer = (fixture) => Layer.mergeAll(LedgerLive, Keeper.toLayer(Effect.succeed({
+    Emit: Effect.fnUntraced(function* (input) {
+        yield* (yield* Keeper.Turn).emit(Paid.make(input));
+    }),
+    Held: () => HeldPaid({ where: (event) => event.orderId === "k" }).pipe(Effect.map(Option.match({ onNone: () => "unpaid", onSome: (event) => `paid-${event.amount}` }))),
+})), Audit.toLayer(Effect.succeed({
+    Record: Effect.fnUntraced(function* (key) {
+        const turn = yield* Audit.Turn;
+        fixture.audits.set(key, { tenant: turn.ref.tenant, caller: turn.caller });
+    }),
+})), EngineProbe.toLayer(Effect.succeed({
+    Probe: (input) => probeBody({ primitives: probePrimitives, fixture: fixture.engine, input }),
+    Inspect: () => Effect.serviceOption(WorkflowEngine.WorkflowEngine).pipe(Effect.map((engine) => (Option.isSome(engine) ? "present" : "absent"))),
+})), Shipper.toLayer(Effect.succeed({
+    Begin: Effect.fnUntraced(function* (input) {
+        const turn = yield* Shipper.Turn;
+        yield* turn.emit(Paid.make({ orderId: input.orderId, amount: 3 }));
+        return yield* (yield* Shipper.intents(turn.id)).Ship(input);
+    }),
+    Defer: Effect.fnUntraced(function* (input) {
+        const turn = yield* Shipper.Turn;
+        return yield* (yield* Shipper.intents(turn.id))
+            .Ship(input)
+            .pipe(Intent.after("500 millis"));
+    }),
+    Pay: Effect.fnUntraced(function* (input) {
+        const turn = yield* Shipper.Turn;
+        yield* turn.emit(Paid.make(input));
+    }),
+    Quote: (input) => Effect.succeed(`q-${input.n}`),
+    Attributed: Effect.fnUntraced(function* (input) {
+        const wf = yield* Shipper.Workflow;
+        yield* AttributedNap("10 seconds");
+        yield* Report.run(input.key, (key) => Effect.gen(function* () {
+            yield* (yield* Audit.get(key)).Record(key).pipe(Effect.orDie);
+            return key;
+        }));
+        return Option.match(wf.principal, {
+            onNone: () => "anonymous",
+            onSome: ({ subject }) => subject,
+        });
+    }),
+    Watch: Effect.fnUntraced(function* (input) {
+        const { mode, orderId } = input;
+        const gated = (step, label) => step.run(orderId, (key) => Effect.gen(function* () {
+            yield* bump(fixture, `${label}:${key}`);
+            const gate = fixture.gates.get(key);
+            if (gate !== undefined)
+                yield* Deferred.await(gate);
+            return label;
+        }));
+        const marked = (step, label) => step.run(orderId, (key) => bump(fixture, `${label}:${key}`).pipe(Effect.as(label)));
+        const paid = (wait, where) => wait({
+            where: where ? (event) => event.orderId === orderId : undefined,
+            timeout: "1 minute",
+        }).pipe(Effect.map(Option.match({ onNone: () => "unpaid", onSome: (event) => `paid-${event.amount}` })));
+        switch (mode) {
+            case "gated":
+                yield* gated(WatchHold, "hold");
+                return yield* paid(WatchFirst, true);
+            case "plain":
+                return yield* paid(WatchFirst, true);
+            case "any":
+                return yield* paid(WatchFirst, false);
+            case "two":
+                return `${yield* paid(WatchFirst, true)}|${yield* paid(WatchSecond, true)}`;
+            case "race":
+                return yield* WatchPick.run([paid(WatchFirst, true), gated(WatchSlow, "slow")]);
+            case "clocks":
+                yield* Effect.all([
+                    WatchNapA("5 seconds").pipe(Effect.andThen(marked(WatchMarkA, "mark-a"))),
+                    WatchNapB("10 seconds").pipe(Effect.andThen(marked(WatchMarkB, "mark-b"))),
+                ], { concurrency: "unbounded" });
+                return "clocks";
+            case "phases":
+                yield* WatchNapA("5 seconds");
+                yield* gated(WatchHold, "hold");
+                yield* WatchNapB("5 seconds");
+                return "phases";
+            case "long":
+                yield* WatchLong("10 seconds");
+                return yield* marked(WatchMarkA, "slept");
+            case "sibling": {
+                const { id } = yield* Shipper.Workflow;
+                const [waited, emitted] = yield* Effect.all([
+                    paid(WatchFirst, true),
+                    WatchEmit.run(orderId, (key) => Effect.gen(function* () {
+                        yield* bump(fixture, `emit:${key}`);
+                        const gate = fixture.gates.get(key);
+                        if (gate !== undefined)
+                            yield* Deferred.await(gate);
+                        yield* (yield* Shipper.get(id))
+                            .Pay({ orderId: key, amount: 8 })
+                            .pipe(Effect.orDie);
+                        return "emitted";
+                    })),
+                ], { concurrency: "unbounded" });
+                return `${waited}|${emitted}`;
+            }
+        }
+        return yield* Effect.die(new Error(`Unknown mode ${mode}`));
+    }),
+    Loose: Effect.fnUntraced(function* () {
+        looseSteps += 1;
+        const Late = Loose.step(`late-${looseSteps}`, { success: Schema.String });
+        return yield* Late.run(undefined, () => Effect.succeed("ran"));
+    }),
+    Ship: Effect.fnUntraced(function* (input) {
+        const wf = yield* Shipper.Workflow;
+        const reservation = yield* Reserve.run(input.sku, (sku) => Effect.gen(function* () {
+            yield* bump(fixture, `reserve:${input.orderId}`);
+            if (sku === "none")
+                return yield* OutOfStock.make({ sku });
+            if (sku.startsWith("charge")) {
+                const ledger = yield* Ledger.get(input.orderId);
+                const first = yield* ledger.Charge(sku).pipe(Effect.orDie);
+                const gate = fixture.blocked;
+                if (sku.includes("block") && gate !== undefined) {
+                    fixture.blocked = undefined;
+                    yield* Deferred.await(gate);
+                }
+                const again = yield* ledger.Charge(sku).pipe(Effect.orDie);
+                return `r-${sku}-${first}-${again}`;
+            }
+            const gate = fixture.blocked;
+            if ((sku.startsWith("block") || sku.startsWith("late")) && gate !== undefined) {
+                fixture.blocked = undefined;
+                yield* Deferred.await(gate);
+            }
+            if (sku.startsWith("late"))
+                return `r-${sku}-${yield* (yield* Ledger.get(input.orderId)).Charge(sku).pipe(Effect.orDie)}`;
+            return `r-${sku}`;
+        }));
+        const label = yield* wf.version("label");
+        if (input.sku.startsWith("twice"))
+            return `${reservation}|${yield* Reserve.run("again", (sku) => Effect.succeed(`r-${sku}`))}`;
+        if (input.sku.startsWith("outside"))
+            yield* (yield* Ledger.get(input.orderId)).Charge(input.sku).pipe(Effect.orDie);
+        if (input.sku.startsWith("sleep"))
+            yield* CoolOff("10 seconds");
+        if (input.sku.startsWith("race"))
+            return `${reservation}:${yield* FirstSignal.run([
+                AwaitPaid({
+                    where: (event) => event.orderId === input.orderId,
+                    timeout: "1 minute",
+                }).pipe(Effect.map(Option.match({
+                    onNone: () => "unpaid",
+                    onSome: (event) => `paid-${event.amount}`,
+                }))),
+                Grace("10 seconds").pipe(Effect.as("grace")),
+            ])}`;
+        if (input.sku.startsWith("wait")) {
+            const paid = yield* AwaitPaid({
+                where: (event) => event.orderId === input.orderId,
+                timeout: "1 minute",
+            });
+            return Option.match(paid, {
+                onNone: () => `${reservation}:unpaid`,
+                onSome: (event) => `${reservation}:paid-${event.amount}`,
+            });
+        }
+        return `${reservation}:v${label}`;
+    }),
+})));
+export const workflowsLive = (fixture) => Layer.mergeAll(workflowsLayer(fixture));
+/** Workflow actors. */
+export const workflowsSuite = {
+    fixture: workflowsFixture,
+    layer: workflowsLive,
+};

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

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type WorkflowsFixture } from "./actors.ts";
+/** Starts, recorded activities, durable sleeps, status, and inspection views of workflows. */
+export declare const workflowBasicConformance: ReadonlyArray<ConformanceCase<WorkflowsFixture>>;

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

@@ -0,0 +1,144 @@
+import { Deferred, Effect, Exit, Option } from "effect";
+import { SqlClient } from "effect/sql";
+import { ActorTest } from "../../actor-test.js";
+import { EngineProbe, OutOfStock, Ship, Shipper } from "./actors.js";
+import { eventually, reset, suspendedRow } from "./harness.js";
+/** Starts, recorded activities, durable sleeps, status, and inspection views of workflows. */
+export const workflowBasicConformance = [
+    {
+        name: "workflows: a live interrupt finishes well within the recovery interval",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            const engine = fixture.engine;
+            const key = "live-interrupt";
+            const gate = yield* Deferred.make();
+            engine.gates.set(key, gate);
+            const probe = yield* EngineProbe.get(key);
+            const run = yield* probe.Probe({ scenario: "compensate-hold", key });
+            yield* eventually(Effect.sync(() => (engine.runs.get(`hold:${key}`) ?? 0) >= 1), "the activity to start");
+            yield* run.interrupt;
+            const exit = yield* run.result.pipe(Effect.exit, Effect.timeoutOrElse({
+                duration: "10 seconds",
+                orElse: () => Effect.die(new Error("The live interrupt waited for recovery")),
+            }));
+            expect(Exit.isFailure(exit) && Exit.hasInterrupts(exit)).toBe(true);
+            expect(engine.runs.get(`compensate:${key}`)).toBe(1);
+        }).pipe(Effect.ensuring(Effect.gen(function* () {
+            const gate = fixture.engine.gates.get("live-interrupt");
+            if (gate !== undefined)
+                yield* Deferred.succeed(gate, undefined);
+        })))),
+    },
+    {
+        name: "workflows: a start returns a stable execution id, records the activity once, and finishes",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const shipper = yield* Shipper.get("stable");
+            const run = yield* shipper.Ship({ orderId: "o1", sku: "a" });
+            expect(run.executionId.startsWith("w1.")).toBe(true);
+            expect(yield* run.result).toBe("r-a:v2");
+            const again = yield* shipper.Ship({ orderId: "o1", sku: "a" });
+            expect(again.executionId).toBe(run.executionId);
+            expect(yield* again.result).toBe("r-a:v2");
+            expect(fixture.runs.get("reserve:o1")).toBe(1);
+            const polled = yield* run.poll;
+            expect(Option.isSome(polled) && polled.value._tag).toBe("Complete");
+            const reattached = yield* Shipper.run(Ship, run.executionId);
+            expect(yield* reattached.result).toBe("r-a:v2");
+        })),
+    },
+    {
+        name: "workflows: a declared activity failure is recorded and fails the run with its class",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const shipper = yield* Shipper.get("failing");
+            const run = yield* shipper.Ship({ orderId: "o2", sku: "none" });
+            const error = yield* run.result.pipe(Effect.flip);
+            expect(error).toBeInstanceOf(OutOfStock);
+            expect(error).toEqual(OutOfStock.make({ sku: "none" }));
+            expect(fixture.runs.get("reserve:o2")).toBe(1);
+        })),
+    },
+    {
+        name: "workflows: a durable sleep suspends and the relay resumes it when due",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            yield* reset(fixture);
+            const test = yield* ActorTest;
+            const shipper = yield* Shipper.get("sleeping");
+            const run = yield* shipper.Ship({ orderId: "o3", sku: "sleep" });
+            yield* suspendedRow(run.executionId);
+            const pending = yield* run.poll;
+            expect(Option.isSome(pending) && pending.value._tag).toBe("Suspended");
+            yield* test.advance("11 seconds");
+            expect(yield* run.result).toBe("r-sleep:v2");
+            expect(fixture.runs.get("reserve:o3")).toBe(1);
+        })),
+    },
+    {
+        name: "workflows: status is running while a resumed run executes and suspended only while parked",
+        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.gates.set("phases", gate);
+            const shipper = yield* Shipper.get("phases");
+            const run = yield* shipper.Watch({ mode: "phases", orderId: "phases" });
+            const status = () => sql `SELECT status FROM durable.workflows
+              WHERE execution_id = ${run.executionId}`.pipe(Effect.map((rows) => rows[0]?.status));
+            yield* suspendedRow(run.executionId);
+            expect(yield* status()).toBe("suspended");
+            yield* test.advance("6 seconds");
+            yield* eventually(Effect.sync(() => fixture.runs.get("hold:phases") === 1), "the resumed run to reach its activity");
+            expect(yield* status()).toBe("running");
+            yield* Deferred.succeed(gate, undefined);
+            yield* suspendedRow(run.executionId);
+            expect(yield* status()).toBe("suspended");
+            yield* test.advance("6 seconds");
+            expect(yield* run.result).toBe("phases");
+            expect(yield* status()).toBe("finished");
+        }).pipe(Effect.ensuring(Effect.sync(() => fixture.gates.delete("phases"))))),
+    },
+    {
+        name: "workflows: durable.workflows and durable.workflow_steps show a suspended then finished execution",
+        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("inspected");
+            const run = yield* shipper.Ship({ orderId: "o-inspect", sku: "sleep" });
+            const execution = () => sql `SELECT execution_id, tenant_id, workflow, workflow_key, status,
+                finished_at IS NOT NULL AS finished, result_bytes > 0 AS stored
+              FROM durable.workflows
+              WHERE tenant_id = ${test.tenant} AND actor_type = 'Shipper' AND actor_id = 'inspected'`;
+            const steps = () => sql `
+              SELECT step, kind, exit IS NOT NULL AS settled,
+                due_at IS NOT DISTINCT FROM to_timestamp(due_at_ms::float8 / 1000) AS dated
+              FROM durable.workflow_steps
+              WHERE tenant_id = ${test.tenant} AND execution_id = ${run.executionId}
+                AND kind IN ('activity', 'clock')
+              ORDER BY started_at_ms, step`;
+            yield* suspendedRow(run.executionId);
+            expect(yield* execution()).toEqual([
+                {
+                    execution_id: run.executionId,
+                    tenant_id: test.tenant,
+                    workflow: "Ship",
+                    workflow_key: "o-inspect",
+                    status: "suspended",
+                    finished: false,
+                    stored: null,
+                },
+            ]);
+            expect(yield* steps()).toEqual([
+                { step: "reserve", kind: "activity", settled: true, dated: true },
+                { step: "cool-off", kind: "clock", settled: false, dated: true },
+            ]);
+            yield* test.advance("11 seconds");
+            expect(yield* run.result).toBe("r-sleep:v2");
+            expect(yield* execution()).toMatchObject([
+                { status: "finished", finished: true, stored: true },
+            ]);
+            expect(yield* steps()).toEqual([]);
+        })),
+    },
+];

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

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type WorkflowsFixture } from "./actors.ts";
+/** The shared engine suite on the framework engine, plus its ours-only divergences. */
+export declare const engineConformance: ReadonlyArray<ConformanceCase<WorkflowsFixture>>;

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

@@ -0,0 +1,80 @@
+import { DateTime, Duration, Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { Actor } from "../../../index.js";
+import { ActorTest } from "../../actor-test.js";
+import { encodeExecutionId } from "../../../identity/execution.js";
+import { engineCases, eventually as eventuallyEngine, } from "../workflow-engine.js";
+import { EngineProbe, Probe } from "./actors.js";
+/**
+ * The shared engine suite's driver for the framework engine, on the
+ * conformance environment's database. Every call pins the first runtime's
+ * tenant, so an execution stays reachable across `restart`.
+ */
+const frameworkDriver = (environment) => Effect.gen(function* () {
+    const tenant = yield* Effect.promise(() => environment.run(Effect.map(Effect.service(ActorTest), (test) => test.tenant)));
+    const inTenant = (effect) => Effect.promise(() => environment.run(effect.pipe(Actor.tenant(tenant))));
+    const runOf = (scenario, key) => Effect.gen(function* () {
+        const executionId = yield* encodeExecutionId({
+            tenant,
+            actor: "EngineProbe",
+            id: key,
+            workflow: "Probe",
+            key: `${scenario}/${key}`,
+        }).pipe(Effect.orDie);
+        const reattach = EngineProbe.run(Probe, executionId).pipe(Effect.orDie);
+        return {
+            executionId,
+            poll: inTenant(Effect.flatMap(reattach, (run) => run.poll).pipe(Effect.orDie)),
+            interrupt: inTenant(Effect.flatMap(reattach, (run) => run.interrupt).pipe(Effect.orDie)),
+        };
+    });
+    const start = (scenario, key) => inTenant(Effect.flatMap(EngineProbe.get(key), (probe) => probe.Probe({ scenario, key })).pipe(Effect.orDie));
+    const driver = {
+        pollWhileRunning: "Suspended",
+        execute: (scenario, key) => start(scenario, key).pipe(Effect.flatMap((run) => inTenant(Effect.exit(run.result)))),
+        start: (scenario, key) => Effect.andThen(start(scenario, key), runOf(scenario, key)),
+        attach: runOf,
+        awaitSuspended: (run) => eventuallyEngine({
+            check: inTenant(Effect.gen(function* () {
+                const sql = yield* SqlClient.SqlClient;
+                const rows = yield* sql `SELECT status FROM actor_workflow_executions
+                WHERE execution_id = ${run.executionId}`;
+                return rows[0]?.status === "suspended";
+            }).pipe(Effect.orDie)),
+            what: `${run.executionId} to suspend`,
+        }),
+        advance: (duration) => inTenant(ActorTest.use((test) => test.advance(Duration.sum(Duration.fromInputUnsafe(duration), Duration.seconds(1))))),
+        restart: Effect.gen(function* () {
+            const now = (test) => test.now.pipe(Effect.map(DateTime.toEpochMillis));
+            const before = yield* inTenant(Effect.flatMap(Effect.service(ActorTest), now));
+            yield* environment.restart;
+            const after = yield* inTenant(Effect.flatMap(Effect.service(ActorTest), now));
+            if (before > after)
+                yield* inTenant(ActorTest.use((test) => test.advance(before - after)));
+        }),
+    };
+    return driver;
+});
+/** The shared engine suite on the framework engine, plus its ours-only divergences. */
+export const engineConformance = [
+    ...engineCases.map((engineCase, index) => ({
+        name: `workflow engine: ${engineCase.name}`,
+        timeoutMs: 60_000,
+        run: ({ expect, environment, fixture }) => Effect.runPromise(Effect.gen(function* () {
+            const driver = yield* frameworkDriver(environment);
+            yield* engineCase.run({
+                driver,
+                fixture: fixture.engine,
+                expect,
+                key: `engine-${index}`,
+            });
+        })),
+    })),
+    {
+        name: "workflow engine: a body reaches no Effect WorkflowEngine, so external DurableDeferred completion is unsupported",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const probe = yield* EngineProbe.get("inspect");
+            expect(yield* (yield* probe.Inspect({})).result).toBe("absent");
+        })),
+    },
+];

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

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type WorkflowsFixture } from "./actors.ts";
+/** Expiry bounds, fencing, deduplication, and body-shape guards of workflows. */
+export declare const workflowGuardConformance: ReadonlyArray<ConformanceCase<WorkflowsFixture>>;