@ewhauser/world-celld 0.6.0 → 0.8.0

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 isPositiveSafeInteger, a as queueClaimName, b as strictIntegerSetting, c as queuePayloadRegistryKey, f as HOOK_CLAIM_LEASE_MS, g as isNonNegativeSafeInteger, h as QUEUE_CLAIM_STALE_MS, l as validateNativeQueueEnvelope, m as MAX_RUN_INDEX_PUBLICATION_LIFETIME_MS, n as QUEUE_PAYLOAD_REGISTRY_PREFIX, o as queueOrphanName, p as LIFECYCLE_COMPACTION_RETRY_MS, r as isInlineRunBody, s as queuePayloadObjectKey, t as NATIVE_QUEUE_MAX_MESSAGE_BYTES, u as validateNativeQueueSendOptions, v as isRecord$1, y as queueDelayDeadline } from "./queue-protocol-DKYt8qZJ.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
@@ -42,6 +42,57 @@ async function authenticate(request, secret) {
 	return { ok: true };
 }
 //#endregion
+//#region src/worker/queue-claims.ts
+/**
+* Idempotency claims for Queue messages. A claim lives either in its own
+* claim cell (named by queue and idempotency key) or, for run-bearing
+* messages whose envelope says so, as an entry in the run's own cell.
+*/
+function cellQueueClaim(cell) {
+	return {
+		claim: (messageId, staleMs) => cell.claimInflight({
+			messageId,
+			staleMs
+		}),
+		hold: (params) => cell.holdInflight(params),
+		release: (messageId) => cell.releaseInflight(messageId),
+		complete: (messageId) => cell.completeQueueMessage(messageId)
+	};
+}
+function runQueueClaim(run, claimName) {
+	return {
+		claim: async (messageId, staleMs) => {
+			const result = await run.claimRunQueueMessage({
+				claimName,
+				messageId,
+				staleMs
+			});
+			return result.expired ? {
+				expired: true,
+				claimed: false
+			} : result;
+		},
+		hold: (params) => run.holdRunQueueMessage({
+			claimName,
+			...params
+		}),
+		release: (messageId) => run.releaseRunQueueMessage({
+			claimName,
+			messageId
+		}),
+		complete: (messageId) => run.completeRunQueueMessage({
+			claimName,
+			messageId
+		})
+	};
+}
+/** The claim a delivered envelope was reserved under, if it has an idempotency key. */
+function deliveryQueueClaim(envelope, runStub) {
+	if (!envelope.idempotencyKey) return void 0;
+	const claimName = queueClaimName(envelope.queueName, envelope.idempotencyKey);
+	return envelope.claimScope === "run" && envelope.runId ? runQueueClaim(runStub(envelope.runId), claimName) : cellQueueClaim(runStub(claimName));
+}
+//#endregion
 //#region src/worker/queue-delivery.ts
 /** Internal delivery contract. No Request/Response objects cross the RPC boundary. */
 const MAX_QUEUE_DELIVERY_RESPONSE_BYTES = 65536;
