@dudousxd/nestjs-durable-testing 0.17.0 → 0.19.0

package/dist/index.js

@@ -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,24 @@ 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("pr", {
         timeoutMs: 2e4
       })).status).toBe("suspended");
-      expect2((await engine.waitForRun("po", {
+      expect3((await engine.waitForRun("pc", {
+        timeoutMs: 2e4
+      })).status).toBe("suspended");
+      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 +1373,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 +1422,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 +1473,175 @@ 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("listOrphanedRuns returns incomplete runs with a free or expired lease, oldest first", async () => {
+      expect3(store.listOrphanedRuns).toBeDefined();
+      if (!store.listOrphanedRuns) return;
+      const created = /* @__PURE__ */ __name((offset) => new Date(at.getTime() + offset * 1e3), "created");
+      await store.createRun(run({
+        id: "held",
+        createdAt: created(1)
+      }));
+      expect3(await store.tryLockRun("held", "live", NOW + 3e4, NOW)).toBe(true);
+      await store.createRun(run({
+        id: "expired",
+        createdAt: created(3)
+      }));
+      expect3(await store.tryLockRun("expired", "dead", NOW, NOW - 1)).toBe(true);
+      await store.createRun(run({
+        id: "free",
+        createdAt: created(2)
+      }));
+      await store.createRun(run({
+        id: "compensating",
+        status: "cancelling",
+        createdAt: created(4)
+      }));
+      await store.createRun(run({
+        id: "parked",
+        status: "suspended",
+        createdAt: created(0)
+      }));
+      await store.createRun(run({
+        id: "done",
+        status: "completed",
+        createdAt: created(0)
+      }));
+      await store.createRun(run({
+        id: "tenant",
+        namespace: "beta",
+        createdAt: created(5)
+      }));
+      expect3((await store.listOrphanedRuns(NOW, 10)).map((r) => r.id)).toEqual([
+        "free",
+        "expired",
+        "compensating",
+        "tenant"
+      ]);
+      expect3((await store.listOrphanedRuns(NOW, 2)).map((r) => r.id)).toEqual([
+        "free",
+        "expired"
+      ]);
+      expect3((await store.listOrphanedRuns(NOW, 10, "beta")).map((r) => r.id)).toEqual([
+        "tenant"
+      ]);
+      expect3((await store.listOrphanedRuns(NOW + 3e4, 10)).map((r) => r.id)).toContain("held");
+      expect3(await store.listOrphanedRuns(NOW, 0)).toEqual([]);
+    });
+    t("updateRunIf writes only over an expected status", async () => {
+      expect3(store.updateRunIf).toBeDefined();
+      if (!store.updateRunIf) return;
+      await store.createRun(run({
+        error: {
+          message: "earlier attempt"
+        }
+      }));
+      expect3(await store.updateRunIf("r1", [
+        "suspended",
+        "blocked"
+      ], {
+        status: "completed",
+        output: {
+          total: 1
+        }
+      })).toBe(false);
+      let current = await store.getRun("r1");
+      expect3(current?.status).toBe("running");
+      expect3(current?.output).toBeUndefined();
+      expect3(await store.updateRunIf("r1", [
+        "pending",
+        "running"
+      ], {
+        status: "suspended",
+        wakeAt: 7e3,
+        error: void 0,
+        updatedAt: new Date(at.getTime() + 1e3)
+      })).toBe(true);
+      current = await store.getRun("r1");
+      expect3(current?.status).toBe("suspended");
+      expect3(current?.wakeAt).toBe(7e3);
+      expect3(current?.error).toBeUndefined();
+      expect3(current?.updatedAt.getTime()).toBe(at.getTime() + 1e3);
+      await store.updateRun("r1", {
+        status: "cancelled",
+        error: {
+          message: "cancelled"
+        }
+      });
+      expect3(await store.updateRunIf("r1", [
+        "running",
+        "suspended"
+      ], {
+        status: "completed",
+        output: {
+          total: 2
+        }
+      })).toBe(false);
+      current = await store.getRun("r1");
+      expect3(current?.status).toBe("cancelled");
+      expect3(current?.error).toEqual({
+        message: "cancelled"
+      });
+      expect3(current?.output).toBeUndefined();
+      expect3(await store.updateRunIf("missing", [
+        "running"
+      ], {
+        status: "completed"
+      })).toBe(false);
+      expect3(await store.getRun("missing")).toBeNull();
+    });
+    t("updateRunIf settling a run terminal drops its singleton admission like updateRun", async () => {
+      expect3(store.updateRunIf).toBeDefined();
+      if (!store.updateRunIf) return;
+      await store.createRun(run({
+        tags: [
+          "singleton:k",
+          SINGLETON_ADMITTED_TAG
+        ]
+      }));
+      expect3(await store.updateRunIf("r1", [
+        "running"
+      ], {
+        status: "completed",
+        output: {
+          ok: true
+        }
+      })).toBe(true);
+      const settled = await store.getRun("r1");
+      expect3(settled?.status).toBe("completed");
+      expect3(settled?.output).toEqual({
+        ok: true
+      });
+      expect3(settled?.tags).toEqual([
+        "singleton:k"
+      ]);
     });
     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 +1649,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 +1661,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 +1862,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 +1904,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 +1938,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 +1994,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 +2003,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 +2029,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 +2077,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 +2112,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 +2143,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 +2179,7 @@ function runStateStoreContract(name, makeStore) {
         id: "d",
         status: "pending"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         statuses: [
           "running",
           "suspended"
@@ -1510,7 +2188,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         status: "running",
         statuses: [
           "running",
@@ -1519,7 +2197,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         statuses: []
       })).toHaveLength(0);
     });
@@ -1541,21 +2219,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 +2249,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 +2276,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 +2286,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 +2319,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 +2348,7 @@ function runStateStoreContract(name, makeStore) {
         status: "failed",
         namespace: "globex"
       }));
