@ewhauser/world-celld 0.5.0 → 0.7.0

package/dist/testing.js

@@ -1,4 +1,4 @@
-import { A as MAX_STREAM_BATCH_BYTES, D as isRecord$1, E as isPositiveSafeInteger, G as validateStreamReadRequest, K as validateStreamWriteChunks, L as STREAM_BATCH_CONTENT_TYPE, N as MAX_STREAM_LONG_POLL_MS, P as MAX_STREAM_READ_BYTES, S as MAX_RUN_INDEX_PUBLICATION_LIFETIME_MS, T as isNonNegativeSafeInteger, U as encodeStreamWriteResult, V as encodeStreamReadResult, W as normalizeStreamError, _ as HOOK_CLAIM_LEASE_MS, a as queueOrphanName, c as validateNativeQueueEnvelope, d as rpcParse, f as rpcStringify, h as createWorkflowIndex, i as queueClaimName, j as MAX_STREAM_CHUNK_BYTES, l as validateNativeQueueSendOptions, n as QUEUE_PAYLOAD_REGISTRY_PREFIX, o as queuePayloadObjectKey, p as parse, s as queuePayloadRegistryKey, t as NATIVE_QUEUE_MAX_MESSAGE_BYTES, u as compact, v as LIFECYCLE_COMPACTION_RETRY_MS, z as decodeStreamWriteBatch } from "./queue-protocol-CmJNMH_5.js";
+import { A as isRecord$1, B as STREAM_BATCH_CONTENT_TYPE, G as encodeStreamReadResult, I as MAX_STREAM_LONG_POLL_MS, L as MAX_STREAM_READ_BYTES, N as MAX_STREAM_BATCH_BYTES, O as isNonNegativeSafeInteger, P as MAX_STREAM_CHUNK_BYTES, T as MAX_RUN_INDEX_PUBLICATION_LIFETIME_MS, U as decodeStreamWriteBatch, V as STREAM_CHUNK_LIMIT_HEADER, X as validateStreamReadRequest, Y as normalizeStreamError, Z as validateStreamWriteChunks, _ as createWorkflowIndex, b as HOOK_CLAIM_LEASE_MS, c as queuePayloadObjectKey, d as validateNativeQueueSendOptions, f as compact, h as parse, i as QUEUE_PAYLOAD_REGISTRY_PREFIX, k as isPositiveSafeInteger, l as queuePayloadRegistryKey, m as rpcStringify, n as listRunsPage, o as queueClaimName, p as rpcParse, q as encodeStreamWriteResult, r as NATIVE_QUEUE_MAX_MESSAGE_BYTES, s as queueOrphanName, t as MAX_RUN_LIST_LIMIT, u as validateNativeQueueEnvelope, v as runIndexMetadata, x as LIFECYCLE_COMPACTION_RETRY_MS } from "./run-list-B__jKuE7.js";
 import { CreateEventSchema, EventSchema, HookSchema, SPEC_VERSION_CURRENT, StepSchema, WaitSchema, WorkflowRunSchema, applyAttributeChanges, eventIdToSlot, getMaxEventsPerRun, isChildEntityCreationEvent, isTerminalStepStatus, isTerminalWorkflowRunStatus, slotToEventId, validateAttributeChanges } from "@workflow/world";
 import http from "node:http";
 //#region src/testing/fake-cell.ts
@@ -180,11 +180,12 @@ var FakeStorage = class {
 			synchronous: false
 		});
 	}
