@ewhauser/world-celld 0.3.2 → 0.4.0

package/dist/testing.js

@@ -1744,8 +1744,11 @@ var RunCatalogDO = class extends DurableObject {
 			prefix: options.prefix ?? "",
 			...options.reverse ? {
 				reverse: true,
-				end: options.cursor
-			} : { startAfter: options.cursor },
+				end: options.cursor ?? options.end
+			} : {
+				startAfter: options.cursor,
+				end: options.end
+			},
 			limit: limit + 1
 		});
 		const page = Array.from(entries).slice(0, limit);
@@ -1759,6 +1762,15 @@ var RunCatalogDO = class extends DurableObject {
 			cursor: listComplete ? void 0 : page.at(-1)?.[0]
 		};
 	}
+	/** Compare-and-delete one rejected retention discovery candidate. */
+	async deleteStaleGlobalRun(runId, key, expectedValue) {
+		if (!key.startsWith("runall:") || !key.endsWith(`:${runId}`)) throw new Error("Stale run catalog deletion requires the exact global run key");
+		if (JSON.parse(expectedValue).runId !== runId) throw new Error("Stale run catalog deletion requires matching run metadata");
+		return await this.ctx.storage.transaction(async (txn) => {
+			if (await txn.get(key) !== expectedValue) return { deleted: false };
+			return { deleted: await txn.delete(key) };
+		});
+	}
 	async expireRun(runId, keys, expiredAt) {
 		if (keys.length !== 2) throw new Error("Run catalog expiry requires exactly two keys");
 		return await this.ctx.storage.transaction(async (txn) => {
@@ -3043,6 +3055,7 @@ function cleanupTombstone(record, now) {
 	return {
 		version: 1,
 		runId: record.runId,
+		status: record.status ?? record.terminalStatus,
 		terminalStatus: record.terminalStatus,
 		completedAt: record.completedAt,
 		expiredAt: record.dueAt,
@@ -3074,6 +3087,28 @@ const STREAM_BYTES_PER_CLEANUP_PAGE = 16777216;
 const QUEUE_REFERENCES_PER_CLEANUP_PAGE = 64;
 const CLEANUP_RETRY_MAX_MS = 36e5;
 const CLEANUP_PROGRESS_KEY = "retention:progress";
+const RUN_QUEUE_SHARDS_KEY = "retention:queue-shards";
+function cleanupRecord(run, dueAt, queueShards, reason) {
+	const terminal = isTerminalWorkflowRunStatus(run.status) ? run : void 0;
+	return {
+		version: 1,
+		runId: run.runId,
+		workflowName: run.workflowName,
+		createdAt: run.createdAt,
+		status: run.status,
+		completedAt: terminal?.completedAt,
+		terminalStatus: terminal?.status,
+		reason,
+		dueAt,
+		queueShards,
+		phase: "retained",
+		generation: 0,
+		attempts: 0,
+		deletedPayloadKeys: 0,
+		deletedStreams: 0,
+		deletedQueueMessages: 0
+	};
+}
 /**
 * Adapt DO storage (or a transaction) to the {@link EventStore} interface
 * shared with the test mocks. No casts: the methods line up structurally,
@@ -3169,6 +3204,7 @@ var WorkflowRunDO = class extends DurableObject {
 				now
 			});
 			if (!outcome.ok) return outcome;
+			if (outcome.runCreated && request.cleanup) await txn.put(RUN_QUEUE_SHARDS_KEY, request.cleanup.queueShards);
 			await txn.put("event_sequence", eventSequence);
 			await putStorageEntries(txn, (outcome.hookToIndex ? [{
 				hookId: outcome.hookToIndex.hookId,
@@ -3182,22 +3218,7 @@ var WorkflowRunDO = class extends DurableObject {
 					...terminalRun,
 					expiredAt: dueAt
 				});
-				const cleanup = {
-					version: 1,
-					runId: run.runId,
-					workflowName: run.workflowName,
-					createdAt: run.createdAt,
-					completedAt: run.completedAt,
-					terminalStatus: run.status,
-					dueAt,
-					queueShards: request.cleanup?.queueShards ?? 1,
-					phase: "retained",
-					generation: 0,
-					attempts: 0,
-					deletedPayloadKeys: 0,
-					deletedStreams: 0,
-					deletedQueueMessages: 0
-				};
+				const cleanup = cleanupRecord(run, dueAt, request.cleanup?.queueShards ?? 1, "terminal-retention");
 				await txn.put("run", run);
 				await txn.put(CLEANUP_RECORD_KEY, cleanup);
 				await txn.setAlarm(dueAt);
@@ -3307,28 +3328,95 @@ var WorkflowRunDO = class extends DurableObject {
 				...terminalRun,
 				expiredAt: dueAt
 			});
-			const cleanup = {
-				version: 1,
-				runId: run.runId,
-				workflowName: run.workflowName,
-				createdAt: run.createdAt,
-				completedAt: run.completedAt,
-				terminalStatus: run.status,
-				dueAt,
-				queueShards: request.queueShards,
-				phase: "retained",
-				generation: 0,
-				attempts: 0,
-				deletedPayloadKeys: 0,
-				deletedStreams: 0,
-				deletedQueueMessages: 0
-			};
+			const cleanup = cleanupRecord(run, dueAt, request.queueShards, "manual");
 			await txn.put("run", run);
 			await txn.put(CLEANUP_RECORD_KEY, cleanup);
 			await txn.setAlarm(values.get("terminal:cleanup") || dueAt.getTime() <= this.now() ? this.now() + 1 : dueAt);
 			return cleanup;
 		});
 	}
+	/**
+	* Apply the fleet-wide maximum-age policy to one authoritative run.
+	*
+	* The catalog is only a discovery index: eligibility is rechecked from the
+	* RunDO's own createdAt. Once eligible, the cleanup deadline immediately
+	* becomes an authoritative write/read fence, including for active runs.
+	*/
+	async enforceRetention(request) {
+		if (!Number.isSafeInteger(request.retentionMs) || request.retentionMs <= 0) throw new Error("world-celld retentionMs must be a positive safe integer");
+		if (!Number.isSafeInteger(request.queueShards) || request.queueShards <= 0) throw new Error("world-celld retention queueShards must be a positive safe integer");
+		if (!Number.isSafeInteger(request.scheduledTime) || request.scheduledTime < 0) throw new Error("world-celld retention scheduledTime must be a non-negative safe integer");
+		const result = await this.ctx.storage.transaction(async (txn) => {
+			const values = await txn.get([
+				CLEANUP_RECORD_KEY,
+				TOMBSTONE_KEY,
+				RUN_QUEUE_SHARDS_KEY,
+				"run"
+			]);
+			const tombstone = values.get(TOMBSTONE_KEY);
+			if (tombstone) return {
+				state: "expired",
+				cleanup: cleanupFromTombstone(tombstone)
+			};
+			const run = values.get("run");
+			if (!run) return {
+				state: "missing",
+				cleanup: null
+			};
+			const dueAtMs = run.createdAt.getTime() + request.retentionMs;
+			if (!Number.isSafeInteger(dueAtMs) || dueAtMs > 864e13) throw new Error(`world-celld retention deadline is out of range for ${run.runId}`);
+			if (dueAtMs > request.scheduledTime) return {
+				state: "not-due",
+				cleanup: null
+			};
+			const dueAt = new Date(dueAtMs);
+			const existing = values.get(CLEANUP_RECORD_KEY);
+			const storedQueueShards = values.get(RUN_QUEUE_SHARDS_KEY);
+			const queueShards = Number.isSafeInteger(storedQueueShards) && storedQueueShards > 0 ? storedQueueShards : request.queueShards;
+			let cleanup = existing;
+			if (!cleanup) {
+				cleanup = cleanupRecord(run, dueAt, queueShards, "maximum-age");
+				await txn.put("run", WorkflowRunSchema.parse({
+					...run,
+					expiredAt: dueAt
+				}));
+				await txn.put(CLEANUP_RECORD_KEY, cleanup);
+			} else if (cleanup.phase === "retained" && dueAtMs < cleanup.dueAt.getTime()) {
+				const terminal = isTerminalWorkflowRunStatus(run.status) ? run : void 0;
+				cleanup = {
+					...cleanup,
+					status: run.status,
+					completedAt: terminal?.completedAt,
+					terminalStatus: terminal?.status,
+					reason: "maximum-age",
+					dueAt,
+					generation: cleanup.generation + 1
+				};
+				await txn.put("run", WorkflowRunSchema.parse({
+					...run,
+					expiredAt: dueAt
+				}));
+				await txn.put(CLEANUP_RECORD_KEY, cleanup);
+			}
+			await txn.setAlarm(this.now() + 1);
+			return {
+				state: cleanup.dueAt.getTime() <= this.now() ? "expired" : "scheduled",
+				cleanup
+			};
+		});
+		if (result.state === "scheduled" || result.state === "expired") {
+			for (let page = 0; page < 2; page++) {
+				const cleanup = await this.ctx.storage.get(CLEANUP_RECORD_KEY);
+				if (cleanup?.phase !== "retained" && cleanup?.phase !== "index") break;
+				await this.executeScheduledCleanupPage();
+			}
+			return {
+				...result,
+				cleanup: await this.getCleanupStatus() ?? result.cleanup
+			};
+		}
+		return result;
+	}
 	async cleanupNow(request) {
 		if (!await this.ctx.storage.get("retention:cleanup")) await this.scheduleCleanup({
 			...request,
@@ -3392,7 +3480,17 @@ var WorkflowRunDO = class extends DurableObject {
 		});
 	}
 	async executeScheduledCleanupPage() {
-		const terminalCleanup = await this.ctx.storage.get(TERMINAL_CLEANUP_KEY);
+		const values = await this.ctx.storage.get([CLEANUP_RECORD_KEY, TERMINAL_CLEANUP_KEY]);
+		const cleanup = values.get(CLEANUP_RECORD_KEY);
+		const terminalCleanup = values.get(TERMINAL_CLEANUP_KEY);
+		if (cleanup && cleanup.phase !== "tombstoned" && cleanup.dueAt.getTime() <= this.now()) {
+			try {
+				await this.executeCleanup(cleanup);
+			} catch (error) {
+				await this.recordCleanupFailure(error, cleanup);
+			}
+			return;
+		}
 		if (terminalCleanup) {
 			try {
 				await this.executeTerminalCleanup(terminalCleanup);
@@ -3401,7 +3499,6 @@ var WorkflowRunDO = class extends DurableObject {
 			}
 			return;
 		}
-		const cleanup = await this.ctx.storage.get(CLEANUP_RECORD_KEY);
 		if (!cleanup || cleanup.phase === "tombstoned") {
 			await this.ctx.storage.deleteAlarm();
 			return;