@ewhauser/world-celld 0.4.1 → 0.6.0

package/dist/testing.js

@@ -1,6 +1,5 @@
-import { B as validateStreamReadRequest, C as queueDelayDeadline, E as MAX_STREAM_CHUNK_BYTES, I as encodeStreamReadResult, M as STREAM_BATCH_CONTENT_TYPE, O as MAX_STREAM_LONG_POLL_MS, P as decodeStreamWriteBatch, R as encodeStreamWriteResult, S as isValidQueueDelaySeconds, T as MAX_STREAM_BATCH_BYTES, V as validateStreamWriteChunks, _ as boundedIntegerOption, b as isPositiveSafeInteger, c as HOOK_CLAIM_LEASE_MS, d as MAX_QUEUE_DELIVERY_TIMEOUT_MS, f as MAX_QUEUE_DERIVED_DEADLINE_HEADROOM_MS, h as QUEUE_INFLIGHT_GRACE_MS, i as parse, k as MAX_STREAM_READ_BYTES, l as LIFECYCLE_COMPACTION_RETRY_MS, m as QUEUE_FENCE_GRACE_MS, n as rpcParse, o as createWorkflowIndex, p as MAX_RUN_INDEX_PUBLICATION_LIFETIME_MS, r as rpcStringify, t as compact, v as checkedQueueTimestampAdd, w as strictIntegerSetting, x as isRecord$1, y as isNonNegativeSafeInteger, z as normalizeStreamError } from "./util-Cu09mVzK.js";
-import { CreateEventSchema, EventSchema, HookSchema, QueuePayloadSchema, SPEC_VERSION_CURRENT, StepSchema, WaitSchema, WorkflowRunSchema, applyAttributeChanges, eventIdToSlot, getMaxEventsPerRun, isChildEntityCreationEvent, isTerminalStepStatus, isTerminalWorkflowRunStatus, slotToEventId, validateAttributeChanges } from "@workflow/world";
-import { WorkflowWorldError } from "@workflow/errors";
+import { A as MAX_STREAM_BATCH_BYTES, D as isRecord$1, E as isPositiveSafeInteger, G as validateStreamReadRequest, K as validateStreamWriteChunks, L as STREAM_BATCH_CONTENT_TYPE, N as MAX_STREAM_LONG_POLL_MS, P as MAX_STREAM_READ_BYTES, S as MAX_RUN_INDEX_PUBLICATION_LIFETIME_MS, T as isNonNegativeSafeInteger, U as encodeStreamWriteResult, V as encodeStreamReadResult, W as normalizeStreamError, _ as HOOK_CLAIM_LEASE_MS, a as queueOrphanName, c as validateNativeQueueEnvelope, d as rpcParse, f as rpcStringify, h as createWorkflowIndex, i as queueClaimName, j as MAX_STREAM_CHUNK_BYTES, l as validateNativeQueueSendOptions, n as QUEUE_PAYLOAD_REGISTRY_PREFIX, o as queuePayloadObjectKey, p as parse, s as queuePayloadRegistryKey, t as NATIVE_QUEUE_MAX_MESSAGE_BYTES, u as compact, v as LIFECYCLE_COMPACTION_RETRY_MS, z as decodeStreamWriteBatch } from "./queue-protocol-CmJNMH_5.js";
+import { CreateEventSchema, EventSchema, HookSchema, SPEC_VERSION_CURRENT, StepSchema, WaitSchema, WorkflowRunSchema, applyAttributeChanges, eventIdToSlot, getMaxEventsPerRun, isChildEntityCreationEvent, isTerminalStepStatus, isTerminalWorkflowRunStatus, slotToEventId, validateAttributeChanges } from "@workflow/world";
 import http from "node:http";
 //#region src/testing/fake-cell.ts
 function applyListOptions(keys, options) {
@@ -458,13 +457,13 @@ const HOOK_CLAIM_CANCELLATION_PREFIX = "hookclaimcancelled:";
 const ATTRIBUTE_EVENT_MARKER_PREFIX = "attrevent:";
 /** Durable lazy-hook resume claims, scoped by the containing run DO. */
 const HOOK_RESUME_CLAIM_PREFIX = "hookresume:";
-const STORAGE_BATCH_SIZE$2 = 128;
+const STORAGE_BATCH_SIZE$1 = 128;
 const MAX_ENTITY_PAGE_SIZE = 1e3;
-async function getMany$1(store, keys) {
+async function getMany(store, keys) {
 	if (store.getMany) {
 		const result = /* @__PURE__ */ new Map();
-		for (let offset = 0; offset < keys.length; offset += STORAGE_BATCH_SIZE$2) {
-			const page = await store.getMany(keys.slice(offset, offset + STORAGE_BATCH_SIZE$2));
+		for (let offset = 0; offset < keys.length; offset += STORAGE_BATCH_SIZE$1) {
+			const page = await store.getMany(keys.slice(offset, offset + STORAGE_BATCH_SIZE$1));
 			for (const entry of page) result.set(...entry);
 		}
 		return result;
@@ -472,10 +471,10 @@ async function getMany$1(store, keys) {
 	const values = await Promise.all(keys.map((key) => store.get(key)));
 	return new Map(keys.flatMap((key, index) => values[index] === void 0 ? [] : [[key, values[index]]]));
 }
-async function deleteMany$1(store, keys) {
+async function deleteMany(store, keys) {
 	if (store.deleteMany) {
 		let deleted = 0;
-		for (let offset = 0; offset < keys.length; offset += STORAGE_BATCH_SIZE$2) deleted += await store.deleteMany(keys.slice(offset, offset + STORAGE_BATCH_SIZE$2));
+		for (let offset = 0; offset < keys.length; offset += STORAGE_BATCH_SIZE$1) deleted += await store.deleteMany(keys.slice(offset, offset + STORAGE_BATCH_SIZE$1));
 		return deleted;
 	}
 	return (await Promise.all(keys.map((key) => store.delete(key)))).filter(Boolean).length;
@@ -604,7 +603,7 @@ async function listByCreationTime(store, indexPrefix, entityPrefix, params) {
 	});
 	const page = Array.from(entries.entries()).slice(0, limit);
 	const entityKeys = page.map(([, id]) => `${entityPrefix}${id}`);
-	const entities = await getMany$1(store, entityKeys);
+	const entities = await getMany(store, entityKeys);
 	const data = entityKeys.flatMap((key) => {
 		const item = entities.get(key);
 		return item === void 0 ? [] : [item];
@@ -631,14 +630,14 @@ async function releaseAllHooks(store) {
 			token: hook.token
 		});
 	}
-	await deleteMany$1(store, keys);
+	await deleteMany(store, keys);
 	return released;
 }
 /** Delete all persisted waits once their owning run becomes terminal. */
 async function releaseAllWaits(store) {
 	if (store.deferTerminalCleanup) return;
 	const waits = await store.list({ prefix: WAIT_KEY_PREFIX });
-	await deleteMany$1(store, Array.from(waits.keys()));
+	await deleteMany(store, Array.from(waits.keys()));
 }
 async function applyEvent(store, ctx) {
 	const { runId, data, now } = ctx;
@@ -1580,24 +1579,12 @@ const BINDINGS = {
 	"hook-ids": {
 		env: "WORKFLOW_HOOK_IDS",
 		methods: /* @__PURE__ */ new Set(["get"])
-	},
-	queue: {
-		env: "WORKFLOW_QUEUE",
-		methods: /* @__PURE__ */ new Set([
-			"enqueue",
-			"stats",
-			"listDeadLetters",
-			"redriveDeadLetter",
-			"purgeDeadLetters",
-			"rearmAlarm",
-			"expireRun",
-			"acknowledgeExpireRun"
-		])
 	}
 };
 /** Request body cap: oversize payloads get a clear 413 instead of an OOM. */
 const MAX_BODY_BYTES = 33554432;
 const MAX_STREAM_WRITE_BODY_BYTES = MAX_STREAM_BATCH_BYTES + 1024;
+const QUEUE_ORPHAN_GRACE_MS = 432e6;
 function errorResponse(status, name, message) {
 	return Response.json({ error: {
 		name,
@@ -1681,6 +1668,25 @@ async function readBoundedBytes(request, maxBytes) {
 	}
 	return body;
 }
+async function parseRpcArguments(request) {
+	if (request.method !== "POST") return errorResponse(405, "MethodNotAllowed", "expected POST");
+	if (!hasContentType(request, "application/json")) return errorResponse(415, "UnsupportedMediaType", "expected application/json");
+	let contentLength;
+	try {
+		contentLength = declaredContentLength(request);
+	} catch (error) {
+		return errorResponse(400, "BadRequest", error.message);
+	}
+	if (contentLength !== null && contentLength > MAX_BODY_BYTES) return errorResponse(413, "PayloadTooLarge", `body exceeds ${MAX_BODY_BYTES} bytes`);
+	try {
+		const text = await readBoundedBody(request);
+		if (text === null) return errorResponse(413, "PayloadTooLarge", `body exceeds ${MAX_BODY_BYTES} bytes`);
+		const parsed = rpcParse(text);
+		return Array.isArray(parsed) ? parsed : errorResponse(400, "BadRequest", "body must be an argument array");
+	} catch {
+		return errorResponse(400, "BadRequest", "malformed rpc body");
+	}
+}
 function parseBoundedInteger(url, name, minimum, maximum) {
 	const raw = url.searchParams.get(name);
 	const value = raw !== null && /^\d+$/.test(raw) ? Number(raw) : NaN;
@@ -1713,6 +1719,111 @@ function createRouter(env) {
 		}
 		const auth = await authenticate(request, env.WORLD_SECRET);
 		if (!auth.ok) return auth.response;
+		if (parts[1] === "queue" && parts.length === 3) {
+			const parsed = await parseRpcArguments(request);
+			if (parsed instanceof Response) return parsed;
+			if (parts[2] === "send") {
+				if (parsed.length < 1 || parsed.length > 2) return errorResponse(400, "BadRequest", "queue send expects an envelope and options");
+				if (!env.WORKFLOW_QUEUE) return errorResponse(500, "WorldMisconfigured", "missing binding: WORKFLOW_QUEUE");
+				let envelope;
+				let options;
+				try {
+					envelope = validateNativeQueueEnvelope(parsed[0]);
+					options = validateNativeQueueSendOptions(parsed[1]);
+					if (envelope.body === void 0 || envelope.payloadKey !== void 0) throw new TypeError("queue send requires an inline body");
+				} catch (error) {
+					return errorResponse(400, "BadRequest", error.message);
+				}
+				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 ? {
+						...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 now = Date.now();
+					const reservationExpiresAt = Math.max(now, envelope.notBefore ?? now) + QUEUE_ORPHAN_GRACE_MS;
+					let claim;
+					if (envelope.idempotencyKey) {
+						claim = namespace.get(namespace.idFromName(queueClaimName(envelope.queueName, envelope.idempotencyKey)));
+						const reservation = await claim.reserveQueueMessage({
+							messageId: envelope.messageId,
+							expiresAt: reservationExpiresAt
+						});
+						if (!reservation.admitted) return new Response(rpcStringify({ messageId: reservation.messageId }), {
+							status: 200,
+							headers: { "content-type": "application/json" }
+						});
+					}
+					if (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,
+							key: payloadKey,
+							orphanExpiresAt
+						});
+						if (!registered.ok) {
+							await claim?.completeQueueMessage(envelope.messageId);
+							return errorResponse(410, "RunExpiredError", registered.message);
+						}
+						const orphan = namespace.get(namespace.idFromName(queueOrphanName(envelope.messageId)));
+						try {
+							await orphan.scheduleQueuePayloadOrphan({
+								messageId: envelope.messageId,
+								runId: envelope.runId,
+								key: payloadKey,
+								expiresAt: orphanExpiresAt
+							});
+						} catch (error) {
+							await run.unregisterQueuePayload(envelope.messageId);
+							await claim?.completeQueueMessage(envelope.messageId);
+							throw error;
+						}
+						try {
+							await payloadStore.write(payloadKey, envelope.body, {
+								runId: envelope.runId,
+								messageId: envelope.messageId
+							});
+						} catch (error) {
+							await claim?.completeQueueMessage(envelope.messageId);
+							throw error;
+						}
+						let finalized;
+						try {
+							finalized = await run.finalizeQueuePayload(envelope.messageId);
+						} catch (error) {
+							await claim?.completeQueueMessage(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);
+							return errorResponse(410, "RunExpiredError", finalized.message);
+						}
+					}
+					await env.WORKFLOW_QUEUE.send(encoded, {
+						contentType: "text",
+						...options
+					});
+					return new Response(rpcStringify({ messageId: envelope.messageId }), {
+						status: 200,
+						headers: { "content-type": "application/json" }
+					});
+				} catch (error) {
+					const err = error;
+					return errorResponse(500, err.name ?? "Error", err.message ?? String(error));
+				}
+			}
+			return errorResponse(404, "NotFound", `unknown queue operation: ${parts[2]}`);
+		}
 		if (parts[1] === "index" && parts.length === 4) {
 			if (request.method !== "POST") return errorResponse(405, "MethodNotAllowed", "expected POST");
 			if (!hasContentType(request, "application/json")) return errorResponse(415, "UnsupportedMediaType", "expected application/json");
@@ -1930,7 +2041,7 @@ async function runIsActive(env, runId) {
 //#region src/worker/durable-objects/HookIdDO.ts
 const MAX_RELEASE_BATCH$1 = 64;
 const CLAIM_DEADLINE_PREFIX$1 = "claim-deadline:";
-function pad$3(ms) {
+function pad$2(ms) {
 	return String(Math.max(0, Math.floor(ms))).padStart(13, "0");
 }
 function recordKey$1(hookId) {
@@ -1940,7 +2051,7 @@ function claimKey$1(hookId) {
 	return indexKey("claim", hookId);
 }
 function claimDeadlineKey$1(hookId, expiresAt) {
-	return `${CLAIM_DEADLINE_PREFIX$1}${pad$3(expiresAt)}:${encodeURIComponent(hookId)}`;
+	return `${CLAIM_DEADLINE_PREFIX$1}${pad$2(expiresAt)}:${encodeURIComponent(hookId)}`;
 }
 /** Hook-ID ownership and lookup shard; every hook ID has one transaction domain. */
 var HookIdDO = class extends DurableObject {
@@ -2074,7 +2185,7 @@ var HookIdDO = class extends DurableObject {
 		await this.ctx.storage.transaction(async (txn) => {
 			const due = await txn.list({
 				prefix: CLAIM_DEADLINE_PREFIX$1,
-				end: `${CLAIM_DEADLINE_PREFIX$1}${pad$3(now + 1)}`,
+				end: `${CLAIM_DEADLINE_PREFIX$1}${pad$2(now + 1)}`,
 				limit: 129
 			});
 			const page = Array.from(due).slice(0, 128);
@@ -2102,7 +2213,7 @@ var HookIdDO = class extends DurableObject {
 //#region src/worker/durable-objects/HookTokenDO.ts
 const MAX_RELEASE_BATCH = 64;
 const CLAIM_DEADLINE_PREFIX = "claim-deadline:";
-function pad$2(ms) {
+function pad$1(ms) {
 	return String(Math.max(0, Math.floor(ms))).padStart(13, "0");
 }
 function recordKey(token) {
@@ -2112,7 +2223,7 @@ function claimKey(token) {
 	return indexKey("claim", token);
 }
 function claimDeadlineKey(token, expiresAt) {
-	return `${CLAIM_DEADLINE_PREFIX}${pad$2(expiresAt)}:${encodeURIComponent(token)}`;
+	return `${CLAIM_DEADLINE_PREFIX}${pad$1(expiresAt)}:${encodeURIComponent(token)}`;
 }
 /** Token-ownership shard. A token hashes to exactly one shard and transaction domain. */
 var HookTokenDO = class extends DurableObject {
@@ -2245,7 +2356,7 @@ var HookTokenDO = class extends DurableObject {
 		await this.ctx.storage.transaction(async (txn) => {
 			const due = await txn.list({
 				prefix: CLAIM_DEADLINE_PREFIX,
-				end: `${CLAIM_DEADLINE_PREFIX}${pad$2(now + 1)}`,
+				end: `${CLAIM_DEADLINE_PREFIX}${pad$1(now + 1)}`,
 				limit: 129
 			});
 			const page = Array.from(due).slice(0, 128);
@@ -2270,705 +2381,6 @@ var HookTokenDO = class extends DurableObject {
 	}
 };
 //#endregion
-//#region src/worker/durable-objects/QueueDO.ts
-const PERMANENT_STATUSES = /* @__PURE__ */ new Set([
-	404,
-	409,
-	410,
-	422
-]);
-const DEFAULT_MAX_ATTEMPTS = 5;
-const DEFAULT_MAX_INFLIGHT = 5;
-const DEFAULT_DELIVERY_TIMEOUT_MS = 3e5;
-/** Move overdue alarms to a new timestamp so celld observes a fresh edge. */
-const MIN_ALARM_DELAY_MS = 1;
-/** Bound expiry recovery so one alarm cannot monopolize the cell. */
-const EXPIRED_INFLIGHT_BATCH = 128;
-const STORAGE_BATCH_SIZE$1 = 128;
-const EXPIRE_RUN_REFERENCE_BATCH = 64;
-const PURGE_DEAD_LETTER_BATCH = 128;
-const MAX_DEAD_LETTER_LIST_SIZE = 1e3;
-const INFLIGHT_DEADLINE_PREFIX = "inflight-deadline:";
-const EXPIRED_RUN_GC_PREFIX = "expired-run-gc:";
-function pad$1(ms) {
-	if (!isNonNegativeSafeInteger(ms) || ms > 9999999999999) throw new Error("queue timestamp must be a non-negative 13-digit integer");
-	return String(ms).padStart(13, "0");
-}
-function dueKey(atMs, messageId) {
-	return `due:${pad$1(atMs)}:${messageId}`;
-}
-function inflightKey(deadlineMs, messageId) {
-	return `${INFLIGHT_DEADLINE_PREFIX}${pad$1(deadlineMs)}:${messageId}`;
-}
-function deadlineFromInflightKey(key) {
-	return Number.parseInt(key.slice(18, 31), 10);
-}
-function inclusiveTimestampEnd(prefix, now) {
-	return now >= 9999999999999 ? `${prefix.slice(0, -1)};` : `${prefix}${pad$1(now + 1)}`;
-}
-function runReferenceKey(runId, messageId) {
-	return `run:${runId}:${messageId}`;
-}
-function expiredRunKey(runId) {
-	return `expired-run:${runId}`;
-}
-function expiredRunGcKey(runId, compactAt) {
-	return `${EXPIRED_RUN_GC_PREFIX}${pad$1(compactAt)}:${encodeURIComponent(runId)}`;
-}
-function validateEnqueueRequest(request) {
-	if (!isRecord$1(request)) throw new Error("world-celld queue enqueue request must be an object");
-	for (const field of [
-		"messageId",
-		"queueName",
-		"body"
-	]) if (typeof request[field] !== "string" || request[field].length === 0) throw new Error(`world-celld queue enqueue ${field} must be a non-empty string`);
-	if (request.pathname !== "flow") throw new Error("world-celld queue enqueue pathname must be flow");
-	if (!isRecord$1(request.config) || typeof request.config.targetBaseUrl !== "string" || request.config.targetBaseUrl.length === 0) throw new Error("world-celld queue enqueue config is invalid");
-	if (!isPositiveSafeInteger(request.config.queueShards)) throw new Error("world-celld queue enqueue queueShards must be a positive safe integer");
-	if (request.delaySeconds !== void 0 && !isValidQueueDelaySeconds(request.delaySeconds)) throw new Error("world-celld queue enqueue delaySeconds is out of range");
-	if (request.runId !== void 0 && (typeof request.runId !== "string" || request.runId.length === 0)) throw new Error("world-celld queue enqueue runId must be a non-empty string");
-	if (request.idempotencyKey !== void 0 && (typeof request.idempotencyKey !== "string" || request.idempotencyKey.length === 0)) throw new Error("world-celld queue enqueue idempotencyKey must be a non-empty string");
-	let body;
-	try {
-		body = parse(request.body);
-	} catch {
-		throw new WorkflowWorldError("world-celld queue enqueue body must be valid tagged JSON", { status: 422 });
-	}
-	const payload = QueuePayloadSchema.safeParse(body);
-	if (!payload.success) throw new WorkflowWorldError("world-celld queue enqueue body is an invalid queue payload", { status: 422 });
-	const payloadRunId = "runId" in payload.data && typeof payload.data.runId === "string" ? payload.data.runId : void 0;
-	if (request.runId !== payloadRunId) throw new WorkflowWorldError("world-celld queue enqueue runId does not match body", { status: 422 });
-}
-async function getMany(storage, keys) {
-	const result = /* @__PURE__ */ new Map();
-	for (let offset = 0; offset < keys.length; offset += STORAGE_BATCH_SIZE$1) {
-		const page = await storage.get(keys.slice(offset, offset + STORAGE_BATCH_SIZE$1));
-		for (const [key, value] of page) result.set(key, value);
-	}
-	return result;
-}
-async function putMany(storage, entries) {
-	const all = Array.from(entries);
-	for (let offset = 0; offset < all.length; offset += STORAGE_BATCH_SIZE$1) await storage.put(Object.fromEntries(all.slice(offset, offset + STORAGE_BATCH_SIZE$1)));
-}
-async function deleteMany(storage, keys) {
-	let deleted = 0;
-	const unique = Array.from(new Set(keys));
-	for (let offset = 0; offset < unique.length; offset += STORAGE_BATCH_SIZE$1) deleted += await storage.delete(unique.slice(offset, offset + STORAGE_BATCH_SIZE$1));
-	return deleted;
-}
-function backoffSeconds(attempt) {
-	return Math.min(60, 2 ** attempt);
-}
-async function cancelUnusedResponseBody(response) {
-	try {
-		await response.body?.cancel();
-	} catch {}
-}
-const MAX_QUEUE_INFLIGHT = 128;
-var QueueDO = class extends DurableObject {
-	#now() {
-		const clock = this.env?.clock;
-		return typeof clock === "function" ? clock() : Date.now();
-	}
-	#fetch() {
-		const impl = this.env?.fetch;
-		return typeof impl === "function" ? impl : fetch;
-	}
-	#intVar(name, fallback) {
-		const raw = this.env?.[name];
-		return strictIntegerSetting(name, raw, fallback, 1);
-	}
-	#maxAttempts() {
-		return this.#intVar("QUEUE_MAX_ATTEMPTS", DEFAULT_MAX_ATTEMPTS);
-	}
-	#maxInflight() {
-		const configured = this.#intVar("QUEUE_MAX_INFLIGHT", DEFAULT_MAX_INFLIGHT);
-		if (configured > MAX_QUEUE_INFLIGHT) throw new Error(`QUEUE_MAX_INFLIGHT must be at most ${MAX_QUEUE_INFLIGHT}`);
-		return configured;
-	}
-	#deliveryTimeoutMs() {
-		const configured = this.#intVar("QUEUE_DELIVERY_TIMEOUT_MS", DEFAULT_DELIVERY_TIMEOUT_MS);
-		if (configured > 3e5) throw new Error(`QUEUE_DELIVERY_TIMEOUT_MS must be at most ${MAX_QUEUE_DELIVERY_TIMEOUT_MS}`);
-		return configured;
-	}
-	#validateRuntimeConfig() {
-		this.#maxAttempts();
-		this.#maxInflight();
-		this.#deliveryTimeoutMs();
-	}
-	async #authoritativeRunExpired(runId) {
-		const namespace = this.env?.WORKFLOW_DB;
-		if (!namespace) throw new Error("world-celld queue missing WORKFLOW_DB binding");
-		return await namespace.get(namespace.idFromName(runId)).getLifecycleStatus() === "expired";
-	}
-	async #withRunMutation(runId, onExpired, onAllowed) {
-		const expired = await this.#authoritativeRunExpired(runId);
-		return await this.ctx.storage.transaction(async (txn) => {
-			if (await txn.get(expiredRunKey(runId)) || expired) return await onExpired(txn);
-			return await onAllowed(txn);
-		});
-	}
-	async enqueue(request) {
-		this.#validateRuntimeConfig();
-		validateEnqueueRequest(request);
-		const storage = this.ctx.storage;
-		const now = this.#now();
-		const dueAt = queueDelayDeadline(now, request.delaySeconds ?? 0, 0, MAX_QUEUE_DERIVED_DEADLINE_HEADROOM_MS);
-		if (dueAt === null) throw new Error("world-celld queue enqueue delaySeconds lacks required delivery headroom");
-		const persist = async (txn) => {
-			const pinned = await txn.get("cfg");
-			if (!pinned) await txn.put("cfg", {
-				queueShards: request.config.queueShards,
-				pinnedAt: now
-			});
-			else if (pinned.queueShards !== request.config.queueShards) return {
-				ok: false,
-				code: "CONFIG_MISMATCH",
-				message: `queue cell shard-count mismatch: pinned ${pinned.queueShards}, got ${request.config.queueShards} — changing queueShards requires draining the fleet`
-			};
-			if (request.idempotencyKey) {
-				const existing = await txn.get(`key:${request.idempotencyKey}`);
-				if (existing) {
-					if (await txn.get(`msg:${existing}`)) {
-						await this.#scheduleNextAlarm(txn, now);
-						return {
-							ok: true,
-							messageId: existing,
-							deduped: true
-						};
-					}
-					await txn.delete(`key:${request.idempotencyKey}`);
-				}
-				await txn.put(`key:${request.idempotencyKey}`, request.messageId);
-			}
-			const row = {
-				messageId: request.messageId,
-				queueName: request.queueName,
-				pathname: request.pathname,
-				body: request.body,
-				runId: request.runId,
-				targetBaseUrl: request.config.targetBaseUrl,
-				idempotencyKey: request.idempotencyKey,
-				attempt: 0,
-				enqueuedAt: now
-			};
-			const scheduleKey = dueKey(dueAt, row.messageId);
-			await txn.put(`msg:${row.messageId}`, row);
-			await txn.put(scheduleKey, row.messageId);
-			if (row.runId) await txn.put(runReferenceKey(row.runId, row.messageId), {
-				messageId: row.messageId,
-				dueKey: scheduleKey,
-				idempotencyKey: row.idempotencyKey
-			});
-			await this.#armAlarmAtMost(txn, dueAt, now);
-			return {
-				ok: true,
-				messageId: row.messageId,
-				deduped: false
-			};
-		};
-		return request.runId ? await this.#withRunMutation(request.runId, async () => ({
-			ok: false,
-			code: "RUN_EXPIRED",
-			message: `Workflow run "${request.runId}" has expired`
-		}), persist) : await storage.transaction(persist);
-	}
-	async alarm() {
-		this.#validateRuntimeConfig();
-		let claimed = [];
-		let failure = null;
-		const attempt = async () => {
-			try {
-				claimed = await this.#claimPhase();
-			} catch (error) {
-				failure = error;
-			}
-		};
-		if (typeof this.ctx.blockConcurrencyWhile === "function") await this.ctx.blockConcurrencyWhile(attempt);
-		else await attempt();
-		if (failure !== null) {
-			const retryAt = checkedQueueTimestampAdd(this.#now(), LIFECYCLE_COMPACTION_RETRY_MS);
-			if (retryAt === null) await this.ctx.storage.deleteAlarm();
-			else await this.ctx.storage.setAlarm(retryAt);
-			throw failure;
-		}
-		for (const claim of claimed) this.ctx.waitUntil(this.#deliver(claim));
-	}
-	/**
-	* Storage-only: recover lost inflight claims, claim due messages up to the
-	* inflight cap, and re-arm the alarm. Never throws for data conditions.
-	*/
-	async #claimPhase() {
-		const storage = this.ctx.storage;
-		const now = this.#now();
-		const maxInflight = this.#maxInflight();
-		return await storage.transaction(async (txn) => {
-			if (await this.#compactExpiredRunFences(txn, now)) {
-				const nextAt = checkedQueueTimestampAdd(now, MIN_ALARM_DELAY_MS);
-				if (nextAt === null) await txn.deleteAlarm();
-				else await txn.setAlarm(nextAt);
-				return [];
-			}
-			const expiredPage = await txn.list({
-				prefix: INFLIGHT_DEADLINE_PREFIX,
-				end: inclusiveTimestampEnd(INFLIGHT_DEADLINE_PREFIX, now),
-				limit: 129
-			});
-			const expired = Array.from(expiredPage.entries()).slice(0, EXPIRED_INFLIGHT_BATCH);
-			const expiredRows = await getMany(txn, expired.map(([, messageId]) => `msg:${messageId}`));
-			await deleteMany(txn, expired.map(([key]) => key));
-			const recoveryWrites = [];
-			for (const [, messageId] of expired) {
-				const row = expiredRows.get(`msg:${messageId}`);
-				if (row) {
-					const recoveryAt = checkedQueueTimestampAdd(now, 0, MAX_QUEUE_DERIVED_DEADLINE_HEADROOM_MS);
-					if (recoveryAt === null) {
-						await this.#deadLetter(txn, row, row.attempt, "inflight recovery exceeded the queue timestamp horizon", now);
-						continue;
-					}
-					const scheduleKey = dueKey(recoveryAt, messageId);
-					recoveryWrites.push([scheduleKey, messageId]);
-					if (row.runId) recoveryWrites.push([runReferenceKey(row.runId, row.messageId), {
-						messageId: row.messageId,
-						dueKey: scheduleKey,
-						idempotencyKey: row.idempotencyKey
-					}]);
-				}
-			}
-			await putMany(txn, recoveryWrites);
-			if (expiredPage.size > EXPIRED_INFLIGHT_BATCH) {
-				const nextAt = checkedQueueTimestampAdd(now, MIN_ALARM_DELAY_MS);
-				if (nextAt === null) await txn.deleteAlarm();
-				else await txn.setAlarm(nextAt);
-				return [];
-			}
-			const inflightCount = (await txn.list({
-				prefix: INFLIGHT_DEADLINE_PREFIX,
-				limit: maxInflight
-			})).size;
-			const rows = [];
-			if (inflightCount < maxInflight) {
-				const due = await txn.list({
-					prefix: "due:",
-					end: inclusiveTimestampEnd("due:", now),
-					limit: maxInflight - inflightCount
-				});
-				const timeoutMs = this.#deliveryTimeoutMs();
-				const dueRows = await getMany(txn, Array.from(due.values(), (messageId) => `msg:${messageId}`));
-				await deleteMany(txn, Array.from(due.keys()));
-				const claimWrites = [];
-				for (const [, messageId] of due) {
-					const row = dueRows.get(`msg:${messageId}`);
-					if (!row) continue;
-					const claimDeadline = checkedQueueTimestampAdd(now, timeoutMs + QUEUE_INFLIGHT_GRACE_MS);
-					if (claimDeadline === null) {
-						await this.#deadLetter(txn, row, row.attempt, "delivery lease exceeded the queue timestamp horizon", now);
-						continue;
-					}
-					const claimKey = inflightKey(claimDeadline, messageId);
-					claimWrites.push([claimKey, messageId]);
-					if (row.runId) claimWrites.push([runReferenceKey(row.runId, row.messageId), {
-						messageId: row.messageId,
-						inflightKey: claimKey,
-						idempotencyKey: row.idempotencyKey
-					}]);
-					rows.push({
-						row,
-						inflightKey: claimKey
-					});
-				}
-				await putMany(txn, claimWrites);
-			}
-			await this.#scheduleNextAlarm(txn, now);
-			return rows;
-		});
-	}
-	async #deliver({ row, inflightKey: claimKey }) {
-		const storage = this.ctx.storage;
-		const timeoutMs = this.#deliveryTimeoutMs();
-		const callbackSecret = this.env?.WORKFLOW_CALLBACK_SECRET;
-		const url = `${row.targetBaseUrl.replace(/\/$/, "")}/.well-known/workflow/v1/${row.pathname}`;
-		if (row.runId && await this.#authoritativeRunExpired(row.runId)) {
-			await storage.transaction((txn) => this.#dropExpiredMessage(txn, row, claimKey, this.#now()));
-			return;
-		}
-		let response = null;
-		let transportError = null;
-		try {
-			response = await this.#fetch()(url, {
-				method: "POST",
-				headers: {
-					"content-type": "application/json",
-					"x-vqs-queue-name": row.queueName,
-					"x-vqs-message-id": row.messageId,
-					"x-vqs-message-attempt": String(row.attempt + 1),
-					...callbackSecret ? { "x-workflow-callback-secret": callbackSecret } : {}
-				},
-				body: row.body,
-				signal: AbortSignal.timeout(timeoutMs)
-			});
-		} catch (error) {
-			transportError = error;
-		}
-		const now = this.#now();
-		if (response?.ok) {
-			await cancelUnusedResponseBody(response);
-			await this.#ack(row, claimKey);
-		} else if (response && response.status === 503) {
-			let timeoutSeconds;
-			try {
-				timeoutSeconds = (await response.json())?.timeoutSeconds;
-			} catch {
-				timeoutSeconds = void 0;
-			}
-			const redeliveryAt = queueDelayDeadline(now, timeoutSeconds, 1, MAX_QUEUE_DERIVED_DEADLINE_HEADROOM_MS);
-			if (redeliveryAt !== null) {
-				const reschedule = async (txn) => {
-					if (!await txn.delete(claimKey)) return;
-					const scheduleKey = dueKey(redeliveryAt, row.messageId);
-					await txn.put(scheduleKey, row.messageId);
-					if (row.runId) await txn.put(runReferenceKey(row.runId, row.messageId), {
-						messageId: row.messageId,
-						dueKey: scheduleKey,
-						idempotencyKey: row.idempotencyKey
-					});
-					await this.#scheduleNextAlarm(txn, now);
-				};
-				if (row.runId) await this.#withRunMutation(row.runId, (txn) => this.#dropExpiredMessage(txn, row, claimKey, now), reschedule);
-				else await storage.transaction(reschedule);
-			} else await this.#retry(row, claimKey, "HTTP 503");
-		} else if (response && PERMANENT_STATUSES.has(response.status)) {
-			await cancelUnusedResponseBody(response);
-			await this.#ack(row, claimKey);
-		} else {
-			const reason = response ? `HTTP ${response.status}` : `transport error: ${String(transportError)}`;
-			if (response) await cancelUnusedResponseBody(response);
-			await this.#retry(row, claimKey, reason);
-		}
-	}
-	async #ack(row, claimKey) {
-		await this.ctx.storage.transaction(async (txn) => {
-			if (!await txn.delete(claimKey)) return;
-			await txn.delete(`msg:${row.messageId}`);
-			if (row.idempotencyKey) {
-				if (await txn.get(`key:${row.idempotencyKey}`) === row.messageId) await txn.delete(`key:${row.idempotencyKey}`);
-			}
-			if (row.runId) await txn.delete(runReferenceKey(row.runId, row.messageId));
-			await this.#scheduleNextAlarm(txn, this.#now());
-		});
-	}
-	async #dropExpiredMessage(txn, row, claimKey, now) {
-		if (!await txn.delete(claimKey)) return;
-		await txn.delete(`msg:${row.messageId}`);
-		if (row.runId) await txn.delete(runReferenceKey(row.runId, row.messageId));
-		if (row.idempotencyKey) {
-			const dedupKey = `key:${row.idempotencyKey}`;
-			if (await txn.get(dedupKey) === row.messageId) await txn.delete(dedupKey);
-		}
-		await this.#scheduleNextAlarm(txn, now);
-	}
-	async #retry(row, claimKey, reason) {
-		const storage = this.ctx.storage;
-		const now = this.#now();
-		const maxAttempts = this.#maxAttempts();
-		const attempt = row.attempt + 1;
-		const retryAt = checkedQueueTimestampAdd(now, backoffSeconds(attempt) * 1e3, MAX_QUEUE_DERIVED_DEADLINE_HEADROOM_MS);
-		const persistRetry = async (txn) => {
-			if (!await txn.delete(claimKey)) return;
-			if (attempt >= maxAttempts || retryAt === null) {
-				await this.#deadLetter(txn, row, attempt, retryAt === null ? `${reason}; retry exceeded the queue timestamp horizon` : reason, now);
-				await this.#scheduleNextAlarm(txn, now);
-				return;
-			}
-			const updated = {
-				...row,
-				attempt,
-				lastError: reason
-			};
-			const scheduleKey = dueKey(retryAt, row.messageId);
-			await txn.put(`msg:${row.messageId}`, updated);
-			await txn.put(scheduleKey, row.messageId);
-			if (row.runId) await txn.put(runReferenceKey(row.runId, row.messageId), {
-				messageId: row.messageId,
-				dueKey: scheduleKey,
-				idempotencyKey: row.idempotencyKey
-			});
-			await this.#scheduleNextAlarm(txn, now);
-		};
-		if (row.runId) await this.#withRunMutation(row.runId, (txn) => this.#dropExpiredMessage(txn, row, claimKey, now), persistRetry);
-		else await storage.transaction(persistRetry);
-	}
-	async #deadLetter(txn, row, attempt, reason, now) {
-		const failedAt = checkedQueueTimestampAdd(now, 0);
-		await txn.delete(`msg:${row.messageId}`);
-		if (row.idempotencyKey) {
-			if (await txn.get(`key:${row.idempotencyKey}`) === row.messageId) await txn.delete(`key:${row.idempotencyKey}`);
-		}
-		if (failedAt === null) {
-			if (row.runId) await txn.delete(runReferenceKey(row.runId, row.messageId));
-			return;
-		}
-		const dead = {
-			...row,
-			attempt,
-			lastError: reason,
-			failedAt
-		};
-		const deadKey = `dlq:${pad$1(failedAt)}:${row.messageId}`;
-		await txn.put(deadKey, dead);
-		if (row.runId) await txn.put(runReferenceKey(row.runId, row.messageId), {
-			messageId: row.messageId,
-			dlqKey: deadKey,
-			idempotencyKey: row.idempotencyKey
-		});
-	}
-	/** Return true when another due compaction page must run immediately. */
-	async #compactExpiredRunFences(txn, now) {
-		const due = await txn.list({
-			prefix: EXPIRED_RUN_GC_PREFIX,
-			end: inclusiveTimestampEnd(EXPIRED_RUN_GC_PREFIX, now),
-			limit: 129
-		});
-		const page = Array.from(due).slice(0, 128);
-		if (page.length === 0) return false;
-		const markerKeys = page.map(([, item]) => expiredRunKey(item.runId));
-		const markers = await getMany(txn, markerKeys);
-		const deletes = [];
-		for (let index = 0; index < page.length; index++) {
-			const [gcKey, item] = page[index];
-			const markerKey = markerKeys[index];
-			const marker = markers.get(markerKey);
-			deletes.push(gcKey);
-			if (marker?.compactAt !== item.compactAt) continue;
-			deletes.push(markerKey);
-		}
-		await deleteMany(txn, deletes);
-		return due.size > 128;
-	}
-	/** Arm the alarm no later than `atMs` (durable backoff never throws). */
-	async #armAlarmAtMost(storage, atMs, now) {
-		const current = await storage.getAlarm();
-		const immediate = checkedQueueTimestampAdd(now, MIN_ALARM_DELAY_MS);
-		if (current !== null && current <= now) {
-			if (immediate === null) await storage.deleteAlarm();
-			else await storage.setAlarm(immediate);
-			return;
-		}
-		const target = atMs <= now ? immediate : atMs;
-		if (target === null) {
-			await storage.deleteAlarm();
-			return;
-		}
-		if (current === null || target < current) await storage.setAlarm(target);
-	}
-	/** Recompute the alarm from the earliest due entry / inflight deadline. */
-	async #rearm() {
-		await this.#scheduleNextAlarm(this.ctx.storage, this.#now());
-	}
-	/** Keep the alarm index consistent with message state in the same transaction. */
-	async #scheduleNextAlarm(storage, now) {
-		let next = null;
-		const due = await storage.list({
-			prefix: "due:",
-			limit: 1
-		});
-		for (const key of due.keys()) next = Number.parseInt(key.slice(4, 17), 10);
-		const inflight = await storage.list({
-			prefix: INFLIGHT_DEADLINE_PREFIX,
-			limit: 1
-		});
-		for (const key of inflight.keys()) {
-			const deadline = deadlineFromInflightKey(key);
-			if (next === null || deadline < next) next = deadline;
-		}
-		const expiryGc = await storage.list({
-			prefix: EXPIRED_RUN_GC_PREFIX,
-			limit: 1
-		});
-		for (const item of expiryGc.values()) if (next === null || item.compactAt < next) next = item.compactAt;
-		if (next !== null) {
-			const target = next <= now ? checkedQueueTimestampAdd(now, MIN_ALARM_DELAY_MS) : next;
-			if (target === null) await storage.deleteAlarm();
-			else await storage.setAlarm(target);
-		} else await storage.deleteAlarm();
-	}
-	async stats() {
-		const storage = this.ctx.storage;
-		const [due, inflight, dlq, alarmAt] = await Promise.all([
-			storage.list({ prefix: "due:" }),
-			storage.list({ prefix: INFLIGHT_DEADLINE_PREFIX }),
-			storage.list({ prefix: "dlq:" }),
-			storage.getAlarm()
-		]);
-		return {
-			pending: due.size,
-			inflight: inflight.size,
-			deadLetters: dlq.size,
-			alarmAt
-		};
-	}
-	async listDeadLetters(params) {
-		if (params !== void 0 && !isRecord$1(params)) throw new Error("world-celld queue dead-letter list options must be an object");
-		const limit = boundedIntegerOption("world-celld queue dead-letter limit", params?.limit, 100, 1, MAX_DEAD_LETTER_LIST_SIZE);
-		if (params?.cursor !== void 0 && typeof params.cursor !== "string") throw new Error("world-celld queue dead-letter cursor must be a string");
-		const entries = await this.ctx.storage.list({
-			prefix: "dlq:",
-			startAfter: params?.cursor,
-			limit: limit + 1
-		});
-		const keys = Array.from(entries.keys());
-		const page = keys.slice(0, limit);
-		const hasMore = keys.length > limit;
-		return {
-			data: page.map((k) => entries.get(k)),
-			cursor: hasMore ? page.at(-1) : null,
-			hasMore
-		};
-	}
-	/** Move a dead letter back to the live queue (attempt count reset). */
-	async redriveDeadLetter(messageId) {
-		if (typeof messageId !== "string" || messageId.length === 0) throw new Error("world-celld queue redrive messageId must be a non-empty string");
-		const storage = this.ctx.storage;
-		const now = this.#now();
-		if (checkedQueueTimestampAdd(now, 0, 330001) === null) return { ok: false };
-		const found = Array.from(await storage.list({ prefix: "dlq:" })).find(([, dead]) => dead.messageId === messageId);
-		if (!found) return { ok: false };
-		const [deadKey, candidate] = found;
-		const redrive = async (txn) => {
-			const dead = await txn.get(deadKey);
-			if (!dead || dead.messageId !== messageId) return { ok: false };
-			const { failedAt: _failedAt, ...rest } = dead;
-			const row = {
-				...rest,
-				attempt: 0,
-				lastError: void 0
-			};
-			if (row.idempotencyKey) {
-				const dedupKey = `key:${row.idempotencyKey}`;
-				const holder = await txn.get(dedupKey);
-				if (holder && holder !== row.messageId && await txn.get(`msg:${holder}`)) return { ok: false };
-				if (holder && holder !== row.messageId) await txn.delete(dedupKey);
-				await txn.put(dedupKey, row.messageId);
-			}
-			await txn.put(`msg:${row.messageId}`, row);
-			const scheduleKey = dueKey(now, row.messageId);
-			await txn.put(scheduleKey, row.messageId);
-			await txn.delete(deadKey);
-			if (row.runId) await txn.put(runReferenceKey(row.runId, row.messageId), {
-				messageId: row.messageId,
-				dueKey: scheduleKey,
-				idempotencyKey: row.idempotencyKey
-			});
-			await this.#armAlarmAtMost(txn, now, now);
-			return { ok: true };
-		};
-		const rejectExpired = async (txn) => {
-			if ((await txn.get(deadKey))?.messageId === messageId) await txn.delete([deadKey, runReferenceKey(candidate.runId, messageId)]);
-			return { ok: false };
-		};
-		return candidate.runId ? await this.#withRunMutation(candidate.runId, rejectExpired, redrive) : await storage.transaction(redrive);
-	}
-	async purgeDeadLetters() {
-		return await this.ctx.storage.transaction(async (txn) => {
-			const entries = await txn.list({
-				prefix: "dlq:",
-				limit: 129
-			});
-			const page = Array.from(entries).slice(0, PURGE_DEAD_LETTER_BATCH);
-			await deleteMany(txn, page.flatMap(([key, dead]) => [key, ...dead.runId ? [runReferenceKey(dead.runId, dead.messageId)] : []]));
-			return {
-				purged: page.length,
-				hasMore: entries.size > PURGE_DEAD_LETTER_BATCH
-			};
-		});
-	}
-	/**
-	* Recovery hatch for celld's six-failure alarm abandonment: derive the due
-	* time again and arm it.
-	*/
-	async rearmAlarm() {
-		await this.#rearm();
-		return { alarmAt: await this.ctx.storage.getAlarm() };
-	}
-	/** Fence a run and purge every live, inflight, and dead-letter message it owns. */
-	async expireRun(runId, expiredAt, options) {
-		if (typeof runId !== "string" || runId.length === 0) throw new Error("world-celld queue expiry runId must be a non-empty string");
-		if (!isNonNegativeSafeInteger(expiredAt)) throw new Error("world-celld queue expiry expiredAt must be a non-negative safe integer");
-		if (options !== void 0 && !isRecord$1(options)) throw new Error("world-celld queue expiry options must be an object");
-		const storage = this.ctx.storage;
-		const limit = boundedIntegerOption("world-celld queue expiry limit", options?.limit, EXPIRE_RUN_REFERENCE_BATCH, 1, EXPIRE_RUN_REFERENCE_BATCH);
-		return await storage.transaction(async (txn) => {
-			const existing = await txn.get(expiredRunKey(runId));
-			const references = await txn.list({
-				prefix: `run:${runId}:`,
-				limit: limit + 1
-			});
-			const page = Array.from(references).slice(0, limit);
-			const dedupHolders = await getMany(txn, page.flatMap(([, reference]) => reference.idempotencyKey ? [`key:${reference.idempotencyKey}`] : []));
-			const keys = [];
-			let count = existing?.deleted ?? 0;
-			for (const [key, reference] of page) {
-				keys.push(`msg:${reference.messageId}`, key);
-				if (reference.inflightKey) keys.push(reference.inflightKey);
-				if (reference.dueKey) keys.push(reference.dueKey);
-				if (reference.dlqKey) keys.push(reference.dlqKey);
-				if (reference.idempotencyKey) {
-					const dedupKey = `key:${reference.idempotencyKey}`;
-					if (dedupHolders.get(dedupKey) === reference.messageId) keys.push(dedupKey);
-				}
-				count++;
-			}
-			await deleteMany(txn, keys);
-			const done = references.size <= limit;
-			const markerExpiredAt = existing?.expiredAt ?? expiredAt;
-			await txn.put(expiredRunKey(runId), {
-				expiredAt: markerExpiredAt,
-				deleted: count,
-				compactAt: existing?.compactAt ?? null
-			});
-			await this.#scheduleNextAlarm(txn, this.#now());
-			return done ? {
-				deleted: count,
-				done: true,
-				receipt: {
-					expiredAt: markerExpiredAt,
-					deleted: count
-				}
-			} : {
-				deleted: count,
-				done: false
-			};
-		});
-	}
-	/** Acknowledge a final cleanup receipt before making its marker compactable. */
-	async acknowledgeExpireRun(runId, receipt) {
-		if (typeof runId !== "string" || runId.length === 0) throw new Error("world-celld queue expiry runId must be a non-empty string");
-		if (!isRecord$1(receipt) || !isNonNegativeSafeInteger(receipt.expiredAt) || !isNonNegativeSafeInteger(receipt.deleted)) throw new Error("world-celld queue expiry receipt is invalid");
-		return await this.ctx.storage.transaction(async (txn) => {
-			const key = expiredRunKey(runId);
-			const marker = await txn.get(key);
-			if (!marker) return { acknowledged: true };
-			if (marker.expiredAt !== receipt.expiredAt || marker.deleted !== receipt.deleted) return { acknowledged: false };
-			if (marker.compactAt === null) {
-				const compactAt = checkedQueueTimestampAdd(this.#now(), QUEUE_FENCE_GRACE_MS);
-				if (compactAt !== null) {
-					await txn.put(key, {
-						...marker,
-						compactAt
-					});
-					await txn.put(expiredRunGcKey(runId, compactAt), {
-						runId,
-						compactAt
-					});
-				}
-			}
-			await this.#scheduleNextAlarm(txn, this.#now());
-			return { acknowledged: true };
-		});
-	}
-};
-//#endregion
 //#region src/worker/durable-objects/RunCatalogDO.ts
 const MAX_INDEX_LIST_SIZE = 1001;
 const EXPIRY_GC_PREFIX = "expiry-gc:";
@@ -3574,6 +2986,24 @@ function expiredRead(tombstone) {
 	};
 }
 //#endregion
+//#region src/worker/queue-payload-store.ts
+function createQueuePayloadStore(binding) {
+	return {
+		async write(key, value, metadata) {
+			await binding.put(key, value, { customMetadata: metadata });
+		},
+		async read(key) {
+			return (await binding.get(key))?.text() ?? null;
+		},
+		async delete(keys) {
+			await binding.delete(keys);
+		}
+	};
+}
+async function deleteQueuePayloadObjects(binding, keys) {
+	await binding.delete(keys);
+}
+//#endregion
 //#region src/worker/durable-objects/WorkflowRunDO.ts
 const STORAGE_BATCH_SIZE = 128;
 const PAYLOAD_DELETE_BATCH = STORAGE_BATCH_SIZE;
@@ -3583,15 +3013,14 @@ const TERMINAL_WAIT_PAGE_SIZE = STORAGE_BATCH_SIZE;
 const STREAMS_PER_CLEANUP_PAGE = 16;
 const STREAM_CHUNKS_PER_CLEANUP_PAGE = STORAGE_BATCH_SIZE;
 const STREAM_BYTES_PER_CLEANUP_PAGE = 16777216;
-const QUEUE_REFERENCES_PER_CLEANUP_PAGE = 64;
+const QUEUE_PAYLOADS_PER_CLEANUP_PAGE = STORAGE_BATCH_SIZE;
 const CLEANUP_RETRY_MAX_MS = 36e5;
-const CLEANUP_PROGRESS_KEY = "retention:progress";
-const RUN_QUEUE_SHARDS_KEY = "retention:queue-shards";
 const MAX_DATE_MS = 864e13;
+const QUEUE_ORPHAN_KEY = "queue-orphan";
+const QUEUE_RESERVATION_KEY = "queue-reservation";
 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`);
-	if (!isPositiveSafeInteger(request.queueShards)) throw new Error("world-celld retention queueShards must be a positive safe integer");
 	return request;
 }
 function retentionDeadline(baseMs, retentionMs, runId) {
@@ -3599,7 +3028,7 @@ function retentionDeadline(baseMs, retentionMs, runId) {
 	if (!Number.isSafeInteger(dueAtMs) || dueAtMs > MAX_DATE_MS) throw new Error(`world-celld retention deadline is out of range for ${runId}`);
 	return dueAtMs;
 }
-function cleanupRecord(run, dueAt, queueShards, reason) {
+function cleanupRecord(run, dueAt, reason) {
 	const terminal = isTerminalWorkflowRunStatus(run.status) ? run : void 0;
 	return {
 		version: 1,
@@ -3611,13 +3040,12 @@ function cleanupRecord(run, dueAt, queueShards, reason) {
 		terminalStatus: terminal?.status,
 		reason,
 		dueAt,
-		queueShards,
 		phase: "retained",
 		generation: 0,
 		attempts: 0,
 		deletedPayloadKeys: 0,
 		deletedStreams: 0,
-		deletedQueueMessages: 0
+		deletedQueuePayloads: 0
 	};
 }
 /**
@@ -3650,8 +3078,8 @@ async function putStorageEntries(storage, entries) {
 * storage transaction: guard checks, the event append, and the entity
 * mutation are atomic even if the DO is evicted mid-operation.
 *
-* Instances named `claim:<queueName>:<idempotencyKey>` are used purely as
-* queue-message dedup claims (see claimInflight/releaseInflight).
+* Instances named `claim:<queueName>:<idempotencyKey>` reserve one message ID
+* at publication time and serialize its deliveries until completion.
 */
 var WorkflowRunDO = class extends DurableObject {
 	now() {
@@ -3718,7 +3146,6 @@ var WorkflowRunDO = class extends DurableObject {
 				now
 			});
 			if (!outcome.ok) return outcome;
-			if (outcome.runCreated && request.cleanup) await txn.put(RUN_QUEUE_SHARDS_KEY, request.cleanup.queueShards);
 			await txn.put("event_sequence", eventSequence);
 			await putStorageEntries(txn, (outcome.hookToIndex ? [{
 				hookId: outcome.hookToIndex.hookId,
@@ -3732,7 +3159,7 @@ var WorkflowRunDO = class extends DurableObject {
 					...terminalRun,
 					expiredAt: dueAt
 				});
-				const cleanup = cleanupRecord(run, dueAt, request.cleanup?.queueShards ?? 1, "terminal-retention");
+				const cleanup = cleanupRecord(run, dueAt, "terminal-retention");
 				await txn.put("run", run);
 				await txn.put(CLEANUP_RECORD_KEY, cleanup);
 				await txn.setAlarm(dueAt);
@@ -3842,7 +3269,7 @@ var WorkflowRunDO = class extends DurableObject {
 				...terminalRun,
 				expiredAt: dueAt
 			});
-			const cleanup = cleanupRecord(run, dueAt, request.queueShards, "manual");
+			const cleanup = cleanupRecord(run, dueAt, "manual");
 			await txn.put("run", run);
 			await txn.put(CLEANUP_RECORD_KEY, cleanup);
 			await txn.setAlarm(values.get("terminal:cleanup") || dueAt.getTime() <= this.now() ? this.now() + 1 : dueAt);
@@ -3863,7 +3290,6 @@ var WorkflowRunDO = class extends DurableObject {
 			const values = await txn.get([
 				CLEANUP_RECORD_KEY,
 				TOMBSTONE_KEY,
-				RUN_QUEUE_SHARDS_KEY,
 				"run"
 			]);
 			const tombstone = values.get(TOMBSTONE_KEY);
@@ -3882,12 +3308,9 @@ var WorkflowRunDO = class extends DurableObject {
 				cleanup: null
 			};
 			const dueAt = new Date(dueAtMs);
-			const existing = values.get(CLEANUP_RECORD_KEY);
-			const storedQueueShards = values.get(RUN_QUEUE_SHARDS_KEY);
-			const queueShards = Number.isSafeInteger(storedQueueShards) && storedQueueShards > 0 ? storedQueueShards : request.queueShards;
-			let cleanup = existing;
+			let cleanup = values.get(CLEANUP_RECORD_KEY);
 			if (!cleanup) {
-				cleanup = cleanupRecord(run, dueAt, queueShards, "maximum-age");
+				cleanup = cleanupRecord(run, dueAt, "maximum-age");
 				await txn.put("run", WorkflowRunSchema.parse({
 					...run,
 					expiredAt: dueAt
@@ -3990,9 +3413,69 @@ var WorkflowRunDO = class extends DurableObject {
 		});
 	}
 	async executeScheduledCleanupPage() {
-		const values = await this.ctx.storage.get([CLEANUP_RECORD_KEY, TERMINAL_CLEANUP_KEY]);
+		const values = await this.ctx.storage.get([
+			CLEANUP_RECORD_KEY,
+			TERMINAL_CLEANUP_KEY,
+			"claim",
+			QUEUE_RESERVATION_KEY,
+			QUEUE_ORPHAN_KEY,
+			"run"
+		]);
 		const cleanup = values.get(CLEANUP_RECORD_KEY);
 		const terminalCleanup = values.get(TERMINAL_CLEANUP_KEY);
+		const claim = values.get("claim");
+		const reservation = values.get(QUEUE_RESERVATION_KEY);
+		if (values.get(QUEUE_ORPHAN_KEY)) {
+			const leased = await this.ctx.storage.transaction(async (txn) => {
+				const current = await txn.get(QUEUE_ORPHAN_KEY);
+				if (!current) return null;
+				if (current.expiresAt > this.now()) {
+					await txn.setAlarm(current.expiresAt);
+					return null;
+				}
+				if (current.deleting) return current;
+				const next = {
+					...current,
+					generation: current.generation + 1,
+					deleting: true
+				};
+				await txn.put(QUEUE_ORPHAN_KEY, next);
+				return next;
+			});
+			if (!leased) return;
+			const bucket = this.env?.WORKFLOW_QUEUE_PAYLOADS;
+			const runs = this.env?.WORKFLOW_DB;
+			if (!bucket || !runs) throw new Error("world-celld queue orphan cleanup is missing required bindings");
+			await deleteQueuePayloadObjects(bucket, leased.key);
+			await runs.get(runs.idFromName(leased.runId)).unregisterQueuePayload(leased.messageId);
+			await this.ctx.storage.transaction(async (txn) => {
+				const current = await txn.get(QUEUE_ORPHAN_KEY);
+				if (current?.messageId !== leased.messageId || current.generation !== leased.generation || !current.deleting) return;
+				await txn.delete(QUEUE_ORPHAN_KEY);
+				await txn.deleteAlarm();
+			});
+			return;
+		}
+		if (claim || reservation) {
+			await this.ctx.storage.transaction(async (txn) => {
+				const current = await txn.get(["claim", QUEUE_RESERVATION_KEY]);
+				let nextClaim = current.get("claim");
+				let nextReservation = current.get(QUEUE_RESERVATION_KEY);
+				const now = this.now();
+				if (nextClaim && nextClaim.expiresAt <= now) {
+					await txn.delete("claim");
+					nextClaim = void 0;
+				}
+				if (nextReservation && nextReservation.expiresAt <= now) {
+					await txn.delete(QUEUE_RESERVATION_KEY);
+					nextReservation = void 0;
+				}
+				const nextAlarm = Math.min(nextClaim?.expiresAt ?? Number.POSITIVE_INFINITY, nextReservation?.expiresAt ?? Number.POSITIVE_INFINITY);
+				if (Number.isFinite(nextAlarm)) await txn.setAlarm(nextAlarm);
+				else await txn.deleteAlarm();
+			});
+			return;
+		}
 		if (cleanup && cleanup.phase !== "tombstoned" && cleanup.dueAt.getTime() <= this.now()) {
 			try {
 				await this.executeCleanup(cleanup);
@@ -4191,85 +3674,27 @@ var WorkflowRunDO = class extends DurableObject {
 		});
 	}
 	async deleteQueuePage(cleanup) {
-		const queues = this.namespace("WORKFLOW_QUEUE");
-		const progress = await this.ctx.storage.get(CLEANUP_PROGRESS_KEY) ?? {
-			queueShard: 0,
-			queueShardDeleted: 0
-		};
-		if (progress.pendingAck) {
-			const { queueShard, receipt } = progress.pendingAck;
-			if (!(await queues.get(queues.idFromName(`q:${queueShard}`)).acknowledgeExpireRun(cleanup.runId, receipt)).acknowledged) throw new Error(`queue shard ${queueShard} rejected expiry receipt for ${cleanup.runId}`);
-			await this.ctx.storage.transaction(async (txn) => {
-				const current = await txn.get(CLEANUP_RECORD_KEY);
-				if (current?.phase !== "queues" || current.generation !== cleanup.generation) return;
-				const persisted = await txn.get(CLEANUP_PROGRESS_KEY);
-				if (persisted?.pendingAck?.queueShard !== queueShard || persisted.pendingAck.receipt.expiredAt !== receipt.expiredAt || persisted.pendingAck.receipt.deleted !== receipt.deleted) return;
-				await txn.put(CLEANUP_RECORD_KEY, {
-					...current,
-					generation: current.generation + 1,
-					attempts: 0,
-					lastError: void 0
-				});
-				await txn.put(CLEANUP_PROGRESS_KEY, {
-					queueShard: queueShard + 1,
-					queueShardDeleted: 0
-				});
-				await txn.setAlarm(this.now() + 1);
-			});
-			return;
-		}
-		if (progress.queueShard < cleanup.queueShards) {
-			const requestedShard = progress.queueShard;
-			const result = await queues.get(queues.idFromName(`q:${requestedShard}`)).expireRun(cleanup.runId, cleanup.dueAt.getTime(), { limit: QUEUE_REFERENCES_PER_CLEANUP_PAGE });
-			await this.ctx.storage.transaction(async (txn) => {
-				const current = await txn.get(CLEANUP_RECORD_KEY);
-				if (current?.phase !== "queues" || current.generation !== cleanup.generation) return;
-				const persisted = await txn.get(CLEANUP_PROGRESS_KEY) ?? {
-					queueShard: 0,
-					queueShardDeleted: 0
-				};
-				if (persisted.queueShard !== requestedShard || persisted.pendingAck) return;
-				if (result.deleted < persisted.queueShardDeleted) throw new Error(`queue shard ${requestedShard} regressed expiry receipt for ${cleanup.runId}`);
-				const delta = result.deleted - persisted.queueShardDeleted;
-				const next = result.done ? {
-					queueShard: requestedShard,
-					queueShardDeleted: result.deleted,
-					pendingAck: {
-						queueShard: requestedShard,
-						receipt: result.receipt
-					}
-				} : {
-					queueShard: requestedShard,
-					queueShardDeleted: result.deleted
-				};
-				await txn.put(CLEANUP_RECORD_KEY, {
-					...current,
-					deletedQueueMessages: current.deletedQueueMessages + delta,
-					generation: current.generation + 1,
-					attempts: 0,
-					lastError: void 0
-				});
-				await txn.put(CLEANUP_PROGRESS_KEY, next);
-				await txn.setAlarm(this.now() + 1);
-			});
-			return;
-		}
+		const entries = await this.ctx.storage.list({
+			prefix: QUEUE_PAYLOAD_REGISTRY_PREFIX,
+			limit: 129
+		});
+		const page = Array.from(entries).slice(0, QUEUE_PAYLOADS_PER_CLEANUP_PAGE);
+		const bucket = this.env?.WORKFLOW_QUEUE_PAYLOADS;
+		if (!bucket) throw new Error("world-celld retention missing binding WORKFLOW_QUEUE_PAYLOADS");
+		if (page.length > 0) await deleteQueuePayloadObjects(bucket, page.map(([, registration]) => registration.key));
 		await this.ctx.storage.transaction(async (txn) => {
 			const current = await txn.get(CLEANUP_RECORD_KEY);
 			if (current?.phase !== "queues" || current.generation !== cleanup.generation) return;
-			const persisted = await txn.get(CLEANUP_PROGRESS_KEY) ?? {
-				queueShard: 0,
-				queueShardDeleted: 0
-			};
-			if (persisted.queueShard >= current.queueShards && !persisted.pendingAck) {
-				await txn.put(CLEANUP_RECORD_KEY, {
-					...current,
-					phase: "payload",
-					generation: current.generation + 1
-				});
-				await txn.delete(CLEANUP_PROGRESS_KEY);
-				await txn.setAlarm(this.now() + 1);
-			}
+			if (page.length > 0) await txn.delete(page.map(([key]) => key));
+			await txn.put(CLEANUP_RECORD_KEY, {
+				...current,
+				deletedQueuePayloads: current.deletedQueuePayloads + page.length,
+				phase: entries.size <= QUEUE_PAYLOADS_PER_CLEANUP_PAGE ? "payload" : "queues",
+				generation: current.generation + 1,
+				attempts: 0,
+				lastError: void 0
+			});
+			await txn.setAlarm(this.now() + 1);
 		});
 	}
 	async deletePayloadBatch() {
@@ -4340,20 +3765,163 @@ var WorkflowRunDO = class extends DurableObject {
 			await txn.setAlarm(this.now() + delay);
 		});
 	}
+	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) => {
+			const { tombstone } = await this.retentionState(txn);
+			if (tombstone) return {
+				ok: false,
+				message: `Workflow run "${tombstone.runId}" expired at ${tombstone.expiredAt.toISOString()}`
+			};
+			await txn.put(queuePayloadRegistryKey(registration.messageId), registration);
+			return { ok: true };
+		});
+	}
+	async finalizeQueuePayload(messageId) {
+		if (typeof messageId !== "string" || messageId.length === 0) throw new TypeError("world-celld queue payload messageId must be a non-empty string");
+		return await this.ctx.storage.transaction(async (txn) => {
+			const { tombstone } = await this.retentionState(txn);
+			if (tombstone) return {
+				ok: false,
+				message: `Workflow run "${tombstone.runId}" expired at ${tombstone.expiredAt.toISOString()}`
+			};
+			return await txn.get(queuePayloadRegistryKey(messageId)) ? { ok: true } : {
+				ok: false,
+				message: "workflow queue payload registration was removed before publication"
+			};
+		});
+	}
+	async unregisterQueuePayload(messageId) {
+		if (typeof messageId !== "string" || messageId.length === 0) throw new TypeError("world-celld queue payload messageId must be a non-empty string");
+		await this.ctx.storage.delete(queuePayloadRegistryKey(messageId));
+	}
+	async scheduleQueuePayloadOrphan(orphan) {
+		if (!orphan || typeof orphan.messageId !== "string" || orphan.messageId.length === 0 || typeof orphan.runId !== "string" || orphan.runId.length === 0 || typeof orphan.key !== "string" || orphan.key.length === 0 || !isNonNegativeSafeInteger(orphan.expiresAt)) throw new TypeError("world-celld queue payload orphan is invalid");
+		await this.ctx.storage.transaction(async (txn) => {
+			const existing = await txn.get(QUEUE_ORPHAN_KEY);
+			if (existing && existing.messageId !== orphan.messageId) throw new Error("world-celld queue payload orphan identity mismatch");
+			if (existing?.deleting) throw new Error("world-celld queue payload orphan deletion is in progress");
+			const next = {
+				...orphan,
+				expiresAt: Math.max(existing?.expiresAt ?? 0, orphan.expiresAt),
+				generation: (existing?.generation ?? 0) + 1,
+				deleting: false
+			};
+			await txn.put(QUEUE_ORPHAN_KEY, next);
+			await txn.setAlarm(next.expiresAt);
+		});
+	}
+	async cancelQueuePayloadOrphan(messageId) {
+		if (typeof messageId !== "string" || messageId.length === 0) throw new TypeError("world-celld queue payload orphan messageId must be a non-empty string");
+		await this.ctx.storage.transaction(async (txn) => {
+			const existing = await txn.get(QUEUE_ORPHAN_KEY);
+			if (!existing || existing.messageId !== messageId) return;
+			await txn.delete(QUEUE_ORPHAN_KEY);
+			await txn.deleteAlarm();
+		});
+	}
+	async reserveQueueMessage(params) {
+		if (typeof params?.messageId !== "string" || params.messageId.length === 0 || !isNonNegativeSafeInteger(params.expiresAt)) throw new TypeError("world-celld queue message reservation is invalid");
+		return await this.ctx.storage.transaction(async (txn) => {
+			const values = await txn.get([QUEUE_RESERVATION_KEY, "claim"]);
+			const existing = values.get(QUEUE_RESERVATION_KEY);
+			const claim = values.get("claim");
+			const now = this.now();
+			if (existing && existing.expiresAt > now && existing.messageId !== params.messageId) {
+				await txn.setAlarm(Math.min(existing.expiresAt, claim?.expiresAt ?? existing.expiresAt));
+				return {
+					admitted: false,
+					messageId: existing.messageId
+				};
+			}
+			const reservation = {
+				messageId: params.messageId,
+				expiresAt: Math.max(existing?.expiresAt ?? 0, params.expiresAt)
+			};
+			await txn.put(QUEUE_RESERVATION_KEY, reservation);
+			await txn.setAlarm(Math.min(reservation.expiresAt, claim?.expiresAt ?? reservation.expiresAt));
+			return {
+				admitted: true,
+				messageId: params.messageId
+			};
+		});
+	}
+	async completeQueueMessage(messageId) {
+		if (typeof messageId !== "string" || messageId.length === 0) throw new TypeError("world-celld queue messageId must be a non-empty string");
+		await this.ctx.storage.transaction(async (txn) => {
+			const values = await txn.get([QUEUE_RESERVATION_KEY, "claim"]);
+			let reservation = values.get(QUEUE_RESERVATION_KEY);
+			let claim = values.get("claim");
+			if (reservation?.messageId === messageId) {
+				await txn.delete(QUEUE_RESERVATION_KEY);
+				reservation = void 0;
+			}
+			if (claim?.messageId === messageId) {
+				await txn.delete("claim");
+				claim = void 0;
+			}
+			const nextAlarm = Math.min(reservation?.expiresAt ?? Number.POSITIVE_INFINITY, claim?.expiresAt ?? Number.POSITIVE_INFINITY);
+			if (Number.isFinite(nextAlarm)) await txn.setAlarm(nextAlarm);
+			else await txn.deleteAlarm();
+		});
+	}
 	async claimInflight(params) {
+		if (typeof params?.messageId !== "string" || params.messageId.length === 0 || !isPositiveSafeInteger(params.staleMs)) throw new TypeError("world-celld queue claim is invalid");
 		return await this.ctx.storage.transaction(async (txn) => {
-			const existing = await txn.get("claim");
+			const values = await txn.get(["claim", QUEUE_RESERVATION_KEY]);
+			const existing = values.get("claim");
+			const reservation = values.get(QUEUE_RESERVATION_KEY);
 			const now = this.now();
-			if (existing && existing.messageId !== params.messageId && now - existing.claimedAt < params.staleMs) return { claimed: false };
+			if (existing && existing.expiresAt > now) {
+				if (existing.messageId !== params.messageId) return { claimed: false };
+				if (existing.retryAt === void 0 || existing.retryAt > now) return {
+					claimed: false,
+					retryAt: existing.retryAt ?? existing.expiresAt
+				};
+			}
+			const expiresAt = now + params.staleMs;
 			await txn.put("claim", {
 				messageId: params.messageId,
-				claimedAt: now
+				expiresAt
 			});
+			await txn.setAlarm(Math.min(expiresAt, reservation?.expiresAt ?? expiresAt));
 			return { claimed: true };
 		});
 	}
-	async releaseInflight() {
-		await this.ctx.storage.delete("claim");
+	async holdInflight(params) {
+		if (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 queue claim hold is invalid");
+		return await this.ctx.storage.transaction(async (txn) => {
+			const values = await txn.get(["claim", QUEUE_RESERVATION_KEY]);
+			const existing = values.get("claim");
+			let reservation = values.get(QUEUE_RESERVATION_KEY);
+			if (!existing || existing.messageId !== params.messageId) return { held: false };
+			const expiresAt = Math.max(existing.expiresAt, params.expiresAt);
+			await txn.put("claim", {
+				...existing,
+				retryAt: params.retryAt,
+				expiresAt
+			});
+			if (reservation?.messageId === params.messageId && params.reservationExpiresAt !== void 0 && params.reservationExpiresAt > reservation.expiresAt) {
+				reservation = {
+					...reservation,
+					expiresAt: params.reservationExpiresAt
+				};
+				await txn.put(QUEUE_RESERVATION_KEY, reservation);
+			}
+			await txn.setAlarm(Math.min(expiresAt, reservation?.expiresAt ?? expiresAt));
+			return { held: true };
+		});
+	}
+	async releaseInflight(messageId) {
+		await this.ctx.storage.transaction(async (txn) => {
+			const values = await txn.get(["claim", QUEUE_RESERVATION_KEY]);
+			const existing = values.get("claim");
+			const reservation = values.get(QUEUE_RESERVATION_KEY);
+			if (!existing || messageId !== void 0 && existing.messageId !== messageId) return;
+			await txn.delete("claim");
+			if (reservation) await txn.setAlarm(reservation.expiresAt);
+			else await txn.deleteAlarm();
+		});
 	}
 };
 //#endregion
@@ -4364,13 +3932,29 @@ var WorkflowRunDO = class extends DurableObject {
 */
 async function startHarness(options = {}) {
 	const cellEnv = { ...options.cellEnv };
+	const queueMessages = [];
+	const queuePayloads = /* @__PURE__ */ new Map();
+	const queuePayloadBucket = {
+		async put(key, value) {
+			queuePayloads.set(key, value);
+		},
+		async get(key) {
+			const value = queuePayloads.get(key);
+			return value === void 0 ? null : { text: async () => value };
+		},
+		async delete(keys) {
+			for (const key of Array.isArray(keys) ? keys : [keys]) queuePayloads.delete(key);
+		}
+	};
+	const nativeQueue = { async send(body) {
+		queueMessages.push(body);
+	} };
 	const fleet = new FakeFleet({
 		runs: WorkflowRunDO,
 		streams: StreamDO,
 		"run-catalog": RunCatalogDO,
 		"hook-tokens": HookTokenDO,
 		"hook-ids": HookIdDO,
-		queue: QueueDO,
 		...options.extraClasses
 	}, cellEnv);
 	cellEnv.clock ??= options.virtualClock ? () => fleet.now : () => Date.now();
@@ -4380,7 +3964,7 @@ async function startHarness(options = {}) {
 		WORKFLOW_RUN_CATALOG: fleet.namespace("run-catalog"),
 		WORKFLOW_HOOK_TOKENS: fleet.namespace("hook-tokens"),
 		WORKFLOW_HOOK_IDS: fleet.namespace("hook-ids"),
-		WORKFLOW_QUEUE: fleet.namespace("queue")
+		WORKFLOW_QUEUE_PAYLOADS: queuePayloadBucket
 	});
 	const router = createRouter({
 		WORKFLOW_DB: fleet.namespace("runs"),
@@ -4388,7 +3972,8 @@ async function startHarness(options = {}) {
 		WORKFLOW_RUN_CATALOG: fleet.namespace("run-catalog"),
 		WORKFLOW_HOOK_TOKENS: fleet.namespace("hook-tokens"),
 		WORKFLOW_HOOK_IDS: fleet.namespace("hook-ids"),
-		WORKFLOW_QUEUE: fleet.namespace("queue"),
+		WORKFLOW_QUEUE: nativeQueue,
+		WORKFLOW_QUEUE_PAYLOADS: createQueuePayloadStore(queuePayloadBucket),
 		WORLD_SECRET: options.secret
 	});
 	const server = http.createServer(async (req, res) => {
@@ -4432,6 +4017,8 @@ async function startHarness(options = {}) {
 	return {
 		url: `http://127.0.0.1:${port}`,
 		fleet,
+		queueMessages,
+		queuePayloads,
 		close: () => new Promise((resolve, reject) => {
 			server.close((err) => err ? reject(err) : resolve());
 			server.closeAllConnections();