@iterativeflow/conformance 2.1.1 → 2.3.0

package/dist/index.d.mts

@@ -103,6 +103,10 @@ declare const shardedClaimConformance: (label: string, makeBackend: () => Backen
  * `Store.dueCronCount(now, names)` — that `engine.pendingWork` composes. Every backend must count the
  * same due work (claimable jobs, due timers, due crons), exclude leased/future work, and filter by
  * flow name identically.
+ *
+ * A row whose run is gone counts under EVERY name filter, matching `Queue.claim` — a sharded fleet
+ * has to see the backlog it can actually lease, or it stays scaled to zero and the row never drains.
+ * An empty `names` is the exception: it means "this worker handles nothing", so it counts nothing.
  */
 declare const pendingWorkConformance: (label: string, makeBackend: () => Backend$1 | Promise<Backend$1>) => void;
 //#endregion

package/dist/index.mjs

@@ -392,6 +392,46 @@ const storeConformance = (label, makeStore) => {
 			expect(await s.deleteRunsOlderThan(after, 1)).toBe(1);
 			expect(await s.deleteRunsOlderThan(after, 1)).toBe(0);
 		});
+		it("deleteRuns narrows by name/version/status, refuses live runs and an empty filter", async () => {
+			const s = await makeStore();
+			const old = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
+			const mk = async (name, version) => (await s.startRun({
+				name,
+				version,
+				input: {},
+				createdAt: old
+			})).runId;
+			const doomed = await mk("f", 1);
+			const otherVersion = await mk("f", 2);
+			const otherStatus = await mk("f", 1);
+			const otherName = await mk("g", 1);
+			const live = await mk("f", 1);
+			await s.markTerminal(doomed, { status: "canceled" });
+			await s.markTerminal(otherVersion, { status: "canceled" });
+			await s.markTerminal(otherStatus, {
+				status: "done",
+				output: 1
+			});
+			await s.markTerminal(otherName, { status: "canceled" });
+			expect(await s.deleteRuns({
+				name: "f",
+				version: 1,
+				status: "canceled"
+			}, 100)).toBe(1);
+			expect(await s.loadRunRow(doomed)).toBeUndefined();
+			for (const spared of [
+				otherVersion,
+				otherStatus,
+				otherName,
+				live
+			]) expect(await s.loadRunRow(spared)).toBeDefined();
+			expect(await s.deleteRuns({
+				status: "pending",
+				before: /* @__PURE__ */ new Date()
+			}, 100)).toBe(0);
+			expect((await s.loadRunRow(live))?.status).toBe("pending");
+			await expect(s.deleteRuns({}, 100)).rejects.toThrow();
+		});
 		it("checkpointStep on an unknown run is rejected (no orphan step)", async () => {
 			const s = await makeStore();
 			await expect(s.checkpointStep({
@@ -575,6 +615,27 @@ const storeConformance = (label, makeStore) => {
 			const again = await s.retryRun(runId);
 			expect(again.retried).toBe(false);
 		});
+		it("retryRun clears the spent attempt budget, so a dead-lettered run gets dispatched again", async () => {
+			const s = await makeStore();
+			const { runId } = await s.startRun({
+				name: "f",
+				version: 1,
+				input: {}
+			});
+			await s.markRunning(runId);
+			await s.markRunning(runId);
+			expect(await s.markRunning(runId)).toBe(3);
+			await s.markTerminal(runId, {
+				status: "failed",
+				error: {
+					code: "X",
+					message: "boom"
+				}
+			});
+			await s.retryRun(runId);
+			expect((await s.loadRunRow(runId))?.attempts).toBe(0);
+			expect(await s.markRunning(runId)).toBe(1);
+		});
 		it("runStats counts runs per status", async () => {
 			const s = await makeStore();
 			const a = await s.startRun({
@@ -2306,7 +2367,7 @@ const claimFilterConformance = (label, makeBackend) => {
 			});
 			expect(onlyB.map((l) => l.runId)).toEqual([b.runId]);
 		});
-		it("an empty set leases nothing; an omitted set leases everything", async () => {
+		it("an empty set leases nothing — not even a run-less job; an omitted set leases everything", async () => {
 			const { store, queue } = await makeBackend();
 			const a = await store.startRun({
 				name: "flow-a",
@@ -2314,6 +2375,7 @@ const claimFilterConformance = (label, makeBackend) => {
 				input: {}
 			});
 			await queue.enqueue(a.runId);
+			await queue.enqueue("orphan-run");
 			expect(await queue.claim({
 				limit: 10,
 				leaseMs: 1e3,
@@ -2325,7 +2387,7 @@ const claimFilterConformance = (label, makeBackend) => {
 				leaseMs: 1e3,
 				now: at(0)
 			});
-			expect(all.map((l) => l.runId)).toEqual([a.runId]);
+			expect(all.map((l) => l.runId).sort()).toEqual([a.runId, "orphan-run"].sort());
 		});
 		it("leases a run-less job under a name filter so it can be acked, not skipped forever", async () => {
 			const { store, queue } = await makeBackend();
@@ -2412,6 +2474,10 @@ const shardedClaimConformance = (label, makeBackend) => {
 * `Store.dueCronCount(now, names)` — that `engine.pendingWork` composes. Every backend must count the
 * same due work (claimable jobs, due timers, due crons), exclude leased/future work, and filter by
 * flow name identically.
+*
+* A row whose run is gone counts under EVERY name filter, matching `Queue.claim` — a sharded fleet
+* has to see the backlog it can actually lease, or it stays scaled to zero and the row never drains.
+* An empty `names` is the exception: it means "this worker handles nothing", so it counts nothing.
 */
 const pendingWorkConformance = (label, makeBackend) => {
 	describe(`pending-work conformance (${label})`, () => {
@@ -2441,6 +2507,7 @@ const pendingWorkConformance = (label, makeBackend) => {
 			const napping = await start("a");
 			await be.timer.schedule(napping, future);
 			await be.timer.schedule("orphan-run", past);
+			await be.queue.enqueue("orphan-job");
 			const futureJob = await start("a");
 			await be.queue.enqueue(futureJob, { runAt: future });
 			await be.store.upsertCron({
@@ -2455,16 +2522,17 @@ const pendingWorkConformance = (label, makeBackend) => {
 		};
 		it("depth counts claimable jobs (not leased/future), filtered by flow name", async () => {
 			const be = await seed();
-			expect((await be.queue.depth(now)).claimable).toBe(2);
-			expect((await be.queue.depth(now, ["a"])).claimable).toBe(1);
-			expect((await be.queue.depth(now, ["b"])).claimable).toBe(1);
+			expect((await be.queue.depth(now)).claimable).toBe(3);
+			expect((await be.queue.depth(now, ["a"])).claimable).toBe(2);
+			expect((await be.queue.depth(now, ["b"])).claimable).toBe(2);
 			expect((await be.queue.depth(now, [])).claimable).toBe(0);
 		});
 		it("dueCount counts due timers incl. run-less (not future), filtered by flow name", async () => {
 			const be = await seed();
 			expect(await be.timer.dueCount(now)).toBe(2);
-			expect(await be.timer.dueCount(now, ["a"])).toBe(1);
-			expect(await be.timer.dueCount(now, ["b"])).toBe(0);
+			expect(await be.timer.dueCount(now, ["a"])).toBe(2);
+			expect(await be.timer.dueCount(now, ["b"])).toBe(1);
+			expect(await be.timer.dueCount(now, [])).toBe(0);
 		});
 		it("dueCronCount counts due crons, filtered by flow name", async () => {
 			const be = await seed();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iterativeflow/conformance",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@iterativeflow/core": "2.1.1"
+    "@iterativeflow/core": "2.3.0"
   },
   "peerDependencies": {
     "vitest": ">=3"