@@ -84,10 +135,10 @@ async function deliverQueueMessage(env, secret, input, attempt) {
 	const namespace = env.WORKFLOW_DB;
 	const payloadStore = env.WORKFLOW_QUEUE_PAYLOADS;
 	const runStub = (name) => namespace.get(namespace.idFromName(name));
-	let claim;
+	const claim = deliveryQueueClaim(envelope, runStub);
 	let claimed = false;
 	async function releaseClaim() {
-		if (claimed) await claim.releaseInflight(envelope.messageId);
+		if (claimed) await claim.release(envelope.messageId);
 	}
 	async function unregisterPayload() {
 		if (envelope.runId) {
@@ -96,12 +147,14 @@ async function deliverQueueMessage(env, secret, input, attempt) {
 		}
 	}
 	try {
-		if (envelope.idempotencyKey) {
-			claim = runStub(queueClaimName(envelope.queueName, envelope.idempotencyKey));
-			const result = await claim.claimInflight({
-				messageId: envelope.messageId,
-				staleMs: QUEUE_CLAIM_STALE_MS
-			});
+		let admission;
+		if (envelope.runId && !envelope.payloadKey && envelope.claimScope !== "run") {
+			admission = runStub(envelope.runId).getQueueAdmission();
+			admission.catch(() => void 0);
+		}
+		if (claim) {
+			const result = await claim.claim(envelope.messageId, QUEUE_CLAIM_STALE_MS);
+			if (result.expired) return { kind: "complete" };
 			if (!result.claimed) {
 				const now = Date.now();
 				if (result.retryAt !== void 0 && result.retryAt > now) return {
@@ -112,13 +165,17 @@ async function deliverQueueMessage(env, secret, input, attempt) {
 			}
 			claimed = true;
 		}
+		if (admission && !(await admission).ok) {
+			await claim?.complete(envelope.messageId);
+			return { kind: "complete" };
+		}
 		let body = envelope.body;
 		if (envelope.payloadKey) {
 			if (!payloadStore) throw new Error("missing binding: WORKFLOW_QUEUE_PAYLOADS");
 			body = await payloadStore.read(envelope.payloadKey) ?? void 0;
 			if (body === void 0) {
 				await unregisterPayload();
-				await claim?.completeQueueMessage(envelope.messageId);
+				await claim?.complete(envelope.messageId);
 				return { kind: "complete" };
 			}
 		}
@@ -141,7 +198,7 @@ async function deliverQueueMessage(env, secret, input, attempt) {
 				await payloadStore.delete(envelope.payloadKey);
 				await unregisterPayload();
 			}
-			await claim?.completeQueueMessage(envelope.messageId);
+			await claim?.complete(envelope.messageId);
 			return { kind: "complete" };
 		}
 		if (callback.status === 503) {
@@ -155,7 +212,7 @@ async function deliverQueueMessage(env, secret, input, attempt) {
 				key: envelope.payloadKey,
 				expiresAt: notBefore + QUEUE_ORPHAN_GRACE_MS$1
 			});
-			if (claim) await claim.holdInflight({
+			if (claim) await claim.hold({
 				messageId: envelope.messageId,
 				retryAt: notBefore,
 				expiresAt: notBefore + QUEUE_CLAIM_STALE_MS,
@@ -197,22 +254,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 +1137,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 +1167,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 +1206,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 +1247,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 +1348,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 +1521,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 +1550,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 +1563,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 +1590,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 +1605,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 +1757,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 +1845,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 +1886,7 @@ function validateIndexRequest(operation, args) {
 }
 const INDEX_OPERATIONS = /* @__PURE__ */ new Set([
 	"runs.list",
+	"runs.list-resolved",
 	"runs.commit",
 	"runs.expire",
 	"hooks.reserve",
@@ -1696,6 +1911,18 @@ const INDEX_OPERATIONS = /* @__PURE__ */ new Set([
 */
 const WORLD_NAME = "world-celld";
 const WORLD_VERSION = "0.1.0";
+/**
+* Per-isolate record of runs whose Queue idempotency claims stay in claim
+* cells (created before run-scoped claims) or live in the run cell. A run's
+* scope never changes, so the cache only saves the run-cell question.
+*/
+const runClaimScopes = /* @__PURE__ */ new Map();
+const MAX_REMEMBERED_RUN_CLAIM_SCOPES = 4096;
+function rememberRunClaimScope(runId, scope) {
+	if (runClaimScopes.has(runId)) return;
+	if (runClaimScopes.size >= MAX_REMEMBERED_RUN_CLAIM_SCOPES) runClaimScopes.delete(runClaimScopes.keys().next().value);
+	runClaimScopes.set(runId, scope);
+}
 function workflowIndex(env) {
 	return createWorkflowIndex({
 		runCatalog: env.WORKFLOW_RUN_CATALOG,
@@ -1703,6 +1930,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 +2003,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 +2120,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) {
@@ -1899,31 +2160,71 @@ function createRouter(env) {
 				try {
 					const namespace = env.WORKFLOW_DB;
 					const payloadStore = env.WORKFLOW_QUEUE_PAYLOADS;
-					const payloadKey = envelope.runId ? queuePayloadObjectKey(envelope.runId, envelope.messageId) : void 0;
-					const brokerEnvelope = payloadKey ? {
+					const inlineRunBody = envelope.runId !== void 0 && isInlineRunBody(envelope.body);
+					const payloadKey = envelope.runId && !inlineRunBody ? queuePayloadObjectKey(envelope.runId, envelope.messageId) : void 0;
+					let brokerEnvelope = payloadKey ? {
 						...envelope,
 						payloadKey,
 						body: void 0
 					} : envelope;
-					const encoded = JSON.stringify(brokerEnvelope);
-					if (new TextEncoder().encode(encoded).byteLength > 128e3) return errorResponse(413, "PayloadTooLarge", `native queue envelope exceeds ${NATIVE_QUEUE_MAX_MESSAGE_BYTES} bytes`);
+					const sized = JSON.stringify({
+						...brokerEnvelope,
+						claimScope: "run"
+					});
+					if (new TextEncoder().encode(sized).byteLength > 128e3) return errorResponse(413, "PayloadTooLarge", `native queue envelope exceeds ${NATIVE_QUEUE_MAX_MESSAGE_BYTES} bytes`);
 					const now = Date.now();
 					const reservationExpiresAt = Math.max(now, envelope.notBefore ?? now) + QUEUE_ORPHAN_GRACE_MS;
+					const run = envelope.runId ? namespace.get(namespace.idFromName(envelope.runId)) : void 0;
 					let claim;
+					let admission;
 					if (envelope.idempotencyKey) {
-						claim = namespace.get(namespace.idFromName(queueClaimName(envelope.queueName, envelope.idempotencyKey)));
-						const reservation = await claim.reserveQueueMessage({
-							messageId: envelope.messageId,
-							expiresAt: reservationExpiresAt
-						});
+						const claimName = queueClaimName(envelope.queueName, envelope.idempotencyKey);
+						let scope = run && envelope.runId ? runClaimScopes.get(envelope.runId) : "cell";
+						let reservation;
+						if (run && envelope.runId && scope !== "cell") {
+							const reserved = await run.reserveRunQueueMessage({
+								claimName,
+								messageId: envelope.messageId,
+								expiresAt: reservationExpiresAt
+							});
+							if (!reserved.ok) return errorResponse(410, "RunExpiredError", reserved.message);
+							scope = reserved.scope;
+							rememberRunClaimScope(envelope.runId, reserved.scope);
+							if (reserved.scope === "run") {
+								reservation = reserved;
+								claim = runQueueClaim(run, claimName);
+								brokerEnvelope = {
+									...brokerEnvelope,
+									claimScope: "run"
+								};
+							}
+						} else if (inlineRunBody && run) {
+							admission = run.getQueueAdmission();
+							admission.catch(() => void 0);
+						}
+						if (!reservation) {
+							const cell = namespace.get(namespace.idFromName(claimName));
+							reservation = await cell.reserveQueueMessage({
+								messageId: envelope.messageId,
+								expiresAt: reservationExpiresAt
+							});
+							claim = cellQueueClaim(cell);
+						}
 						if (!reservation.admitted) return new Response(rpcStringify({ messageId: reservation.messageId }), {
 							status: 200,
 							headers: { "content-type": "application/json" }
 						});
+					} else if (inlineRunBody && run) admission = run.getQueueAdmission();
+					const encoded = JSON.stringify(brokerEnvelope);
+					if (admission) {
+						const admitted = await admission;
+						if (!admitted.ok) {
+							await claim?.complete(envelope.messageId);
+							return errorResponse(410, "RunExpiredError", admitted.message);
+						}
 					}
-					if (envelope.runId && payloadKey) {
+					if (run && envelope.runId && payloadKey) {
 						if (!payloadStore) return errorResponse(500, "WorldMisconfigured", "missing binding: WORKFLOW_QUEUE_PAYLOADS");
-						const run = namespace.get(namespace.idFromName(envelope.runId));
 						const orphanExpiresAt = reservationExpiresAt;
 						const registered = await run.registerQueuePayload({
 							messageId: envelope.messageId,
@@ -1931,7 +2232,7 @@ function createRouter(env) {
 							orphanExpiresAt
 						});
 						if (!registered.ok) {
-							await claim?.completeQueueMessage(envelope.messageId);
+							await claim?.complete(envelope.messageId);
 							return errorResponse(410, "RunExpiredError", registered.message);
 						}
 						const orphan = namespace.get(namespace.idFromName(queueOrphanName(envelope.messageId)));
@@ -1944,7 +2245,7 @@ function createRouter(env) {
 							});
 						} catch (error) {
 							await run.unregisterQueuePayload(envelope.messageId);
-							await claim?.completeQueueMessage(envelope.messageId);
+							await claim?.complete(envelope.messageId);
 							throw error;
 						}
 						try {
@@ -1953,21 +2254,21 @@ function createRouter(env) {
 								messageId: envelope.messageId
 							});
 						} catch (error) {
-							await claim?.completeQueueMessage(envelope.messageId);
+							await claim?.complete(envelope.messageId);
 							throw error;
 						}
 						let finalized;
 						try {
 							finalized = await run.finalizeQueuePayload(envelope.messageId);
 						} catch (error) {
-							await claim?.completeQueueMessage(envelope.messageId);
+							await claim?.complete(envelope.messageId);
 							throw error;
 						}
 						if (!finalized.ok) {
 							await payloadStore.delete(payloadKey);
 							await run.unregisterQueuePayload(envelope.messageId);
 							await orphan.cancelQueuePayloadOrphan(envelope.messageId);
-							await claim?.completeQueueMessage(envelope.messageId);
+							await claim?.complete(envelope.messageId);
 							return errorResponse(410, "RunExpiredError", finalized.message);
 						}
 					}
@@ -2026,6 +2327,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 +2394,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 +2457,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 +3027,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 +3150,23 @@ 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;
+const SEGMENT_LAYOUT = 2;
+const SEGMENT_KEY_PREFIX = "seg:";
+const SEGMENT_SIZE_KEY_PREFIX = "segsize:";
+/** Payload bytes per segment row, well below the 2 MiB per-value storage limit. */
+const MAX_SEGMENT_BYTES = 1048576;
+/** Layout of a stream's first write. Existing streams keep the layout they started with. */
+const NEW_STREAM_LAYOUT = SEGMENT_LAYOUT;
+/** 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)));
@@ -2852,7 +3185,7 @@ function validateMeta(meta) {
 		"closed",
 		"errored",
 		"expired"
-	].includes(candidate.state) || candidate.ownerRunId !== void 0 && typeof candidate.ownerRunId !== "string" || candidate.payloadDeleted !== void 0 && typeof candidate.payloadDeleted !== "boolean") throw new Error("Invalid persisted stream metadata");
+	].includes(candidate.state) || candidate.ownerRunId !== void 0 && typeof candidate.ownerRunId !== "string" || candidate.payloadDeleted !== void 0 && typeof candidate.payloadDeleted !== "boolean" || candidate.layout !== void 0 && candidate.layout !== SEGMENT_LAYOUT) throw new Error("Invalid persisted stream metadata");
 	const error = candidate.error;
 	if (error !== void 0 && (!error || typeof error !== "object" || typeof error.name !== "string" || typeof error.message !== "string") || candidate.state === "errored" !== (error !== void 0)) throw new Error("Invalid persisted stream error metadata");
 	return candidate;
@@ -2864,6 +3197,80 @@ function chunkKey(index) {
 function chunkSizeKey(index) {
 	return `${CHUNK_SIZE_KEY_PREFIX}${index.toString().padStart(12, "0")}`;
 }
+function segmentKey(start) {
+	return `${SEGMENT_KEY_PREFIX}${start.toString().padStart(12, "0")}`;
+}
+function segmentSizeKey(start) {
+	return `${SEGMENT_SIZE_KEY_PREFIX}${start.toString().padStart(12, "0")}`;
+}
+function startFromSegmentKey(key, prefix) {
+	const suffix = key.slice(prefix.length);
+	const start = Number(suffix);
+	if (!key.startsWith(prefix) || !/^\d{12}$/.test(suffix) || !Number.isSafeInteger(start) || start > MAX_STREAM_INDEX) throw new Error(`Invalid persisted stream segment key "${key}"`);
+	return start;
+}
+function validateSegmentSize(value, start) {
+	const size = value;
+	if (!size || !Number.isSafeInteger(size.count) || size.count < 1 || !Number.isSafeInteger(size.bytes) || size.bytes < 0) throw new Error(`Invalid persisted stream segment size at index ${start}`);
+	return size;
+}
+/** Pack chunks as `[u32 count][u32 length]*count` followed by the payloads. */
+function encodeSegment(chunks) {
+	const payloadBytes = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+	const header = 4 + 4 * chunks.length;
+	const encoded = new Uint8Array(header + payloadBytes);
+	const view = new DataView(encoded.buffer);
+	view.setUint32(0, chunks.length);
+	let offset = header;
+	for (let index = 0; index < chunks.length; index++) {
+		view.setUint32(4 + 4 * index, chunks[index].byteLength);
+		encoded.set(chunks[index], offset);
+		offset += chunks[index].byteLength;
+	}
+	return encoded;
+}
+function decodeSegment(value, start, size) {
+	if (!(value instanceof Uint8Array) || value.byteLength < 4) throw new Error(`Invalid persisted stream segment at index ${start}`);
+	const view = new DataView(value.buffer, value.byteOffset, value.byteLength);
+	const count = view.getUint32(0);
+	const header = 4 + 4 * count;
+	if (count !== size.count || header + size.bytes !== value.byteLength) throw new Error(`Invalid persisted stream segment at index ${start}`);
+	const chunks = [];
+	let offset = header;
+	for (let index = 0; index < count; index++) {
+		const length = view.getUint32(4 + 4 * index);
+		if (offset + length > value.byteLength) throw new Error(`Invalid persisted stream segment at index ${start}`);
+		chunks.push(value.subarray(offset, offset + length));
+		offset += length;
+	}
+	if (offset !== value.byteLength) throw new Error(`Invalid persisted stream segment at index ${start}`);
+	return chunks;
+}
+/** Group one write's chunks into segments of at most MAX_SEGMENT_BYTES payload bytes. */
+function packSegments(startIndex, chunks) {
+	const segments = [];
+	let current = [];
+	let bytes = 0;
+	let start = startIndex;
+	for (const chunk of chunks) {
+		if (current.length > 0 && bytes + chunk.byteLength > MAX_SEGMENT_BYTES) {
+			segments.push({
+				start,
+				chunks: current
+			});
+			start += current.length;
+			current = [];
+			bytes = 0;
+		}
+		current.push(chunk);
+		bytes += chunk.byteLength;
+	}
+	if (current.length > 0) segments.push({
+		start,
+		chunks: current
+	});
+	return segments;
+}
 function indexFromChunkSizeKey(key) {
 	const suffix = key.slice(11);
 	const index = Number(suffix);
@@ -2880,6 +3287,9 @@ function validateChunkSize(size, index) {
 	if (typeof size !== "number" || !Number.isSafeInteger(size) || size < 0 || size > 1048576) throw new Error(`Invalid persisted stream chunk size at index ${index}`);
 	return size;
 }
+async function deleteInBatches(txn, keys) {
+	for (let offset = 0; offset < keys.length; offset += DELETE_BATCH_KEYS) await txn.delete(keys.slice(offset, offset + DELETE_BATCH_KEYS));
+}
 function compactChunk(chunk) {
 	return chunk.byteOffset === 0 && chunk.byteLength === chunk.buffer.byteLength ? chunk : new Uint8Array(chunk);
 }
@@ -2899,6 +3309,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) => {
@@ -2967,29 +3386,8 @@ var StreamDO = class extends DurableObject {
 		const meta = await this.getMeta();
 		this.assertOwner(meta, request.runId);
 		const available = meta.state === "expired" ? 0 : Math.max(0, Math.min(request.maxChunks, meta.count - request.startIndex));
-		const chunks = [];
-		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 selectedIndexes = [];
-			const selectedSizes = [];
-			let bytes = 0;
-			for (const index of indexes) {
-				const size = validateChunkSize(storedSizes.get(chunkSizeKey(index)), index);
-				if (bytes + size > request.maxBytes) break;
-				selectedIndexes.push(index);
-				selectedSizes.push(size);
-				bytes += size;
-			}
-			const payloadKeys = selectedIndexes.map(chunkKey);
-			const storedChunks = await this.ctx.storage.get(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]}`);
-				chunks.push(chunk);
-			}
-		}
+		let chunks = [];
+		if (available > 0) chunks = meta.layout === SEGMENT_LAYOUT ? await this.readSegmentRows(request.startIndex, available, request.maxBytes) : await this.readChunkRows(request.startIndex, available, request.maxBytes);
 		return {
 			startIndex: request.startIndex,
 			tailIndex: meta.count - 1,
@@ -2999,10 +3397,91 @@ var StreamDO = class extends DurableObject {
 			error: meta.error
 		};
 	}
+	async readChunkRows(startIndex, available, maxBytes) {
+		const indexes = Array.from({ length: available }, (_, offset) => startIndex + offset);
+		const sizeKeys = indexes.map(chunkSizeKey);
+		const storedSizes = await this.getMany(sizeKeys);
+		const selectedIndexes = [];
+		const selectedSizes = [];
+		let bytes = 0;
+		for (const index of indexes) {
+			const size = validateChunkSize(storedSizes.get(chunkSizeKey(index)), index);
+			if (bytes + size > maxBytes) break;
+			selectedIndexes.push(index);
+			selectedSizes.push(size);
+			bytes += size;
+		}
+		const payloadKeys = selectedIndexes.map(chunkKey);
+		const storedChunks = await this.getMany(payloadKeys);
+		const chunks = [];
+		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]}`);
+			chunks.push(chunk);
+		}
+		return chunks;
+	}
+	/**
+	* Plan from the small segment size rows, then load only the segments that
+	* cover the requested range. A read that starts on a segment boundary (the
+	* common sequential case) needs one list and one multi-get.
+	*/
+	async readSegmentRows(startIndex, available, maxBytes) {
+		const endIndex = startIndex + available;
+		const listed = await this.ctx.storage.list({
+			prefix: SEGMENT_SIZE_KEY_PREFIX,
+			start: segmentSizeKey(startIndex),
+			end: segmentSizeKey(endIndex),
+			limit: available
+		});
+		const planned = [];
+		for (const [key, value] of listed) {
+			const start = startFromSegmentKey(key, SEGMENT_SIZE_KEY_PREFIX);
+			planned.push({
+				start,
+				size: validateSegmentSize(value, start)
+			});
+		}
+		if (planned[0]?.start !== startIndex) {
+			const entry = (await this.ctx.storage.list({
+				prefix: SEGMENT_SIZE_KEY_PREFIX,
+				end: segmentSizeKey(startIndex + 1),
+				reverse: true,
+				limit: 1
+			})).entries().next().value;
+			if (!entry) throw new Error(`Missing persisted stream segment at index ${startIndex}`);
+			const start = startFromSegmentKey(entry[0], SEGMENT_SIZE_KEY_PREFIX);
+			planned.unshift({
+				start,
+				size: validateSegmentSize(entry[1], start)
+			});
+		}
+		const selected = [];
+		let plannedBytes = 0;
+		for (const segment of planned) {
+			if (selected.length > 0 && plannedBytes >= maxBytes) break;
+			selected.push(segment);
+			plannedBytes += segment.size.bytes;
+		}
+		const values = await this.getMany(selected.map(({ start }) => segmentKey(start)));
+		const chunks = [];
+		let bytes = 0;
+		let expected = startIndex;
+		for (const { start, size } of selected) {
+			if (start > expected) throw new Error(`Missing persisted stream segment at index ${expected}`);
+			const segment = decodeSegment(values.get(segmentKey(start)), start, size);
+			for (let offset = expected - start; offset < segment.length; offset++) {
+				if (expected >= endIndex || bytes + segment[offset].byteLength > maxBytes) return chunks;
+				chunks.push(segment[offset]);
+				bytes += segment[offset].byteLength;
+				expected++;
+			}
+		}
+		return chunks;
+	}
 	/** Append one bounded binary batch with contiguous indexes. */
 	async writeChunks(runId, chunks) {
 		validateStreamWriteChunks(chunks);
-		const storedChunks = chunks.map(compactChunk);
 		return await this.runMutation(async () => {
 			const committed = await this.ctx.storage.transaction(async (txn) => {
 				const stored = await txn.get(META_KEY);
@@ -3010,18 +3489,30 @@ var StreamDO = class extends DurableObject {
 				this.assertWritable(meta, runId);
 				const startIndex = meta.count;
 				if (startIndex + chunks.length > MAX_STREAM_INDEX) throw new Error("Stream offset limit exceeded");
+				const layout = stored === void 0 ? NEW_STREAM_LAYOUT : meta.layout;
 				const nextMeta = {
 					count: startIndex + chunks.length,
 					state: "open",
-					ownerRunId: runId
+					ownerRunId: runId,
+					...layout === void 0 ? {} : { layout }
 				};
-				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;
+				const entries = [[META_KEY, nextMeta]];
+				if (layout === SEGMENT_LAYOUT) for (const segment of packSegments(startIndex, chunks)) {
+					entries.push([segmentKey(segment.start), encodeSegment(segment.chunks)]);
+					entries.push([segmentSizeKey(segment.start), {
+						count: segment.chunks.length,
+						bytes: segment.chunks.reduce((total, chunk) => total + chunk.byteLength, 0)
+					}]);
+				}
+				else {
+					const storedChunks = chunks.map(compactChunk);
+					for (let offset = 0; offset < storedChunks.length; offset++) {
+						const index = startIndex + offset;
+						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: {
@@ -3155,6 +3646,102 @@ var StreamDO = class extends DurableObject {
 			};
 		});
 	}
+	/** Delete one page of per-chunk rows, listing size rows to avoid loading payloads. */
+	async expireChunkPage(txn, limit, byteLimit) {
+		const candidates = await txn.list({
+			prefix: CHUNK_SIZE_KEY_PREFIX,
+			limit: limit + 1
+		});
+		const page = [];
+		let bytes = 0;
+		for (const [key, storedSize] of Array.from(candidates).slice(0, limit)) {
+			const index = indexFromChunkSizeKey(key);
+			const size = validateChunkSize(storedSize, index);
+			if (page.length > 0 && bytes + size > byteLimit) break;
+			page.push({
+				index,
+				size
+			});
+			bytes += size;
+		}
+		let payloadFallback = false;
+		if (candidates.size === 0) {
+			const first = (await txn.list({
+				prefix: CHUNK_KEY_PREFIX,
+				limit: 1
+			})).entries().next().value;
+			if (first) {
+				const [key, payload] = first;
+				page.push({
+					index: indexFromChunkKey(key),
+					size: payload instanceof Uint8Array ? payload.byteLength : 0
+				});
+				bytes = page[0].size;
+				payloadFallback = true;
+			}
+		}
+		await deleteInBatches(txn, page.flatMap(({ index }) => [chunkKey(index), chunkSizeKey(index)]));
+		let done = candidates.size === page.length;
+		if (payloadFallback) done = (await txn.list({
+			prefix: CHUNK_KEY_PREFIX,
+			limit: 1
+		})).size === 0;
+		else if (done && candidates.size > 0) done = (await txn.list({
+			prefix: CHUNK_KEY_PREFIX,
+			limit: 1
+		})).size === 0;
+		return {
+			chunks: page.length,
+			bytes,
+			done
+		};
+	}
+	/**
+	* Delete one page of segment rows, listing segment size rows to avoid
+	* loading payloads. One segment always makes progress, even when it holds
+	* more chunks or bytes than the page allows.
+	*/
+	async expireSegmentPage(txn, limit, byteLimit) {
+		const candidates = await txn.list({
+			prefix: SEGMENT_SIZE_KEY_PREFIX,
+			limit: limit + 1
+		});
+		const page = [];
+		let chunks = 0;
+		let bytes = 0;
+		for (const [key, value] of candidates) {
+			const start = startFromSegmentKey(key, SEGMENT_SIZE_KEY_PREFIX);
+			const size = validateSegmentSize(value, start);
+			if (page.length > 0 && (chunks + size.count > limit || bytes + size.bytes > byteLimit)) break;
+			page.push(start);
+			chunks += size.count;
+			bytes += size.bytes;
+		}
+		let orphan = false;
+		if (candidates.size === 0) {
+			const first = (await txn.list({
+				prefix: SEGMENT_KEY_PREFIX,
+				limit: 1
+			})).entries().next().value;
+			if (first) {
+				page.push(startFromSegmentKey(first[0], SEGMENT_KEY_PREFIX));
+				bytes = first[1] instanceof Uint8Array ? first[1].byteLength : 0;
+				chunks = 1;
+				orphan = true;
+			}
+		}
+		await deleteInBatches(txn, page.flatMap((start) => [segmentKey(start), segmentSizeKey(start)]));
+		let done = !orphan && candidates.size === page.length;
+		if (orphan || done) done = (await txn.list({
+			prefix: SEGMENT_KEY_PREFIX,
+			limit: 1
+		})).size === 0;
+		return {
+			chunks,
+			bytes,
+			done
+		};
+	}
 	/**
 	* Fence the stream and delete one bounded page. Listing size keys avoids
 	* loading payloads, and the transaction makes a crash retry resume safely.
@@ -3168,50 +3755,8 @@ var StreamDO = class extends DurableObject {
 				const meta = stored === void 0 ? emptyMeta() : validateMeta(stored);
 				this.assertOwner(meta, runId);
 				const firstFence = meta.state !== "expired";
-				const candidates = await txn.list({
-					prefix: CHUNK_SIZE_KEY_PREFIX,
-					limit: limit + 1
-				});
-				const page = [];
-				let bytes = 0;
-				for (const [key, storedSize] of Array.from(candidates).slice(0, limit)) {
-					const index = indexFromChunkSizeKey(key);
-					const size = validateChunkSize(storedSize, index);
-					if (page.length > 0 && bytes + size > byteLimit) break;
-					page.push({
-						index,
-						size
-					});
-					bytes += size;
-				}
-				let payloadFallback = false;
-				if (candidates.size === 0) {
-					const first = (await txn.list({
-						prefix: CHUNK_KEY_PREFIX,
-						limit: 1
-					})).entries().next().value;
-					if (first) {
-						const [key, payload] = first;
-						page.push({
-							index: indexFromChunkKey(key),
-							size: payload instanceof Uint8Array ? payload.byteLength : 0
-						});
-						bytes = page[0].size;
-						payloadFallback = true;
-					}
-				}
-				const keys = page.flatMap(({ index }) => [chunkKey(index), chunkSizeKey(index)]);
-				if (keys.length > 0) await txn.delete(keys);
-				let done = candidates.size === page.length;
-				if (payloadFallback) done = (await txn.list({
-					prefix: CHUNK_KEY_PREFIX,
-					limit: 1
-				})).size === 0;
-				else if (done && candidates.size > 0) done = (await txn.list({
-					prefix: CHUNK_KEY_PREFIX,
-					limit: 1
-				})).size === 0;
-				if (done && page.length === 0 && meta.state === "expired" && meta.payloadDeleted) return {
+				const { chunks, bytes, done } = meta.layout === SEGMENT_LAYOUT ? await this.expireSegmentPage(txn, limit, byteLimit) : await this.expireChunkPage(txn, limit, byteLimit);
+				if (done && chunks === 0 && meta.state === "expired" && meta.payloadDeleted) return {
 					meta,
 					result: {
 						deleted: false,
@@ -3235,7 +3780,7 @@ var StreamDO = class extends DurableObject {
 					meta: nextMeta,
 					result: {
 						deleted: firstFence,
-						chunks: page.length,
+						chunks,
 						bytes,
 						done
 					}
@@ -3250,19 +3795,29 @@ 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;
 const MAX_DATE_MS = 864e13;
 const QUEUE_ORPHAN_KEY = "queue-orphan";
 const QUEUE_RESERVATION_KEY = "queue-reservation";
+/** Run-scoped Queue idempotency state, one key per claim name, in the run's own cell. */
+const RUN_QUEUE_CLAIM_PREFIX = "queue-claim:";
+/**
+* Present when every idempotency claim of this run lives in the run's own
+* cell. Written only when the run is created, so a run keeps one claim scope
+* for its whole life and claims made before the marker existed stay valid.
+*/
+const RUN_QUEUE_CLAIM_SCOPE_KEY = "queue-claim-scope";
 function validateCleanupRequest(request, allowDisabled) {
 	if (!isRecord$1(request)) throw new Error("world-celld retention request must be an object");
 	if (!(allowDisabled ? isNonNegativeSafeInteger(request.retentionMs) : isPositiveSafeInteger(request.retentionMs))) throw new Error(`world-celld retentionMs must be a ${allowDisabled ? "non-negative" : "positive"} safe integer`);
@@ -3316,6 +3871,12 @@ async function putStorageEntries(storage, entries) {
 	const all = Array.from(entries);
 	for (let offset = 0; offset < all.length; offset += STORAGE_BATCH_SIZE) await storage.put(Object.fromEntries(all.slice(offset, offset + STORAGE_BATCH_SIZE)));
 }
+function runQueueClaimKey(claimName) {
+	return `${RUN_QUEUE_CLAIM_PREFIX}${claimName}`;
+}
+function validRunQueueClaimName(claimName) {
+	return typeof claimName === "string" && claimName.startsWith("claim:");
+}
 /**
 * Durable Object for managing a single workflow run's state.
 *
@@ -3338,11 +3899,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 +3941,23 @@ 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);
+			if (outcome.runCreated) await txn.put(RUN_QUEUE_CLAIM_SCOPE_KEY, "run");
 			await putStorageEntries(txn, (outcome.hookToIndex ? [{
 				hookId: outcome.hookToIndex.hookId,
 				token: outcome.hookToIndex.token
@@ -3771,10 +4337,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,
@@ -4010,6 +4624,150 @@ var WorkflowRunDO = class extends DurableObject {
 			await txn.setAlarm(this.now() + delay);
 		});
 	}
+	/**
+	* Read-only admission for a run-bearing Queue message whose body travels
+	* inline in the broker envelope. It answers what payload registration does
+	* for offloaded bodies, without writing anything.
+	*/
+	async getQueueAdmission() {
+		const { tombstone } = await this.retentionState(this.ctx.storage);
+		return tombstone ? {
+			ok: false,
+			message: `Workflow run "${tombstone.runId}" expired at ${tombstone.expiredAt.toISOString()}`
+		} : { ok: true };
+	}
+	/**
+	* Enqueue-side admission and idempotency reservation in one transaction,
+	* for a run-scoped claim. Replaces a separate claim cell's reservation plus
+	* the run expiry check.
+	*/
+	async reserveRunQueueMessage(params) {
+		if (!validRunQueueClaimName(params?.claimName) || typeof params.messageId !== "string" || params.messageId.length === 0 || !isNonNegativeSafeInteger(params.expiresAt)) throw new TypeError("world-celld run queue reservation is invalid");
+		return await this.ctx.storage.transaction(async (txn) => {
+			const key = runQueueClaimKey(params.claimName);
+			const values = await txn.get([
+				TOMBSTONE_KEY,
+				CLEANUP_RECORD_KEY,
+				RUN_QUEUE_CLAIM_SCOPE_KEY,
+				key
+			]);
+			const tombstone = this.tombstoneFrom(values);
+			if (tombstone) return {
+				ok: false,
+				message: `Workflow run "${tombstone.runId}" expired at ${tombstone.expiredAt.toISOString()}`
+			};
+			if (values.get("queue-claim-scope") !== "run") return {
+				ok: true,
+				scope: "cell"
+			};
+			const state = values.get(key) ?? {};
+			const existing = state.reservation;
+			if (existing && existing.expiresAt > this.now() && existing.messageId !== params.messageId) return {
+				ok: true,
+				scope: "run",
+				admitted: false,
+				messageId: existing.messageId
+			};
+			await txn.put(key, {
+				...state,
+				reservation: {
+					messageId: params.messageId,
+					expiresAt: Math.max(existing?.expiresAt ?? 0, params.expiresAt)
+				}
+			});
+			return {
+				ok: true,
+				scope: "run",
+				admitted: true,
+				messageId: params.messageId
+			};
+		});
+	}
+	/** Delivery-side run expiry check and in-flight claim in one transaction. */
+	async claimRunQueueMessage(params) {
+		if (!validRunQueueClaimName(params?.claimName) || typeof params.messageId !== "string" || params.messageId.length === 0 || !isPositiveSafeInteger(params.staleMs)) throw new TypeError("world-celld run queue claim is invalid");
+		return await this.ctx.storage.transaction(async (txn) => {
+			const key = runQueueClaimKey(params.claimName);
+			const values = await txn.get([
+				TOMBSTONE_KEY,
+				CLEANUP_RECORD_KEY,
+				key
+			]);
+			if (this.tombstoneFrom(values)) return { expired: true };
+			const state = values.get(key) ?? {};
+			const existing = state.claim;
+			const now = this.now();
+			if (existing && existing.expiresAt > now) {
+				if (existing.messageId !== params.messageId) return {
+					expired: false,
+					claimed: false
+				};
+				if (existing.retryAt === void 0 || existing.retryAt > now) return {
+					expired: false,
+					claimed: false,
+					retryAt: existing.retryAt ?? existing.expiresAt
+				};
+			}
+			await txn.put(key, {
+				...state,
+				claim: {
+					messageId: params.messageId,
+					expiresAt: now + params.staleMs
+				}
+			});
+			return {
+				expired: false,
+				claimed: true
+			};
+		});
+	}
+	async holdRunQueueMessage(params) {
+		if (!validRunQueueClaimName(params?.claimName) || typeof params.messageId !== "string" || params.messageId.length === 0 || !isNonNegativeSafeInteger(params.retryAt) || !isNonNegativeSafeInteger(params.expiresAt) || params.reservationExpiresAt !== void 0 && !isNonNegativeSafeInteger(params.reservationExpiresAt)) throw new TypeError("world-celld run queue claim hold is invalid");
+		return await this.ctx.storage.transaction(async (txn) => {
+			const key = runQueueClaimKey(params.claimName);
+			const state = await txn.get(key) ?? {};
+			const existing = state.claim;
+			if (!existing || existing.messageId !== params.messageId) return { held: false };
+			const next = {
+				...state,
+				claim: {
+					...existing,
+					retryAt: params.retryAt,
+					expiresAt: Math.max(existing.expiresAt, params.expiresAt)
+				}
+			};
+			if (state.reservation?.messageId === params.messageId && params.reservationExpiresAt !== void 0 && params.reservationExpiresAt > state.reservation.expiresAt) next.reservation = {
+				...state.reservation,
+				expiresAt: params.reservationExpiresAt
+			};
+			await txn.put(key, next);
+			return { held: true };
+		});
+	}
+	async releaseRunQueueMessage(params) {
+		if (!validRunQueueClaimName(params?.claimName) || typeof params.messageId !== "string") throw new TypeError("world-celld run queue claim release is invalid");
+		await this.ctx.storage.transaction(async (txn) => {
+			const key = runQueueClaimKey(params.claimName);
+			const state = await txn.get(key);
+			if (state?.claim?.messageId !== params.messageId) return;
+			const { claim: _released, ...rest } = state;
+			if (rest.reservation) await txn.put(key, rest);
+			else await txn.delete(key);
+		});
+	}
+	async completeRunQueueMessage(params) {
+		if (!validRunQueueClaimName(params?.claimName) || typeof params.messageId !== "string") throw new TypeError("world-celld run queue completion is invalid");
+		await this.ctx.storage.transaction(async (txn) => {
+			const key = runQueueClaimKey(params.claimName);
+			const state = await txn.get(key);
+			if (!state) return;
+			const next = {};
+			if (state.reservation && state.reservation.messageId !== params.messageId) next.reservation = state.reservation;
+			if (state.claim && state.claim.messageId !== params.messageId) next.claim = state.claim;
+			if (next.reservation || next.claim) await txn.put(key, next);
+			else await txn.delete(key);
+		});
+	}
 	async registerQueuePayload(registration) {
 		if (!registration || typeof registration.messageId !== "string" || registration.messageId.length === 0 || typeof registration.key !== "string" || registration.key.length === 0 || !isNonNegativeSafeInteger(registration.orphanExpiresAt)) throw new TypeError("world-celld queue payload registration is invalid");
 		return await this.ctx.storage.transaction(async (txn) => {