@dudousxd/nestjs-durable-testing 0.14.0 → 0.16.0

package/dist/index.js

@@ -287,6 +287,19 @@ var DURABLE_CANONICAL_COLUMNS = {
     name: "name",
     payload: "payload",
     publishedAt: "published_at"
+  },
+  // Persisted schedules (`engine.schedules`). `spec`/`state` are engine-owned JSON documents.
+  durable_schedules: {
+    id: "id",
+    namespace: "namespace",
+    workflow: "workflow",
+    paused: "paused",
+    nextFireAt: "next_fire_at",
+    tags: "tags",
+    spec: "spec",
+    state: "state",
+    createdAt: "created_at",
+    updatedAt: "updated_at"
   }
 };
 function assertDurableColumns(resolve, expected = DURABLE_CANONICAL_COLUMNS) {
@@ -386,7 +399,7 @@ async function assertReplayable(register, history) {
 __name(assertReplayable, "assertReplayable");
 
 // src/state-store-conformance.ts
-import { WorkflowEngine as WorkflowEngine3 } from "@dudousxd/nestjs-durable-core";
+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";
 var StateStoreUnavailableError = class extends Error {
   static {
@@ -403,6 +416,8 @@ function isUnavailable(err) {
 }
 __name(isUnavailable, "isUnavailable");
 var at = /* @__PURE__ */ new Date("2026-06-11T00:00:00.000Z");
+var NOW = Date.parse("2026-06-20T00:00:00.000Z");
+var DAY = 864e5;
 var run = /* @__PURE__ */ __name((over = {}) => ({
   id: "r1",
   workflow: "checkout",
@@ -434,6 +449,7 @@ var checkpoint = /* @__PURE__ */ __name((over = {}) => ({
 function runStateStoreContract(name, makeStore) {
   describe2(`StateStore contract: ${name}`, () => {
     let store;
+    let peerStore;
     let cleanup;
     let supportsAsyncTransaction = true;
     let supportsTagFilter = true;
@@ -443,6 +459,7 @@ function runStateStoreContract(name, makeStore) {
       try {
         const ctx = await makeStore();
         store = ctx.store;
+        peerStore = ctx.peerStore ?? ctx.store;
         cleanup = ctx.cleanup;
         supportsAsyncTransaction = ctx.supportsAsyncTransaction ?? true;
         supportsTagFilter = ctx.supportsTagFilter ?? true;
@@ -468,6 +485,197 @@ function runStateStoreContract(name, makeStore) {
         await fn();
       });
     }, "t");
+    t("atomically admits holders without displacement by later same-millisecond IDs", async () => {
+      expect2(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",
+        tags: [
+          "singleton:k",
+          "user-tag"
+        ]
+      }));
+      expect2(await claim("z-holder")).toBe(true);
+      await store.updateRun("z-holder", {
+        status: "suspended",
+        wakeAt: 1e4
+      });
+      expect2(await claim("z-holder")).toBe(true);
+      await store.updateRun("z-holder", {
+        status: "blocked",
+        lockedBy: "expired",
+        lockedUntil: 0
+      });
+      await store.createRun(run({
+        id: "a-waiter",
+        tags: [
+          "singleton:k"
+        ]
+      }));
+      expect2(await claim("a-waiter")).toBe(false);
+      expect2(await claim("z-holder")).toBe(true);
+      await store.updateRun("z-holder", {
+        status: "cancelling"
+      });
+      expect2(await claim("a-waiter")).toBe(false);
+      await store.updateRun("z-holder", {
+        status: "completed"
+      });
+      expect2((await store.getRun("z-holder"))?.tags).toEqual([
+        "singleton:k",
+        "user-tag"
+      ]);
+      expect2(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);
+    });
+    t("singleton denial atomically parks waiters and preserves cancelling/terminal state", async () => {
+      await store.createRun(run({
+        id: "holder",
+        tags: [
+          "singleton:k"
+        ]
+      }));
+      expect2(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({
+        status: "suspended",
+        wakeAt: 12e3
+      });
+      await store.updateRun("waiter", {
+        status: "cancelling",
+        wakeAt: void 0
+      });
+      expect2(await peerStore.tryAdmitSingleton?.("waiter", "singleton:k", "checkout", 1, 14e3)).toBe(false);
+      expect2(await store.getRun("waiter")).toMatchObject({
+        status: "cancelling"
+      });
+      expect2((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");
+      await store.updateRun("holder", {
+        status: "completed"
+      });
+      await store.createRun(run({
+        id: "cancelling",
+        status: "cancelling",
+        tags: [
+          "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);
+    });
+    t("competing store instances atomically claim an empty singleton slot", async () => {
+      for (const id of [
+        "a-first",
+        "b-second",
+        "c-third"
+      ]) {
+        await store.createRun(run({
+          id,
+          tags: [
+            "singleton:k"
+          ]
+        }));
+      }
+      const results = await Promise.all([
+        peerStore.tryAdmitSingleton?.("b-second", "singleton:k", "checkout", 1),
+        store.tryAdmitSingleton?.("a-first", "singleton:k", "checkout", 1),
+        peerStore.tryAdmitSingleton?.("c-third", "singleton:k", "checkout", 1)
+      ]);
+      expect2(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);
+    });
+    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");
+      for (const id of [
+        "z-holder",
+        "y-holder"
+      ]) {
+        await store.createRun(run({
+          id,
+          tags: [
+            "singleton:k"
+          ]
+        }));
+        expect2(await claim(id)).toBe(true);
+      }
+      for (const id of [
+        "a-waiter",
+        "b-waiter",
+        "c-waiter"
+      ]) {
+        await store.createRun(run({
+          id,
+          status: "pending",
+          tags: [
+            "singleton:k"
+          ]
+        }));
+      }
+      expect2(await Promise.all([
+        "a-waiter",
+        "b-waiter",
+        "c-waiter"
+      ].map((id) => claim(id)))).toEqual([
+        false,
+        false,
+        false
+      ]);
+      await store.updateRun("z-holder", {
+        status: "failed"
+      });
+      expect2(await Promise.all([
+        "c-waiter",
+        "b-waiter",
+        "a-waiter"
+      ].map((id) => claim(id)))).toEqual([
+        false,
+        false,
+        true
+      ]);
+      const active = await store.listRuns({
+        workflow: "checkout",
+        statuses: [
+          "running",
+          "pending"
+        ]
+      });
+      expect2(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);
+      await store.createRun(run({
+        id: "other-workflow",
+        workflow: "other",
+        tags: [
+          "singleton:k"
+        ]
+      }));
+      expect2(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");
@@ -544,6 +752,249 @@ function runStateStoreContract(name, makeStore) {
     t("deleteRun is a no-op for a missing run", async () => {
       await expect2(store.deleteRun("nope")).resolves.toBeUndefined();
     });
+    t("deleteRuns removes every listed run with its rows and ignores missing ids", async () => {
+      await store.createRun(run({
+        id: "d1",
+        searchAttributes: {
+          tier: "pro"
+        }
+      }));
+      await store.createRun(run({
+        id: "d2"
+      }));
+      await store.createRun(run({
+        id: "keep"
+      }));
+      await store.saveCheckpoint(checkpoint({
+        runId: "d1",
+        stepId: "d1:0"
+      }));
+      await store.putSignalWaiter({
+        token: "approve-d2",
+        runId: "d2",
+        seq: 0
+      });
+      expect2(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({
+        attributes: [
+          {
+            key: "tier",
+            op: "eq",
+            value: "pro"
+          }
+        ]
+      })).toEqual([]);
+      await expect2(store.deleteRuns?.([])).resolves.toBeUndefined();
+    });
+    const aged = /* @__PURE__ */ __name((id, ageDays, over = {}) => run({
+      id,
+      status: "completed",
+      createdAt: new Date(NOW - ageDays * DAY),
+      updatedAt: new Date(NOW - ageDays * DAY),
+      ...over
+    }), "aged");
+    const ids = /* @__PURE__ */ __name(async () => (await store.listRuns({})).map((r) => r.id).sort(), "ids");
+    t("pruneTerminalRuns drops terminal runs past maxAge and never touches live ones", async () => {
+      await store.createRun(aged("old-done", 10));
+      await store.createRun(aged("old-failed", 10, {
+        status: "failed"
+      }));
+      await store.createRun(aged("old-live", 10, {
+        status: "suspended"
+      }));
+      await store.createRun(aged("fresh-done", 1));
+      await store.saveCheckpoint(checkpoint({
+        runId: "old-done",
+        stepId: "old-done:0"
+      }));
+      expect2(typeof store.pruneTerminalRuns).toBe("function");
+      const deleted = await store.pruneTerminalRuns?.({
+        statuses: [
+          "completed",
+          "failed",
+          "suspended"
+        ],
+        maxAge: "7d"
+      }, NOW, 100);
+      expect2(deleted).toBe(2);
+      expect2(await ids()).toEqual([
+        "fresh-done",
+        "old-live"
+      ]);
+      expect2(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));
+      const policy = {
+        statuses: [
+          "completed"
+        ],
+        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([
+        "c1",
+        "c2"
+      ]);
+    });
+    t("a scoped retention policy only prunes (and counts) the runs its scope matches", async () => {
+      await store.createRun(aged("acme-old", 10, {
+        namespace: "acme"
+      }));
+      await store.createRun(aged("acme-new", 1, {
+        namespace: "acme"
+      }));
+      await store.createRun(aged("beta-old", 10, {
+        namespace: "beta"
+      }));
+      await store.createRun(aged("report-old", 10, {
+        workflow: "report"
+      }));
+      await store.pruneTerminalRuns?.({
+        statuses: [
+          "completed"
+        ],
+        maxAge: "7d",
+        scope: {
+          namespace: "acme"
+        }
+      }, NOW, 100);
+      expect2(await ids()).toEqual([
+        "acme-new",
+        "beta-old",
+        "report-old"
+      ]);
+      await store.pruneTerminalRuns?.({
+        statuses: [
+          "completed"
+        ],
+        maxAge: "7d",
+        scope: {
+          workflows: [
+            "report"
+          ]
+        }
+      }, NOW, 100);
+      expect2(await ids()).toEqual([
+        "acme-new",
+        "beta-old"
+      ]);
+      await store.createRun(aged("acme-mid", 3, {
+        namespace: "acme"
+      }));
+      await store.pruneTerminalRuns?.({
+        statuses: [
+          "completed"
+        ],
+        maxCount: 1,
+        scope: {
+          namespace: "acme"
+        }
+      }, NOW, 100);
+      expect2(await ids()).toEqual([
+        "acme-new",
+        "beta-old"
+      ]);
+    });
+    t("a retention scope can select by tag and by search attribute", async () => {
+      if (!supportsTagFilter) return;
+      await store.createRun(aged("chat-old", 10, {
+        tags: [
+          "chat",
+          "tenant:t1"
+        ]
+      }));
+      await store.createRun(aged("chatty-old", 10, {
+        tags: [
+          "chatty"
+        ]
+      }));
+      await store.createRun(aged("attr-old", 10, {
+        searchAttributes: {
+          tenantId: "t2"
+        }
+      }));
+      await store.createRun(aged("attr-other", 10, {
+        searchAttributes: {
+          tenantId: "t3"
+        }
+      }));
+      await store.pruneTerminalRuns?.({
+        statuses: [
+          "completed"
+        ],
+        maxAge: "7d",
+        scope: {
+          tags: [
+            "chat"
+          ]
+        }
+      }, NOW, 100);
+      expect2(await ids()).toEqual([
+        "attr-old",
+        "attr-other",
+        "chatty-old"
+      ]);
+      await store.pruneTerminalRuns?.({
+        statuses: [
+          "completed"
+        ],
+        maxAge: "7d",
+        scope: {
+          attributes: [
+            {
+              key: "tenantId",
+              op: "eq",
+              value: "t2"
+            }
+          ]
+        }
+      }, NOW, 100);
+      expect2(await ids()).toEqual([
+        "attr-other",
+        "chatty-old"
+      ]);
+    });
+    t("engine.purgeRuns deletes a scope with its child subtrees and cancels live runs", async () => {
+      const engine = new WorkflowEngine3({
+        store
+      });
+      engine.register("p-child", "1", async (ctx) => ctx.waitForSignal("never"));
+      engine.register("p-root", "1", async (ctx) => {
+        await ctx.startChild("p-child", {}, "pc");
+        return ctx.waitForSignal("never");
+      });
+      engine.register("p-other", "1", async () => "done");
+      await engine.start("p-root", {}, "pr");
+      await engine.start("p-other", {}, "po");
+      expect2((await engine.waitForRun("pc", {
+        timeoutMs: 2e4
+      })).status).toBe("suspended");
+      expect2((await engine.waitForRun("po", {
+        timeoutMs: 2e4
+      })).status).toBe("completed");
+      await expect2(engine.purgeRuns({})).rejects.toThrow(/empty scope/);
+      expect2(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();
+    });
     t("updateRun maps every patchable field \u2014 clears error and patches tags/lockedBy/input/timers", async () => {
       await store.createRun(run({
         status: "failed",
@@ -1427,6 +1878,149 @@ function runStateStoreContract(name, makeStore) {
         "pro"
       ]);
     });
+    t("searches values server-side, BEFORE the bound", async () => {
+      if (!store.runValueFacets) return;
+      await store.createRun(run({
+        id: "a",
+        namespace: "acme-prod"
+      }));
+      await store.createRun(run({
+        id: "b",
+        namespace: "acme-staging"
+      }));
+      await store.createRun(run({
+        id: "c",
+        namespace: "globex"
+      }));
+      await store.createRun(run({
+        id: "d",
+        namespace: "globex"
+      }));
+      const matches = await store.runValueFacets({
+        field: "namespace"
+      }, {}, {
+        search: "acme"
+      });
+      expect2(matches.map((row) => row.value).sort()).toEqual([
+        "acme-prod",
+        "acme-staging"
+      ]);
+      expect2((await store.runValueFacets({
+        field: "namespace"
+      }, {}, {
+        limit: 1
+      })).map((r) => r.value)).toEqual([
+        "globex"
+      ]);
+      expect2((await store.runValueFacets({
+        field: "namespace"
+      }, {}, {
+        limit: 1,
+        search: "staging"
+      })).map((r) => r.value)).toEqual([
+        "acme-staging"
+      ]);
+    });
+    t("pages values in a stable order, so page two continues page one", async () => {
+      if (!store.runValueFacets) return;
+      await store.createRun(run({
+        id: "a",
+        namespace: "one"
+      }));
+      await store.createRun(run({
+        id: "b",
+        namespace: "one"
+      }));
+      await store.createRun(run({
+        id: "c",
+        namespace: "one"
+      }));
+      await store.createRun(run({
+        id: "d",
+        namespace: "two"
+      }));
+      await store.createRun(run({
+        id: "e",
+        namespace: "two"
+      }));
+      await store.createRun(run({
+        id: "f",
+        namespace: "three"
+      }));
+      const first = await store.runValueFacets({
+        field: "namespace"
+      }, {}, {
+        limit: 2
+      });
+      const second = await store.runValueFacets({
+        field: "namespace"
+      }, {}, {
+        limit: 2,
+        offset: 2
+      });
+      expect2(first).toEqual([
+        {
+          value: "one",
+          count: 3
+        },
+        {
+          value: "two",
+          count: 2
+        }
+      ]);
+      expect2(second).toEqual([
+        {
+          value: "three",
+          count: 1
+        }
+      ]);
+      expect2(new Set([
+        ...first,
+        ...second
+      ].map((r) => r.value)).size).toBe(3);
+    });
+    t("searches and pages the tag axis too, where the values actually pile up", async () => {
+      if (!store.runValueFacets) return;
+      if (!supportsTagFilter) return;
+      await store.createRun(run({
+        id: "a",
+        tags: [
+          "type:mvr",
+          "etl"
+        ]
+      }));
+      await store.createRun(run({
+        id: "b",
+        tags: [
+          "type:mel",
+          "etl"
+        ]
+      }));
+      await store.createRun(run({
+        id: "c",
+        tags: [
+          "etl"
+        ]
+      }));
+      expect2((await store.runValueFacets({
+        field: "tag"
+      }, {}, {
+        search: "type:"
+      })).map((r) => r.value).sort()).toEqual([
+        "type:mel",
+        "type:mvr"
+      ]);
+      expect2(await store.runValueFacets({
+        field: "tag"
+      }, {}, {
+        limit: 1
+      })).toEqual([
+        {
+          value: "etl",
+          count: 3
+        }
+      ]);
+    });
     t("bounds the values it returns, keeping the most common ones", async () => {
       if (!store.runValueFacets) return;
       await store.createRun(run({
@@ -1452,6 +2046,293 @@ function runStateStoreContract(name, makeStore) {
         }
       ]);
     });
+    t("countRuns counts the same set listRuns returns, without the paging", async () => {
+      expect2(typeof store.countRuns).toBe("function");
+      await store.createRun(run({
+        id: "n1",
+        status: "running",
+        namespace: "a",
+        tags: [
+          "q"
+        ]
+      }));
+      await store.createRun(run({
+        id: "n2",
+        status: "pending",
+        namespace: "a"
+      }));
+      await store.createRun(run({
+        id: "n3",
+        status: "completed",
+        namespace: "a",
+        tags: [
+          "q"
+        ]
+      }));
+      await store.createRun(run({
+        id: "n4",
+        status: "running",
+        namespace: "b",
+        tags: [
+          "q"
+        ]
+      }));
+      expect2(await store.countRuns?.({})).toBe(4);
+      expect2(await store.countRuns?.({
+        namespace: "a"
+      })).toBe(3);
+      expect2(await store.countRuns?.({
+        namespace: "a",
+        statuses: [
+          "pending",
+          "running"
+        ]
+      })).toBe(2);
+      expect2(await store.countRuns?.({
+        statuses: []
+      })).toBe(0);
+      if (supportsTagFilter) {
+        expect2(await store.countRuns?.({
+          tag: "q",
+          statuses: [
+            "running",
+            "pending"
+          ]
+        })).toBe(2);
+      }
+    });
+    t("engine rejects a start over its concurrency quota and frees the slot once a run settles", async () => {
+      if (!supportsTagFilter) return;
+      const engine = new WorkflowEngine3({
+        store
+      });
+      engine.register("q-wait", "1", async (ctx) => ctx.waitForSignal("never"));
+      const quota = {
+        key: "tenant:a",
+        limit: 1,
+        countStatuses: [
+          "pending",
+          "running",
+          "suspended"
+        ]
+      };
+      await engine.start("q-wait", {}, "q1", {
+        concurrency: quota
+      });
+      expect2((await engine.waitForRun("q1", {
+        timeoutMs: 2e4
+      })).status).toBe("suspended");
+      await expect2(engine.start("q-wait", {}, "q2", {
+        concurrency: quota
+      })).rejects.toThrow(/concurrency limit/);
+      expect2(await store.getRun("q2")).toBeNull();
+      await engine.start("q-wait", {}, "q3", {
+        concurrency: {
+          ...quota,
+          key: "tenant:b"
+        }
+      });
+      expect2((await engine.waitForRun("q1", {
+        timeoutMs: 2e4
+      })).status).toBe("suspended");
+      await engine.cancel("q1");
+      expect2((await store.getRun("q1"))?.status).toBe("cancelled");
+      await engine.start("q-wait", {}, "q4", {
+        concurrency: quota
+      });
+      expect2(await store.getRun("q4")).not.toBeNull();
+      for (const id of [
+        "q3",
+        "q4"
+      ]) await engine.waitForRun(id, {
+        timeoutMs: 2e4
+      });
+      await engine.drain();
+    });
+    const schedule = /* @__PURE__ */ __name((over = {}) => ({
+      id: "s1",
+      namespace: "default",
+      workflow: "digest",
+      paused: false,
+      nextFireAt: NOW + 6e4,
+      tags: [
+        "tenant:a"
+      ],
+      spec: {
+        v: 1,
+        cron: "0 9 * * *",
+        input: {
+          userId: "u1",
+          deep: [
+            1,
+            {
+              x: true
+            }
+          ]
+        }
+      },
+      state: {
+        window: NOW + 6e4
+      },
+      createdAt: at,
+      updatedAt: at,
+      ...over
+    }), "schedule");
+    t("saves, reads back, replaces and deletes a schedule", async () => {
+      expect2(typeof store.saveSchedule).toBe("function");
+      await store.saveSchedule?.(schedule());
+      const loaded = await store.getSchedule?.("s1");
+      expect2(loaded).toMatchObject({
+        id: "s1",
+        namespace: "default",
+        workflow: "digest",
+        paused: false,
+        nextFireAt: NOW + 6e4,
+        tags: [
+          "tenant:a"
+        ],
+        spec: {
+          v: 1,
+          cron: "0 9 * * *",
+          input: {
+            userId: "u1",
+            deep: [
+              1,
+              {
+                x: true
+              }
+            ]
+          }
+        },
+        state: {
+          window: NOW + 6e4
+        }
+      });
+      expect2(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();
+    });
+    t("updateSchedule patches, and compare-and-sets on nextFireAt", async () => {
+      await store.saveSchedule?.(schedule());
+      expect2(await store.updateSchedule?.("s1", {
+        paused: true
+      })).toBe(true);
+      expect2((await store.getSchedule?.("s1"))?.paused).toBe(true);
+      const next = {
+        nextFireAt: NOW + 12e4,
+        state: {
+          window: NOW + 12e4,
+          fires: 1
+        }
+      };
+      expect2(await store.updateSchedule?.("s1", next, NOW + 6e4)).toBe(true);
+      expect2(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({
+        window: NOW + 12e4,
+        fires: 1
+      });
+      await store.updateSchedule?.("s1", {
+        nextFireAt: null
+      });
+      expect2(await store.updateSchedule?.("s1", {
+        nextFireAt: NOW
+      }, NOW + 1)).toBe(false);
+      expect2(await store.updateSchedule?.("s1", {
+        nextFireAt: NOW
+      }, null)).toBe(true);
+      expect2(await store.updateSchedule?.("ghost", {
+        paused: true
+      })).toBe(false);
+    });
+    t('lists schedules by namespace/workflow/tag/paused and answers "due by"', async () => {
+      await store.saveSchedule?.(schedule({
+        id: "a",
+        nextFireAt: NOW - 10
+      }));
+      await store.saveSchedule?.(schedule({
+        id: "b",
+        nextFireAt: NOW - 20,
+        namespace: "x"
+      }));
+      await store.saveSchedule?.(schedule({
+        id: "c",
+        nextFireAt: NOW - 30,
+        paused: true
+      }));
+      await store.saveSchedule?.(schedule({
+        id: "d",
+        nextFireAt: NOW + 10,
+        workflow: "other"
+      }));
+      await store.saveSchedule?.(schedule({
+        id: "e",
+        nextFireAt: null,
+        tags: [
+          "tenant:b"
+        ]
+      }));
+      const ids2 = /* @__PURE__ */ __name(async (q) => (await store.listSchedules?.(q) ?? []).map((r) => r.id), "ids");
+      expect2(await ids2({})).toEqual([
+        "c",
+        "b",
+        "a",
+        "d",
+        "e"
+      ]);
+      expect2(await ids2({
+        dueBy: NOW
+      })).toEqual([
+        "b",
+        "a"
+      ]);
+      expect2(await ids2({
+        dueBy: NOW,
+        namespace: "default"
+      })).toEqual([
+        "a"
+      ]);
+      expect2(await ids2({
+        dueBy: NOW,
+        limit: 1
+      })).toEqual([
+        "b"
+      ]);
+      expect2(await ids2({
+        workflow: "other"
+      })).toEqual([
+        "d"
+      ]);
+      expect2(await ids2({
+        paused: true
+      })).toEqual([
+        "c"
+      ]);
+      if (supportsTagFilter) expect2(await ids2({
+        tag: "tenant:b"
+      })).toEqual([
+        "e"
+      ]);
+      expect2(await ids2({
+        limit: 2,
+        offset: 1
+      })).toEqual([
+        "b",
+        "a"
+      ]);
+    });
     t("orders listRuns newest-first and paginates with limit/offset", async () => {
       await store.createRun(run({
         id: "old",
@@ -1751,6 +2632,184 @@ function runStateStoreContract(name, makeStore) {
       expect2((await store.takeSignalWaiter("child:r.child.0"))?.parallelGroup).toBe("gather:0");
       expect2((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");
+      await store.createRun(run({
+        id: "p"
+      }));
+      const entry = /* @__PURE__ */ __name((i, status) => ({
+        waiter: {
+          token: `child:p.all.0.${i}`,
+          runId: "p",
+          seq: i,
+          parallelGroup: "all:0"
+        },
+        checkpoint: checkpoint({
+          runId: "p",
+          seq: i,
+          stepId: `p:${i}`,
+          name: `signal:child:p.all.0.${i}`,
+          kind: "signal",
+          status,
+          parallelGroup: "all:0"
+        })
+      }), "entry");
+      const entries = Array.from({
+        length: 250
+      }, (_, 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);
+      const cps = await store.listCheckpoints("p");
+      expect2(cps).toHaveLength(250);
+      expect2(cps[7]).toMatchObject({
+        name: "signal:child:p.all.0.7",
+        status: "running"
+      });
+      expect2(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();
+    });
+    t("compactCheckpoints replaces a seq range with one checkpoint, atomically", async () => {
+      expect2(store.compactCheckpoints).toBeTypeOf("function");
+      await store.createRun(run({
+        id: "r"
+      }));
+      await store.createRun(run({
+        id: "other"
+      }));
+      for (let seq = 0; seq < 10; seq += 1) {
+        await store.saveCheckpoint(checkpoint({
+          runId: "r",
+          seq,
+          stepId: `r:${seq}`
+        }));
+      }
+      await store.saveCheckpoint(checkpoint({
+        runId: "other",
+        seq: 3,
+        stepId: "other:3"
+      }));
+      const into = checkpoint({
+        runId: "r",
+        seq: 2,
+        stepId: "r:2",
+        name: "fan:r.all.2.",
+        kind: "signal",
+        output: {
+          from: 0,
+          values: [
+            {
+              n: 1
+            },
+            "two",
+            null
+          ]
+        },
+        parallelGroup: "all:2"
+      });
+      await store.compactCheckpoints?.("r", 2, 7, into);
+      const left = await store.listCheckpoints("r");
+      expect2(left.map((cp) => cp.seq)).toEqual([
+        0,
+        1,
+        2,
+        8,
+        9
+      ]);
+      expect2(left[2]).toMatchObject({
+        name: "fan:r.all.2.",
+        parallelGroup: "all:2"
+      });
+      expect2(left[2]?.output).toEqual({
+        from: 0,
+        values: [
+          {
+            n: 1
+          },
+          "two",
+          null
+        ]
+      });
+      expect2(await store.listCheckpoints("other")).toHaveLength(1);
+    });
+    t("listSignalWaitersByRun returns only the given runs' waiters", async () => {
+      expect2(store.listSignalWaitersByRun).toBeTypeOf("function");
+      await store.putSignalWaiter({
+        token: "child:a.all.0.0",
+        runId: "a",
+        seq: 0,
+        parallelGroup: "all:0"
+      });
+      await store.putSignalWaiter({
+        token: "approve-a",
+        runId: "a",
+        seq: 1
+      });
+      await store.putSignalWaiter({
+        token: "approve-b",
+        runId: "b",
+        seq: 0
+      });
+      await store.putSignalWaiter({
+        token: "approve-c",
+        runId: "c",
+        seq: 0
+      });
+      const tokens = /* @__PURE__ */ __name(async (ids2) => (await store.listSignalWaitersByRun?.(ids2) ?? []).map((w) => w.token).sort(), "tokens");
+      expect2(await tokens([
+        "a",
+        "b"
+      ])).toEqual([
+        "approve-a",
+        "approve-b",
+        "child:a.all.0.0"
+      ]);
+      expect2(await tokens([
+        "missing"
+      ])).toEqual([]);
+      expect2(await tokens([])).toEqual([]);
+      expect2((await store.listSignalWaitersByRun?.([
+        "a"
+      ]))?.find((w) => w.seq === 0)).toEqual({
+        token: "child:a.all.0.0",
+        runId: "a",
+        seq: 0,
+        parallelGroup: "all:0"
+      });
+    });
+    t("hasSignalWaiter answers by run and exact token prefix", async () => {
+      expect2(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",
+        runId: "p_1",
+        seq: 3,
+        parallelGroup: "all:3"
+      });
+      await store.putSignalWaiter({
+        token: "child:p_1.all.4.0.all.0.0",
+        runId: "p_1.all.4.0",
+        seq: 0
+      });
+      await store.putSignalWaiter({
+        token: "child:pX1.all.3.0",
+        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);
+      await store.takeSignalWaiter("child:p_1.all.3.0");
+      expect2(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({
         token: "approve-1",