npm - @dudousxd/nestjs-durable-testing - Versions diffs - 0.17.0 → 0.18.0 - Mend

@dudousxd/nestjs-durable-testing 0.17.0 → 0.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js CHANGED Viewed

@@ -187,7 +187,7 @@ async function assertOutput(store, runId, expected) {
 }
 __name(assertOutput, "assertOutput");
 async function recordedSteps(store, runId) {
-  return (await store.listCheckpoints(runId)).map((cp) => cp.name);
+  return (await store.listCheckpoints(runId)).map((cp2) => cp2.name);
 }
 __name(recordedSteps, "recordedSteps");
 async function assertStepsRan(store, runId, names) {
@@ -200,10 +200,10 @@ async function assertStepsRan(store, runId, names) {
 }
 __name(assertStepsRan, "assertStepsRan");
 async function assertStepAttempts(store, runId, name, attempts) {
-  const cp = (await store.listCheckpoints(runId)).find((c) => c.name === name);
-  if (!cp) throw new Error(`expected step "${name}" to have run, but it did not`);
-  if (cp.attempts !== attempts) {
-    throw new Error(`expected step "${name}" to take ${attempts} attempt(s), took ${cp.attempts}`);
+  const cp2 = (await store.listCheckpoints(runId)).find((c) => c.name === name);
+  if (!cp2) throw new Error(`expected step "${name}" to have run, but it did not`);
+  if (cp2.attempts !== attempts) {
+    throw new Error(`expected step "${name}" to take ${attempts} attempt(s), took ${cp2.attempts}`);
   }
 }
 __name(assertStepAttempts, "assertStepAttempts");
@@ -341,11 +341,11 @@ var MutableClock = class {
     this.current = current;
   }
   now = /* @__PURE__ */ __name(() => this.current, "now");
-  set(ms) {
-    this.current = ms;
+  set(ms2) {
+    this.current = ms2;
   }
-  advance(ms) {
-    this.current += ms;
+  advance(ms2) {
+    this.current += ms2;
   }
 };
 function createTestEngine() {
@@ -362,8 +362,8 @@ function createTestEngine() {
     store,
     transport,
     clock,
-    async tick(ms) {
-      clock.advance(ms);
+    async tick(ms2) {
+      clock.advance(ms2);
       return engine.resumeDueTimers(clock.now());
     },
     async run(workflow, input, runId, opts) {
@@ -384,7 +384,7 @@ async function assertReplayable(register, history) {
     lockedBy: void 0,
     lockedUntil: void 0
   });
-  for (const cp of history.checkpoints) await store.saveCheckpoint(cp);
+  for (const cp2 of history.checkpoints) await store.saveCheckpoint(cp2);
   const engine = new WorkflowEngine2({
     store
   });
@@ -400,7 +400,352 @@ __name(assertReplayable, "assertReplayable");
 // src/state-store-conformance.ts
 import { SINGLETON_ADMITTED_TAG, WorkflowEngine as WorkflowEngine3 } from "@dudousxd/nestjs-durable-core";
-import { beforeEach, describe as describe2, expect as expect2, it as it2 } from "vitest";
+import { beforeEach, describe as describe2, expect as expect3, it as it2 } from "vitest";
+// src/checkpoint-aggregation-contract.ts
+import { SUMMARY_CHILD_LIMIT, aggregatesCheckpoints, checkpointStatsOf, childIdsOf, pageFan, pageFanFromStore, queryCheckpointsOf, summarizeRunFromStore, summarizeTimeline } from "@dudousxd/nestjs-durable-core";
+import { expect as expect2 } from "vitest";
+var base = Date.parse("2026-06-11T00:00:00.000Z");
+var ms = /* @__PURE__ */ __name((n) => new Date(base + n), "ms");
+function cp(seq, over = {}) {
+  return {
+    runId: "r1",
+    seq,
+    name: "Lines.process",
+    kind: "remote",
+    stepId: `r1:${seq}`,
+    status: "completed",
+    output: {
+      n: seq
+    },
+    attempts: 1,
+    enqueuedAt: ms(seq * 10),
+    startedAt: ms(seq * 10 + 3),
+    finishedAt: ms(seq * 10 + 7),
+    ...over
+  };
+}
+__name(cp, "cp");
+var child = /* @__PURE__ */ __name((seq, group, over = {}) => cp(seq, {
+  name: `signal:child:r1.all.${group.split(":")[1]}.${seq}`,
+  kind: "signal",
+  parallelGroup: group,
+  output: {
+    ok: true,
+    value: seq
+  },
+  ...over
+}), "child");
+var folded = /* @__PURE__ */ __name((seq, group, wave, from, n) => cp(seq, {
+  name: `fan:r1.all.${group.split(":")[1]}.w${wave}.`,
+  kind: "signal",
+  parallelGroup: group,
+  output: {
+    from,
+    values: Array.from({
+      length: n
+    }, (_, i) => i)
+  }
+}), "folded");
+function aggregationFixture() {
+  const rows = [
+    cp(0, {
+      name: "Lines.load",
+      kind: "local"
+    })
+  ];
+  rows.push(cp(1, {
+    name: "spawn:audit-1",
+    kind: "local",
+    output: "audit-1"
+  }));
+  for (let i = 0; i < 120; i++) {
+    const seq = 2 + i;
+    rows.push(cp(seq, {
+      parallelGroup: "steps:2:120",
+      ...i % 4 === 0 && i < 100 ? {
+        status: "failed",
+        attempts: 3,
+        error: {
+          message: `bad ${i}`
+        }
+      } : i >= 100 && i < 120 && i !== 105 && i !== 106 ? {
+        status: "pending",
+        output: void 0
+      } : i === 105 || i === 106 ? {
+        status: "running",
+        output: void 0
+      } : {}
+    }));
+  }
+  for (let i = 0; i < 5; i++) rows.push(cp(122 + i, {
+    parallelGroup: "steps:122:5"
+  }));
+  for (let i = 0; i < 30; i++) {
+    rows.push(cp(127 + i, {
+      parallelGroup: "steps:127:40000",
+      name: "Rows.score",
+      ...i >= 12 ? {
+        status: "pending",
+        output: void 0
+      } : {}
+    }));
+  }
+  for (let i = 0; i < 30; i++) {
+    rows.push(cp(157 + i, {
+      parallelGroup: "steps:157:60:failFast",
+      name: i % 2 === 0 ? "Check.a" : "Check.b",
+      ...i === 7 ? {
+        status: "failed",
+        error: {
+          message: "stop"
+        }
+      } : {}
+    }));
+  }
+  for (let i = 0; i < 60; i++) {
+    const seq = 187 + i;
+    rows.push(child(seq, "all:187:n80", {
+      ...i >= 50 ? {
+        status: "running",
+        output: void 0
+      } : i % 3 === 0 ? {
+        output: {
+          ok: false,
+          error: `child ${i}`
+        }
+      } : i % 7 === 1 ? {
+        status: "failed",
+        error: {
+          message: "lost"
+        }
+      } : {}
+    }));
+  }
+  rows.push(folded(247, "all:187:n80", 9, 60, 20));
+  rows.push(folded(300, "all:300:n3000:failFast", 0, 0, 1e3));
+  rows.push(folded(301, "all:300:n3000:failFast", 1, 1e3, 1e3));
+  rows.push(folded(302, "all:300:n3000:failFast", 2, 2e3, 0));
+  for (let i = 0; i < 4; i++) {
+    rows.push(child(303 + i, "all:300:n3000:failFast", {
+      status: "running",
+      output: void 0
+    }));
+  }
+  rows.push(child(400, "all:400:n3"));
+  rows.push(child(401, "all:400:n3", {
+    output: {
+      ok: false,
+      error: "narrow"
+    }
+  }));
+  rows.push(child(402, "all:400:n3", {
+    status: "running",
+    output: void 0
+  }));
+  for (let i = 0; i < 55; i++) {
+    rows.push(child(450 + i, "all:450", i === 54 ? {
+      output: {
+        ok: false
+      }
+    } : {}));
+  }
+  rows.push(cp(600, {
+    name: "Lines.report",
+    kind: "local",
+    status: "failed"
+  }));
+  return rows;
+}
+__name(aggregationFixture, "aggregationFixture");
+var GROUPS = [
+  "steps:2:120",
+  "steps:122:5",
+  "steps:127:40000",
+  "steps:157:60:failFast",
+  "all:187:n80",
+  "all:300:n3000:failFast",
+  "all:400:n3",
+  "all:450",
+  "absent"
+];
+var QUERIES = [
+  {},
+  {
+    offset: 10,
+    limit: 7
+  },
+  {
+    offset: 0,
+    limit: 500
+  },
+  {
+    offset: 118,
+    limit: 50
+  },
+  {
+    offset: 5e3
+  },
+  {
+    failedOnly: true
+  },
+  {
+    failedOnly: true,
+    offset: 3,
+    limit: 4
+  },
+  {
+    failedOnly: true,
+    offset: 15,
+    limit: 10
+  },
+  {
+    failedOnly: true,
+    offset: 1e3
+  }
+];
+function comparable(stats) {
+  return stats.map(({ minName, maxName, ...rest }) => ({
+    ...rest,
+    uniform: minName === maxName
+  })).sort((a, b) => `${a.group}|${a.status}|${a.nameKind}`.localeCompare(`${b.group}|${b.status}|${b.nameKind}`));
+}
+__name(comparable, "comparable");
+async function seed(store, run2) {
+  await store.createRun(run2());
+  for (const row of aggregationFixture()) await store.saveCheckpoint(row);
+  await store.createRun(run2({
+    id: "r2"
+  }));
+  for (let i = 0; i < 3; i++) {
+    await store.saveCheckpoint(cp(2 + i, {
+      runId: "r2",
+      stepId: `r2:${i}`,
+      parallelGroup: "steps:2:120",
+      status: "failed"
+    }));
+  }
+}
+__name(seed, "seed");
+function registerCheckpointAggregationCases(t, getStore, run2) {
+  t("checkpointStats and queryCheckpoints agree with the in-memory reference", async () => {
+    const store = getStore();
+    expect2(store.checkpointStats).toBeDefined();
+    expect2(store.queryCheckpoints).toBeDefined();
+    if (!aggregatesCheckpoints(store)) return;
+    await seed(store, run2);
+    const full = await store.listCheckpoints("r1");
+    expect2(comparable(await store.checkpointStats("r1"))).toEqual(comparable(checkpointStatsOf(full)));
+    for (const group of GROUPS) {
+      expect2(comparable(await store.checkpointStats("r1", {
+        group
+      }))).toEqual(comparable(checkpointStatsOf(full, {
+        group
+      })));
+    }
+    expect2(await store.checkpointStats("nope")).toEqual([]);
+    const queries = [
+      {},
+      {
+        group: "steps:2:120"
+      },
+      {
+        group: "steps:2:120",
+        statuses: [
+          "failed"
+        ],
+        limit: 20
+      },
+      {
+        group: "steps:2:120",
+        offset: 30,
+        limit: 5
+      },
+      {
+        group: "all:187:n80",
+        statuses: [
+          "completed"
+        ],
+        namePrefixes: [
+          "signal:child:"
+        ]
+      },
+      {
+        excludeGroups: [
+          "steps:2:120",
+          "all:187:n80",
+          "all:450"
+        ]
+      },
+      {
+        excludeGroups: []
+      },
+      {
+        namePrefixes: [
+          "signal:child:",
+          "fan:",
+          "spawn:"
+        ],
+        offset: 200,
+        limit: 200
+      },
+      {
+        namePrefixes: [
+          "fan:"
+        ]
+      },
+      {
+        statuses: []
+      },
+      {
+        namePrefixes: []
+      },
+      {
+        statuses: [
+          "pending",
+          "running"
+        ],
+        offset: 3
+      }
+    ];
+    for (const query of queries) {
+      expect2(await store.queryCheckpoints("r1", query)).toEqual(queryCheckpointsOf(full, query));
+    }
+  });
+  t("a run detail read through the aggregates is the one summarizeTimeline builds", async () => {
+    const store = getStore();
+    if (!aggregatesCheckpoints(store)) return;
+    await seed(store, run2);
+    const full = await store.listCheckpoints("r1");
+    for (const over of [
+      50,
+      0,
+      1e3
+    ]) {
+      const ids = childIdsOf(full);
+      const expected = {
+        ...summarizeTimeline(full, over),
+        children: ids.slice(0, SUMMARY_CHILD_LIMIT),
+        childCount: ids.length
+      };
+      expect2(await summarizeRunFromStore(store, "r1", over)).toEqual(expected);
+    }
+  });
+  t("a fan page read through the aggregates is the one pageFan builds", async () => {
+    const store = getStore();
+    if (!aggregatesCheckpoints(store)) return;
+    await seed(store, run2);
+    const full = await store.listCheckpoints("r1");
+    for (const group of GROUPS) {
+      for (const query of QUERIES) {
+        expect2(await pageFanFromStore(store, "r1", group, query)).toEqual(pageFan(full, group, query));
+      }
+    }
+  });
+}
+__name(registerCheckpointAggregationCases, "registerCheckpointAggregationCases");
+// src/state-store-conformance.ts
 var StateStoreUnavailableError = class extends Error {
   static {
     __name(this, "StateStoreUnavailableError");
@@ -486,7 +831,7 @@ function runStateStoreContract(name, makeStore) {
       });
     }, "t");
     t("atomically admits holders without displacement by later same-millisecond IDs", async () => {
-      expect2(store.tryAdmitSingleton).toBeTypeOf("function");
+      expect3(store.tryAdmitSingleton).toBeTypeOf("function");
       const claim = /* @__PURE__ */ __name((id, limit = 1) => store.tryAdmitSingleton?.(id, "singleton:k", "checkout", limit), "claim");
       await store.createRun(run({
         id: "z-holder",
@@ -495,12 +840,12 @@ function runStateStoreContract(name, makeStore) {
           "user-tag"
         ]
       }));
-      expect2(await claim("z-holder")).toBe(true);
+      expect3(await claim("z-holder")).toBe(true);
       await store.updateRun("z-holder", {
         status: "suspended",
         wakeAt: 1e4
       });
-      expect2(await claim("z-holder")).toBe(true);
+      expect3(await claim("z-holder")).toBe(true);
       await store.updateRun("z-holder", {
         status: "blocked",
         lockedBy: "expired",
@@ -512,25 +857,25 @@ function runStateStoreContract(name, makeStore) {
           "singleton:k"
         ]
       }));
-      expect2(await claim("a-waiter")).toBe(false);
-      expect2(await claim("z-holder")).toBe(true);
+      expect3(await claim("a-waiter")).toBe(false);
+      expect3(await claim("z-holder")).toBe(true);
       await store.updateRun("z-holder", {
         status: "cancelling"
       });
-      expect2(await claim("a-waiter")).toBe(false);
+      expect3(await claim("a-waiter")).toBe(false);
       await store.updateRun("z-holder", {
         status: "completed"
       });
-      expect2((await store.getRun("z-holder"))?.tags).toEqual([
+      expect3((await store.getRun("z-holder"))?.tags).toEqual([
         "singleton:k",
         "user-tag"
       ]);
-      expect2(await claim("a-waiter")).toBe(true);
+      expect3(await claim("a-waiter")).toBe(true);
       await store.updateRun("z-holder", {
         status: "running"
       });
-      expect2(await claim("z-holder")).toBe(false);
-      expect2(await claim("missing")).toBe(false);
+      expect3(await claim("z-holder")).toBe(false);
+      expect3(await claim("missing")).toBe(false);
     });
     t("singleton denial atomically parks waiters and preserves cancelling/terminal state", async () => {
       await store.createRun(run({
@@ -539,15 +884,15 @@ function runStateStoreContract(name, makeStore) {
           "singleton:k"
         ]
       }));
-      expect2(await store.tryAdmitSingleton?.("holder", "singleton:k", "checkout", 1)).toBe(true);
+      expect3(await store.tryAdmitSingleton?.("holder", "singleton:k", "checkout", 1)).toBe(true);
       await store.createRun(run({
         id: "waiter",
         tags: [
           "singleton:k"
         ]
       }));
-      expect2(await peerStore.tryAdmitSingleton?.("waiter", "singleton:k", "checkout", 1, 12e3)).toBe(false);
-      expect2(await store.getRun("waiter")).toMatchObject({
+      expect3(await peerStore.tryAdmitSingleton?.("waiter", "singleton:k", "checkout", 1, 12e3)).toBe(false);
+      expect3(await store.getRun("waiter")).toMatchObject({
         status: "suspended",
         wakeAt: 12e3
       });
@@ -555,16 +900,16 @@ function runStateStoreContract(name, makeStore) {
         status: "cancelling",
         wakeAt: void 0
       });
-      expect2(await peerStore.tryAdmitSingleton?.("waiter", "singleton:k", "checkout", 1, 14e3)).toBe(false);
-      expect2(await store.getRun("waiter")).toMatchObject({
+      expect3(await peerStore.tryAdmitSingleton?.("waiter", "singleton:k", "checkout", 1, 14e3)).toBe(false);
+      expect3(await store.getRun("waiter")).toMatchObject({
         status: "cancelling"
       });
-      expect2((await store.getRun("waiter"))?.wakeAt).toBeUndefined();
+      expect3((await store.getRun("waiter"))?.wakeAt).toBeUndefined();
       await store.updateRun("waiter", {
         status: "cancelled"
       });
-      expect2(await peerStore.tryAdmitSingleton?.("waiter", "singleton:k", "checkout", 1, 16e3)).toBe(false);
-      expect2((await store.getRun("waiter"))?.status).toBe("cancelled");
+      expect3(await peerStore.tryAdmitSingleton?.("waiter", "singleton:k", "checkout", 1, 16e3)).toBe(false);
+      expect3((await store.getRun("waiter"))?.status).toBe("cancelled");
       await store.updateRun("holder", {
         status: "completed"
       });
@@ -575,8 +920,8 @@ function runStateStoreContract(name, makeStore) {
           "singleton:k"
         ]
       }));
-      expect2(await store.tryAdmitSingleton?.("cancelling", "singleton:k", "checkout", 1, 18e3)).toBe(false);
-      expect2((await store.getRun("cancelling"))?.tags).not.toContain(SINGLETON_ADMITTED_TAG);
+      expect3(await store.tryAdmitSingleton?.("cancelling", "singleton:k", "checkout", 1, 18e3)).toBe(false);
+      expect3((await store.getRun("cancelling"))?.tags).not.toContain(SINGLETON_ADMITTED_TAG);
     });
     t("competing store instances atomically claim an empty singleton slot", async () => {
       for (const id of [
@@ -596,13 +941,13 @@ function runStateStoreContract(name, makeStore) {
         store.tryAdmitSingleton?.("a-first", "singleton:k", "checkout", 1),
         peerStore.tryAdmitSingleton?.("c-third", "singleton:k", "checkout", 1)
       ]);
-      expect2(results).toEqual([
+      expect3(results).toEqual([
         false,
         true,
         false
       ]);
-      expect2(await peerStore.tryAdmitSingleton?.("a-first", "singleton:k", "checkout", 1)).toBe(true);
-      expect2((await store.getRun("a-first"))?.tags).toContain(SINGLETON_ADMITTED_TAG);
+      expect3(await peerStore.tryAdmitSingleton?.("a-first", "singleton:k", "checkout", 1)).toBe(true);
+      expect3((await store.getRun("a-first"))?.tags).toContain(SINGLETON_ADMITTED_TAG);
     });
     t("concurrent singleton claims honor limits and independent keys/workflows", async () => {
       const claim = /* @__PURE__ */ __name((id, tag = "singleton:k", workflow = "checkout") => store.tryAdmitSingleton?.(id, tag, workflow, 2), "claim");
@@ -616,7 +961,7 @@ function runStateStoreContract(name, makeStore) {
             "singleton:k"
           ]
         }));
-        expect2(await claim(id)).toBe(true);
+        expect3(await claim(id)).toBe(true);
       }
       for (const id of [
         "a-waiter",
@@ -631,7 +976,7 @@ function runStateStoreContract(name, makeStore) {
           ]
         }));
       }
-      expect2(await Promise.all([
+      expect3(await Promise.all([
         "a-waiter",
         "b-waiter",
         "c-waiter"
@@ -643,7 +988,7 @@ function runStateStoreContract(name, makeStore) {
       await store.updateRun("z-holder", {
         status: "failed"
       });
-      expect2(await Promise.all([
+      expect3(await Promise.all([
         "c-waiter",
         "b-waiter",
         "a-waiter"
@@ -659,14 +1004,14 @@ function runStateStoreContract(name, makeStore) {
           "pending"
         ]
       });
-      expect2(active.filter((r) => r.tags?.includes(SINGLETON_ADMITTED_TAG))).toHaveLength(2);
+      expect3(active.filter((r) => r.tags?.includes(SINGLETON_ADMITTED_TAG))).toHaveLength(2);
       await store.createRun(run({
         id: "other-key",
         tags: [
           "singleton:other"
         ]
       }));
-      expect2(await claim("other-key", "singleton:other")).toBe(true);
+      expect3(await claim("other-key", "singleton:other")).toBe(true);
       await store.createRun(run({
         id: "other-workflow",
         workflow: "other",
@@ -674,18 +1019,18 @@ function runStateStoreContract(name, makeStore) {
           "singleton:k"
         ]
       }));
-      expect2(await claim("other-workflow", "singleton:k", "other")).toBe(true);
+      expect3(await claim("other-workflow", "singleton:k", "other")).toBe(true);
     });
     t("creates a run and reads it back with its JSON input", async () => {
       await store.createRun(run());
       const loaded = await store.getRun("r1");
-      expect2(loaded?.workflow).toBe("checkout");
-      expect2(loaded?.input).toEqual({
+      expect3(loaded?.workflow).toBe("checkout");
+      expect3(loaded?.input).toEqual({
         orderId: "o1"
       });
     });
     t("returns null for a missing run", async () => {
-      expect2(await store.getRun("nope")).toBeNull();
+      expect3(await store.getRun("nope")).toBeNull();
     });
     t("updates a run (status/output) and round-trips recoveryAttempts + dead status", async () => {
       await store.createRun(run({
@@ -699,18 +1044,18 @@ function runStateStoreContract(name, makeStore) {
         updatedAt: at
       });
       const done = await store.getRun("r1");
-      expect2(done?.status).toBe("completed");
-      expect2(done?.output).toEqual({
+      expect3(done?.status).toBe("completed");
+      expect3(done?.output).toEqual({
         total: 42
       });
-      expect2(done?.recoveryAttempts).toBe(3);
+      expect3(done?.recoveryAttempts).toBe(3);
       await store.updateRun("r1", {
         status: "dead",
         recoveryAttempts: 4
       });
       const dead = await store.getRun("r1");
-      expect2(dead?.status).toBe("dead");
-      expect2(dead?.recoveryAttempts).toBe(4);
+      expect3(dead?.status).toBe("dead");
+      expect3(dead?.recoveryAttempts).toBe(4);
     });
     t("round-trips a run dispatch priority", async () => {
       await store.createRun(run({
@@ -720,8 +1065,8 @@ function runStateStoreContract(name, makeStore) {
       await store.createRun(run({
         id: "noprio"
       }));
-      expect2((await store.getRun("withprio"))?.priority).toBe(7);
-      expect2((await store.getRun("noprio"))?.priority).toBeUndefined();
+      expect3((await store.getRun("withprio"))?.priority).toBe(7);
+      expect3((await store.getRun("noprio"))?.priority).toBeUndefined();
     });
     t("deleteRun removes the run and all its rows (checkpoints, waiters, attributes)", async () => {
       await store.createRun(run({
@@ -736,10 +1081,10 @@ function runStateStoreContract(name, makeStore) {
         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({
+      expect3(await store.getRun("r1")).toBeNull();
+      expect3(await store.listCheckpoints("r1")).toEqual([]);
+      expect3(await store.listSignalWaiters("approve-")).toEqual([]);
+      expect3(await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -750,7 +1095,7 @@ function runStateStoreContract(name, makeStore) {
       })).toEqual([]);
     });
     t("deleteRun is a no-op for a missing run", async () => {
-      await expect2(store.deleteRun("nope")).resolves.toBeUndefined();
+      await expect3(store.deleteRun("nope")).resolves.toBeUndefined();
     });
     t("deleteRuns removes every listed run with its rows and ignores missing ids", async () => {
       await store.createRun(run({
@@ -774,18 +1119,18 @@ function runStateStoreContract(name, makeStore) {
         runId: "d2",
         seq: 0
       });
-      expect2(typeof store.deleteRuns).toBe("function");
+      expect3(typeof store.deleteRuns).toBe("function");
       await store.deleteRuns?.([
         "d1",
         "d2",
         "ghost"
       ]);
-      expect2(await store.getRun("d1")).toBeNull();
-      expect2(await store.getRun("d2")).toBeNull();
-      expect2(await store.getRun("keep")).not.toBeNull();
-      expect2(await store.listCheckpoints("d1")).toEqual([]);
-      expect2(await store.listSignalWaiters("approve-")).toEqual([]);
-      expect2(await store.listRuns({
+      expect3(await store.getRun("d1")).toBeNull();
+      expect3(await store.getRun("d2")).toBeNull();
+      expect3(await store.getRun("keep")).not.toBeNull();
+      expect3(await store.listCheckpoints("d1")).toEqual([]);
+      expect3(await store.listSignalWaiters("approve-")).toEqual([]);
+      expect3(await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -794,7 +1139,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       })).toEqual([]);
-      await expect2(store.deleteRuns?.([])).resolves.toBeUndefined();
+      await expect3(store.deleteRuns?.([])).resolves.toBeUndefined();
     });
     const aged = /* @__PURE__ */ __name((id, ageDays, over = {}) => run({
       id,
@@ -817,7 +1162,7 @@ function runStateStoreContract(name, makeStore) {
         runId: "old-done",
         stepId: "old-done:0"
       }));
-      expect2(typeof store.pruneTerminalRuns).toBe("function");
+      expect3(typeof store.pruneTerminalRuns).toBe("function");
       const deleted = await store.pruneTerminalRuns?.({
         statuses: [
           "completed",
@@ -826,12 +1171,12 @@ function runStateStoreContract(name, makeStore) {
         ],
         maxAge: "7d"
       }, NOW, 100);
-      expect2(deleted).toBe(2);
-      expect2(await ids()).toEqual([
+      expect3(deleted).toBe(2);
+      expect3(await ids()).toEqual([
         "fresh-done",
         "old-live"
       ]);
-      expect2(await store.listCheckpoints("old-done")).toEqual([]);
+      expect3(await store.listCheckpoints("old-done")).toEqual([]);
     });
     t("pruneTerminalRuns keeps only the newest maxCount and drains in batches of limit", async () => {
       for (let i = 1; i <= 5; i++) await store.createRun(aged(`c${i}`, i));
@@ -841,10 +1186,10 @@ function runStateStoreContract(name, makeStore) {
         ],
         maxCount: 2
       };
-      expect2(await store.pruneTerminalRuns?.(policy, NOW, 2)).toBe(2);
-      expect2(await store.pruneTerminalRuns?.(policy, NOW, 2)).toBe(1);
-      expect2(await store.pruneTerminalRuns?.(policy, NOW, 2)).toBe(0);
-      expect2(await ids()).toEqual([
+      expect3(await store.pruneTerminalRuns?.(policy, NOW, 2)).toBe(2);
+      expect3(await store.pruneTerminalRuns?.(policy, NOW, 2)).toBe(1);
+      expect3(await store.pruneTerminalRuns?.(policy, NOW, 2)).toBe(0);
+      expect3(await ids()).toEqual([
         "c1",
         "c2"
       ]);
@@ -871,7 +1216,7 @@ function runStateStoreContract(name, makeStore) {
           namespace: "acme"
         }
       }, NOW, 100);
-      expect2(await ids()).toEqual([
+      expect3(await ids()).toEqual([
         "acme-new",
         "beta-old",
         "report-old"
@@ -887,7 +1232,7 @@ function runStateStoreContract(name, makeStore) {
           ]
         }
       }, NOW, 100);
-      expect2(await ids()).toEqual([
+      expect3(await ids()).toEqual([
         "acme-new",
         "beta-old"
       ]);
@@ -903,7 +1248,7 @@ function runStateStoreContract(name, makeStore) {
           namespace: "acme"
         }
       }, NOW, 100);
-      expect2(await ids()).toEqual([
+      expect3(await ids()).toEqual([
         "acme-new",
         "beta-old"
       ]);
@@ -942,7 +1287,7 @@ function runStateStoreContract(name, makeStore) {
           ]
         }
       }, NOW, 100);
-      expect2(await ids()).toEqual([
+      expect3(await ids()).toEqual([
         "attr-old",
         "attr-other",
         "chatty-old"
@@ -962,7 +1307,7 @@ function runStateStoreContract(name, makeStore) {
           ]
         }
       }, NOW, 100);
-      expect2(await ids()).toEqual([
+      expect3(await ids()).toEqual([
         "attr-other",
         "chatty-old"
       ]);
@@ -979,21 +1324,21 @@ function runStateStoreContract(name, makeStore) {
       engine.register("p-other", "1", async () => "done");
       await engine.start("p-root", {}, "pr");
       await engine.start("p-other", {}, "po");
-      expect2((await engine.waitForRun("pc", {
+      expect3((await engine.waitForRun("pc", {
         timeoutMs: 2e4
       })).status).toBe("suspended");
-      expect2((await engine.waitForRun("po", {
+      expect3((await engine.waitForRun("po", {
         timeoutMs: 2e4
       })).status).toBe("completed");
-      await expect2(engine.purgeRuns({})).rejects.toThrow(/empty scope/);
-      expect2(await engine.purgeRuns({
+      await expect3(engine.purgeRuns({})).rejects.toThrow(/empty scope/);
+      expect3(await engine.purgeRuns({
         workflows: [
           "p-root"
         ]
       })).toBe(2);
-      expect2(await store.getRun("pr")).toBeNull();
-      expect2(await store.getRun("pc")).toBeNull();
-      expect2(await store.getRun("po")).not.toBeNull();
+      expect3(await store.getRun("pr")).toBeNull();
+      expect3(await store.getRun("pc")).toBeNull();
+      expect3(await store.getRun("po")).not.toBeNull();
     });
     t("updateRun maps every patchable field \u2014 clears error and patches tags/lockedBy/input/timers", async () => {
       await store.createRun(run({
@@ -1025,29 +1370,29 @@ function runStateStoreContract(name, makeStore) {
         updatedAt: at
       });
       const r = await store.getRun("r1");
-      expect2(r?.status).toBe("completed");
-      expect2(r?.output).toEqual({
+      expect3(r?.status).toBe("completed");
+      expect3(r?.output).toEqual({
         ok: true
       });
-      expect2(r?.error).toBeUndefined();
-      expect2(r?.input).toEqual({
+      expect3(r?.error).toBeUndefined();
+      expect3(r?.input).toEqual({
         orderId: "o2"
       });
-      expect2(r?.tags).toEqual([
+      expect3(r?.tags).toEqual([
         "x",
         "y"
       ]);
-      expect2(r?.lockedBy).toBe("owner-2");
-      expect2(r?.wakeAt).toBe(123456);
-      expect2(r?.lockedUntil).toBe(222222);
+      expect3(r?.lockedBy).toBe("owner-2");
+      expect3(r?.wakeAt).toBe(123456);
+      expect3(r?.lockedUntil).toBe(222222);
       await store.updateRun("r1", {
         awaitingDecisionTaskId: "turn-7"
       });
-      expect2((await store.getRun("r1"))?.awaitingDecisionTaskId).toBe("turn-7");
+      expect3((await store.getRun("r1"))?.awaitingDecisionTaskId).toBe("turn-7");
       await store.updateRun("r1", {
         awaitingDecisionTaskId: void 0
       });
-      expect2((await store.getRun("r1"))?.awaitingDecisionTaskId).toBeUndefined();
+      expect3((await store.getRun("r1"))?.awaitingDecisionTaskId).toBeUndefined();
     });
     t("listDueTimers returns the most overdue first, capped at limit", async () => {
       for (const [id, wakeAt] of [
@@ -1074,18 +1419,18 @@ function runStateStoreContract(name, makeStore) {
           wakeAt
         }));
       }
-      expect2((await store.listDueTimers(5e3)).map((r) => r.id)).toEqual([
+      expect3((await store.listDueTimers(5e3)).map((r) => r.id)).toEqual([
         "earliest",
         "middle",
         "late"
       ]);
-      expect2((await store.listDueTimers(5e3, void 0, 2)).map((r) => r.id)).toEqual([
+      expect3((await store.listDueTimers(5e3, void 0, 2)).map((r) => r.id)).toEqual([
         "earliest",
         "middle"
       ]);
     });
     t("countCheckpoints counts a seq range by status", async () => {
-      expect2(store.countCheckpoints).toBeDefined();
+      expect3(store.countCheckpoints).toBeDefined();
       if (!store.countCheckpoints) return;
       await store.createRun(run());
       for (const [seq, status] of [
@@ -1125,32 +1470,33 @@ function runStateStoreContract(name, makeStore) {
         status: "pending",
         stepId: "other:2"
       }));
-      expect2(await store.countCheckpoints("r1", 1, 3, [
+      expect3(await store.countCheckpoints("r1", 1, 3, [
         "pending"
       ])).toBe(2);
-      expect2(await store.countCheckpoints("r1", 0, 4, [
+      expect3(await store.countCheckpoints("r1", 0, 4, [
         "pending",
         "failed"
       ])).toBe(4);
-      expect2(await store.countCheckpoints("r1", 2, 2, [
+      expect3(await store.countCheckpoints("r1", 2, 2, [
         "pending"
       ])).toBe(1);
-      expect2(await store.countCheckpoints("r1", 1, 4, [
+      expect3(await store.countCheckpoints("r1", 1, 4, [
         "pending"
       ])).toBe(3);
-      expect2(await store.countCheckpoints("r1", 0, 0, [
+      expect3(await store.countCheckpoints("r1", 0, 0, [
         "completed"
       ])).toBe(1);
-      expect2(await store.countCheckpoints("other", 0, 4, [
+      expect3(await store.countCheckpoints("other", 0, 4, [
         "pending"
       ])).toBe(1);
-      expect2(await store.countCheckpoints("r1", 5, 9, [
+      expect3(await store.countCheckpoints("r1", 5, 9, [
         "pending"
       ])).toBe(0);
-      expect2(await store.countCheckpoints("r1", 0, 4, [])).toBe(0);
+      expect3(await store.countCheckpoints("r1", 0, 4, [])).toBe(0);
     });
+    registerCheckpointAggregationCases(t, () => store, run);
     t("saveCheckpointIfPending writes over a pending row only", async () => {
-      expect2(store.saveCheckpointIfPending).toBeDefined();
+      expect3(store.saveCheckpointIfPending).toBeDefined();
       if (!store.saveCheckpointIfPending) return;
       await store.createRun(run());
       const pending = checkpoint({
@@ -1158,11 +1504,11 @@ function runStateStoreContract(name, makeStore) {
         output: void 0
       });
       await store.saveCheckpoint(pending);
-      expect2(await store.saveCheckpointIfPending({
+      expect3(await store.saveCheckpointIfPending({
         ...pending,
         wakeAt: 5e3
       })).toBe(true);
-      expect2((await store.getCheckpoint("r1", 0))?.wakeAt).toBe(5e3);
+      expect3((await store.getCheckpoint("r1", 0))?.wakeAt).toBe(5e3);
       const done = {
         ...pending,
         status: "completed",
@@ -1170,33 +1516,190 @@ function runStateStoreContract(name, makeStore) {
           ok: true
         }
       };
-      expect2(await store.saveCheckpointIfPending(done)).toBe(true);
-      expect2(await store.saveCheckpointIfPending({
+      expect3(await store.saveCheckpointIfPending(done)).toBe(true);
+      expect3(await store.saveCheckpointIfPending({
         ...pending,
         wakeAt: 9e3
       })).toBe(false);
       const after = await store.getCheckpoint("r1", 0);
-      expect2(after?.status).toBe("completed");
-      expect2(after?.output).toEqual({
+      expect3(after?.status).toBe("completed");
+      expect3(after?.output).toEqual({
         ok: true
       });
-      expect2(after?.wakeAt).toBeUndefined();
+      expect3(after?.wakeAt).toBeUndefined();
       await store.saveCheckpoint(checkpoint({
         seq: 1,
         status: "failed",
         stepId: "r1:1"
       }));
-      expect2(await store.saveCheckpointIfPending({
+      expect3(await store.saveCheckpointIfPending({
         ...pending,
         seq: 1,
         stepId: "r1:1"
       })).toBe(false);
-      expect2((await store.getCheckpoint("r1", 1))?.status).toBe("failed");
-      expect2(await store.saveCheckpointIfPending({
+      expect3((await store.getCheckpoint("r1", 1))?.status).toBe("failed");
+      expect3(await store.saveCheckpointIfPending({
         ...pending,
         seq: 9
       })).toBe(false);
-      expect2(await store.getCheckpoint("r1", 9)).toBeNull();
+      expect3(await store.getCheckpoint("r1", 9)).toBeNull();
+    });
+    t("saveCheckpointsIfPending settles a batch row by row, in order", async () => {
+      expect3(store.saveCheckpointsIfPending).toBeDefined();
+      if (!store.saveCheckpointsIfPending) return;
+      expect3(await store.saveCheckpointsIfPending([])).toEqual([]);
+      await store.createRun(run());
+      await store.createRun(run({
+        id: "r2"
+      }));
+      const pending = /* @__PURE__ */ __name((runId, seq) => checkpoint({
+        runId,
+        seq,
+        stepId: `${runId}:${seq}`,
+        status: "pending",
+        output: void 0,
+        wakeAt: 5e3
+      }), "pending");
+      for (const seq of [
+        0,
+        1,
+        2,
+        3
+      ]) await store.saveCheckpoint(pending("r1", seq));
+      await store.saveCheckpoint(pending("r2", 0));
+      await store.saveCheckpoint({
+        ...pending("r1", 1),
+        status: "completed",
+        output: {
+          first: 1
+        }
+      });
+      const done = /* @__PURE__ */ __name((runId, seq, output) => ({
+        ...pending(runId, seq),
+        status: "completed",
+        output,
+        wakeAt: void 0
+      }), "done");
+      const wrote = await store.saveCheckpointsIfPending([
+        done("r1", 0, {
+          n: 0
+        }),
+        done("r1", 1, {
+          n: 1
+        }),
+        // A second copy of the same row: compared against the first copy's write, so refused.
+        done("r1", 0, {
+          n: "dup"
+        }),
+        {
+          ...pending("r1", 2),
+          status: "failed",
+          error: {
+            message: "boom"
+          },
+          wakeAt: void 0
+        },
+        // No such row: nothing is written.
+        done("r1", 9, {
+          n: 9
+        }),
+        // Another run's row, same seq as one above.
+        done("r2", 0, {
+          n: "r2"
+        })
+      ]);
+      expect3(wrote).toEqual([
+        true,
+        false,
+        false,
+        true,
+        false,
+        true
+      ]);
+      const r1 = await store.listCheckpoints("r1");
+      expect3(r1.map((c) => [
+        c.seq,
+        c.status,
+        c.output
+      ])).toEqual([
+        [
+          0,
+          "completed",
+          {
+            n: 0
+          }
+        ],
+        [
+          1,
+          "completed",
+          {
+            first: 1
+          }
+        ],
+        [
+          2,
+          "failed",
+          void 0
+        ],
+        [
+          3,
+          "pending",
+          void 0
+        ]
+      ]);
+      expect3(r1[2]?.error).toEqual({
+        message: "boom"
+      });
+      expect3(r1[0]?.wakeAt).toBeUndefined();
+      expect3(r1[3]?.wakeAt).toBe(5e3);
+      expect3(await store.getCheckpoint("r1", 9)).toBeNull();
+      expect3((await store.getCheckpoint("r2", 0))?.output).toEqual({
+        n: "r2"
+      });
+      expect3(await store.saveCheckpointsIfPending([
+        {
+          ...pending("r1", 3),
+          wakeAt: 9e3
+        },
+        done("r1", 3, {
+          n: 3
+        })
+      ])).toEqual([
+        true,
+        true
+      ]);
+      expect3((await store.getCheckpoint("r1", 3))?.output).toEqual({
+        n: 3
+      });
+    });
+    t("saveCheckpointsIfPending writes a wide batch", async () => {
+      if (!store.saveCheckpointsIfPending) return;
+      await store.createRun(run());
+      const n = 600;
+      const rows = Array.from({
+        length: n
+      }, (_, seq) => checkpoint({
+        seq,
+        stepId: `r1:${seq}`,
+        status: "pending",
+        output: void 0
+      }));
+      for (const row of rows) await store.saveCheckpoint(row);
+      const wrote = await store.saveCheckpointsIfPending(rows.map((row) => ({
+        ...row,
+        status: "completed",
+        output: {
+          seq: row.seq
+        }
+      })));
+      expect3(wrote.every((w) => w === true)).toBe(true);
+      expect3(wrote).toHaveLength(n);
+      expect3(await store.countCheckpoints?.("r1", 0, n - 1, [
+        "completed"
+      ])).toBe(n);
+      expect3((await store.getCheckpoint("r1", n - 1))?.output).toEqual({
+        seq: n - 1
+      });
     });
     t("upserts checkpoints, reads them by (runId, seq), and lists them ordered by seq", async () => {
       await store.createRun(run());
@@ -1214,13 +1717,13 @@ function runStateStoreContract(name, makeStore) {
           again: true
         }
       }));
-      expect2((await store.getCheckpoint("r1", 0))?.output).toEqual({
+      expect3((await store.getCheckpoint("r1", 0))?.output).toEqual({
         ok: true,
         again: true
       });
-      expect2((await store.getCheckpoint("r1", 1))?.name).toBe("charge");
+      expect3((await store.getCheckpoint("r1", 1))?.name).toBe("charge");
       const list = await store.listCheckpoints("r1");
-      expect2(list.map((c) => c.seq)).toEqual([
+      expect3(list.map((c) => c.seq)).toEqual([
         0,
         1
       ]);
@@ -1256,14 +1759,14 @@ function runStateStoreContract(name, makeStore) {
         }
       }));
       const getLatestCheckpointByName = store.getLatestCheckpointByName;
-      expect2(getLatestCheckpointByName).toBeDefined();
+      expect3(getLatestCheckpointByName).toBeDefined();
       if (!getLatestCheckpointByName) return;
       const latest = await getLatestCheckpointByName.call(store, "r1", "event:progress");
-      expect2(latest?.seq).toBe(3);
-      expect2(latest?.output).toEqual({
+      expect3(latest?.seq).toBe(3);
+      expect3(latest?.output).toEqual({
         pct: 90
       });
-      expect2(await getLatestCheckpointByName.call(store, "r1", "event:missing")).toBeUndefined();
+      expect3(await getLatestCheckpointByName.call(store, "r1", "event:missing")).toBeUndefined();
     });
     t("listCheckpointsByNamePrefix returns prefix matches ordered by seq (empty => none)", async () => {
       await store.createRun(run());
@@ -1290,18 +1793,48 @@ function runStateStoreContract(name, makeStore) {
         output: "child-b"
       }));
       const listCheckpointsByNamePrefix = store.listCheckpointsByNamePrefix;
-      expect2(listCheckpointsByNamePrefix).toBeDefined();
+      expect3(listCheckpointsByNamePrefix).toBeDefined();
       if (!listCheckpointsByNamePrefix) return;
       const matches = await listCheckpointsByNamePrefix.call(store, "r1", [
         "signal:child:",
         "spawn:"
       ]);
-      expect2(matches.map((c) => c.name)).toEqual([
+      expect3(matches.map((c) => c.name)).toEqual([
         "spawn:0",
         "signal:child:c2",
         "spawn:1"
       ]);
-      expect2(await listCheckpointsByNamePrefix.call(store, "r1", [])).toEqual([]);
+      expect3(await listCheckpointsByNamePrefix.call(store, "r1", [])).toEqual([]);
+    });
+    t("a name or token prefix matches literally \u2014 `_` and `%` are not wildcards", async () => {
+      await store.createRun(run());
+      await store.saveCheckpoint(checkpoint({
+        seq: 0,
+        name: "signal:child:job_1.onError.0"
+      }));
+      await store.saveCheckpoint(checkpoint({
+        seq: 1,
+        name: "signal:child:jobX1.onError.0"
+      }));
+      await store.putSignalWaiter({
+        token: "child:job_1.child.0",
+        runId: "r1",
+        seq: 2
+      });
+      await store.putSignalWaiter({
+        token: "child:jobX1.child.0",
+        runId: "r1",
+        seq: 3
+      });
+      const matches = await store.listCheckpointsByNamePrefix?.("r1", [
+        "signal:child:job_1."
+      ]);
+      expect3(matches?.map((c) => c.name)).toEqual([
+        "signal:child:job_1.onError.0"
+      ]);
+      expect3((await store.listSignalWaiters("child:job_1.")).map((w) => w.token)).toEqual([
+        "child:job_1.child.0"
+      ]);
     });
     t("round-trips checkpoint events and reads back a missing checkpoint as null", async () => {
       await store.createRun(run());
@@ -1316,7 +1849,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       }));
-      expect2((await store.getCheckpoint("r1", 0))?.events).toEqual([
+      expect3((await store.getCheckpoint("r1", 0))?.events).toEqual([
         {
           at: 1,
           level: "error",
@@ -1325,7 +1858,7 @@ function runStateStoreContract(name, makeStore) {
           status: "failed"
         }
       ]);
-      expect2(await store.getCheckpoint("r1", 99)).toBeNull();
+      expect3(await store.getCheckpoint("r1", 99)).toBeNull();
     });
     t("lists incomplete runs, pending runs (FIFO), and due timers", async () => {
       await store.createRun(run({
@@ -1351,20 +1884,20 @@ function runStateStoreContract(name, makeStore) {
         status: "pending",
         createdAt: /* @__PURE__ */ new Date("2026-06-11T00:00:01.000Z")
       }));
-      expect2((await store.listIncompleteRuns()).map((r) => r.id)).toEqual([
+      expect3((await store.listIncompleteRuns()).map((r) => r.id)).toEqual([
         "running1"
       ]);
-      expect2((await store.listPendingRuns(10)).map((r) => r.id)).toEqual([
+      expect3((await store.listPendingRuns(10)).map((r) => r.id)).toEqual([
         "pending1",
         "pending2"
       ]);
-      expect2((await store.listPendingRuns(1)).map((r) => r.id)).toEqual([
+      expect3((await store.listPendingRuns(1)).map((r) => r.id)).toEqual([
         "pending1"
       ]);
-      expect2((await store.listDueTimers(1e4)).map((r) => r.id)).toEqual([
+      expect3((await store.listDueTimers(1e4)).map((r) => r.id)).toEqual([
         "suspended1"
       ]);
-      expect2(await store.listDueTimers(1e3)).toHaveLength(0);
+      expect3(await store.listDueTimers(1e3)).toHaveLength(0);
     });
     t("keeps a worker inside its own namespace on every path that picks work up", async () => {
       await store.createRun(run({
@@ -1399,33 +1932,33 @@ function runStateStoreContract(name, makeStore) {
         wakeAt: 5e3,
         namespace: "beta"
       }));
-      expect2((await store.listPendingRuns(10, "alpha")).map((r) => r.id)).toEqual([
+      expect3((await store.listPendingRuns(10, "alpha")).map((r) => r.id)).toEqual([
         "a-pending"
       ]);
-      expect2((await store.listIncompleteRuns("alpha")).map((r) => r.id)).toEqual([
+      expect3((await store.listIncompleteRuns("alpha")).map((r) => r.id)).toEqual([
         "a-running"
       ]);
-      expect2((await store.listDueTimers(1e4, "alpha")).map((r) => r.id)).toEqual([
+      expect3((await store.listDueTimers(1e4, "alpha")).map((r) => r.id)).toEqual([
         "a-timer"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         namespace: "alpha",
         status: "running"
       })).map((r) => r.id)).toEqual([
         "a-running"
       ]);
-      expect2((await store.listPendingRuns(1, "alpha")).map((r) => r.id)).toEqual([
+      expect3((await store.listPendingRuns(1, "alpha")).map((r) => r.id)).toEqual([
         "a-pending"
       ]);
-      expect2((await store.listPendingRuns(10)).map((r) => r.id).sort()).toEqual([
+      expect3((await store.listPendingRuns(10)).map((r) => r.id).sort()).toEqual([
         "a-pending",
         "b-pending"
       ]);
-      expect2((await store.listIncompleteRuns()).map((r) => r.id).sort()).toEqual([
+      expect3((await store.listIncompleteRuns()).map((r) => r.id).sort()).toEqual([
         "a-running",
         "b-running"
       ]);
-      expect2((await store.listDueTimers(1e4)).map((r) => r.id).sort()).toEqual([
+      expect3((await store.listDueTimers(1e4)).map((r) => r.id).sort()).toEqual([
         "a-timer",
         "b-timer"
       ]);
@@ -1434,20 +1967,20 @@ function runStateStoreContract(name, makeStore) {
       await store.createRun(run({
         id: "r1"
       }));
-      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);
+      expect3(await store.tryLockRun("r1", "A", 2e3, 1e3)).toBe(true);
+      expect3(await store.tryLockRun("r1", "B", 3e3, 1500)).toBe(false);
+      expect3(await store.tryLockRun("r1", "B", 4e3, 2500)).toBe(true);
       await store.releaseRunLock("r1");
-      expect2(await store.tryLockRun("r1", "C", 9e3, 2600)).toBe(true);
+      expect3(await store.tryLockRun("r1", "C", 9e3, 2600)).toBe(true);
     });
     t("renewRunLock only succeeds for the current owner", async () => {
       await store.createRun(run({
         id: "r1"
       }));
-      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);
+      expect3(await store.tryLockRun("r1", "A", 2e3, 1e3)).toBe(true);
+      expect3(await store.renewRunLock("r1", "A", 5e3)).toBe(true);
+      expect3(await store.renewRunLock("r1", "B", 9e3)).toBe(false);
+      expect3(await store.tryLockRun("r1", "B", 6e3, 4e3)).toBe(false);
     });
     t("filters listRuns by workflow and by status", async () => {
       await store.createRun(run({
@@ -1465,19 +1998,19 @@ function runStateStoreContract(name, makeStore) {
         workflow: "checkout",
         status: "completed"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         workflow: "checkout"
       })).map((r) => r.id).sort()).toEqual([
         "a",
         "c"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         status: "running"
       })).map((r) => r.id).sort()).toEqual([
         "a",
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         workflow: "checkout",
         status: "running"
       })).map((r) => r.id)).toEqual([
@@ -1501,7 +2034,7 @@ function runStateStoreContract(name, makeStore) {
         id: "d",
         status: "pending"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         statuses: [
           "running",
           "suspended"
@@ -1510,7 +2043,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         status: "running",
         statuses: [
           "running",
@@ -1519,7 +2052,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         statuses: []
       })).toHaveLength(0);
     });
@@ -1541,21 +2074,21 @@ function runStateStoreContract(name, makeStore) {
       await store.createRun(run({
         id: "c"
       }));
-      expect2((await store.getRun("a"))?.tags).toEqual([
+      expect3((await store.getRun("a"))?.tags).toEqual([
         "etl",
         "critical"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         tag: "etl"
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         tag: "etl-foo"
       })).map((r) => r.id)).toEqual([
         "b"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         tag: "nope"
       })).toHaveLength(0);
     });
@@ -1571,17 +2104,17 @@ function runStateStoreContract(name, makeStore) {
       await store.createRun(run({
         id: "c"
       }));
-      expect2((await store.getRun("a"))?.origin).toBe("@dudousxd/nestjs-catalog-pipeline");
-      expect2((await store.getRun("c"))?.origin).toBeUndefined();
-      expect2((await store.listRuns({
+      expect3((await store.getRun("a"))?.origin).toBe("@dudousxd/nestjs-catalog-pipeline");
+      expect3((await store.getRun("c"))?.origin).toBeUndefined();
+      expect3((await store.listRuns({
         origin: "@dudousxd/nestjs-catalog-pipeline"
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         origin: "unknown"
       })).toEqual([]);
-      expect2((await store.listRuns({})).map((r) => r.id).sort()).toEqual([
+      expect3((await store.listRuns({})).map((r) => r.id).sort()).toEqual([
         "a",
         "b",
         "c"
@@ -1598,7 +2131,7 @@ function runStateStoreContract(name, makeStore) {
       await store.createRun(run({
         id: "c"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         origin: null
       })).map((r) => r.id).sort()).toEqual([
         "b",
@@ -1608,7 +2141,7 @@ function runStateStoreContract(name, makeStore) {
         id: "d",
         status: "dead"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         origin: null,
         status: "dead"
       })).map((r) => r.id)).toEqual([
@@ -1641,22 +2174,22 @@ function runStateStoreContract(name, makeStore) {
         status: "failed"
       }));
       const facets = await store.runFacets({});
-      expect2(facets).toContainEqual({
+      expect3(facets).toContainEqual({
         status: "completed",
         origin: "pkg-a",
         count: 2
       });
-      expect2(facets).toContainEqual({
+      expect3(facets).toContainEqual({
         status: "failed",
         origin: "pkg-b",
         count: 1
       });
-      expect2(facets).toContainEqual({
+      expect3(facets).toContainEqual({
         status: "failed",
         origin: null,
         count: 2
       });
-      expect2(facets.reduce((n, f) => n + f.count, 0)).toBe(5);
+      expect3(facets.reduce((n, f) => n + f.count, 0)).toBe(5);
     });
     t("narrows runFacets on the same predicates listRuns pages", async () => {
       if (!store.runFacets) return;
@@ -1670,7 +2203,7 @@ function runStateStoreContract(name, makeStore) {
         status: "failed",
         namespace: "globex"
       }));
-      expect2(await store.runFacets({
+      expect3(await store.runFacets({
         namespace: "acme"
       })).toEqual([
         {
@@ -1699,7 +2232,7 @@ function runStateStoreContract(name, makeStore) {
         namespace: "initech",
         workflow: "wc"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         statuses: [
           "failed",
           "dead"
@@ -1708,7 +2241,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         namespaces: [
           "acme",
           "globex"
@@ -1717,7 +2250,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         workflows: [
           "wa",
           "wc"
@@ -1739,7 +2272,7 @@ function runStateStoreContract(name, makeStore) {
       await store.createRun(run({
         id: "c"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         origins: [
           "pkg-a",
           null
@@ -1748,7 +2281,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "c"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         origins: [
           "pkg-a",
           "pkg-b"
@@ -1769,7 +2302,7 @@ function runStateStoreContract(name, makeStore) {
         status: "dead",
         namespace: "acme"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         namespaces: [
           "acme"
         ],
@@ -1779,13 +2312,13 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "b"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         namespaces: []
       })).toEqual([]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         statuses: []
       })).toEqual([]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         origins: []
       })).toEqual([]);
     });
@@ -1810,7 +2343,7 @@ function runStateStoreContract(name, makeStore) {
           "adhoc"
         ]
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         tags: [
           "etl",
           "nightly"
@@ -1819,7 +2352,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         tags: []
       })).toEqual([]);
     });
@@ -1860,7 +2393,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       });
-      expect2(inSet.map((r) => r.id).sort()).toEqual([
+      expect3(inSet.map((r) => r.id).sort()).toEqual([
         "a",
         "b"
       ]);
@@ -1876,10 +2409,10 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       });
-      expect2(mixed.map((r) => r.id)).toEqual([
+      expect3(mixed.map((r) => r.id)).toEqual([
         "d"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -1888,7 +2421,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       })).toEqual([]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -1916,7 +2449,7 @@ function runStateStoreContract(name, makeStore) {
         id: "c",
         namespace: "globex"
       }));
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "namespace"
       }, {})).toEqual([
         {
@@ -1941,11 +2474,11 @@ function runStateStoreContract(name, makeStore) {
       const values = await store.runValueFacets({
         field: "origin"
       }, {});
-      expect2(values).toContainEqual({
+      expect3(values).toContainEqual({
         value: "pkg-a",
         count: 1
       });
-      expect2(values).toContainEqual({
+      expect3(values).toContainEqual({
         value: null,
         count: 1
       });
@@ -1967,7 +2500,7 @@ function runStateStoreContract(name, makeStore) {
           "nightly"
         ]
       }));
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "tag"
       }, {
         namespace: "acme"
@@ -1999,7 +2532,7 @@ function runStateStoreContract(name, makeStore) {
           tier: "free"
         }
       }));
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "tag"
       }, {})).toEqual([
         {
@@ -2011,7 +2544,7 @@ function runStateStoreContract(name, makeStore) {
           count: 1
         }
       ]);
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "attributeKey"
       }, {})).toEqual([
         {
@@ -2019,7 +2552,7 @@ function runStateStoreContract(name, makeStore) {
           count: 2
         }
       ]);
-      expect2((await store.runValueFacets({
+      expect3((await store.runValueFacets({
         field: "attributeValue",
         key: "tier"
       }, {})).map((r) => r.value).sort()).toEqual([
@@ -2050,18 +2583,18 @@ function runStateStoreContract(name, makeStore) {
       }, {}, {
         search: "acme"
       });
-      expect2(matches.map((row) => row.value).sort()).toEqual([
+      expect3(matches.map((row) => row.value).sort()).toEqual([
         "acme-prod",
         "acme-staging"
       ]);
-      expect2((await store.runValueFacets({
+      expect3((await store.runValueFacets({
         field: "namespace"
       }, {}, {
         limit: 1
       })).map((r) => r.value)).toEqual([
         "globex"
       ]);
-      expect2((await store.runValueFacets({
+      expect3((await store.runValueFacets({
         field: "namespace"
       }, {}, {
         limit: 1,
@@ -2107,7 +2640,7 @@ function runStateStoreContract(name, makeStore) {
         limit: 2,
         offset: 2
       });
-      expect2(first).toEqual([
+      expect3(first).toEqual([
         {
           value: "one",
           count: 3
@@ -2117,13 +2650,13 @@ function runStateStoreContract(name, makeStore) {
           count: 2
         }
       ]);
-      expect2(second).toEqual([
+      expect3(second).toEqual([
         {
           value: "three",
           count: 1
         }
       ]);
-      expect2(new Set([
+      expect3(new Set([
         ...first,
         ...second
       ].map((r) => r.value)).size).toBe(3);
@@ -2151,7 +2684,7 @@ function runStateStoreContract(name, makeStore) {
           "etl"
         ]
       }));
-      expect2((await store.runValueFacets({
+      expect3((await store.runValueFacets({
         field: "tag"
       }, {}, {
         search: "type:"
@@ -2159,7 +2692,7 @@ function runStateStoreContract(name, makeStore) {
         "type:mel",
         "type:mvr"
       ]);
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "tag"
       }, {}, {
         limit: 1
@@ -2184,7 +2717,7 @@ function runStateStoreContract(name, makeStore) {
         id: "c",
         namespace: "globex"
       }));
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "namespace"
       }, {}, {
         limit: 1
@@ -2196,7 +2729,7 @@ function runStateStoreContract(name, makeStore) {
       ]);
     });
     t("countRuns counts the same set listRuns returns, without the paging", async () => {
-      expect2(typeof store.countRuns).toBe("function");
+      expect3(typeof store.countRuns).toBe("function");
       await store.createRun(run({
         id: "n1",
         status: "running",
@@ -2226,22 +2759,22 @@ function runStateStoreContract(name, makeStore) {
           "q"
         ]
       }));
-      expect2(await store.countRuns?.({})).toBe(4);
-      expect2(await store.countRuns?.({
+      expect3(await store.countRuns?.({})).toBe(4);
+      expect3(await store.countRuns?.({
         namespace: "a"
       })).toBe(3);
-      expect2(await store.countRuns?.({
+      expect3(await store.countRuns?.({
         namespace: "a",
         statuses: [
           "pending",
           "running"
         ]
       })).toBe(2);
-      expect2(await store.countRuns?.({
+      expect3(await store.countRuns?.({
         statuses: []
       })).toBe(0);
       if (supportsTagFilter) {
-        expect2(await store.countRuns?.({
+        expect3(await store.countRuns?.({
           tag: "q",
           statuses: [
             "running",
@@ -2268,28 +2801,28 @@ function runStateStoreContract(name, makeStore) {
       await engine.start("q-wait", {}, "q1", {
         concurrency: quota
       });
-      expect2((await engine.waitForRun("q1", {
+      expect3((await engine.waitForRun("q1", {
         timeoutMs: 2e4
       })).status).toBe("suspended");
-      await expect2(engine.start("q-wait", {}, "q2", {
+      await expect3(engine.start("q-wait", {}, "q2", {
         concurrency: quota
       })).rejects.toThrow(/concurrency limit/);
-      expect2(await store.getRun("q2")).toBeNull();
+      expect3(await store.getRun("q2")).toBeNull();
       await engine.start("q-wait", {}, "q3", {
         concurrency: {
           ...quota,
           key: "tenant:b"
         }
       });
-      expect2((await engine.waitForRun("q1", {
+      expect3((await engine.waitForRun("q1", {
         timeoutMs: 2e4
       })).status).toBe("suspended");
       await engine.cancel("q1");
-      expect2((await store.getRun("q1"))?.status).toBe("cancelled");
+      expect3((await store.getRun("q1"))?.status).toBe("cancelled");
       await engine.start("q-wait", {}, "q4", {
         concurrency: quota
       });
-      expect2(await store.getRun("q4")).not.toBeNull();
+      expect3(await store.getRun("q4")).not.toBeNull();
       for (const id of [
         "q3",
         "q4"
@@ -2328,10 +2861,10 @@ function runStateStoreContract(name, makeStore) {
       ...over
     }), "schedule");
     t("saves, reads back, replaces and deletes a schedule", async () => {
-      expect2(typeof store.saveSchedule).toBe("function");
+      expect3(typeof store.saveSchedule).toBe("function");
       await store.saveSchedule?.(schedule());
       const loaded = await store.getSchedule?.("s1");
-      expect2(loaded).toMatchObject({
+      expect3(loaded).toMatchObject({
         id: "s1",
         namespace: "default",
         workflow: "digest",
@@ -2357,27 +2890,27 @@ function runStateStoreContract(name, makeStore) {
           window: NOW + 6e4
         }
       });
-      expect2(loaded?.createdAt.getTime()).toBe(at.getTime());
+      expect3(loaded?.createdAt.getTime()).toBe(at.getTime());
       await store.saveSchedule?.(schedule({
         workflow: "digest2",
         nextFireAt: null,
         tags: void 0
       }));
       const replaced = await store.getSchedule?.("s1");
-      expect2(replaced?.workflow).toBe("digest2");
-      expect2(replaced?.nextFireAt).toBeNull();
-      expect2(replaced?.tags ?? []).toEqual([]);
-      expect2(await store.getSchedule?.("nope")).toBeNull();
-      expect2(await store.deleteSchedule?.("s1")).toBe(true);
-      expect2(await store.deleteSchedule?.("s1")).toBe(false);
-      expect2(await store.getSchedule?.("s1")).toBeNull();
+      expect3(replaced?.workflow).toBe("digest2");
+      expect3(replaced?.nextFireAt).toBeNull();
+      expect3(replaced?.tags ?? []).toEqual([]);
+      expect3(await store.getSchedule?.("nope")).toBeNull();
+      expect3(await store.deleteSchedule?.("s1")).toBe(true);
+      expect3(await store.deleteSchedule?.("s1")).toBe(false);
+      expect3(await store.getSchedule?.("s1")).toBeNull();
     });
     t("updateSchedule patches, and compare-and-sets on nextFireAt", async () => {
       await store.saveSchedule?.(schedule());
-      expect2(await store.updateSchedule?.("s1", {
+      expect3(await store.updateSchedule?.("s1", {
         paused: true
       })).toBe(true);
-      expect2((await store.getSchedule?.("s1"))?.paused).toBe(true);
+      expect3((await store.getSchedule?.("s1"))?.paused).toBe(true);
       const next = {
         nextFireAt: NOW + 12e4,
         state: {
@@ -2385,24 +2918,24 @@ function runStateStoreContract(name, makeStore) {
           fires: 1
         }
       };
-      expect2(await store.updateSchedule?.("s1", next, NOW + 6e4)).toBe(true);
-      expect2(await store.updateSchedule?.("s1", next, NOW + 6e4)).toBe(false);
+      expect3(await store.updateSchedule?.("s1", next, NOW + 6e4)).toBe(true);
+      expect3(await store.updateSchedule?.("s1", next, NOW + 6e4)).toBe(false);
       const after = await store.getSchedule?.("s1");
-      expect2(after?.nextFireAt).toBe(NOW + 12e4);
-      expect2(after?.state).toEqual({
+      expect3(after?.nextFireAt).toBe(NOW + 12e4);
+      expect3(after?.state).toEqual({
         window: NOW + 12e4,
         fires: 1
       });
       await store.updateSchedule?.("s1", {
         nextFireAt: null
       });
-      expect2(await store.updateSchedule?.("s1", {
+      expect3(await store.updateSchedule?.("s1", {
         nextFireAt: NOW
       }, NOW + 1)).toBe(false);
-      expect2(await store.updateSchedule?.("s1", {
+      expect3(await store.updateSchedule?.("s1", {
         nextFireAt: NOW
       }, null)).toBe(true);
-      expect2(await store.updateSchedule?.("ghost", {
+      expect3(await store.updateSchedule?.("ghost", {
         paused: true
       })).toBe(false);
     });
@@ -2434,47 +2967,47 @@ function runStateStoreContract(name, makeStore) {
         ]
       }));
       const ids2 = /* @__PURE__ */ __name(async (q) => (await store.listSchedules?.(q) ?? []).map((r) => r.id), "ids");
-      expect2(await ids2({})).toEqual([
+      expect3(await ids2({})).toEqual([
         "c",
         "b",
         "a",
         "d",
         "e"
       ]);
-      expect2(await ids2({
+      expect3(await ids2({
         dueBy: NOW
       })).toEqual([
         "b",
         "a"
       ]);
-      expect2(await ids2({
+      expect3(await ids2({
         dueBy: NOW,
         namespace: "default"
       })).toEqual([
         "a"
       ]);
-      expect2(await ids2({
+      expect3(await ids2({
         dueBy: NOW,
         limit: 1
       })).toEqual([
         "b"
       ]);
-      expect2(await ids2({
+      expect3(await ids2({
         workflow: "other"
       })).toEqual([
         "d"
       ]);
-      expect2(await ids2({
+      expect3(await ids2({
         paused: true
       })).toEqual([
         "c"
       ]);
-      if (supportsTagFilter) expect2(await ids2({
+      if (supportsTagFilter) expect3(await ids2({
         tag: "tenant:b"
       })).toEqual([
         "e"
       ]);
-      expect2(await ids2({
+      expect3(await ids2({
         limit: 2,
         offset: 1
       })).toEqual([
@@ -2495,18 +3028,18 @@ function runStateStoreContract(name, makeStore) {
         id: "new",
         createdAt: /* @__PURE__ */ new Date("2026-06-11T00:00:02.000Z")
       }));
-      expect2((await store.listRuns({})).map((r) => r.id)).toEqual([
+      expect3((await store.listRuns({})).map((r) => r.id)).toEqual([
         "new",
         "mid",
         "old"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         limit: 2
       })).map((r) => r.id)).toEqual([
         "new",
         "mid"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         limit: 2,
         offset: 1
       })).map((r) => r.id)).toEqual([
@@ -2536,11 +3069,11 @@ function runStateStoreContract(name, makeStore) {
           tier: "pro"
         }
       }));
-      expect2((await store.getRun("b"))?.searchAttributes).toEqual({
+      expect3((await store.getRun("b"))?.searchAttributes).toEqual({
         amount: 200,
         tier: "pro"
       });
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "amount",
@@ -2552,7 +3085,7 @@ function runStateStoreContract(name, makeStore) {
         "b",
         "c"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2568,7 +3101,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2600,7 +3133,7 @@ function runStateStoreContract(name, makeStore) {
           other: 1
         }
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "vip",
@@ -2611,7 +3144,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "vip",
@@ -2638,7 +3171,7 @@ function runStateStoreContract(name, makeStore) {
         "lt",
         "lte"
       ]) {
-        expect2(await store.listRuns({
+        expect3(await store.listRuns({
           attributes: [
             {
               key: "missing",
@@ -2657,7 +3190,7 @@ function runStateStoreContract(name, makeStore) {
           amount: 10
         }
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2673,7 +3206,7 @@ function runStateStoreContract(name, makeStore) {
           tier: "pro"
         }
       });
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2684,7 +3217,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2693,7 +3226,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       })).toHaveLength(0);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         attributes: [
           {
             key: "amount",
@@ -2736,7 +3269,7 @@ function runStateStoreContract(name, makeStore) {
         ],
         limit: 10
       });
-      expect2(res.map((r) => r.id)).toEqual([
+      expect3(res.map((r) => r.id)).toEqual([
         "a"
       ]);
     });
@@ -2756,12 +3289,12 @@ function runStateStoreContract(name, makeStore) {
         runId: "r3",
         seq: 5
       });
-      expect2((await store.listSignalWaiters("approve-")).map((w) => w.token).sort()).toEqual([
+      expect3((await store.listSignalWaiters("approve-")).map((w) => w.token).sort()).toEqual([
         "approve-1",
         "approve-2"
       ]);
-      expect2((await store.takeSignalWaiter("approve-1"))?.seq).toBe(3);
-      expect2(await store.takeSignalWaiter("approve-1")).toBeNull();
+      expect3((await store.takeSignalWaiter("approve-1"))?.seq).toBe(3);
+      expect3(await store.takeSignalWaiter("approve-1")).toBeNull();
     });
     t("round-trips a signal waiter parallelGroup (child-fan tag) through put \u2192 take \u2192 list", async () => {
       await store.putSignalWaiter({
@@ -2776,13 +3309,13 @@ function runStateStoreContract(name, makeStore) {
         seq: 9
       });
       const listed = await store.listSignalWaiters("child:");
-      expect2(listed.find((w) => w.token === "child:r.child.0")?.parallelGroup).toBe("gather:0");
-      expect2(listed.find((w) => w.token === "child:r.child.9")?.parallelGroup).toBeUndefined();
-      expect2((await store.takeSignalWaiter("child:r.child.0"))?.parallelGroup).toBe("gather:0");
-      expect2((await store.takeSignalWaiter("child:r.child.9"))?.parallelGroup).toBeUndefined();
+      expect3(listed.find((w) => w.token === "child:r.child.0")?.parallelGroup).toBe("gather:0");
+      expect3(listed.find((w) => w.token === "child:r.child.9")?.parallelGroup).toBeUndefined();
+      expect3((await store.takeSignalWaiter("child:r.child.0"))?.parallelGroup).toBe("gather:0");
+      expect3((await store.takeSignalWaiter("child:r.child.9"))?.parallelGroup).toBeUndefined();
     });
     t("registerChildWaits writes every waiter and placeholder, and upserts on repeat", async () => {
-      expect2(store.registerChildWaits).toBeTypeOf("function");
+      expect3(store.registerChildWaits).toBeTypeOf("function");
       await store.createRun(run({
         id: "p"
       }));
@@ -2808,24 +3341,24 @@ function runStateStoreContract(name, makeStore) {
       }, (_, i) => entry(i, "running"));
       await store.registerChildWaits?.(entries);
       const waiters = await store.listSignalWaiters("child:p.all.0.");
-      expect2(waiters).toHaveLength(250);
-      expect2(waiters.find((w) => w.token === "child:p.all.0.7")).toEqual(entries[7]?.waiter);
+      expect3(waiters).toHaveLength(250);
+      expect3(waiters.find((w) => w.token === "child:p.all.0.7")).toEqual(entries[7]?.waiter);
       const cps = await store.listCheckpoints("p");
-      expect2(cps).toHaveLength(250);
-      expect2(cps[7]).toMatchObject({
+      expect3(cps).toHaveLength(250);
+      expect3(cps[7]).toMatchObject({
         name: "signal:child:p.all.0.7",
         status: "running"
       });
-      expect2(cps[7]?.parallelGroup).toBe("all:0");
+      expect3(cps[7]?.parallelGroup).toBe("all:0");
       await store.registerChildWaits?.([
         entry(7, "completed")
       ]);
-      expect2((await store.getCheckpoint("p", 7))?.status).toBe("completed");
-      expect2(await store.listCheckpoints("p")).toHaveLength(250);
-      await expect2(store.registerChildWaits?.([])).resolves.toBeUndefined();
+      expect3((await store.getCheckpoint("p", 7))?.status).toBe("completed");
+      expect3(await store.listCheckpoints("p")).toHaveLength(250);
+      await expect3(store.registerChildWaits?.([])).resolves.toBeUndefined();
     });
     t("compactCheckpoints replaces a seq range with one checkpoint, atomically", async () => {
-      expect2(store.compactCheckpoints).toBeTypeOf("function");
+      expect3(store.compactCheckpoints).toBeTypeOf("function");
       await store.createRun(run({
         id: "r"
       }));
@@ -2864,18 +3397,18 @@ function runStateStoreContract(name, makeStore) {
       });
       await store.compactCheckpoints?.("r", 2, 7, into);
       const left = await store.listCheckpoints("r");
-      expect2(left.map((cp) => cp.seq)).toEqual([
+      expect3(left.map((cp2) => cp2.seq)).toEqual([
         0,
         1,
         2,
         8,
         9
       ]);
-      expect2(left[2]).toMatchObject({
+      expect3(left[2]).toMatchObject({
         name: "fan:r.all.2.",
         parallelGroup: "all:2"
       });
-      expect2(left[2]?.output).toEqual({
+      expect3(left[2]?.output).toEqual({
         from: 0,
         values: [
           {
@@ -2885,10 +3418,10 @@ function runStateStoreContract(name, makeStore) {
           null
         ]
       });
-      expect2(await store.listCheckpoints("other")).toHaveLength(1);
+      expect3(await store.listCheckpoints("other")).toHaveLength(1);
     });
     t("listSignalWaitersByRun returns only the given runs' waiters", async () => {
-      expect2(store.listSignalWaitersByRun).toBeTypeOf("function");
+      expect3(store.listSignalWaitersByRun).toBeTypeOf("function");
       await store.putSignalWaiter({
         token: "child:a.all.0.0",
         runId: "a",
@@ -2911,7 +3444,7 @@ function runStateStoreContract(name, makeStore) {
         seq: 0
       });
       const tokens = /* @__PURE__ */ __name(async (ids2) => (await store.listSignalWaitersByRun?.(ids2) ?? []).map((w) => w.token).sort(), "tokens");
-      expect2(await tokens([
+      expect3(await tokens([
         "a",
         "b"
       ])).toEqual([
@@ -2919,11 +3452,11 @@ function runStateStoreContract(name, makeStore) {
         "approve-b",
         "child:a.all.0.0"
       ]);
-      expect2(await tokens([
+      expect3(await tokens([
         "missing"
       ])).toEqual([]);
-      expect2(await tokens([])).toEqual([]);
-      expect2((await store.listSignalWaitersByRun?.([
+      expect3(await tokens([])).toEqual([]);
+      expect3((await store.listSignalWaitersByRun?.([
         "a"
       ]))?.find((w) => w.seq === 0)).toEqual({
         token: "child:a.all.0.0",
@@ -2933,7 +3466,7 @@ function runStateStoreContract(name, makeStore) {
       });
     });
     t("hasSignalWaiter answers by run and exact token prefix", async () => {
-      expect2(store.hasSignalWaiter).toBeTypeOf("function");
+      expect3(store.hasSignalWaiter).toBeTypeOf("function");
       const has = /* @__PURE__ */ __name((runId, prefix) => store.hasSignalWaiter?.(runId, prefix), "has");
       await store.putSignalWaiter({
         token: "child:p_1.all.3.0",
@@ -2951,13 +3484,13 @@ function runStateStoreContract(name, makeStore) {
         runId: "p_1",
         seq: 9
       });
-      expect2(await has("p_1", "child:p_1.all.3.")).toBe(true);
-      expect2(await has("p_1", "child:p_1.all.4.")).toBe(false);
-      expect2(await has("other", "child:p_1.all.3.")).toBe(false);
-      expect2(await has("p_1", "child:p%.all.3.")).toBe(false);
-      expect2(await has("p_1", "CHILD:p_1.all.3.")).toBe(false);
+      expect3(await has("p_1", "child:p_1.all.3.")).toBe(true);
+      expect3(await has("p_1", "child:p_1.all.4.")).toBe(false);
+      expect3(await has("other", "child:p_1.all.3.")).toBe(false);
+      expect3(await has("p_1", "child:p%.all.3.")).toBe(false);
+      expect3(await has("p_1", "CHILD:p_1.all.3.")).toBe(false);
       await store.takeSignalWaiter("child:p_1.all.3.0");
-      expect2(await has("p_1", "child:p_1.all.3.")).toBe(false);
+      expect3(await has("p_1", "child:p_1.all.3.")).toBe(false);
     });
     t("removeSignalWaiter deletes only the exact (token, runId, seq) row, never a different run's", async () => {
       await store.putSignalWaiter({
@@ -2975,7 +3508,7 @@ function runStateStoreContract(name, makeStore) {
         runId: "r1",
         seq: 3
       });
-      expect2((await store.listSignalWaiters("approve-")).map((w) => w.runId)).toEqual([
+      expect3((await store.listSignalWaiters("approve-")).map((w) => w.runId)).toEqual([
         "r2"
       ]);
       await store.removeSignalWaiter({
@@ -2983,7 +3516,7 @@ function runStateStoreContract(name, makeStore) {
         runId: "r2",
         seq: 999
       });
-      expect2((await store.listSignalWaiters("approve-")).map((w) => w.runId)).toEqual([
+      expect3((await store.listSignalWaiters("approve-")).map((w) => w.runId)).toEqual([
         "r2"
       ]);
       await store.removeSignalWaiter({
@@ -2991,7 +3524,7 @@ function runStateStoreContract(name, makeStore) {
         runId: "r2",
         seq: 7
       });
-      expect2(await store.listSignalWaiters("approve-")).toEqual([]);
+      expect3(await store.listSignalWaiters("approve-")).toEqual([]);
       await store.removeSignalWaiter({
         token: "never-registered",
         runId: "r1",
@@ -3008,18 +3541,18 @@ function runStateStoreContract(name, makeStore) {
       await store.bufferSignal("other", {
         n: 9
       });
-      expect2(await store.takeBufferedSignal("sig")).toEqual({
+      expect3(await store.takeBufferedSignal("sig")).toEqual({
         payload: {
           n: 1
         }
       });
-      expect2(await store.takeBufferedSignal("sig")).toEqual({
+      expect3(await store.takeBufferedSignal("sig")).toEqual({
         payload: {
           n: 2
         }
       });
-      expect2(await store.takeBufferedSignal("sig")).toBeNull();
-      expect2(await store.takeBufferedSignal("other")).toEqual({
+      expect3(await store.takeBufferedSignal("sig")).toBeNull();
+      expect3(await store.takeBufferedSignal("other")).toEqual({
         payload: {
           n: 9
         }
@@ -3051,7 +3584,7 @@ function runStateStoreContract(name, makeStore) {
         publishedAt: 50
       });
       const listed = await store.listBufferedEvents("order.paid", 10);
-      expect2(listed.map((e) => e.payload)).toEqual([
+      expect3(listed.map((e) => e.payload)).toEqual([
         {
           n: 1
         },
@@ -3059,13 +3592,13 @@ function runStateStoreContract(name, makeStore) {
           n: 2
         }
       ]);
-      expect2(listed.map((e) => e.id)).toEqual([
+      expect3(listed.map((e) => e.id)).toEqual([
         "e1",
         "e2"
       ]);
-      expect2(listed[0]?.publishedAt).toBe(100);
-      expect2(await store.listBufferedEvents("order.paid", 10)).toHaveLength(2);
-      expect2(await store.listBufferedEvents("other.event", 10)).toEqual([
+      expect3(listed[0]?.publishedAt).toBe(100);
+      expect3(await store.listBufferedEvents("order.paid", 10)).toHaveLength(2);
+      expect3(await store.listBufferedEvents("other.event", 10)).toEqual([
         {
           id: "e3",
           payload: {
@@ -3094,7 +3627,7 @@ function runStateStoreContract(name, makeStore) {
         id: "c",
         publishedAt: 3
       });
-      expect2(await store.listBufferedEvents("evt", 2)).toHaveLength(2);
+      expect3(await store.listBufferedEvents("evt", 2)).toHaveLength(2);
     });
     t("removeBufferedEvent atomically deletes by id \u2014 true iff a row existed, false on a repeat/absent id", async () => {
       await store.bufferEvent({
@@ -3105,10 +3638,10 @@ function runStateStoreContract(name, makeStore) {
         id: "x1",
         publishedAt: 1
       });
-      expect2(await store.removeBufferedEvent("x1")).toBe(true);
-      expect2(await store.listBufferedEvents("evt", 10)).toEqual([]);
-      expect2(await store.removeBufferedEvent("x1")).toBe(false);
-      expect2(await store.removeBufferedEvent("never-buffered")).toBe(false);
+      expect3(await store.removeBufferedEvent("x1")).toBe(true);
+      expect3(await store.listBufferedEvents("evt", 10)).toEqual([]);
+      expect3(await store.removeBufferedEvent("x1")).toBe(false);
+      expect3(await store.removeBufferedEvent("never-buffered")).toBe(false);
     });
     t("transaction commits the checkpoint atomically and returns the work result", async () => {
       if (!store.transaction) return;
@@ -3124,10 +3657,10 @@ function runStateStoreContract(name, makeStore) {
         }));
         return "ok";
       });
-      expect2(result).toBe("ok");
-      const cp = await store.getCheckpoint("r1", 7);
-      expect2(cp?.name).toBe("tx-step");
-      expect2(cp?.output).toEqual({
+      expect3(result).toBe("ok");
+      const cp2 = await store.getCheckpoint("r1", 7);
+      expect3(cp2?.name).toBe("tx-step");
+      expect3(cp2?.output).toEqual({
         paid: true
       });
     });
@@ -3154,11 +3687,11 @@ function runStateStoreContract(name, makeStore) {
       await engine.start("wf", {
         x: 1
       }, "run1");
-      expect2((await engine.waitForRun("run1")).status).toBe("failed");
+      expect3((await engine.waitForRun("run1")).status).toBe("failed");
       const resumed = await engine.resume("run1");
-      expect2(resumed.status).toBe("completed");
-      expect2(resumed.output).toBe(15);
-      expect2(aRuns).toBe(1);
+      expect3(resumed.status).toBe("completed");
+      expect3(resumed.output).toBe(15);
+      expect3(aRuns).toBe(1);
     });
     t("starts the version the caller pinned, and refuses one that is not registered", async () => {
       const engine = new WorkflowEngine3({
@@ -3179,19 +3712,19 @@ function runStateStoreContract(name, makeStore) {
       const pinned = await engine.waitForRun("pinned-run", {
         timeoutMs: 2e4
       });
-      expect2(pinned.output).toBe("v1-output");
-      expect2(ran).toEqual([
+      expect3(pinned.output).toBe("v1-output");
+      expect3(ran).toEqual([
         "v1"
       ]);
-      expect2((await store.getRun("pinned-run"))?.workflowVersion).toBe("1");
+      expect3((await store.getRun("pinned-run"))?.workflowVersion).toBe("1");
       await engine.start("vwf", {}, "newest-run");
-      expect2((await engine.waitForRun("newest-run", {
+      expect3((await engine.waitForRun("newest-run", {
         timeoutMs: 2e4
       })).output).toBe("v2-output");
-      await expect2(engine.start("vwf", {}, "ghost-run", {
+      await expect3(engine.start("vwf", {}, "ghost-run", {
         version: "9"
       })).rejects.toThrow(/vwf@9 is not registered/);
-      expect2(await store.getRun("ghost-run")).toBeNull();
+      expect3(await store.getRun("ghost-run")).toBeNull();
     });
     t("cancels a timed-out run\u2019s live child subtree, not just the run itself", async () => {
       const engine = new WorkflowEngine3({
@@ -3214,16 +3747,16 @@ function runStateStoreContract(name, makeStore) {
         "tc",
         "tgc"
       ]) {
-        expect2((await engine.waitForRun(id, {
+        expect3((await engine.waitForRun(id, {
           timeoutMs: 2e4
         })).status).toBe("suspended");
       }
       await engine.sweepTimeouts(Date.now() + 37e5);
       const parent = await store.getRun("tp");
-      expect2(parent?.status).toBe("cancelled");
-      expect2(parent?.error?.code).toBe("execution_timeout");
-      expect2((await store.getRun("tc"))?.status).toBe("cancelled");
-      expect2((await store.getRun("tgc"))?.status).toBe("cancelled");
+      expect3(parent?.status).toBe("cancelled");
+      expect3(parent?.error?.code).toBe("execution_timeout");
+      expect3((await store.getRun("tc"))?.status).toBe("cancelled");
+      expect3((await store.getRun("tgc"))?.status).toBe("cancelled");
     });
   });
 }
@@ -3295,6 +3828,7 @@ export {
   DURABLE_CANONICAL_COLUMNS,
   MutableClock,
   StateStoreUnavailableError,
+  aggregationFixture,
   assertDurableColumns,
   assertOutput,
   assertReplayable,
@@ -3307,6 +3841,7 @@ export {
   failTimes,
   preserveColumnExpectation,
   recordedSteps,
+  registerCheckpointAggregationCases,
   runAdmissionBackendContract,
   runStateStoreContract
 };