-      expect2(await store.runFacets({
+      expect3(await store.runFacets({
         namespace: "acme"
       })).toEqual([
         {
@@ -1699,7 +2377,7 @@ function runStateStoreContract(name, makeStore) {
         namespace: "initech",
         workflow: "wc"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         statuses: [
           "failed",
           "dead"
@@ -1708,7 +2386,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         namespaces: [
           "acme",
           "globex"
@@ -1717,7 +2395,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         workflows: [
           "wa",
           "wc"
@@ -1739,7 +2417,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 +2426,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "c"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         origins: [
           "pkg-a",
           "pkg-b"
@@ -1769,7 +2447,7 @@ function runStateStoreContract(name, makeStore) {
         status: "dead",
         namespace: "acme"
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         namespaces: [
           "acme"
         ],
@@ -1779,13 +2457,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 +2488,7 @@ function runStateStoreContract(name, makeStore) {
           "adhoc"
         ]
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         tags: [
           "etl",
           "nightly"
@@ -1819,7 +2497,7 @@ function runStateStoreContract(name, makeStore) {
         "a",
         "b"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         tags: []
       })).toEqual([]);
     });
@@ -1860,7 +2538,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 +2554,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 +2566,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       })).toEqual([]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -1916,7 +2594,7 @@ function runStateStoreContract(name, makeStore) {
         id: "c",
         namespace: "globex"
       }));
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "namespace"
       }, {})).toEqual([
         {
@@ -1941,11 +2619,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 +2645,7 @@ function runStateStoreContract(name, makeStore) {
           "nightly"
         ]
       }));
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "tag"
       }, {
         namespace: "acme"
@@ -1999,7 +2677,7 @@ function runStateStoreContract(name, makeStore) {
           tier: "free"
         }
       }));
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "tag"
       }, {})).toEqual([
         {
@@ -2011,7 +2689,7 @@ function runStateStoreContract(name, makeStore) {
           count: 1
         }
       ]);
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "attributeKey"
       }, {})).toEqual([
         {
@@ -2019,7 +2697,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 +2728,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 +2785,7 @@ function runStateStoreContract(name, makeStore) {
         limit: 2,
         offset: 2
       });
-      expect2(first).toEqual([
+      expect3(first).toEqual([
         {
           value: "one",
           count: 3
@@ -2117,13 +2795,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 +2829,7 @@ function runStateStoreContract(name, makeStore) {
           "etl"
         ]
       }));
-      expect2((await store.runValueFacets({
+      expect3((await store.runValueFacets({
         field: "tag"
       }, {}, {
         search: "type:"
@@ -2159,7 +2837,7 @@ function runStateStoreContract(name, makeStore) {
         "type:mel",
         "type:mvr"
       ]);
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "tag"
       }, {}, {
         limit: 1
@@ -2184,7 +2862,7 @@ function runStateStoreContract(name, makeStore) {
         id: "c",
         namespace: "globex"
       }));
-      expect2(await store.runValueFacets({
+      expect3(await store.runValueFacets({
         field: "namespace"
       }, {}, {
         limit: 1
@@ -2196,7 +2874,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 +2904,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 +2946,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 +3006,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 +3035,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 +3063,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 +3112,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 +3173,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 +3214,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 +3230,7 @@ function runStateStoreContract(name, makeStore) {
         "b",
         "c"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2568,7 +3246,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "b"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2600,7 +3278,7 @@ function runStateStoreContract(name, makeStore) {
           other: 1
         }
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "vip",
@@ -2611,7 +3289,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "vip",
@@ -2638,7 +3316,7 @@ function runStateStoreContract(name, makeStore) {
         "lt",
         "lte"
       ]) {
-        expect2(await store.listRuns({
+        expect3(await store.listRuns({
           attributes: [
             {
               key: "missing",
@@ -2657,7 +3335,7 @@ function runStateStoreContract(name, makeStore) {
           amount: 10
         }
       }));
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2673,7 +3351,7 @@ function runStateStoreContract(name, makeStore) {
           tier: "pro"
         }
       });
-      expect2((await store.listRuns({
+      expect3((await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2684,7 +3362,7 @@ function runStateStoreContract(name, makeStore) {
       })).map((r) => r.id)).toEqual([
         "a"
       ]);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         attributes: [
           {
             key: "tier",
@@ -2693,7 +3371,7 @@ function runStateStoreContract(name, makeStore) {
           }
         ]
       })).toHaveLength(0);
-      expect2(await store.listRuns({
+      expect3(await store.listRuns({
         attributes: [
           {
             key: "amount",
@@ -2736,7 +3414,7 @@ function runStateStoreContract(name, makeStore) {
         ],
         limit: 10
       });
-      expect2(res.map((r) => r.id)).toEqual([
+      expect3(res.map((r) => r.id)).toEqual([
         "a"
       ]);
     });
@@ -2756,12 +3434,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 +3454,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 +3486,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 +3542,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 +3563,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 +3589,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 +3597,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 +3611,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 +3629,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 +3653,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 +3661,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 +3669,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 +3686,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 +3729,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 +3737,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 +3772,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 +3783,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 +3802,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 +3832,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 +3857,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 +3892,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 +3973,7 @@ export {
   DURABLE_CANONICAL_COLUMNS,
   MutableClock,
   StateStoreUnavailableError,
+  aggregationFixture,
   assertDurableColumns,
   assertOutput,
   assertReplayable,
@@ -3307,6 +3986,7 @@ export {
   failTimes,
   preserveColumnExpectation,
   recordedSteps,
+  registerCheckpointAggregationCases,
   runAdmissionBackendContract,
   runStateStoreContract
 };