@dudousxd/nestjs-durable-testing 0.13.0 → 0.15.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) {
@@ -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",
@@ -544,6 +559,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",
@@ -1080,6 +1338,808 @@ function runStateStoreContract(name, makeStore) {
         }
       ]);
     });
+    t("matches ANY of a set of statuses, workflows, tenants or origins", async () => {
+      await store.createRun(run({
+        id: "a",
+        status: "failed",
+        namespace: "acme",
+        workflow: "wa"
+      }));
+      await store.createRun(run({
+        id: "b",
+        status: "dead",
+        namespace: "globex",
+        workflow: "wb"
+      }));
+      await store.createRun(run({
+        id: "c",
+        status: "completed",
+        namespace: "initech",
+        workflow: "wc"
+      }));
+      expect2((await store.listRuns({
+        statuses: [
+          "failed",
+          "dead"
+        ]
+      })).map((r) => r.id).sort()).toEqual([
+        "a",
+        "b"
+      ]);
+      expect2((await store.listRuns({
+        namespaces: [
+          "acme",
+          "globex"
+        ]
+      })).map((r) => r.id).sort()).toEqual([
+        "a",
+        "b"
+      ]);
+      expect2((await store.listRuns({
+        workflows: [
+          "wa",
+          "wc"
+        ]
+      })).map((r) => r.id).sort()).toEqual([
+        "a",
+        "c"
+      ]);
+    });
+    t("carries the absent-origin bucket INSIDE a set of origins", async () => {
+      await store.createRun(run({
+        id: "a",
+        origin: "pkg-a"
+      }));
+      await store.createRun(run({
+        id: "b",
+        origin: "pkg-b"
+      }));
+      await store.createRun(run({
+        id: "c"
+      }));
+      expect2((await store.listRuns({
+        origins: [
+          "pkg-a",
+          null
+        ]
+      })).map((r) => r.id).sort()).toEqual([
+        "a",
+        "c"
+      ]);
+      expect2((await store.listRuns({
+        origins: [
+          "pkg-a",
+          "pkg-b"
+        ]
+      })).map((r) => r.id).sort()).toEqual([
+        "a",
+        "b"
+      ]);
+    });
+    t("ANDs a plural predicate with everything else, and matches nothing when empty", async () => {
+      await store.createRun(run({
+        id: "a",
+        status: "failed",
+        namespace: "acme"
+      }));
+      await store.createRun(run({
+        id: "b",
+        status: "dead",
+        namespace: "acme"
+      }));
+      expect2((await store.listRuns({
+        namespaces: [
+          "acme"
+        ],
+        statuses: [
+          "dead"
+        ]
+      })).map((r) => r.id)).toEqual([
+        "b"
+      ]);
+      expect2(await store.listRuns({
+        namespaces: []
+      })).toEqual([]);
+      expect2(await store.listRuns({
+        statuses: []
+      })).toEqual([]);
+      expect2(await store.listRuns({
+        origins: []
+      })).toEqual([]);
+    });
+    t("matches runs carrying ANY of a set of tags", async () => {
+      if (!supportsTagFilter) return;
+      await store.createRun(run({
+        id: "a",
+        tags: [
+          "etl"
+        ]
+      }));
+      await store.createRun(run({
+        id: "b",
+        tags: [
+          "nightly",
+          "batch"
+        ]
+      }));
+      await store.createRun(run({
+        id: "c",
+        tags: [
+          "adhoc"
+        ]
+      }));
+      expect2((await store.listRuns({
+        tags: [
+          "etl",
+          "nightly"
+        ]
+      })).map((r) => r.id).sort()).toEqual([
+        "a",
+        "b"
+      ]);
+      expect2(await store.listRuns({
+        tags: []
+      })).toEqual([]);
+    });
+    t("matches a search attribute against a SET of values (the `in` predicate)", async () => {
+      await store.createRun(run({
+        id: "a",
+        searchAttributes: {
+          tier: "pro"
+        }
+      }));
+      await store.createRun(run({
+        id: "b",
+        searchAttributes: {
+          tier: "enterprise"
+        }
+      }));
+      await store.createRun(run({
+        id: "c",
+        searchAttributes: {
+          tier: "free"
+        }
+      }));
+      await store.createRun(run({
+        id: "d",
+        searchAttributes: {
+          amount: 200
+        }
+      }));
+      const inSet = await store.listRuns({
+        attributes: [
+          {
+            key: "tier",
+            op: "in",
+            values: [
+              "pro",
+              "enterprise"
+            ]
+          }
+        ]
+      });
+      expect2(inSet.map((r) => r.id).sort()).toEqual([
+        "a",
+        "b"
+      ]);
+      const mixed = await store.listRuns({
+        attributes: [
+          {
+            key: "amount",
+            op: "in",
+            values: [
+              200,
+              "none"
+            ]
+          }
+        ]
+      });
+      expect2(mixed.map((r) => r.id)).toEqual([
+        "d"
+      ]);
+      expect2(await store.listRuns({
+        attributes: [
+          {
+            key: "tier",
+            op: "in",
+            values: []
+          }
+        ]
+      })).toEqual([]);
+      expect2((await store.listRuns({
+        attributes: [
+          {
+            key: "tier",
+            op: "in",
+            values: [
+              "pro"
+            ]
+          }
+        ]
+      })).map((r) => r.id)).toEqual([
+        "a"
+      ]);
+    });
+    t("enumerates the distinct values of a run column, counted and ordered by frequency", async () => {
+      if (!store.runValueFacets) return;
+      await store.createRun(run({
+        id: "a",
+        namespace: "acme"
+      }));
+      await store.createRun(run({
+        id: "b",
+        namespace: "acme"
+      }));
+      await store.createRun(run({
+        id: "c",
+        namespace: "globex"
+      }));
+      expect2(await store.runValueFacets({
+        field: "namespace"
+      }, {})).toEqual([
+        {
+          value: "acme",
+          count: 2
+        },
+        {
+          value: "globex",
+          count: 1
+        }
+      ]);
+    });
+    t("reports the unattributed bucket as a `null` value, not as a name", async () => {
+      if (!store.runValueFacets) return;
+      await store.createRun(run({
+        id: "a",
+        origin: "pkg-a"
+      }));
+      await store.createRun(run({
+        id: "b"
+      }));
+      const values = await store.runValueFacets({
+        field: "origin"
+      }, {});
+      expect2(values).toContainEqual({
+        value: "pkg-a",
+        count: 1
+      });
+      expect2(values).toContainEqual({
+        value: null,
+        count: 1
+      });
+    });
+    t("scopes the values to the SAME predicates the list is under", async () => {
+      if (!store.runValueFacets) return;
+      if (!supportsTagFilter) return;
+      await store.createRun(run({
+        id: "a",
+        namespace: "acme",
+        tags: [
+          "etl"
+        ]
+      }));
+      await store.createRun(run({
+        id: "b",
+        namespace: "globex",
+        tags: [
+          "nightly"
+        ]
+      }));
+      expect2(await store.runValueFacets({
+        field: "tag"
+      }, {
+        namespace: "acme"
+      })).toEqual([
+        {
+          value: "etl",
+          count: 1
+        }
+      ]);
+    });
+    t("enumerates tags, attribute keys and the values under one key", async () => {
+      if (!store.runValueFacets) return;
+      await store.createRun(run({
+        id: "a",
+        tags: [
+          "etl"
+        ],
+        searchAttributes: {
+          tier: "pro"
+        }
+      }));
+      await store.createRun(run({
+        id: "b",
+        tags: [
+          "etl",
+          "nightly"
+        ],
+        searchAttributes: {
+          tier: "free"
+        }
+      }));
+      expect2(await store.runValueFacets({
+        field: "tag"
+      }, {})).toEqual([
+        {
+          value: "etl",
+          count: 2
+        },
+        {
+          value: "nightly",
+          count: 1
+        }
+      ]);
+      expect2(await store.runValueFacets({
+        field: "attributeKey"
+      }, {})).toEqual([
+        {
+          value: "tier",
+          count: 2
+        }
+      ]);
+      expect2((await store.runValueFacets({
+        field: "attributeValue",
+        key: "tier"
+      }, {})).map((r) => r.value).sort()).toEqual([
+        "free",
+        "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({
+        id: "a",
+        namespace: "acme"
+      }));
+      await store.createRun(run({
+        id: "b",
+        namespace: "acme"
+      }));
+      await store.createRun(run({
+        id: "c",
+        namespace: "globex"
+      }));
+      expect2(await store.runValueFacets({
+        field: "namespace"
+      }, {}, {
+        limit: 1
+      })).toEqual([
+        {
+          value: "acme",
+          count: 2
+        }
+      ]);
+    });
+    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",