openworkflow 0.4.1 → 0.6.0

package/dist/{core/backend-test-suite.js → backend.testsuite.js}

@@ -1,20 +1,15 @@
 import { randomUUID } from "node:crypto";
 import { afterAll, beforeAll, describe, expect, test } from "vitest";
 /**
- * Runs the Backend compliance test suite.
- *
- * This function wraps all the tests that verify a Backend implementation
- * conforms to the Backend interface contract. It uses the factory to create
- * backend instances and the teardown function to clean them up.
- *
- * @param factory - Creates a new isolated Backend instance
- * @param teardown - Cleans up a Backend instance
+ * Runs the Backend test suite.
+ * @param options - Test suite options
  */
-export function testBackend(factory, teardown) {
+export function testBackend(options) {
+    const { setup, teardown } = options;
     describe("Backend", () => {
         let backend;
         beforeAll(async () => {
-            backend = await factory();
+            backend = await setup();
         });
         afterAll(async () => {
             await teardown(backend);
@@ -87,77 +82,119 @@ export function testBackend(factory, teardown) {
         });
         describe("listWorkflowRuns()", () => {
             test("lists workflow runs ordered by creation time", async () => {
-                const isolatedBackend = await factory();
-                const first = await createPendingWorkflowRun(isolatedBackend);
+                const backend = await setup();
+                const first = await createPendingWorkflowRun(backend);
                 await sleep(10); // ensure timestamp difference
-                const second = await createPendingWorkflowRun(isolatedBackend);
-                const listed = await isolatedBackend.listWorkflowRuns({});
-                expect(listed.data.map((run) => run.id)).toEqual([first.id, second.id]);
-                await teardown(isolatedBackend);
+                const second = await createPendingWorkflowRun(backend);
+                const listed = await backend.listWorkflowRuns({});
+                const listedIds = listed.data.map((run) => run.id);
+                expect(listedIds).toEqual([second.id, first.id]);
+                await teardown(backend);
             });
             test("paginates workflow runs", async () => {
-                const isolatedBackend = await factory();
+                const backend = await setup();
                 const runs = [];
                 for (let i = 0; i < 5; i++) {
-                    runs.push(await createPendingWorkflowRun(isolatedBackend));
+                    runs.push(await createPendingWorkflowRun(backend));
                     await sleep(10);
                 }
                 // p1
-                const page1 = await isolatedBackend.listWorkflowRuns({ limit: 2 });
+                const page1 = await backend.listWorkflowRuns({ limit: 2 });
                 expect(page1.data).toHaveLength(2);
-                expect(page1.data[0]?.id).toBe(runs[0]?.id);
-                expect(page1.data[1]?.id).toBe(runs[1]?.id);
+                expect(page1.data[0]?.id).toBe(runs[4]?.id);
+                expect(page1.data[1]?.id).toBe(runs[3]?.id);
                 expect(page1.pagination.next).not.toBeNull();
                 expect(page1.pagination.prev).toBeNull();
                 // p2
-                const page2 = await isolatedBackend.listWorkflowRuns({
+                const page2 = await backend.listWorkflowRuns({
                     limit: 2,
                     after: page1.pagination.next, // eslint-disable-line @typescript-eslint/no-non-null-assertion
                 });
                 expect(page2.data).toHaveLength(2);
                 expect(page2.data[0]?.id).toBe(runs[2]?.id);
-                expect(page2.data[1]?.id).toBe(runs[3]?.id);
+                expect(page2.data[1]?.id).toBe(runs[1]?.id);
                 expect(page2.pagination.next).not.toBeNull();
                 expect(page2.pagination.prev).not.toBeNull();
                 // p3
-                const page3 = await isolatedBackend.listWorkflowRuns({
+                const page3 = await backend.listWorkflowRuns({
                     limit: 2,
                     after: page2.pagination.next, // eslint-disable-line @typescript-eslint/no-non-null-assertion
                 });
                 expect(page3.data).toHaveLength(1);
-                expect(page3.data[0]?.id).toBe(runs[4]?.id);
+                expect(page3.data[0]?.id).toBe(runs[0]?.id);
                 expect(page3.pagination.next).toBeNull();
                 expect(page3.pagination.prev).not.toBeNull();
                 // p2 again
-                const page2Back = await isolatedBackend.listWorkflowRuns({
+                const page2Back = await backend.listWorkflowRuns({
                     limit: 2,
                     before: page3.pagination.prev, // eslint-disable-line @typescript-eslint/no-non-null-assertion
                 });
                 expect(page2Back.data).toHaveLength(2);
                 expect(page2Back.data[0]?.id).toBe(runs[2]?.id);
-                expect(page2Back.data[1]?.id).toBe(runs[3]?.id);
+                expect(page2Back.data[1]?.id).toBe(runs[1]?.id);
                 expect(page2Back.pagination.next).toEqual(page2.pagination.next);
                 expect(page2Back.pagination.prev).toEqual(page2.pagination.prev);
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("handles empty results", async () => {
-                const isolatedBackend = await factory();
-                const listed = await isolatedBackend.listWorkflowRuns({});
+                const backend = await setup();
+                const listed = await backend.listWorkflowRuns({});
                 expect(listed.data).toHaveLength(0);
                 expect(listed.pagination.next).toBeNull();
                 expect(listed.pagination.prev).toBeNull();
-                await teardown(isolatedBackend);
+                await teardown(backend);
+            });
+            test("paginates correctly with id as tiebreaker when multiple items have the same created_at timestamp", async () => {
+                const backend = await setup();
+                const runs = [];
+                for (let i = 0; i < 5; i++) {
+                    runs.push(await createPendingWorkflowRun(backend));
+                }
+                runs.sort((a, b) => {
+                    const timeDiff = b.createdAt.getTime() - a.createdAt.getTime();
+                    if (timeDiff !== 0)
+                        return timeDiff;
+                    return b.id.localeCompare(a.id);
+                });
+                const page1 = await backend.listWorkflowRuns({ limit: 2 });
+                expect(page1.data).toHaveLength(2);
+                expect(page1.data[0]?.id).toBe(runs[0]?.id);
+                expect(page1.data[1]?.id).toBe(runs[1]?.id);
+                expect(page1.pagination.next).not.toBeNull();
+                const page2 = await backend.listWorkflowRuns({
+                    limit: 2,
+                    after: page1.pagination.next, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                });
+                expect(page2.data).toHaveLength(2);
+                expect(page2.data[0]?.id).toBe(runs[2]?.id);
+                expect(page2.data[1]?.id).toBe(runs[3]?.id);
+                expect(page2.pagination.next).not.toBeNull();
+                const page3 = await backend.listWorkflowRuns({
+                    limit: 2,
+                    after: page2.pagination.next, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                });
+                expect(page3.data).toHaveLength(1);
+                expect(page3.data[0]?.id).toBe(runs[4]?.id);
+                expect(page3.pagination.next).toBeNull();
+                const page2Back = await backend.listWorkflowRuns({
+                    limit: 2,
+                    before: page3.pagination.prev, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                });
+                expect(page2Back.data).toHaveLength(2);
+                expect(page2Back.data[0]?.id).toBe(runs[2]?.id);
+                expect(page2Back.data[1]?.id).toBe(runs[3]?.id);
+                await teardown(backend);
             });
         });
         describe("claimWorkflowRun()", () => {
             // because claims involve timing and leases, we create and teardown a new
             // namespaced backend instance for each test
             test("claims workflow runs and respects leases, reclaiming if lease expires", async () => {
-                const isolatedBackend = await factory();
-                await createPendingWorkflowRun(isolatedBackend);
+                const backend = await setup();
+                await createPendingWorkflowRun(backend);
                 const firstLeaseMs = 30;
                 const firstWorker = randomUUID();
-                const claimed = await isolatedBackend.claimWorkflowRun({
+                const claimed = await backend.claimWorkflowRun({
                     workerId: firstWorker,
                     leaseDurationMs: firstLeaseMs,
                 });
@@ -166,13 +203,13 @@ export function testBackend(factory, teardown) {
                 expect(claimed?.attempts).toBe(1);
                 expect(claimed?.startedAt).not.toBeNull();
                 const secondWorker = randomUUID();
-                const blocked = await isolatedBackend.claimWorkflowRun({
+                const blocked = await backend.claimWorkflowRun({
                     workerId: secondWorker,
                     leaseDurationMs: 10,
                 });
                 expect(blocked).toBeNull();
-                await sleep(firstLeaseMs);
-                const reclaimed = await isolatedBackend.claimWorkflowRun({
+                await sleep(firstLeaseMs + 5); // small buffer for timing variability
+                const reclaimed = await backend.claimWorkflowRun({
                     workerId: secondWorker,
                     leaseDurationMs: 10,
                 });
@@ -180,12 +217,12 @@ export function testBackend(factory, teardown) {
                 expect(reclaimed?.attempts).toBe(2);
                 expect(reclaimed?.workerId).toBe(secondWorker);
                 expect(reclaimed?.startedAt?.getTime()).toBe(claimed?.startedAt?.getTime());
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("prioritizes pending workflow runs over expired running ones", async () => {
-                const isolatedBackend = await factory();
-                const running = await createPendingWorkflowRun(isolatedBackend);
-                const runningClaim = await isolatedBackend.claimWorkflowRun({
+                const backend = await setup();
+                const running = await createPendingWorkflowRun(backend);
+                const runningClaim = await backend.claimWorkflowRun({
                     workerId: "worker-running",
                     leaseDurationMs: 5,
                 });
@@ -194,28 +231,28 @@ export function testBackend(factory, teardown) {
                 expect(runningClaim.id).toBe(running.id);
                 await sleep(10); // wait for running's lease to expire
                 // pending claimed first, even though running expired
-                const pending = await createPendingWorkflowRun(isolatedBackend);
-                const claimedFirst = await isolatedBackend.claimWorkflowRun({
+                const pending = await createPendingWorkflowRun(backend);
+                const claimedFirst = await backend.claimWorkflowRun({
                     workerId: "worker-second",
                     leaseDurationMs: 100,
                 });
                 expect(claimedFirst?.id).toBe(pending.id);
                 // running claimed second
-                const claimedSecond = await isolatedBackend.claimWorkflowRun({
+                const claimedSecond = await backend.claimWorkflowRun({
                     workerId: "worker-third",
                     leaseDurationMs: 100,
                 });
                 expect(claimedSecond?.id).toBe(running.id);
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("returns null when no workflow runs are available", async () => {
-                const isolatedBackend = await factory();
-                const claimed = await isolatedBackend.claimWorkflowRun({
+                const backend = await setup();
+                const claimed = await backend.claimWorkflowRun({
                     workerId: randomUUID(),
                     leaseDurationMs: 10,
                 });
                 expect(claimed).toBeNull();
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
         });
         describe("extendWorkflowRunLease()", () => {
@@ -262,42 +299,42 @@ export function testBackend(factory, teardown) {
                 expect(fetched?.status).toBe("sleeping");
             });
             test("fails when trying to sleep a canceled workflow", async () => {
-                const isolatedBackend = await factory();
+                const backend = await setup();
                 // completed run
-                let claimed = await createClaimedWorkflowRun(isolatedBackend);
-                await isolatedBackend.completeWorkflowRun({
+                let claimed = await createClaimedWorkflowRun(backend);
+                await backend.completeWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId: claimed.workerId ?? "",
                     output: null,
                 });
-                await expect(isolatedBackend.sleepWorkflowRun({
+                await expect(backend.sleepWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId: claimed.workerId ?? "",
                     availableAt: new Date(Date.now() + 60_000),
                 })).rejects.toThrow("Failed to sleep workflow run");
                 // failed run
-                claimed = await createClaimedWorkflowRun(isolatedBackend);
-                await isolatedBackend.failWorkflowRun({
+                claimed = await createClaimedWorkflowRun(backend);
+                await backend.failWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId: claimed.workerId ?? "",
-                    error: null,
+                    error: { message: "failed" },
                 });
-                await expect(isolatedBackend.sleepWorkflowRun({
+                await expect(backend.sleepWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId: claimed.workerId ?? "",
                     availableAt: new Date(Date.now() + 60_000),
                 })).rejects.toThrow("Failed to sleep workflow run");
                 // canceled run
-                claimed = await createClaimedWorkflowRun(isolatedBackend);
-                await isolatedBackend.cancelWorkflowRun({
+                claimed = await createClaimedWorkflowRun(backend);
+                await backend.cancelWorkflowRun({
                     workflowRunId: claimed.id,
                 });
-                await expect(isolatedBackend.sleepWorkflowRun({
+                await expect(backend.sleepWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId: claimed.workerId ?? "",
                     availableAt: new Date(Date.now() + 60_000),
                 })).rejects.toThrow("Failed to sleep workflow run");
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
         });
         describe("completeWorkflowRun()", () => {
@@ -346,6 +383,7 @@ export function testBackend(factory, teardown) {
                 expect(failed.output).toBeNull();
                 expect(failed.finishedAt).toBeNull();
                 expect(failed.workerId).toBeNull();
+                expect(failed.startedAt).toBeNull(); // cleared on failure for retry
                 expect(failed.availableAt).not.toBeNull();
                 if (!failed.availableAt)
                     throw new Error("Expected availableAt");
@@ -353,20 +391,20 @@ export function testBackend(factory, teardown) {
                 expect(delayMs).toBeGreaterThanOrEqual(900); // ~1s with some tolerance
                 expect(delayMs).toBeLessThan(1500);
             });
-            test("reschedules with increasing backoff on multiple failures (known slow test)", async () => {
+            test("reschedules with increasing backoff on multiple failures", async () => {
                 // this test needs isolated namespace
-                const isolatedBackend = await factory();
-                await createPendingWorkflowRun(isolatedBackend);
+                const backend = await setup();
+                await createPendingWorkflowRun(backend);
                 // fail first attempt
                 let workerId = randomUUID();
-                let claimed = await isolatedBackend.claimWorkflowRun({
+                let claimed = await backend.claimWorkflowRun({
                     workerId,
                     leaseDurationMs: 20,
                 });
                 if (!claimed)
                     throw new Error("Expected workflow run to be claimed");
                 expect(claimed.attempts).toBe(1);
-                const firstFailed = await isolatedBackend.failWorkflowRun({
+                const firstFailed = await backend.failWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId,
                     error: { message: "first failure" },
@@ -375,7 +413,7 @@ export function testBackend(factory, teardown) {
                 await sleep(1100); // wait for first backoff (~1s)
                 // fail second attempt
                 workerId = randomUUID();
-                claimed = await isolatedBackend.claimWorkflowRun({
+                claimed = await backend.claimWorkflowRun({
                     workerId,
                     leaseDurationMs: 20,
                 });
@@ -383,7 +421,7 @@ export function testBackend(factory, teardown) {
                     throw new Error("Expected workflow run to be claimed");
                 expect(claimed.attempts).toBe(2);
                 const beforeSecondFail = Date.now();
-                const secondFailed = await isolatedBackend.failWorkflowRun({
+                const secondFailed = await backend.failWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId,
                     error: { message: "second failure" },
@@ -395,7 +433,7 @@ export function testBackend(factory, teardown) {
                 const delayMs = secondFailed.availableAt.getTime() - beforeSecondFail;
                 expect(delayMs).toBeGreaterThanOrEqual(1900); // ~2s with some tolerance
                 expect(delayMs).toBeLessThan(2500);
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
         });
         describe("createStepAttempt()", () => {
@@ -472,6 +510,7 @@ export function testBackend(factory, teardown) {
                     workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion,
                     output: { ok: true },
                 });
+                await sleep(10); // ensure timestamp difference
                 const second = await backend.createStepAttempt({
                     workflowRunId: claimed.id,
                     workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
@@ -483,10 +522,8 @@ export function testBackend(factory, teardown) {
                 const listed = await backend.listStepAttempts({
                     workflowRunId: claimed.id,
                 });
-                expect(listed.data.map((step) => step.stepName)).toEqual([
-                    first.stepName,
-                    second.stepName,
-                ]);
+                const listedStepNames = listed.data.map((step) => step.stepName);
+                expect(listedStepNames).toEqual([first.stepName, second.stepName]);
             });
             test("paginates step attempts", async () => {
                 const claimed = await createClaimedWorkflowRun(backend);
@@ -572,23 +609,6 @@ export function testBackend(factory, teardown) {
                 expect(listed.pagination.prev).toBeNull();
             });
         });
-        describe("getStepAttempt() duplicate", () => {
-            test("returns a persisted step attempt", async () => {
-                const claimed = await createClaimedWorkflowRun(backend);
-                const created = await backend.createStepAttempt({
-                    workflowRunId: claimed.id,
-                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
-                    stepName: randomUUID(),
-                    kind: "function",
-                    config: {},
-                    context: null,
-                });
-                const got = await backend.getStepAttempt({
-                    stepAttemptId: created.id,
-                });
-                expect(got).toEqual(created);
-            });
-        });
         describe("completeStepAttempt()", () => {
             test("marks running step attempts as completed", async () => {
                 const claimed = await createClaimedWorkflowRun(backend);
@@ -619,6 +639,50 @@ export function testBackend(factory, teardown) {
                 expect(fetched?.error).toBeNull();
                 expect(fetched?.finishedAt).not.toBeNull();
             });
+            test("throws when workflow is not running", async () => {
+                const backend = await setup();
+                await createPendingWorkflowRun(backend);
+                // create a step attempt by first claiming the workflow
+                const claimed = await backend.claimWorkflowRun({
+                    workerId: randomUUID(),
+                    leaseDurationMs: 100,
+                });
+                if (!claimed)
+                    throw new Error("Failed to claim workflow run");
+                const stepAttempt = await backend.createStepAttempt({
+                    workflowRunId: claimed.id,
+                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    stepName: randomUUID(),
+                    kind: "function",
+                    config: {},
+                    context: null,
+                });
+                // complete the workflow so it's no longer running
+                await backend.completeWorkflowRun({
+                    workflowRunId: claimed.id,
+                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    output: null,
+                });
+                // try to complete the step attempt
+                await expect(backend.completeStepAttempt({
+                    workflowRunId: claimed.id,
+                    stepAttemptId: stepAttempt.id,
+                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    output: { foo: "bar" },
+                })).rejects.toThrow("Failed to mark step attempt completed");
+                await teardown(backend);
+            });
+            test("throws when step attempt does not exist", async () => {
+                const backend = await setup();
+                const claimed = await createClaimedWorkflowRun(backend);
+                await expect(backend.completeStepAttempt({
+                    workflowRunId: claimed.id,
+                    stepAttemptId: randomUUID(),
+                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    output: { foo: "bar" },
+                })).rejects.toThrow("Failed to mark step attempt completed");
+                await teardown(backend);
+            });
         });
         describe("failStepAttempt()", () => {
             test("marks running step attempts as failed", async () => {
@@ -650,6 +714,50 @@ export function testBackend(factory, teardown) {
                 expect(fetched?.output).toBeNull();
                 expect(fetched?.finishedAt).not.toBeNull();
             });
+            test("throws when workflow is not running", async () => {
+                const backend = await setup();
+                await createPendingWorkflowRun(backend);
+                // create a step attempt by first claiming the workflow
+                const claimed = await backend.claimWorkflowRun({
+                    workerId: randomUUID(),
+                    leaseDurationMs: 100,
+                });
+                if (!claimed)
+                    throw new Error("Failed to claim workflow run");
+                const stepAttempt = await backend.createStepAttempt({
+                    workflowRunId: claimed.id,
+                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    stepName: randomUUID(),
+                    kind: "function",
+                    config: {},
+                    context: null,
+                });
+                // complete the workflow so it's no longer running
+                await backend.completeWorkflowRun({
+                    workflowRunId: claimed.id,
+                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    output: null,
+                });
+                // try to fail the step attempt
+                await expect(backend.failStepAttempt({
+                    workflowRunId: claimed.id,
+                    stepAttemptId: stepAttempt.id,
+                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    error: { message: "nope" },
+                })).rejects.toThrow("Failed to mark step attempt failed");
+                await teardown(backend);
+            });
+            test("throws when step attempt does not exist", async () => {
+                const backend = await setup();
+                const claimed = await createClaimedWorkflowRun(backend);
+                await expect(backend.failStepAttempt({
+                    workflowRunId: claimed.id,
+                    stepAttemptId: randomUUID(),
+                    workerId: claimed.workerId, // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    error: { message: "nope" },
+                })).rejects.toThrow("Failed to mark step attempt failed");
+                await teardown(backend);
+            });
         });
         describe("deadline_at", () => {
             test("creates a workflow run with a deadline", async () => {
@@ -668,9 +776,9 @@ export function testBackend(factory, teardown) {
                 expect(created.deadlineAt?.getTime()).toBe(deadline.getTime());
             });
             test("does not claim workflow runs past their deadline", async () => {
-                const isolatedBackend = await factory();
+                const backend = await setup();
                 const pastDeadline = new Date(Date.now() - 1000);
-                await isolatedBackend.createWorkflowRun({
+                await backend.createWorkflowRun({
                     workflowName: randomUUID(),
                     version: null,
                     idempotencyKey: null,
@@ -680,17 +788,17 @@ export function testBackend(factory, teardown) {
                     availableAt: null,
                     deadlineAt: pastDeadline,
                 });
-                const claimed = await isolatedBackend.claimWorkflowRun({
+                const claimed = await backend.claimWorkflowRun({
                     workerId: randomUUID(),
                     leaseDurationMs: 1000,
                 });
                 expect(claimed).toBeNull();
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("marks deadline-expired workflow runs as failed when claiming", async () => {
-                const isolatedBackend = await factory();
+                const backend = await setup();
                 const pastDeadline = new Date(Date.now() - 1000);
-                const created = await isolatedBackend.createWorkflowRun({
+                const created = await backend.createWorkflowRun({
                     workflowName: randomUUID(),
                     version: null,
                     idempotencyKey: null,
@@ -701,13 +809,13 @@ export function testBackend(factory, teardown) {
                     deadlineAt: pastDeadline,
                 });
                 // attempt to claim triggers deadline check
-                const claimed = await isolatedBackend.claimWorkflowRun({
+                const claimed = await backend.claimWorkflowRun({
                     workerId: randomUUID(),
                     leaseDurationMs: 1000,
                 });
                 expect(claimed).toBeNull();
                 // verify it was marked as failed
-                const failed = await isolatedBackend.getWorkflowRun({
+                const failed = await backend.getWorkflowRun({
                     workflowRunId: created.id,
                 });
                 expect(failed?.status).toBe("failed");
@@ -716,12 +824,12 @@ export function testBackend(factory, teardown) {
                 });
                 expect(failed?.finishedAt).not.toBeNull();
                 expect(failed?.availableAt).toBeNull();
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("does not reschedule failed workflow runs if next retry would exceed deadline", async () => {
-                const isolatedBackend = await factory();
+                const backend = await setup();
                 const deadline = new Date(Date.now() + 500); // 500ms from now
-                const created = await isolatedBackend.createWorkflowRun({
+                const created = await backend.createWorkflowRun({
                     workflowName: randomUUID(),
                     version: null,
                     idempotencyKey: null,
@@ -732,13 +840,13 @@ export function testBackend(factory, teardown) {
                     deadlineAt: deadline,
                 });
                 const workerId = randomUUID();
-                const claimed = await isolatedBackend.claimWorkflowRun({
+                const claimed = await backend.claimWorkflowRun({
                     workerId,
                     leaseDurationMs: 100,
                 });
                 expect(claimed).not.toBeNull();
                 // should mark as permanently failed since retry backoff (1s) would exceed deadline (500ms)
-                const failed = await isolatedBackend.failWorkflowRun({
+                const failed = await backend.failWorkflowRun({
                     workflowRunId: created.id,
                     workerId,
                     error: { message: "test error" },
@@ -746,12 +854,13 @@ export function testBackend(factory, teardown) {
                 expect(failed.status).toBe("failed");
                 expect(failed.availableAt).toBeNull();
                 expect(failed.finishedAt).not.toBeNull();
-                await teardown(isolatedBackend);
+                expect(failed.startedAt).toBeNull(); // cleared on permanent failure
+                await teardown(backend);
             });
             test("reschedules failed workflow runs if retry would complete before deadline", async () => {
-                const isolatedBackend = await factory();
+                const backend = await setup();
                 const deadline = new Date(Date.now() + 5000); // in 5 seconds
-                const created = await isolatedBackend.createWorkflowRun({
+                const created = await backend.createWorkflowRun({
                     workflowName: randomUUID(),
                     version: null,
                     idempotencyKey: null,
@@ -762,13 +871,13 @@ export function testBackend(factory, teardown) {
                     deadlineAt: deadline,
                 });
                 const workerId = randomUUID();
-                const claimed = await isolatedBackend.claimWorkflowRun({
+                const claimed = await backend.claimWorkflowRun({
                     workerId,
                     leaseDurationMs: 100,
                 });
                 expect(claimed).not.toBeNull();
                 // should reschedule since retry backoff (1s) is before deadline (5s
-                const failed = await isolatedBackend.failWorkflowRun({
+                const failed = await backend.failWorkflowRun({
                     workflowRunId: created.id,
                     workerId,
                     error: { message: "test error" },
@@ -776,15 +885,15 @@ export function testBackend(factory, teardown) {
                 expect(failed.status).toBe("pending");
                 expect(failed.availableAt).not.toBeNull();
                 expect(failed.finishedAt).toBeNull();
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
         });
         describe("cancelWorkflowRun()", () => {
             test("cancels a pending workflow run", async () => {
-                const isolatedBackend = await factory();
-                const created = await createPendingWorkflowRun(isolatedBackend);
+                const backend = await setup();
+                const created = await createPendingWorkflowRun(backend);
                 expect(created.status).toBe("pending");
-                const canceled = await isolatedBackend.cancelWorkflowRun({
+                const canceled = await backend.cancelWorkflowRun({
                     workflowRunId: created.id,
                 });
                 expect(canceled.status).toBe("canceled");
@@ -792,60 +901,60 @@ export function testBackend(factory, teardown) {
                 expect(canceled.availableAt).toBeNull();
                 expect(canceled.finishedAt).not.toBeNull();
                 expect(deltaSeconds(canceled.finishedAt)).toBeLessThan(1);
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("cancels a running workflow run", async () => {
-                const isolatedBackend = await factory();
-                const created = await createClaimedWorkflowRun(isolatedBackend);
+                const backend = await setup();
+                const created = await createClaimedWorkflowRun(backend);
                 expect(created.status).toBe("running");
                 expect(created.workerId).not.toBeNull();
-                const canceled = await isolatedBackend.cancelWorkflowRun({
+                const canceled = await backend.cancelWorkflowRun({
                     workflowRunId: created.id,
                 });
                 expect(canceled.status).toBe("canceled");
                 expect(canceled.workerId).toBeNull();
                 expect(canceled.availableAt).toBeNull();
                 expect(canceled.finishedAt).not.toBeNull();
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("cancels a sleeping workflow run", async () => {
-                const isolatedBackend = await factory();
-                const claimed = await createClaimedWorkflowRun(isolatedBackend);
+                const backend = await setup();
+                const claimed = await createClaimedWorkflowRun(backend);
                 // put workflow to sleep
                 const sleepUntil = new Date(Date.now() + 60_000); // 1 minute from now
-                const sleeping = await isolatedBackend.sleepWorkflowRun({
+                const sleeping = await backend.sleepWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId: claimed.workerId ?? "",
                     availableAt: sleepUntil,
                 });
                 expect(sleeping.status).toBe("sleeping");
-                const canceled = await isolatedBackend.cancelWorkflowRun({
+                const canceled = await backend.cancelWorkflowRun({
                     workflowRunId: sleeping.id,
                 });
                 expect(canceled.status).toBe("canceled");
                 expect(canceled.workerId).toBeNull();
                 expect(canceled.availableAt).toBeNull();
                 expect(canceled.finishedAt).not.toBeNull();
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("throws error when canceling a completed workflow run", async () => {
-                const isolatedBackend = await factory();
-                const claimed = await createClaimedWorkflowRun(isolatedBackend);
+                const backend = await setup();
+                const claimed = await createClaimedWorkflowRun(backend);
                 // mark as completed
-                await isolatedBackend.completeWorkflowRun({
+                await backend.completeWorkflowRun({
                     workflowRunId: claimed.id,
                     workerId: claimed.workerId ?? "",
                     output: { result: "success" },
                 });
-                await expect(isolatedBackend.cancelWorkflowRun({
+                await expect(backend.cancelWorkflowRun({
                     workflowRunId: claimed.id,
                 })).rejects.toThrow(/Cannot cancel workflow run .* with status completed/);
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("throws error when canceling a failed workflow run", async () => {
-                const isolatedBackend = await factory();
+                const backend = await setup();
                 // create with deadline that's already passed to make it fail
-                const workflowWithDeadline = await isolatedBackend.createWorkflowRun({
+                const workflowWithDeadline = await backend.createWorkflowRun({
                     workflowName: randomUUID(),
                     version: null,
                     idempotencyKey: null,
@@ -856,105 +965,126 @@ export function testBackend(factory, teardown) {
                     deadlineAt: new Date(Date.now() - 1000), // deadline in the past
                 });
                 // try to claim it, which should mark it as failed due to deadline
-                const claimed = await isolatedBackend.claimWorkflowRun({
+                const claimed = await backend.claimWorkflowRun({
                     workerId: randomUUID(),
                     leaseDurationMs: 100,
                 });
                 // if claim succeeds, manually fail it
                 if (claimed?.workerId) {
-                    await isolatedBackend.failWorkflowRun({
+                    await backend.failWorkflowRun({
                         workflowRunId: claimed.id,
                         workerId: claimed.workerId,
                         error: { message: "test error" },
                     });
                 }
                 // get a workflow that's definitely failed
-                const failedRun = await isolatedBackend.getWorkflowRun({
+                const failedRun = await backend.getWorkflowRun({
                     workflowRunId: workflowWithDeadline.id,
                 });
                 if (failedRun?.status === "failed") {
-                    await expect(isolatedBackend.cancelWorkflowRun({
+                    await expect(backend.cancelWorkflowRun({
                         workflowRunId: failedRun.id,
                     })).rejects.toThrow(/Cannot cancel workflow run .* with status failed/);
                 }
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("is idempotent when canceling an already canceled workflow run", async () => {
-                const isolatedBackend = await factory();
-                const created = await createPendingWorkflowRun(isolatedBackend);
-                const firstCancel = await isolatedBackend.cancelWorkflowRun({
+                const backend = await setup();
+                const created = await createPendingWorkflowRun(backend);
+                const firstCancel = await backend.cancelWorkflowRun({
                     workflowRunId: created.id,
                 });
                 expect(firstCancel.status).toBe("canceled");
-                const secondCancel = await isolatedBackend.cancelWorkflowRun({
+                const secondCancel = await backend.cancelWorkflowRun({
                     workflowRunId: created.id,
                 });
                 expect(secondCancel.status).toBe("canceled");
                 expect(secondCancel.id).toBe(firstCancel.id);
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("throws error when canceling a non-existent workflow run", async () => {
-                const isolatedBackend = await factory();
+                const backend = await setup();
                 const nonExistentId = randomUUID();
-                await expect(isolatedBackend.cancelWorkflowRun({
+                await expect(backend.cancelWorkflowRun({
                     workflowRunId: nonExistentId,
                 })).rejects.toThrow(`Workflow run ${nonExistentId} does not exist`);
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
             test("canceled workflow is not claimed by workers", async () => {
-                const isolatedBackend = await factory();
-                const created = await createPendingWorkflowRun(isolatedBackend);
+                const backend = await setup();
+                const created = await createPendingWorkflowRun(backend);
                 // cancel the workflow
-                await isolatedBackend.cancelWorkflowRun({
+                await backend.cancelWorkflowRun({
                     workflowRunId: created.id,
                 });
                 // try to claim work
-                const claimed = await isolatedBackend.claimWorkflowRun({
+                const claimed = await backend.claimWorkflowRun({
                     workerId: randomUUID(),
                     leaseDurationMs: 100,
                 });
                 // should not claim the canceled workflow
                 expect(claimed).toBeNull();
-                await teardown(isolatedBackend);
+                await teardown(backend);
             });
         });
-        // Helper function for creating workflow runs that uses the shared backend
-        async function createPendingWorkflowRun(b) {
-            return await b.createWorkflowRun({
-                workflowName: randomUUID(),
-                version: null,
-                idempotencyKey: null,
-                input: null,
-                config: {},
-                context: null,
-                availableAt: null,
-                deadlineAt: null,
-            });
-        }
-        async function createClaimedWorkflowRun(b) {
-            await createPendingWorkflowRun(b);
-            const claimed = await b.claimWorkflowRun({
-                workerId: randomUUID(),
-                leaseDurationMs: 100,
-            });
-            if (!claimed)
-                throw new Error("Failed to claim workflow run");
-            return claimed;
-        }
     });
 }
-// Helper functions
+/**
+ * Create a pending workflow run for tests.
+ * @param b - Backend
+ * @returns Created workflow run
+ */
+async function createPendingWorkflowRun(b) {
+    return await b.createWorkflowRun({
+        workflowName: randomUUID(),
+        version: null,
+        idempotencyKey: null,
+        input: null,
+        config: {},
+        context: null,
+        availableAt: null,
+        deadlineAt: null,
+    });
+}
+/**
+ * Create and claim a workflow run for tests.
+ * @param b - Backend
+ * @returns Claimed workflow run
+ */
+async function createClaimedWorkflowRun(b) {
+    await createPendingWorkflowRun(b);
+    const claimed = await b.claimWorkflowRun({
+        workerId: randomUUID(),
+        leaseDurationMs: 100,
+    });
+    if (!claimed)
+        throw new Error("Failed to claim workflow run");
+    return claimed;
+}
+/**
+ * Get delta in seconds from now.
+ * @param date - Date to compare
+ * @returns Delta in seconds
+ */
 function deltaSeconds(date) {
     if (!date)
         return Infinity;
     return Math.abs((Date.now() - date.getTime()) / 1000);
 }
+/**
+ * Create a Date one year in the future.
+ * @returns Future Date
+ */
 function newDateInOneYear() {
     const d = new Date();
     d.setFullYear(d.getFullYear() + 1);
     return d;
 }
+/**
+ * Sleep for a given duration.
+ * @param ms - Milliseconds to sleep
+ * @returns Promise resolved after sleeping
+ */
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=backend-test-suite.js.map