@dudousxd/nestjs-durable-testing 0.5.0 → 0.7.0

package/dist/index.js

@@ -5,6 +5,170 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/admission-backend-conformance.ts
+import { describe, expect, it } from "vitest";
+function runAdmissionBackendContract(name, makeBackend) {
+  describe(`AdmissionBackend contract: ${name}`, () => {
+    let now = 1e6;
+    const make = /* @__PURE__ */ __name((config) => {
+      now = 1e6;
+      const backend = makeBackend(() => now);
+      backend.register(config);
+      return backend;
+    }, "make");
+    it("caps concurrency: a second call blocks until the first releases", async () => {
+      const b = make({
+        name: "q",
+        concurrency: 1
+      });
+      expect((await b.tryAdmit("q", {
+        waiterId: "a"
+      })).ok).toBe(true);
+      expect((await b.tryAdmit("q", {
+        waiterId: "b"
+      })).ok).toBe(false);
+      await b.release("q", "a");
+      expect((await b.tryAdmit("q", {
+        waiterId: "b"
+      })).ok).toBe(true);
+    });
+    it("enforces a fixed-window rate limit", async () => {
+      const b = make({
+        name: "q",
+        rateLimit: {
+          limit: 2,
+          periodMs: 1e3
+        }
+      });
+      expect((await b.tryAdmit("q", {
+        waiterId: "1"
+      })).ok).toBe(true);
+      expect((await b.tryAdmit("q", {
+        waiterId: "2"
+      })).ok).toBe(true);
+      expect((await b.tryAdmit("q", {
+        waiterId: "3"
+      })).ok).toBe(false);
+      now += 1001;
+      expect((await b.tryAdmit("q", {
+        waiterId: "4"
+      })).ok).toBe(true);
+    });
+    it("admits the highest-priority waiter first when a slot frees", async () => {
+      const b = make({
+        name: "q",
+        concurrency: 1
+      });
+      expect((await b.tryAdmit("q", {
+        waiterId: "holder"
+      })).ok).toBe(true);
+      expect((await b.tryAdmit("q", {
+        waiterId: "low",
+        priority: 1
+      })).ok).toBe(false);
+      expect((await b.tryAdmit("q", {
+        waiterId: "high",
+        priority: 9
+      })).ok).toBe(false);
+      await b.release("q", "holder");
+      expect((await b.tryAdmit("q", {
+        waiterId: "low",
+        priority: 1
+      })).ok).toBe(false);
+      expect((await b.tryAdmit("q", {
+        waiterId: "high",
+        priority: 9
+      })).ok).toBe(true);
+    });
+    it("orders plain-concurrency waiters by arrival (FIFO) \u2014 no priority/fairness configured", async () => {
+      const b = make({
+        name: "q",
+        concurrency: 1
+      });
+      expect((await b.tryAdmit("q", {
+        waiterId: "holder"
+      })).ok).toBe(true);
+      expect((await b.tryAdmit("q", {
+        waiterId: "first"
+      })).ok).toBe(false);
+      expect((await b.tryAdmit("q", {
+        waiterId: "second"
+      })).ok).toBe(false);
+      await b.release("q", "holder");
+      expect((await b.tryAdmit("q", {
+        waiterId: "second"
+      })).ok).toBe(false);
+      expect((await b.tryAdmit("q", {
+        waiterId: "first"
+      })).ok).toBe(true);
+    });
+    it("admits the most-recent arrival first when order is LIFO", async () => {
+      const b = make({
+        name: "q",
+        concurrency: 1,
+        order: "lifo"
+      });
+      expect((await b.tryAdmit("q", {
+        waiterId: "holder"
+      })).ok).toBe(true);
+      expect((await b.tryAdmit("q", {
+        waiterId: "first"
+      })).ok).toBe(false);
+      expect((await b.tryAdmit("q", {
+        waiterId: "second"
+      })).ok).toBe(false);
+      await b.release("q", "holder");
+      expect((await b.tryAdmit("q", {
+        waiterId: "first"
+      })).ok).toBe(false);
+      expect((await b.tryAdmit("q", {
+        waiterId: "second"
+      })).ok).toBe(true);
+    });
+    it("round-robins a contended slot across fairness keys", async () => {
+      const b = make({
+        name: "q",
+        concurrency: 1,
+        fairness: "key"
+      });
+      expect((await b.tryAdmit("q", {
+        waiterId: "a0",
+        key: "A"
+      })).ok).toBe(true);
+      expect((await b.tryAdmit("q", {
+        waiterId: "a1",
+        key: "A"
+      })).ok).toBe(false);
+      expect((await b.tryAdmit("q", {
+        waiterId: "b0",
+        key: "B"
+      })).ok).toBe(false);
+      await b.release("q", "a0");
+      expect((await b.tryAdmit("q", {
+        waiterId: "a1",
+        key: "A"
+      })).ok).toBe(false);
+      expect((await b.tryAdmit("q", {
+        waiterId: "b0",
+        key: "B"
+      })).ok).toBe(true);
+    });
+    it("leaves an unregistered queue ungated", async () => {
+      const b = make({
+        name: "q",
+        concurrency: 1
+      });
+      expect((await b.tryAdmit("other", {
+        waiterId: "x"
+      })).ok).toBe(true);
+      expect((await b.tryAdmit("other", {
+        waiterId: "y"
+      })).ok).toBe(true);
+    });
+  });
+}
+__name(runAdmissionBackendContract, "runAdmissionBackendContract");
+
 // src/assertions.ts
 async function requireRun(store, runId) {
   const run2 = await store.getRun(runId);
@@ -200,7 +364,7 @@ __name(assertReplayable, "assertReplayable");
 
 // src/state-store-conformance.ts
 import { WorkflowEngine as WorkflowEngine3 } from "@dudousxd/nestjs-durable-core";
-import { beforeEach, describe, expect, it } from "vitest";
+import { beforeEach, describe as describe2, expect as expect2, it as it2 } from "vitest";
 var StateStoreUnavailableError = class extends Error {
   static {
     __name(this, "StateStoreUnavailableError");
@@ -245,7 +409,7 @@ var checkpoint = /* @__PURE__ */ __name((over = {}) => ({
   ...over
 }), "checkpoint");
 function runStateStoreContract(name, makeStore) {
-  describe(`StateStore contract: ${name}`, () => {
+  describe2(`StateStore contract: ${name}`, () => {
     let store;
     let cleanup;
     let supportsAsyncTransaction = true;
@@ -276,7 +440,7 @@ function runStateStoreContract(name, makeStore) {
       };
     });
     const t = /* @__PURE__ */ __name((label, fn) => {
-      it(label, async () => {
+      it2(label, async () => {
         if (skipReason) return;
         await fn();
       });
@@ -284,13 +448,13 @@ function runStateStoreContract(name, makeStore) {
     t("creates a run and reads it back with its JSON input", async () => {
       await store.createRun(run());
       const loaded = await store.getRun("r1");
-      expect(loaded?.workflow).toBe("checkout");
-      expect(loaded?.input).toEqual({
+      expect2(loaded?.workflow).toBe("checkout");
+      expect2(loaded?.input).toEqual({
         orderId: "o1"
       });
     });
     t("returns null for a missing run", async () => {
-      expect(await store.getRun("nope")).toBeNull();
+      expect2(await store.getRun("nope")).toBeNull();
     });
     t("updates a run (status/output) and round-trips recoveryAttempts + dead status", async () => {
       await store.createRun(run({
@@ -304,18 +468,104 @@ function runStateStoreContract(name, makeStore) {
         updatedAt: at
       });
       const done = await store.getRun("r1");
-      expect(done?.status).toBe("completed");
-      expect(done?.output).toEqual({
+      expect2(done?.status).toBe("completed");
+      expect2(done?.output).toEqual({
         total: 42
       });
-      expect(done?.recoveryAttempts).toBe(3);
+      expect2(done?.recoveryAttempts).toBe(3);
       await store.updateRun("r1", {
         status: "dead",
         recoveryAttempts: 4
       });
       const dead = await store.getRun("r1");
-      expect(dead?.status).toBe("dead");
-      expect(dead?.recoveryAttempts).toBe(4);
+      expect2(dead?.status).toBe("dead");
+      expect2(dead?.recoveryAttempts).toBe(4);
+    });
+    t("round-trips a run dispatch priority", async () => {
+      await store.createRun(run({
+        id: "withprio",
+        priority: 7
+      }));
+      await store.createRun(run({
+        id: "noprio"
+      }));
+      expect2((await store.getRun("withprio"))?.priority).toBe(7);
+      expect2((await store.getRun("noprio"))?.priority).toBeUndefined();
+    });
+    t("deleteRun removes the run and all its rows (checkpoints, waiters, attributes)", async () => {
+      await store.createRun(run({
+        searchAttributes: {
+          tier: "pro"
+        }
+      }));
+      await store.saveCheckpoint(checkpoint());
+      await store.putSignalWaiter({
+        token: "approve-r1",
+        runId: "r1",
+        seq: 0
+      });
+      await store.deleteRun("r1");
+      expect2(await store.getRun("r1")).toBeNull();
+      expect2(await store.listCheckpoints("r1")).toEqual([]);
+      expect2(await store.listSignalWaiters("approve-")).toEqual([]);
+      expect2(await store.listRuns({
+        attributes: [
+          {
+            key: "tier",
+            op: "eq",
+            value: "pro"
+          }
+        ]
+      })).toEqual([]);
+    });
+    t("deleteRun is a no-op for a missing run", async () => {
+      await expect2(store.deleteRun("nope")).resolves.toBeUndefined();
+    });
+    t("updateRun maps every patchable field \u2014 clears error and patches tags/lockedBy/input/timers", async () => {
+      await store.createRun(run({
+        status: "failed",
+        error: {
+          message: "boom"
+        },
+        tags: [
+          "old"
+        ],
+        lockedBy: "owner-1"
+      }));
+      await store.updateRun("r1", {
+        status: "completed",
+        output: {
+          ok: true
+        },
+        error: void 0,
+        input: {
+          orderId: "o2"
+        },
+        tags: [
+          "x",
+          "y"
+        ],
+        lockedBy: "owner-2",
+        wakeAt: 123456,
+        lockedUntil: 222222,
+        updatedAt: at
+      });
+      const r = await store.getRun("r1");
+      expect2(r?.status).toBe("completed");
+      expect2(r?.output).toEqual({
+        ok: true
+      });
+      expect2(r?.error).toBeUndefined();
+      expect2(r?.input).toEqual({
+        orderId: "o2"
+      });
+      expect2(r?.tags).toEqual([
+        "x",
+        "y"
+      ]);
+      expect2(r?.lockedBy).toBe("owner-2");
+      expect2(r?.wakeAt).toBe(123456);
+      expect2(r?.lockedUntil).toBe(222222);
     });
     t("upserts checkpoints, reads them by (runId, seq), and lists them ordered by seq", async () => {
       await store.createRun(run());
@@ -333,13 +583,13 @@ function runStateStoreContract(name, makeStore) {
           again: true
         }
       }));
-      expect((await store.getCheckpoint("r1", 0))?.output).toEqual({
+      expect2((await store.getCheckpoint("r1", 0))?.output).toEqual({
         ok: true,
         again: true
       });
-      expect((await store.getCheckpoint("r1", 1))?.name).toBe("charge");
+      expect2((await store.getCheckpoint("r1", 1))?.name).toBe("charge");
       const list = await store.listCheckpoints("r1");
-      expect(list.map((c) => c.seq)).toEqual([
+      expect2(list.map((c) => c.seq)).toEqual([
         0,
         1
       ]);
@@ -375,14 +625,14 @@ function runStateStoreContract(name, makeStore) {
         }
       }));
       const getLatestCheckpointByName = store.getLatestCheckpointByName;
-      expect(getLatestCheckpointByName).toBeDefined();
+      expect2(getLatestCheckpointByName).toBeDefined();
       if (!getLatestCheckpointByName) return;
       const latest = await getLatestCheckpointByName.call(store, "r1", "event:progress");
-      expect(latest?.seq).toBe(3);
-      expect(latest?.output).toEqual({
+      expect2(latest?.seq).toBe(3);
+      expect2(latest?.output).toEqual({
         pct: 90
       });
-      expect(await getLatestCheckpointByName.call(store, "r1", "event:missing")).toBeUndefined();
+      expect2(await getLatestCheckpointByName.call(store, "r1", "event:missing")).toBeUndefined();
     });
     t("listCheckpointsByNamePrefix returns prefix matches ordered by seq (empty => none)", async () => {
       await store.createRun(run());
@@ -409,18 +659,18 @@ function runStateStoreContract(name, makeStore) {
         output: "child-b"
       }));
       const listCheckpointsByNamePrefix = store.listCheckpointsByNamePrefix;
-      expect(listCheckpointsByNamePrefix).toBeDefined();
+      expect2(listCheckpointsByNamePrefix).toBeDefined();
       if (!listCheckpointsByNamePrefix) return;
       const matches = await listCheckpointsByNamePrefix.call(store, "r1", [
         "signal:child:",
         "spawn:"
       ]);
-      expect(matches.map((c) => c.name)).toEqual([
+      expect2(matches.map((c) => c.name)).toEqual([
         "spawn:0",
         "signal:child:c2",
         "spawn:1"
       ]);
-      expect(await listCheckpointsByNamePrefix.call(store, "r1", [])).toEqual([]);
+      expect2(await listCheckpointsByNamePrefix.call(store, "r1", [])).toEqual([]);
     });
     t("round-trips checkpoint events and reads back a missing checkpoint as null", async () => {
       await store.createRun(run());
@@ -435,7 +685,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       }));
-      expect((await store.getCheckpoint("r1", 0))?.events).toEqual([
+      expect2((await store.getCheckpoint("r1", 0))?.events).toEqual([
         {
           at: 1,
           level: "error",
@@ -444,7 +694,7 @@ function runStateStoreContract(name, makeStore) {
           status: "failed"
         }
       ]);
-      expect(await store.getCheckpoint("r1", 99)).toBeNull();
+      expect2(await store.getCheckpoint("r1", 99)).toBeNull();
     });
     t("lists incomplete runs, pending runs (FIFO), and due timers", async () => {
       await store.createRun(run({
@@ -470,39 +720,39 @@ function runStateStoreContract(name, makeStore) {
         status: "pending",
         createdAt: /* @__PURE__ */ new Date("2026-06-11T00:00:01.000Z")
       }));
-      expect((await store.listIncompleteRuns()).map((r) => r.id)).toEqual([
+      expect2((await store.listIncompleteRuns()).map((r) => r.id)).toEqual([
         "running1"
       ]);
-      expect((await store.listPendingRuns(10)).map((r) => r.id)).toEqual([
+      expect2((await store.listPendingRuns(10)).map((r) => r.id)).toEqual([
         "pending1",
         "pending2"
       ]);
-      expect((await store.listPendingRuns(1)).map((r) => r.id)).toEqual([
+      expect2((await store.listPendingRuns(1)).map((r) => r.id)).toEqual([
         "pending1"
       ]);
-      expect((await store.listDueTimers(1e4)).map((r) => r.id)).toEqual([
+      expect2((await store.listDueTimers(1e4)).map((r) => r.id)).toEqual([
         "suspended1"
       ]);
-      expect(await store.listDueTimers(1e3)).toHaveLength(0);
+      expect2(await store.listDueTimers(1e3)).toHaveLength(0);
     });
     t("tryLockRun is atomic and respects lease expiry", async () => {
       await store.createRun(run({
         id: "r1"
       }));
-      expect(await store.tryLockRun("r1", "A", 2e3, 1e3)).toBe(true);
-      expect(await store.tryLockRun("r1", "B", 3e3, 1500)).toBe(false);
-      expect(await store.tryLockRun("r1", "B", 4e3, 2500)).toBe(true);
+      expect2(await store.tryLockRun("r1", "A", 2e3, 1e3)).toBe(true);
+      expect2(await store.tryLockRun("r1", "B", 3e3, 1500)).toBe(false);
+      expect2(await store.tryLockRun("r1", "B", 4e3, 2500)).toBe(true);
       await store.releaseRunLock("r1");
-      expect(await store.tryLockRun("r1", "C", 9e3, 2600)).toBe(true);
+      expect2(await store.tryLockRun("r1", "C", 9e3, 2600)).toBe(true);
     });
     t("renewRunLock only succeeds for the current owner", async () => {
       await store.createRun(run({
         id: "r1"
       }));
-      expect(await store.tryLockRun("r1", "A", 2e3, 1e3)).toBe(true);
-      expect(await store.renewRunLock("r1", "A", 5e3)).toBe(true);
-      expect(await store.renewRunLock("r1", "B", 9e3)).toBe(false);
-      expect(await store.tryLockRun("r1", "B", 6e3, 4e3)).toBe(false);
+      expect2(await store.tryLockRun("r1", "A", 2e3, 1e3)).toBe(true);
+      expect2(await store.renewRunLock("r1", "A", 5e3)).toBe(true);
+      expect2(await store.renewRunLock("r1", "B", 9e3)).toBe(false);
+      expect2(await store.tryLockRun("r1", "B", 6e3, 4e3)).toBe(false);
     });
     t("filters listRuns by workflow and by status", async () => {
       await store.createRun(run({
@@ -520,19 +770,19 @@ function runStateStoreContract(name, makeStore) {
         workflow: "checkout",
         status: "completed"
       }));
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         workflow: "checkout"
       })).map((r) => r.id).sort()).toEqual([
         "a",
         "c"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         status: "running"
       })).map((r) => r.id).sort()).toEqual([
         "a",
         "b"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         workflow: "checkout",
         status: "running"
       })).map((r) => r.id)).toEqual([
@@ -556,7 +806,7 @@ function runStateStoreContract(name, makeStore) {
         id: "d",
         status: "pending"
       }));
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         statuses: [
           "running",
           "suspended"
@@ -565,7 +815,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         status: "running",
         statuses: [
           "running",
@@ -574,7 +824,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect(await store.listRuns({
+      expect2(await store.listRuns({
         statuses: []
       })).toHaveLength(0);
     });
@@ -596,21 +846,21 @@ function runStateStoreContract(name, makeStore) {
       await store.createRun(run({
         id: "c"
       }));
-      expect((await store.getRun("a"))?.tags).toEqual([
+      expect2((await store.getRun("a"))?.tags).toEqual([
         "etl",
         "critical"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         tag: "etl"
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         tag: "etl-foo"
       })).map((r) => r.id)).toEqual([
         "b"
       ]);
-      expect(await store.listRuns({
+      expect2(await store.listRuns({
         tag: "nope"
       })).toHaveLength(0);
     });
@@ -627,18 +877,18 @@ function runStateStoreContract(name, makeStore) {
         id: "new",
         createdAt: /* @__PURE__ */ new Date("2026-06-11T00:00:02.000Z")
       }));
-      expect((await store.listRuns({})).map((r) => r.id)).toEqual([
+      expect2((await store.listRuns({})).map((r) => r.id)).toEqual([
         "new",
         "mid",
         "old"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         limit: 2
       })).map((r) => r.id)).toEqual([
         "new",
         "mid"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         limit: 2,
         offset: 1
       })).map((r) => r.id)).toEqual([
@@ -668,11 +918,11 @@ function runStateStoreContract(name, makeStore) {
           tier: "pro"
         }
       }));
-      expect((await store.getRun("b"))?.searchAttributes).toEqual({
+      expect2((await store.getRun("b"))?.searchAttributes).toEqual({
         amount: 200,
         tier: "pro"
       });
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         attributes: [
           {
             key: "amount",
@@ -684,7 +934,7 @@ function runStateStoreContract(name, makeStore) {
         "b",
         "c"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -700,7 +950,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "b"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -732,7 +982,7 @@ function runStateStoreContract(name, makeStore) {
           other: 1
         }
       }));
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         attributes: [
           {
             key: "vip",
@@ -743,7 +993,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         attributes: [
           {
             key: "vip",
@@ -770,7 +1020,7 @@ function runStateStoreContract(name, makeStore) {
         "lt",
         "lte"
       ]) {
-        expect(await store.listRuns({
+        expect2(await store.listRuns({
           attributes: [
             {
               key: "missing",
@@ -789,7 +1039,7 @@ function runStateStoreContract(name, makeStore) {
           amount: 10
         }
       }));
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -805,7 +1055,7 @@ function runStateStoreContract(name, makeStore) {
           tier: "pro"
         }
       });
-      expect((await store.listRuns({
+      expect2((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -816,7 +1066,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect(await store.listRuns({
+      expect2(await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -825,7 +1075,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       })).toHaveLength(0);
-      expect(await store.listRuns({
+      expect2(await store.listRuns({
         attributes: [
           {
             key: "amount",
@@ -868,7 +1118,7 @@ function runStateStoreContract(name, makeStore) {
         ],
         limit: 10
       });
-      expect(res.map((r) => r.id)).toEqual([
+      expect2(res.map((r) => r.id)).toEqual([
         "a"
       ]);
     });
@@ -888,12 +1138,12 @@ function runStateStoreContract(name, makeStore) {
         runId: "r3",
         seq: 5
       });
-      expect((await store.listSignalWaiters("approve-")).map((w) => w.token).sort()).toEqual([
+      expect2((await store.listSignalWaiters("approve-")).map((w) => w.token).sort()).toEqual([
         "approve-1",
         "approve-2"
       ]);
-      expect((await store.takeSignalWaiter("approve-1"))?.seq).toBe(3);
-      expect(await store.takeSignalWaiter("approve-1")).toBeNull();
+      expect2((await store.takeSignalWaiter("approve-1"))?.seq).toBe(3);
+      expect2(await store.takeSignalWaiter("approve-1")).toBeNull();
     });
     t("buffers signals and takes them FIFO per token", async () => {
       await store.bufferSignal("sig", {
@@ -905,18 +1155,18 @@ function runStateStoreContract(name, makeStore) {
       await store.bufferSignal("other", {
         n: 9
       });
-      expect(await store.takeBufferedSignal("sig")).toEqual({
+      expect2(await store.takeBufferedSignal("sig")).toEqual({
         payload: {
           n: 1
         }
       });
-      expect(await store.takeBufferedSignal("sig")).toEqual({
+      expect2(await store.takeBufferedSignal("sig")).toEqual({
         payload: {
           n: 2
         }
       });
-      expect(await store.takeBufferedSignal("sig")).toBeNull();
-      expect(await store.takeBufferedSignal("other")).toEqual({
+      expect2(await store.takeBufferedSignal("sig")).toBeNull();
+      expect2(await store.takeBufferedSignal("other")).toEqual({
         payload: {
           n: 9
         }
@@ -936,10 +1186,10 @@ function runStateStoreContract(name, makeStore) {
         }));
         return "ok";
       });
-      expect(result).toBe("ok");
+      expect2(result).toBe("ok");
       const cp = await store.getCheckpoint("r1", 7);
-      expect(cp?.name).toBe("tx-step");
-      expect(cp?.output).toEqual({
+      expect2(cp?.name).toBe("tx-step");
+      expect2(cp?.output).toEqual({
         paid: true
       });
     });
@@ -966,11 +1216,11 @@ function runStateStoreContract(name, makeStore) {
       await engine.start("wf", {
         x: 1
       }, "run1");
-      expect((await engine.waitForRun("run1")).status).toBe("failed");
+      expect2((await engine.waitForRun("run1")).status).toBe("failed");
       const resumed = await engine.resume("run1");
-      expect(resumed.status).toBe("completed");
-      expect(resumed.output).toBe(15);
-      expect(aRuns).toBe(1);
+      expect2(resumed.status).toBe("completed");
+      expect2(resumed.output).toBe(15);
+      expect2(aRuns).toBe(1);
     });
   });
 }
@@ -5515,6 +5765,7 @@ export {
   failTimes,
   preserveColumnExpectation,
   recordedSteps,
+  runAdmissionBackendContract,
   runStateStoreContract
 };
 //# sourceMappingURL=index.js.map