-	/** Inject one matching write failure, including writes inside transactions. */
-	failNextMutation(predicate, error = /* @__PURE__ */ new Error("injected fake storage mutation failure")) {
+	/** Inject matching write failures (one by default), including writes inside transactions. */
+	failNextMutation(predicate, error = /* @__PURE__ */ new Error("injected fake storage mutation failure"), times = 1) {
 		this.mutationFailure = {
 			predicate,
-			error
+			error,
+			remaining: times
 		};
 	}
 	/** Inject one matching storage read failure, including reads inside transactions. */
@@ -198,7 +199,8 @@ var FakeStorage = class {
 	maybeFailMutation(mutation) {
 		if (!this.mutationFailure?.predicate(mutation)) return;
 		const { error } = this.mutationFailure;
-		this.mutationFailure = void 0;
+		this.mutationFailure.remaining -= 1;
+		if (this.mutationFailure.remaining <= 0) this.mutationFailure = void 0;
 		throw error;
 	}
 	/** @internal Shared with FakeTransaction so read failures model transactional reads too. */
@@ -1250,6 +1252,7 @@ async function finalizeEventPage(store, outcome, params) {
 		maxEvents: getMaxEventsPerRun()
 	} : outcome;
 	if (!result.event) return result;
+	if (params?.preloadEvents && result.event.eventType === "hook_received") return await attachHookReplayPreload(store, result);
 	if (typeof params?.sinceCursor === "string") {
 		const page = await listByPrefix(store, EVENT_KEY_PREFIX, {
 			limit: 100,
@@ -1279,6 +1282,32 @@ async function finalizeEventPage(store, outcome, params) {
 		hasMore: events.length < skippedCount
 	};
 }
+/**
+* Lazy hook resume preload: return the run and its complete replay log with
+* the hook_received write, read in the same transaction, so the runtime can
+* skip its run_started write and the index publication that follows it. The
+* runtime trusts only a complete log with a non-null cursor, so a run that is
+* not started, not running, or over the event ceiling gets the plain result.
+*/
+async function attachHookReplayPreload(store, result) {
+	const run = await store.get(RUN_KEY);
+	if (!run?.startedAt || run.status !== "running") return result;
+	const maxEvents = getMaxEventsPerRun();
+	const log = await listByPrefix(store, EVENT_KEY_PREFIX, {
+		limit: maxEvents,
+		sortOrder: "asc"
+	}, (event) => event.eventId);
+	const last = log.data.at(-1);
+	if (log.hasMore || last === void 0) return result;
+	return {
+		...result,
+		replayRun: run,
+		maxEvents,
+		events: log.data,
+		cursor: last.eventId,
+		hasMore: false
+	};
+}
 //#endregion
 //#region src/worker/auth.ts
 /**
@@ -1415,6 +1444,34 @@ function listOptions(value) {
 	}
 	return parsed;
 }
+const RUN_STATUSES = /* @__PURE__ */ new Set([
+	"pending",
+	"running",
+	"completed",
+	"failed",
+	"cancelled"
+]);
+function runListRequest(value) {
+	if (!isRecord$1(value)) invalid("run list request must be an object");
+	const limit = value.limit;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) invalid(`request.limit must be an integer between 1 and ${MAX_RUN_LIST_LIMIT}`);
+	const parsed = { limit };
+	if (value.workflowName !== void 0) parsed.workflowName = nonEmptyString(value.workflowName, "request.workflowName");
+	if (value.cursor !== void 0) parsed.cursor = stringValue(value.cursor, "request.cursor");
+	if (value.statuses !== void 0) {
+		if (!Array.isArray(value.statuses) || value.statuses.length === 0 || !value.statuses.every((status) => RUN_STATUSES.has(status))) invalid("request.statuses must be a non-empty array of run statuses");
+		parsed.statuses = value.statuses;
+	}
+	if (value.sortOrder !== void 0) {
+		if (value.sortOrder !== "asc" && value.sortOrder !== "desc") invalid("request.sortOrder must be 'asc' or 'desc'");
+		parsed.sortOrder = value.sortOrder;
+	}
+	if (value.resolveData !== void 0) {
+		if (value.resolveData !== "none" && value.resolveData !== "all") invalid("request.resolveData must be 'none' or 'all'");
+		parsed.resolveData = value.resolveData;
+	}
+	return parsed;
+}
 function runCommit(args) {
 	exactArgs(args, 3);
 	const parsedRun = WorkflowRunSchema.safeParse(args[0]);
@@ -1475,6 +1532,12 @@ function validateIndexRequest(operation, args) {
 				operation,
 				args: [listOptions(args[0])]
 			};
+		case "runs.list-resolved":
+			exactArgs(args, 1);
+			return {
+				operation,
+				args: [runListRequest(args[0])]
+			};
 		case "runs.commit": return runCommit(args);
 		case "runs.expire":
 			exactArgs(args, 1);
@@ -1510,6 +1573,7 @@ function validateIndexRequest(operation, args) {
 }
 const INDEX_OPERATIONS = /* @__PURE__ */ new Set([
 	"runs.list",
+	"runs.list-resolved",
 	"runs.commit",
 	"runs.expire",
 	"hooks.reserve",
@@ -1541,6 +1605,37 @@ function workflowIndex(env) {
 		hookIds: env.WORKFLOW_HOOK_IDS
 	});
 }
+/**
+* Publish a committed applyEvent outcome to the derivative indexes inside the
+* fleet, sparing the client a round trip per run mutation. Each index write is
+* idempotent under the outcome's publication lease. A failed write leaves its
+* flag unset, so the client publishes it itself exactly as it would without
+* this step; older clients ignore the flags and publish again.
+*/
+async function publishApplyEventIndexes(env, runId, outcome) {
+	if (typeof outcome !== "object" || outcome === null) return;
+	const success = outcome;
+	if (success.ok !== true) return;
+	const index = workflowIndex(env);
+	const publications = [];
+	if (success.run && typeof success.indexPublicationExpiresAt === "number") {
+		const run = success.run;
+		const lease = success.indexPublicationExpiresAt;
+		publications.push((async () => {
+			await index.commitRun(run, runIndexMetadata(run), lease);
+			success.runIndexPublished = true;
+		})());
+	}
+	const releasedHooks = success.releasedHooks;
+	if (Array.isArray(releasedHooks) && releasedHooks.length > 0) publications.push((async () => {
+		await index.releaseHookIndexes({
+			runId,
+			hooks: releasedHooks
+		});
+		success.hookIndexesReleased = true;
+	})());
+	await Promise.allSettled(publications);
+}
 const BINDINGS = {
 	runs: {
 		env: "WORKFLOW_DB",
@@ -1583,7 +1678,7 @@ const BINDINGS = {
 };
 /** Request body cap: oversize payloads get a clear 413 instead of an OOM. */
 const MAX_BODY_BYTES = 33554432;
-const MAX_STREAM_WRITE_BODY_BYTES = MAX_STREAM_BATCH_BYTES + 1024;
+const MAX_STREAM_WRITE_BODY_BYTES = MAX_STREAM_BATCH_BYTES + 2048 + 1024;
 const QUEUE_ORPHAN_GRACE_MS = 432e6;
 function errorResponse(status, name, message) {
 	return Response.json({ error: {
@@ -1700,7 +1795,10 @@ function parseBoundedInteger(url, name, minimum, maximum) {
 function streamResponse(body) {
 	return new Response(body, {
 		status: 200,
-		headers: { "content-type": STREAM_BATCH_CONTENT_TYPE }
+		headers: {
+			"content-type": STREAM_BATCH_CONTENT_TYPE,
+			[STREAM_CHUNK_LIMIT_HEADER]: String(512)
+		}
 	});
 }
 function createRouter(env) {
@@ -1864,6 +1962,18 @@ function createRouter(env) {
 					case "runs.list":
 						result = await index.listRuns(...validated.args);
 						break;
+					case "runs.list-resolved": {
+						const runs = env.WORKFLOW_DB;
+						if (!runs) return errorResponse(500, "WorldMisconfigured", "missing binding: WORKFLOW_DB");
+						result = await listRunsPage({
+							listRuns: (options) => index.listRuns(options),
+							readRun: async (runId) => {
+								const outcome = await runs.get(runs.idFromName(runId)).getRun();
+								return outcome.ok ? outcome.value : null;
+							}
+						}, ...validated.args);
+						break;
+					}
 					case "runs.commit":
 						result = await index.commitRun(...validated.args);
 						break;
@@ -1920,7 +2030,7 @@ function createRouter(env) {
 					const readRequest = {
 						runId,
 						startIndex: parseBoundedInteger(url, "startIndex", 0, 2147483647),
-						maxChunks: parseBoundedInteger(url, "maxChunks", 0, 32),
+						maxChunks: parseBoundedInteger(url, "maxChunks", 0, 512),
 						maxBytes: parseBoundedInteger(url, "maxBytes", MAX_STREAM_CHUNK_BYTES, MAX_STREAM_READ_BYTES),
 						waitMs: parseBoundedInteger(url, "waitMs", 0, MAX_STREAM_LONG_POLL_MS)
 					};
@@ -1984,6 +2094,7 @@ function createRouter(env) {
 		}
 		try {
 			const result = await namespace.get(namespace.idFromName(name))[method](...args);
+			if (bindingKey === "runs" && method === "applyEvent") await publishApplyEventIndexes(env, name, result);
 			return new Response(rpcStringify(result ?? null), {
 				status: 200,
 				headers: { "content-type": "application/json" }
@@ -2413,9 +2524,18 @@ var RunCatalogDO = class extends DurableObject {
 	async upsertRun(runId, keys, serializedMetadata, publicationExpiresAt) {
 		const canonicalKeys = canonicalCatalogKeys(runId, keys);
 		return await this.ctx.storage.transaction(async (txn) => {
-			if (await txn.get(expiredKey(runId)) !== void 0) return { stored: false };
+			const recordKey = catalogKeysKey(runId);
+			const existing = await txn.get([
+				expiredKey(runId),
+				canonicalKeys[0],
+				canonicalKeys[1],
+				recordKey
+			]);
+			if (existing.get(expiredKey(runId)) !== void 0) return { stored: false };
 			const now = this.now();
 			if (!Number.isSafeInteger(publicationExpiresAt) || publicationExpiresAt <= now || publicationExpiresAt > now + 1200900) return { stored: false };
+			const record = existing.get(recordKey);
+			if (existing.get(canonicalKeys[0]) === serializedMetadata && existing.get(canonicalKeys[1]) === serializedMetadata && record?.keys.length === canonicalKeys.length && record.keys.every((key, index) => key === canonicalKeys[index])) return { stored: true };
 			await txn.put({
 				[canonicalKeys[0]]: serializedMetadata,
 				[canonicalKeys[1]]: serializedMetadata,
@@ -2527,13 +2647,16 @@ const CHUNK_SIZE_KEY_PREFIX = "chunk-size:";
 const STREAM_REGISTRY_PREFIX = "stream:";
 const REGISTRY_OWNER_KEY = "registry:owner";
 const REGISTRY_EXPIRED_KEY = "registry:expired";
-/** Each chunk occupies a payload key and a size key; one delete accepts at most 128 keys. */
+/** Each chunk occupies a payload key and a size key, deleted in calls of at most 128 keys. */
 const DEFAULT_EXPIRE_CHUNK_LIMIT = 64;
-const MAX_EXPIRE_CHUNK_LIMIT = 64;
+const MAX_EXPIRE_CHUNK_LIMIT = 256;
+const DELETE_BATCH_KEYS = 128;
 /** Bound storage deletion work as well as item count; one oversized chunk still makes progress. */
 const DEFAULT_EXPIRE_BYTE_LIMIT = 16777216;
 const MAX_EXPIRE_BYTE_LIMIT = DEFAULT_EXPIRE_BYTE_LIMIT;
 const MAX_STREAM_INDEX = 2147483647;
+/** One storage get or put call accepts at most 128 keys. */
+const STORAGE_BATCH_KEYS = 128;
 function boundedLimit(value, fallback, maximum) {
 	if (value === void 0 || !Number.isFinite(value)) return fallback;
 	return Math.max(1, Math.min(maximum, Math.floor(value)));
@@ -2599,6 +2722,15 @@ var StreamDO = class extends DurableObject {
 	mutationTail = Promise.resolve();
 	changeVersion = 0;
 	waiters = /* @__PURE__ */ new Set();
+	/** Multi-key read split into calls within the per-call key limit. */
+	async getMany(keys) {
+		if (keys.length <= STORAGE_BATCH_KEYS) return await this.ctx.storage.get(keys);
+		const groups = [];
+		for (let offset = 0; offset < keys.length; offset += STORAGE_BATCH_KEYS) groups.push(keys.slice(offset, offset + STORAGE_BATCH_KEYS));
+		const merged = /* @__PURE__ */ new Map();
+		for (const result of await Promise.all(groups.map((group) => this.ctx.storage.get(group)))) for (const [key, value] of result) merged.set(key, value);
+		return merged;
+	}
 	async getMeta() {
 		if (this.meta) return this.meta;
 		this.metaLoad ??= this.ctx.storage.get(META_KEY).then((meta) => {
@@ -2671,7 +2803,7 @@ var StreamDO = class extends DurableObject {
 		if (available > 0) {
 			const indexes = Array.from({ length: available }, (_, offset) => request.startIndex + offset);
 			const sizeKeys = indexes.map(chunkSizeKey);
-			const storedSizes = await this.ctx.storage.get(sizeKeys);
+			const storedSizes = await this.getMany(sizeKeys);
 			const selectedIndexes = [];
 			const selectedSizes = [];
 			let bytes = 0;
@@ -2683,7 +2815,7 @@ var StreamDO = class extends DurableObject {
 				bytes += size;
 			}
 			const payloadKeys = selectedIndexes.map(chunkKey);
-			const storedChunks = await this.ctx.storage.get(payloadKeys);
+			const storedChunks = await this.getMany(payloadKeys);
 			for (let offset = 0; offset < payloadKeys.length; offset++) {
 				const chunk = storedChunks.get(payloadKeys[offset]);
 				if (!(chunk instanceof Uint8Array) || chunk.byteLength !== selectedSizes[offset]) throw new Error(`Invalid persisted stream chunk at index ${selectedIndexes[offset]}`);
@@ -2715,13 +2847,13 @@ var StreamDO = class extends DurableObject {
 					state: "open",
 					ownerRunId: runId
 				};
-				const entries = { [META_KEY]: nextMeta };
+				const entries = [[META_KEY, nextMeta]];
 				for (let offset = 0; offset < storedChunks.length; offset++) {
 					const index = startIndex + offset;
-					entries[chunkKey(index)] = storedChunks[offset];
-					entries[chunkSizeKey(index)] = storedChunks[offset].byteLength;
+					entries.push([chunkKey(index), storedChunks[offset]]);
+					entries.push([chunkSizeKey(index), storedChunks[offset].byteLength]);
 				}
-				await txn.put(entries);
+				for (let offset = 0; offset < entries.length; offset += STORAGE_BATCH_KEYS) await txn.put(Object.fromEntries(entries.slice(offset, offset + STORAGE_BATCH_KEYS)));
 				return {
 					meta: nextMeta,
 					result: {
@@ -2901,7 +3033,7 @@ var StreamDO = class extends DurableObject {
 					}
 				}
 				const keys = page.flatMap(({ index }) => [chunkKey(index), chunkSizeKey(index)]);
-				if (keys.length > 0) await txn.delete(keys);
+				for (let offset = 0; offset < keys.length; offset += DELETE_BATCH_KEYS) await txn.delete(keys.slice(offset, offset + DELETE_BATCH_KEYS));
 				let done = candidates.size === page.length;
 				if (payloadFallback) done = (await txn.list({
 					prefix: CHUNK_KEY_PREFIX,
@@ -3005,13 +3137,15 @@ async function deleteQueuePayloadObjects(binding, keys) {
 }
 //#endregion
 //#region src/worker/durable-objects/WorkflowRunDO.ts
+const EVENT_SEQUENCE_KEY = "event_sequence";
 const STORAGE_BATCH_SIZE = 128;
 const PAYLOAD_DELETE_BATCH = STORAGE_BATCH_SIZE;
 const HOOK_MARKER_PAGE_SIZE = 64;
 const TERMINAL_HOOK_PAGE_SIZE = 64;
 const TERMINAL_WAIT_PAGE_SIZE = STORAGE_BATCH_SIZE;
 const STREAMS_PER_CLEANUP_PAGE = 16;
-const STREAM_CHUNKS_PER_CLEANUP_PAGE = STORAGE_BATCH_SIZE;
+/** StreamDO deletes a page in 128-key calls within one transaction. */
+const STREAM_CHUNKS_PER_CLEANUP_PAGE = 256;
 const STREAM_BYTES_PER_CLEANUP_PAGE = 16777216;
 const QUEUE_PAYLOADS_PER_CLEANUP_PAGE = STORAGE_BATCH_SIZE;
 const CLEANUP_RETRY_MAX_MS = 36e5;
@@ -3093,11 +3227,14 @@ var WorkflowRunDO = class extends DurableObject {
 		if (!cleanup || cleanup.phase === "retained" && cleanup.dueAt.getTime() > now) return null;
 		return cleanupTombstone(cleanup, cleanup.tombstonedAt ?? cleanup.dueAt);
 	}
-	async retentionState(storage, now = this.now()) {
-		const values = await storage.get([TOMBSTONE_KEY, CLEANUP_RECORD_KEY]);
+	async retentionState(storage, now = this.now(), options) {
+		const keys = [TOMBSTONE_KEY, CLEANUP_RECORD_KEY];
+		if (options?.withEventSequence) keys.push(EVENT_SEQUENCE_KEY);
+		const values = await storage.get(keys);
 		return {
 			cleanup: values.get(CLEANUP_RECORD_KEY),
-			tombstone: this.tombstoneFrom(values, now)
+			tombstone: this.tombstoneFrom(values, now),
+			eventSequence: values.get(EVENT_SEQUENCE_KEY) ?? 0
 		};
 	}
 	async read(reader) {
@@ -3132,21 +3269,22 @@ var WorkflowRunDO = class extends DurableObject {
 		if (request.cleanup !== void 0) validateCleanupRequest(request.cleanup, true);
 		return await this.ctx.storage.transaction(async (txn) => {
 			const now = new Date(this.now());
-			const retention = await this.retentionState(txn, now.getTime());
+			const retention = await this.retentionState(txn, now.getTime(), { withEventSequence: true });
 			const { tombstone } = retention;
 			if (tombstone) return {
 				ok: false,
 				code: "RUN_EXPIRED",
 				message: `Workflow run "${request.runId}" expired at ${tombstone.expiredAt.toISOString()}`
 			};
-			let eventSequence = await txn.get("event_sequence") ?? 0;
+			const storedSequence = retention.eventSequence;
+			let eventSequence = storedSequence;
 			const outcome = await applyEvent(storeFrom(txn), {
 				...request,
 				nextEventId: () => slotToEventId(++eventSequence),
 				now
 			});
 			if (!outcome.ok) return outcome;
-			await txn.put("event_sequence", eventSequence);
+			if (eventSequence !== storedSequence) await txn.put(EVENT_SEQUENCE_KEY, eventSequence);
 			await putStorageEntries(txn, (outcome.hookToIndex ? [{
 				hookId: outcome.hookToIndex.hookId,
 				token: outcome.hookToIndex.token
@@ -3526,10 +3664,58 @@ var WorkflowRunDO = class extends DurableObject {
 		if (cleanup.phase === "payload") await this.deletePayloadBatch();
 	}
 	async executeTerminalCleanup(cleanup) {
+		if (cleanup.phase === "hooks" && await this.completeSmallTerminalCleanup(cleanup)) return;
 		if (cleanup.phase === "hooks") await this.deleteTerminalHookPage(cleanup);
 		else if (cleanup.phase === "markers") await this.deleteTerminalHookMarkerPage(cleanup);
 		else await this.deleteTerminalWaitPage(cleanup);
 	}
+	/**
+	* Most runs end with a handful of hooks and waits. When every terminal
+	* phase fits in one page, release the hook indexes once and delete hooks,
+	* markers, and waits in a single transaction instead of one alarm and one
+	* transaction per phase. Returns false, having changed nothing locally, when
+	* any phase needs paging; the paged phases then run as before.
+	*/
+	async completeSmallTerminalCleanup(cleanup) {
+		const [hookEntries, markerEntries] = await Promise.all([this.ctx.storage.list({
+			prefix: HOOK_KEY_PREFIX,
+			limit: 65
+		}), this.ctx.storage.list({
+			prefix: HOOK_MARKER_PREFIX,
+			limit: 65
+		})]);
+		if (hookEntries.size > TERMINAL_HOOK_PAGE_SIZE || markerEntries.size > HOOK_MARKER_PAGE_SIZE) return false;
+		const hooks = Array.from(hookEntries.values());
+		const references = /* @__PURE__ */ new Map();
+		for (const reference of [...hooks.map((hook) => ({
+			hookId: hook.hookId,
+			token: hook.token
+		})), ...markerEntries.values()]) references.set(`${reference.hookId}\u0000${reference.token}`, reference);
+		if (references.size > 0) await this.workflowIndex().releaseHookIndexes({
+			runId: cleanup.runId,
+			hooks: Array.from(references.values())
+		});
+		return await this.ctx.storage.transaction(async (txn) => {
+			const current = await txn.get(TERMINAL_CLEANUP_KEY);
+			if (!current || current.phase !== cleanup.phase || current.generation !== cleanup.generation) return true;
+			const waits = await txn.list({
+				prefix: WAIT_KEY_PREFIX,
+				limit: 129
+			});
+			if (waits.size > TERMINAL_WAIT_PAGE_SIZE) return false;
+			const keys = [
+				...hooks.flatMap((hook) => [`${HOOK_KEY_PREFIX}${hook.hookId}`, hookCreationIndexKey(hook)]),
+				...markerEntries.keys(),
+				...waits.keys()
+			];
+			for (let offset = 0; offset < keys.length; offset += STORAGE_BATCH_SIZE) await txn.delete(keys.slice(offset, offset + STORAGE_BATCH_SIZE));
+			await txn.delete(TERMINAL_CLEANUP_KEY);
+			const retention = await txn.get(CLEANUP_RECORD_KEY);
+			if (retention && retention.phase !== "tombstoned") await txn.setAlarm(Math.max(this.now() + 1, retention.dueAt.getTime()));
+			else await txn.deleteAlarm();
+			return true;
+		});
+	}
 	async deleteTerminalHookPage(cleanup) {
 		const entries = await this.ctx.storage.list({
 			prefix: HOOK_KEY_PREFIX,