@ewhauser/world-celld 0.5.0 → 0.7.0

package/dist/worker.d.ts

@@ -224,6 +224,15 @@ interface ApplyEventSuccess {
   maxEvents?: number;
   /** Deadline for publishing this authoritative mutation to derivative indexes. */
   indexPublicationExpiresAt?: number;
+  /** Set by the worker router after it published `run` to the run catalog. */
+  runIndexPublished?: true;
+  /** Set by the worker router after it released `releasedHooks` from the hook indexes. */
+  hookIndexesReleased?: true;
+  /**
+   * The unchanged run returned with a `preloadEvents` hook_received replay
+   * log. It is not a run mutation, so it carries no index publication.
+   */
+  replayRun?: WorkflowRun;
 }
 type ApplyEventOutcome = ApplyEventSuccess | ApplyEventFailure;
 //#endregion
@@ -383,6 +392,8 @@ declare class StreamDO extends DurableObject {
   private mutationTail;
   private changeVersion;
   private readonly waiters;
+  /** Multi-key read split into calls within the per-call key limit. */
+  private getMany;
   private getMeta;
   private assertOwner;
   private assertWritable;
@@ -503,6 +514,14 @@ declare class WorkflowRunDO extends DurableObject {
   private executeScheduledCleanupPage;
   private executeCleanup;
   private executeTerminalCleanup;
+  /**
+   * 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.
+   */
+  private completeSmallTerminalCleanup;
   private deleteTerminalHookPage;
   private deleteTerminalHookMarkerPage;
   private deleteTerminalWaitPage;

package/dist/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","names":[],"sources":["../src/worker/queue-payload-store.ts","../src/worker/router.ts","../src/worker/do-base.ts","../src/retention.ts","../src/apply-event.ts","../src/stream-protocol.ts","../src/indexes.ts","../src/config.ts","../src/worker/durable-objects/hook-index-shared.ts","../src/worker/durable-objects/HookIdDO.ts","../src/worker/durable-objects/HookTokenDO.ts","../src/worker/durable-objects/RunCatalogDO.ts","../src/worker/durable-objects/StreamDO.ts","../src/worker/durable-objects/WorkflowRunDO.ts","../src/worker/worker.ts"],"mappings":"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"}
+{"version":3,"file":"worker.d.ts","names":[],"sources":["../src/worker/queue-payload-store.ts","../src/worker/router.ts","../src/worker/do-base.ts","../src/retention.ts","../src/apply-event.ts","../src/stream-protocol.ts","../src/indexes.ts","../src/config.ts","../src/worker/durable-objects/hook-index-shared.ts","../src/worker/durable-objects/HookIdDO.ts","../src/worker/durable-objects/HookTokenDO.ts","../src/worker/durable-objects/RunCatalogDO.ts","../src/worker/durable-objects/StreamDO.ts","../src/worker/durable-objects/WorkflowRunDO.ts","../src/worker/worker.ts"],"mappings":"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"}

package/dist/worker.js

@@ -1,4 +1,4 @@
-import { _ as isRecord$1, a as queueOrphanName, c as validateNativeQueueEnvelope, d as HOOK_CLAIM_LEASE_MS, f as LIFECYCLE_COMPACTION_RETRY_MS, g as isPositiveSafeInteger, h as isNonNegativeSafeInteger, i as queueClaimName, l as validateNativeQueueSendOptions, m as QUEUE_CLAIM_STALE_MS, n as QUEUE_PAYLOAD_REGISTRY_PREFIX, o as queuePayloadObjectKey, p as MAX_RUN_INDEX_PUBLICATION_LIFETIME_MS, s as queuePayloadRegistryKey, t as NATIVE_QUEUE_MAX_MESSAGE_BYTES, v as queueDelayDeadline, y as strictIntegerSetting } from "./queue-protocol-Ds44uuND.js";
+import { _ as isRecord$1, a as queueOrphanName, c as validateNativeQueueEnvelope, d as HOOK_CLAIM_LEASE_MS, f as LIFECYCLE_COMPACTION_RETRY_MS, g as isPositiveSafeInteger, h as isNonNegativeSafeInteger, i as queueClaimName, l as validateNativeQueueSendOptions, m as QUEUE_CLAIM_STALE_MS, n as QUEUE_PAYLOAD_REGISTRY_PREFIX, o as queuePayloadObjectKey, p as MAX_RUN_INDEX_PUBLICATION_LIFETIME_MS, s as queuePayloadRegistryKey, t as NATIVE_QUEUE_MAX_MESSAGE_BYTES, v as queueDelayDeadline, y as strictIntegerSetting } from "./queue-protocol-CtH7UUCO.js";
 import { DurableObject, WorkerEntrypoint } from "cloudflare:workers";
 import { CreateEventSchema, EventSchema, HookSchema, SPEC_VERSION_CURRENT, StepSchema, WaitSchema, WorkflowRunSchema, applyAttributeChanges, eventIdToSlot, getMaxEventsPerRun, isChildEntityCreationEvent, isTerminalStepStatus, isTerminalWorkflowRunStatus, slotToEventId, validateAttributeChanges } from "@workflow/world";
 //#region src/worker/auth.ts
@@ -197,22 +197,34 @@ function dateReviver(key, value) {
 	return value;
 }
 /**
-* Base64 helpers. Modified vs upstream: implemented over atob/btoa instead of
-* Buffer so this module is safe inside the celld worker bundle (workerd has
-* no Buffer global); atob/btoa are global in both workerd and Node >= 16.
+* Base64 helpers. Modified vs upstream: implemented without Buffer so this
+* module is safe inside the celld worker bundle (workerd has no Buffer
+* global). Uses the native Uint8Array base64 methods where the runtime has
+* them (Node >= 25, current V8) and falls back to atob/btoa elsewhere.
 */
-function b64encode(bytes) {
+const nativeToBase64 = Uint8Array.prototype.toBase64;
+const nativeFromBase64 = Uint8Array.fromBase64;
+/** Small enough to stay far below engine argument-count limits and fast to spread. */
+const FALLBACK_ENCODE_CHUNK = 4096;
+/** @internal Exported for tests; use b64encode. */
+function b64encodeFallback(bytes) {
 	let bin = "";
-	const CHUNK = 32768;
-	for (let i = 0; i < bytes.length; i += CHUNK) bin += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+	for (let i = 0; i < bytes.length; i += FALLBACK_ENCODE_CHUNK) bin += String.fromCharCode.apply(null, bytes.subarray(i, i + FALLBACK_ENCODE_CHUNK));
 	return btoa(bin);
 }
-function b64decode(text) {
+/** @internal Exported for tests; use b64decode. */
+function b64decodeFallback(text) {
 	const bin = atob(text);
 	const out = new Uint8Array(bin.length);
 	for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
 	return out;
 }
+function b64encode(bytes) {
+	return nativeToBase64 ? nativeToBase64.call(bytes) : b64encodeFallback(bytes);
+}
+function b64decode(text) {
+	return nativeFromBase64 ? nativeFromBase64(text) : b64decodeFallback(text);
+}
 /**
 * JSON reviver that decodes tagged Uint8Array objects and ISO date strings.
 * Supports both:
@@ -1068,6 +1080,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,
@@ -1097,6 +1110,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/codec.ts
 /**
@@ -1110,7 +1149,8 @@ async function finalizeEventPage(store, outcome, params) {
 * `{__type:'Date', iso}`.
 *
 * Runs on both sides of the wire, including inside the celld worker — so no
-* Node built-ins (Buffer): base64 goes through atob/btoa.
+* Node built-ins (Buffer): base64 uses the native Uint8Array methods or
+* atob/btoa.
 */
 function rpcReplacer(key, value) {
 	const original = this && typeof this === "object" ? this[key] : void 0;
@@ -1150,6 +1190,79 @@ function rpcStringify(value) {
 function rpcParse(text) {
 	return JSON.parse(text, rpcReviver);
 }
+/** Largest page the fleet-side list accepts, matching the catalog page limit. */
+const MAX_RUN_LIST_LIMIT = 1e3;
+/**
+* Run statuses only move pending -> running -> terminal, and terminal statuses
+* are immutable. An older index value may therefore safely exclude a filter
+* only when it is already terminal, or when the caller asks for pending and
+* the index has advanced beyond pending. Earlier non-terminal metadata cannot
+* exclude a later status because a post-commit index write may need replay.
+*/
+function indexStatusExcludes(indexed, requested) {
+	if (requested === void 0 || indexed === requested) return false;
+	return isTerminalWorkflowRunStatus(indexed) || requested === "pending";
+}
+function stripRunData(run) {
+	const { input: _input, output: _output, ...rest } = run;
+	return rest;
+}
+/**
+* Page through the run catalog, verifying every candidate against its
+* authoritative run cell. Runs on the client against remote bindings, or in
+* the worker router against fleet bindings.
+*/
+async function listRunsPage(deps, request) {
+	const { statuses, limit } = request;
+	const prefix = request.workflowName ? `run:${request.workflowName}:` : "runall:";
+	const reverse = request.sortOrder === "desc";
+	const matches = [];
+	let scanCursor = request.cursor;
+	let exhausted = false;
+	while (matches.length <= limit && !exhausted) {
+		const kvList = await deps.listRuns({
+			prefix,
+			limit: Math.min(MAX_RUN_LIST_LIMIT, Math.max(50, limit)),
+			cursor: scanCursor,
+			reverse
+		});
+		if (kvList.keys.length === 0) {
+			exhausted = true;
+			break;
+		}
+		const candidates = [];
+		for (const key of kvList.keys) {
+			const metadata = JSON.parse(key.value);
+			if (statuses?.every((status) => indexStatusExcludes(metadata.status, status))) continue;
+			candidates.push({
+				key: key.name,
+				metadata
+			});
+		}
+		for (let offset = 0; offset < candidates.length && matches.length <= limit;) {
+			const needed = limit + 1 - matches.length;
+			const batch = candidates.slice(offset, offset + Math.min(8, needed));
+			const resolved = await Promise.all(batch.map(async ({ key, metadata }) => {
+				const run = await deps.readRun(metadata.runId);
+				return run && (statuses === void 0 || statuses.includes(run.status)) ? {
+					key,
+					run
+				} : null;
+			}));
+			for (const match of resolved) if (match) matches.push(match);
+			offset += batch.length;
+		}
+		exhausted = kvList.list_complete;
+		scanCursor = kvList.cursor ?? kvList.keys.at(-1)?.name;
+	}
+	const hasMore = matches.length > limit;
+	const page = matches.slice(0, limit);
+	return {
+		data: page.map(({ run }) => request.resolveData === "none" ? stripRunData(run) : run),
+		cursor: hasMore ? page.at(-1)?.key ?? null : null,
+		hasMore
+	};
+}
 const INDEX_PROTOCOL_VERSION = "v1";
 const HOOK_RELEASE_BATCH = 64;
 /** Stable FNV-1a routing hash. Collisions share a shard but never a storage key. */
@@ -1178,6 +1291,14 @@ function hookIdShardName(hookId) {
 function allRunCatalogShardNames() {
 	return Array.from({ length: 16 }, (_, shard) => `run-catalog:${INDEX_PROTOCOL_VERSION}:${shard.toString(16).padStart(2, "0")}`);
 }
+/** Catalog metadata for a run; the client and the worker router must agree on it. */
+function runIndexMetadata(run) {
+	return JSON.stringify({
+		runId: run.runId,
+		createdAt: run.createdAt.toISOString(),
+		status: run.status
+	});
+}
 function stub(namespace, name) {
 	return namespace.get(namespace.idFromName(name));
 }
@@ -1343,6 +1464,8 @@ const STREAM_BATCH_CONTENT_TYPE = "application/vnd.world-celld.stream-batch.v1";
 const MAX_STREAM_CHUNK_BYTES = 1048576;
 /** Keeps serialized RPC bodies well below the 32 MiB Workers RPC limit. */
 const MAX_STREAM_BATCH_BYTES = 8388608;
+/** Response header on stream requests: the per-request chunk limit this worker accepts. */
+const STREAM_CHUNK_LIMIT_HEADER = "x-world-celld-stream-chunks";
 const MAX_STREAM_READ_BYTES = 8388608;
 const MAX_STREAM_ERROR_BYTES = 16384;
 /** Must remain below the default 30 second fleet request deadline. */
@@ -1370,7 +1493,7 @@ function requireSafeIndex(value, field) {
 }
 function validateStreamWriteChunks(chunks) {
 	if (chunks.length === 0) throw protocolError("batch must contain at least one chunk");
-	if (chunks.length > 32) throw protocolError(`batch exceeds 32 chunks`);
+	if (chunks.length > 512) throw protocolError(`batch exceeds 512 chunks`);
 	let totalBytes = 0;
 	for (const chunk of chunks) {
 		if (!(chunk instanceof Uint8Array)) throw protocolError("chunk is not binary data");
@@ -1383,7 +1506,7 @@ function validateStreamWriteChunks(chunks) {
 function validateStreamReadRequest(request) {
 	if (!request.runId) throw protocolError("runId is required");
 	if (!Number.isSafeInteger(request.startIndex) || request.startIndex < 0 || request.startIndex > 2147483647) throw protocolError("startIndex must be between 0 and 2147483647");
-	if (!Number.isSafeInteger(request.maxChunks) || request.maxChunks < 0 || request.maxChunks > 32) throw protocolError(`maxChunks must be between 0 and 32`);
+	if (!Number.isSafeInteger(request.maxChunks) || request.maxChunks < 0 || request.maxChunks > 512) throw protocolError(`maxChunks must be between 0 and 512`);
 	if (!Number.isSafeInteger(request.maxBytes) || request.maxBytes < 1048576 || request.maxBytes > 8388608) throw protocolError(`maxBytes must be between ${MAX_STREAM_CHUNK_BYTES} and ${MAX_STREAM_READ_BYTES}`);
 	if (!Number.isSafeInteger(request.waitMs) || request.waitMs < 0 || request.waitMs > 2e4) throw protocolError(`waitMs must be between 0 and ${MAX_STREAM_LONG_POLL_MS}`);
 }
@@ -1410,7 +1533,7 @@ function decodeStreamWriteBatch(encoded) {
 function encodeStreamWriteResult(result) {
 	requireSafeIndex(result.startIndex, "startIndex");
 	requireSafeIndex(result.tailIndex, "tailIndex");
-	if (!Number.isSafeInteger(result.count) || result.count < 1 || result.count > 32) throw protocolError("write count is out of range");
+	if (!Number.isSafeInteger(result.count) || result.count < 1 || result.count > 512) throw protocolError("write count is out of range");
 	const encoded = new Uint8Array(WRITE_ACK_BYTES);
 	const view = new DataView(encoded.buffer);
 	view.setUint32(0, WRITE_ACK_MAGIC);
@@ -1425,7 +1548,7 @@ function encodeStreamReadResult(result) {
 	requireSafeIndex(result.tailIndex, "tailIndex");
 	let chunkBytes = 0;
 	for (const chunk of result.chunks) chunkBytes += 4 + chunk.byteLength;
-	if (result.chunks.length > 32 || chunkBytes > 8388736) throw protocolError("read result exceeds configured bounds");
+	if (result.chunks.length > 512 || chunkBytes > 8390656) throw protocolError("read result exceeds configured bounds");
 	const encoder = new TextEncoder();
 	const errorName = result.error ? encoder.encode(result.error.name) : /* @__PURE__ */ new Uint8Array();
 	const errorMessage = result.error ? encoder.encode(result.error.message) : /* @__PURE__ */ new Uint8Array();
@@ -1577,6 +1700,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]);
@@ -1637,6 +1788,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);
@@ -1672,6 +1829,7 @@ function validateIndexRequest(operation, args) {
 }
 const INDEX_OPERATIONS = /* @__PURE__ */ new Set([
 	"runs.list",
+	"runs.list-resolved",
 	"runs.commit",
 	"runs.expire",
 	"hooks.reserve",
@@ -1703,6 +1861,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",
@@ -1745,7 +1934,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 = 8389632;
+const MAX_STREAM_WRITE_BODY_BYTES = 8391680;
 const QUEUE_ORPHAN_GRACE_MS = 432e6;
 function errorResponse(status, name, message) {
 	return Response.json({ error: {
@@ -1862,7 +2051,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) {
@@ -2026,6 +2218,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;
@@ -2081,7 +2285,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)
 					};
@@ -2144,6 +2348,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" }
@@ -2713,9 +2918,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,
@@ -2827,13 +3041,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)));
@@ -2899,6 +3116,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) => {
@@ -2971,7 +3197,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;
@@ -2983,7 +3209,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]}`);
@@ -3015,13 +3241,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: {
@@ -3201,7 +3427,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,
@@ -3250,13 +3476,15 @@ var StreamDO = class extends DurableObject {
 };
 //#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;
@@ -3338,11 +3566,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) {
@@ -3377,21 +3608,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
@@ -3771,10 +4003,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,