@ewhauser/world-celld 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.7.0 (2026-09-27)
+
+## What's Changed
+* test(perf): cover mixed workflows, sustained load, and node failover by @ewhauser in https://github.com/ewhauser/world-celld/pull/64
+* feat!: require celld v0.6.0 by @ewhauser in https://github.com/ewhauser/world-celld/pull/67
+* perf(queue): dispatch consumer batches without a fill wait by @ewhauser in https://github.com/ewhauser/world-celld/pull/69
+* perf(codec): use native base64 and a faster fallback by @ewhauser in https://github.com/ewhauser/world-celld/pull/70
+* perf(runs): list runs inside the fleet in one round trip by @ewhauser in https://github.com/ewhauser/world-celld/pull/74
+* perf(indexes): publish run mutations to indexes inside the fleet by @ewhauser in https://github.com/ewhauser/world-celld/pull/72
+* perf(runs): keep idempotent run replays read-only by @ewhauser in https://github.com/ewhauser/world-celld/pull/75
+* perf(events): honor preloadEvents on lazy hook resume by @ewhauser in https://github.com/ewhauser/world-celld/pull/71
+* perf(streams): negotiate 512-chunk stream batches by @ewhauser in https://github.com/ewhauser/world-celld/pull/73
+* perf(retention): finish small terminal cleanups in one pass by @ewhauser in https://github.com/ewhauser/world-celld/pull/76
+* perf(retention): expire streams in pages of up to 256 chunks by @ewhauser in https://github.com/ewhauser/world-celld/pull/77
+
+
+**Full Changelog**: https://github.com/ewhauser/world-celld/compare/v0.6.0...v0.7.0
+
 ## 0.6.0 (2026-09-16)
 
 ## What's Changed

package/README.md

@@ -87,16 +87,17 @@ requests. It must be reachable from every celld node.
 
 ## Deploy the worker
 
-Before deploying, you need a celld v0.5.0 fleet, `esbuild` on `PATH`, and an
+Before deploying, you need a celld v0.6.0 fleet, `esbuild` on `PATH`, and an
 object store that meets celld's conditional-write requirements. Refer to the
 [celld documentation](https://github.com/denoland/celld) for fleet and storage
 setup.
 
-**world-celld 0.5.0 is a breaking release and requires celld v0.5.0.**
-Older runtimes and node-level worker-variable overrides are unsupported.
+**world-celld requires celld v0.6.0.** Older runtimes and node-level
+worker-variable overrides are unsupported.
 
-For an existing fleet, follow the [v0.5.0 upgrade and feature review](docs/celld-v0.5-upgrade.md).
-Stop every old celld node before starting v0.5.0; this is not a rolling upgrade.
+For an existing fleet, follow the [v0.6.0 upgrade and feature review](docs/celld-v0.6-upgrade.md).
+A multi-node fleet uses fleet durability by default; stop every old celld node
+before starting v0.6.0, because that is not a rolling upgrade.
 
 Before either deploy, set `vars.WORLD_SECRET` in both copied Wrangler configs
 to the same secret from your secret manager. Set optional
@@ -104,10 +105,10 @@ to the same secret from your secret manager. Set optional
 `vars.WORKFLOW_RETENTION_MS` there to the desired maximum workflow age
 (for example, `"7776000000"` for 90 days). Use private deployment copies outside
 source control: celld persists these variables in the deployment stored in the
-fleet bucket. v0.5.0 rejects `CELLD_VAR_*`; `.dev.vars` is read only by
+fleet bucket. celld rejects `CELLD_VAR_*`; `.dev.vars` is read only by
 `celld dev`, not by `celld deploy`.
 
-No second storage service is required for queue payloads. celld v0.5.0 serves
+No second storage service is required for queue payloads. celld v0.6.0 serves
 the `WORKFLOW_QUEUE_PAYLOADS` binding from the existing fleet bucket under
 `r2/workflow-world-queue-payloads/`. `r2_buckets` is the Wrangler-compatible
 configuration key for that binding; it does not require Cloudflare R2.
@@ -163,7 +164,7 @@ More deployment detail is in [`celld-worker/README.md`](./celld-worker/README.md
 and [`celld-queue-worker/README.md`](./celld-queue-worker/README.md).
 
 For opt-in bucket or collector telemetry and local `.dev.vars` setup, see
-the [operational examples](docs/celld-v0.5-upgrade.md#adopt-telemetry).
+the [operational examples](docs/celld-v0.6-upgrade.md#adopt-telemetry).
 
 ## How it works
 
@@ -347,7 +348,7 @@ pnpm test:integration
 
 ### Real celld restart smoke
 
-The required CI smoke owns native celld v0.5.0 and MinIO processes on loopback,
+The required CI smoke owns native celld v0.6.0 and MinIO processes on loopback,
 uses fresh temporary bucket and runtime state, and kills celld with `SIGKILL`
 before deleting its local working state and starting a new process against the
 bucket-backed state. It checks that:
@@ -382,12 +383,11 @@ failover correctness.
 
 The opt-in performance harness starts a fresh MinIO bucket and a single celld
 node with Docker Compose. Its queue workload verifies that every accepted
-message reaches a successful callback, including forced `503` redeliveries. A
-second workload creates terminal runs with streams and delayed queue messages,
-then verifies complete payload cleanup without resurrection. Results include
-queue and cleanup throughput plus p50, p95, p99, and maximum latency and are
-saved under `.perf-results/`. The harness pins celld v0.5.0 and deploys the same
-two-script native Queue topology as the restart smoke.
+message reaches a successful callback, including forced `503` redeliveries. It
+also measures a mixed run/step/hook/stream/queue lifecycle and terminal-run
+cleanup. Results include throughput plus p50, p95, p99, and maximum latency and
+are saved under `.perf-results/`. The harness pins celld v0.6.0 and deploys the
+same two-script native Queue topology as the restart smoke.
 
 > This harness runs a single celld node and leaves the required storage-contract
 > probe enabled. Passing it does not establish multi-node fencing, ownership
@@ -422,6 +422,23 @@ Useful controls are `PERF_PAYLOAD_BYTES`, `PERF_RETRY_EVERY`,
 because local machines vary. Message-loss, message-ID, callback validity, and
 duplicate-success checks are always enforced.
 
+`PERF_WORKFLOW_RUNS` and `PERF_WORKFLOW_CONCURRENCY` control the mixed workload.
+Set `PERF_STEADY_SECONDS` to enable a duration-based queue run at
+`PERF_STEADY_RATE` arrivals per second; its JSON records schedule lag and
+one-second backlog samples. For a repeatable concurrency/payload sweep, run
+`pnpm test:perf:minio:matrix`. It runs four isolated profiles and writes a
+manifest with the Git commit, hardware, workload settings, and result paths.
+`PERF_MATRIX_SOAK_SECONDS` changes the final steady profile's duration (60
+seconds by default). Compare runs on the same host with the same profile and
+without unrelated load; the harness does not set portable latency budgets.
+
+`pnpm test:perf:minio:failover` starts one celld node, seeds a run, stream, and
+queue workload (including accepted deliveries forced to retry), starts a peer
+against the same bucket, kills the first node, then measures peer recovery and
+delivery of both pending and new messages. Its output is
+`minio-failover-latest.json`. This is a two-node local handoff test, not a
+production object-store or fleet qualification.
+
 Bug reports and focused pull requests are welcome. Please include a regression
 test for behavior changes and run the checks above before submitting a PR.
 

package/celld-queue-worker/README.md

@@ -1,6 +1,6 @@
 # world-celld Queue consumer
 
-This companion celld v0.5.0 script consumes the native `workflow-world` Queue
+This companion celld v0.6.0 script consumes the native `workflow-world` Queue
 and forwards each delivery to the primary `workflow-world` script through a
 `QueueDeliveryRpc` named service binding. The consumer calls
 `deliver(secret, envelope, attempt)` and handles `complete`, `suspend`, or `retry`
@@ -16,7 +16,7 @@ celld deploy ./workflow-world-queue --bucket s3://my-cells-bucket
 
 Before deploying, set `vars.WORLD_SECRET` in the copied Wrangler config to the
 same bearer secret used by the primary worker. Keep that private deployment
-config out of source control. v0.5.0 rejects `CELLD_VAR_*` node overrides.
+config out of source control. celld rejects `CELLD_VAR_*` node overrides.
 Deploy the primary worker after this script so it remains the fleet's
 public application. Native Queue operations are available through `celld queue
 info`, `peek`, `pause`, `resume`, `purge`, and `redrive`.

package/celld-queue-worker/wrangler.jsonc

@@ -11,7 +11,9 @@
       {
         "queue": "workflow-world",
         "max_batch_size": 10,
-        "max_batch_timeout": 1,
+        // Dispatch as soon as a message is ready. Every workflow step hop
+        // goes through this queue, so a batch-fill wait adds to each hop.
+        "max_batch_timeout": 0,
         "max_retries": 100,
         "dead_letter_queue": "workflow-world-dlq",
         "max_concurrency": 25,

package/celld-worker/README.md

@@ -15,7 +15,7 @@ Copy this directory and the companion Queue consumer out of `node_modules` so
 worker last. Before deploying, set `vars.WORLD_SECRET` in both copied
 Wrangler configs to the same secret from your secret manager. Keep those
 private deployment copies out of source control; celld stores their variables
-in the fleet bucket. Stop the whole old fleet before starting v0.5.0 nodes:
+in the fleet bucket. Stop the whole old fleet before starting v0.6.0 nodes:
 
 ```sh
 cp -r node_modules/@ewhauser/world-celld/celld-worker ./workflow-world
@@ -30,7 +30,7 @@ to the native Queue.
 
 Requirements:
 
-- celld v0.5.0 (the currently tested runtime baseline).
+- celld v0.6.0 (the currently tested runtime baseline).
 - `esbuild` on PATH (celld shells out to it).
 - A bucket with conditional-write support (celld's fencing requirement).
 - `WORLD_SECRET` set in the deployment config (`vars.WORLD_SECRET`) —
@@ -46,7 +46,7 @@ names the Workers-compatible binding API; it does not require Cloudflare R2.
 The bundled `wrangler.jsonc` declares an hourly UTC cron trigger. It does no
 catalog work by default. Set `vars.WORKFLOW_RETENTION_MS` to `"7776000000"`
 in the primary Wrangler config and redeploy to enable a maximum workflow age
-measured from run creation. v0.5.0 rejects `CELLD_VAR_*` node overrides.
+measured from run creation. celld rejects `CELLD_VAR_*` node overrides.
 `.dev.vars` overrides apply only to `celld dev`, not production deployments.
 
 `7776000000` is 90 days. The policy includes pending and running workflows as

package/dist/index.d.ts

@@ -149,6 +149,15 @@ interface ApplyEventSuccess {
   maxEvents?: number;
   /** Deadline for publishing this authoritative mutation to derivative indexes. */
   indexPublicationExpiresAt?: number;
+  /** Set by the worker router after it published `run` to the run catalog. */
+  runIndexPublished?: true;
+  /** Set by the worker router after it released `releasedHooks` from the hook indexes. */
+  hookIndexesReleased?: true;
+  /**
+   * The unchanged run returned with a `preloadEvents` hook_received replay
+   * log. It is not a run mutation, so it carries no index publication.
+   */
+  replayRun?: WorkflowRun;
 }
 type ApplyEventOutcome = ApplyEventSuccess | ApplyEventFailure;
 //#endregion
@@ -211,12 +220,16 @@ interface DurableObjectIdLike {
 }
 //#endregion
 //#region src/stream-protocol.d.ts
-/** Metadata plus payload and size-index entries remain below the 128-key platform limit. */
+/**
+ * Chunks per write request that every worker accepts. A client sends larger
+ * batches only after a worker advertises {@link STREAM_CHUNK_LIMIT_HEADER}.
+ */
 declare const MAX_STREAM_WRITE_CHUNKS = 32;
 /** A chunk remains below the 2 MiB SQLite-backed DO key/value limit. */
 declare const MAX_STREAM_CHUNK_BYTES: number;
 /** Keeps serialized RPC bodies well below the 32 MiB Workers RPC limit. */
 declare const MAX_STREAM_BATCH_BYTES: number;
+/** Chunks per read request that every worker accepts; see {@link MAX_STREAM_WRITE_CHUNKS}. */
 declare const MAX_STREAM_READ_CHUNKS = 32;
 declare const MAX_STREAM_READ_BYTES: number;
 declare const MAX_STREAM_ERROR_BYTES: number;
@@ -264,6 +277,13 @@ interface CelldStreamer extends Omit<Streamer, 'streams'> {
 }
 /** Direct StreamDO RPC surface. Remote stubs specialize read/write as binary HTTP. */
 interface StreamDOStub {
+  /**
+   * Remote stubs only: the per-request chunk limit the fleet has advertised.
+   * Stubs without it are held to the baseline every worker accepts.
+   */
+  streamChunkLimit?(): number;
+  /** Remote stubs only: drop an advertised limit an older worker rejected. */
+  resetStreamChunkLimit?(): void;
   writeChunks(runId: string, chunks: Uint8Array[]): Promise<StreamWriteResult>;
   readChunks(request: StreamReadRequest, signal?: AbortSignal): Promise<StreamReadResult>;
   closeStream(runId: string): Promise<void>;
@@ -323,6 +343,24 @@ interface CelldQueueProducer {
   send(envelope: NativeQueueEnvelope, options?: NativeQueueSendOptions): Promise<NativeQueueSendResult>;
 }
 //#endregion
+//#region src/run-list.d.ts
+type RunStatus = WorkflowRun['status'];
+/** Wire shape of a run listing, shared by the client and the worker router. */
+interface RunListRequest {
+  workflowName?: string;
+  statuses?: RunStatus[];
+  limit: number;
+  cursor?: string;
+  sortOrder?: 'asc' | 'desc';
+  /** 'none' strips run input and output from the returned page. */
+  resolveData?: 'none' | 'all';
+}
+interface RunListPage {
+  data: WorkflowRun[];
+  cursor: string | null;
+  hasMore: boolean;
+}
+//#endregion
 //#region src/indexes.d.ts
 interface IndexListOptions {
   prefix?: string;
@@ -360,6 +398,11 @@ interface WorkflowIndex {
     stored: boolean;
   }>;
   listRuns(options?: IndexListOptions): Promise<IndexListPage>;
+  /**
+   * Remote only: the complete run listing performed inside the fleet. Resolves
+   * to null when the worker predates the route; the caller then lists itself.
+   */
+  listResolvedRuns?(request: RunListRequest): Promise<RunListPage | null>;
   getHookByToken(token: string): Promise<string | null>;
   getHookById(hookId: string): Promise<string | null>;
   reserveHook(token: string, owner: HookTokenOwner): Promise<HookReservationResult>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/retention.ts","../src/apply-event.ts","../src/storage.ts","../src/stream-protocol.ts","../src/streamer.ts","../src/queue-protocol.ts","../src/queue.ts","../src/indexes.ts","../src/config.ts","../src/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/retention.ts","../src/apply-event.ts","../src/storage.ts","../src/stream-protocol.ts","../src/streamer.ts","../src/queue-protocol.ts","../src/queue.ts","../src/run-list.ts","../src/indexes.ts","../src/config.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.js

@@ -1,5 +1,5 @@
-import { A as MAX_STREAM_BATCH_BYTES, B as decodeStreamWriteResult, C as boundedIntegerOption, F as MAX_STREAM_READ_CHUNKS, H as encodeStreamWriteBatch, I as MAX_STREAM_WRITE_CHUNKS, L as STREAM_BATCH_CONTENT_TYPE, M as MAX_STREAM_ERROR_BYTES, N as MAX_STREAM_LONG_POLL_MS, O as queueDelayDeadline, P as MAX_STREAM_READ_BYTES, R as decodeStreamReadResult, W as normalizeStreamError, b as MAX_QUEUE_DELIVERY_TIMEOUT_MS, d as rpcParse, f as rpcStringify, h as createWorkflowIndex, j as MAX_STREAM_CHUNK_BYTES, k as strictIntegerSetting, m as stringify, p as parse, r as nativeQueueDelaySeconds, u as compact, w as checkedQueueTimestampAdd, x as MAX_QUEUE_DERIVED_DEADLINE_HEADROOM_MS, y as MAX_FLEET_RPC_TIMEOUT_MS } from "./queue-protocol-CmJNMH_5.js";
-import { CreateEventSchema, EventSchema, HookSchema, MessageId, QueuePayloadSchema, SPEC_VERSION_CURRENT, StepSchema, WaitSchema, WorkflowRunSchema, isTerminalWorkflowRunStatus, parseQueueName } from "@workflow/world";
+import { B as STREAM_BATCH_CONTENT_TYPE, C as MAX_QUEUE_DELIVERY_TIMEOUT_MS, D as checkedQueueTimestampAdd, E as boundedIntegerOption, F as MAX_STREAM_ERROR_BYTES, H as decodeStreamReadResult, I as MAX_STREAM_LONG_POLL_MS, J as isChunkLimitRejection, K as encodeStreamWriteBatch, L as MAX_STREAM_READ_BYTES, M as strictIntegerSetting, N as MAX_STREAM_BATCH_BYTES, P as MAX_STREAM_CHUNK_BYTES, R as MAX_STREAM_READ_CHUNKS, S as MAX_FLEET_RPC_TIMEOUT_MS, V as STREAM_CHUNK_LIMIT_HEADER, W as decodeStreamWriteResult, Y as normalizeStreamError, _ as createWorkflowIndex, a as nativeQueueDelaySeconds, f as compact, g as stringify, h as parse, j as queueDelayDeadline, m as rpcStringify, n as listRunsPage, p as rpcParse, v as runIndexMetadata, w as MAX_QUEUE_DERIVED_DEADLINE_HEADROOM_MS, z as MAX_STREAM_WRITE_CHUNKS } from "./run-list-B__jKuE7.js";
+import { CreateEventSchema, EventSchema, HookSchema, MessageId, QueuePayloadSchema, SPEC_VERSION_CURRENT, StepSchema, WaitSchema, WorkflowRunSchema, parseQueueName } from "@workflow/world";
 import { EntityConflictError, HookNotFoundError, RunExpiredError, RunNotSupportedError, TooEarlyError, WorkflowRunNotFoundError, WorkflowWorldError } from "@workflow/errors";
 import { monotonicFactory } from "ulid";
 //#region src/config.ts
@@ -132,6 +132,23 @@ const READ_ATTEMPTS = 3;
 const MAX_WRITE_RESPONSE_BYTES = 64;
 const MAX_READ_RESPONSE_BYTES = MAX_STREAM_READ_BYTES + 65536;
 const MAX_ERROR_RESPONSE_BYTES = 65536;
+/**
+* Per-request chunk limit the fleet has advertised, per transport. Absent
+* until a worker advertises one, so a client never sends an older worker more
+* than the baseline it accepts; a response without the header drops back.
+*/
+const advertisedChunkLimits = /* @__PURE__ */ new WeakMap();
+function streamChunkLimit(transport) {
+	return advertisedChunkLimits.get(transport) ?? 32;
+}
+function resetStreamChunkLimit(transport) {
+	advertisedChunkLimits.delete(transport);
+}
+function recordStreamChunkLimit(transport, response) {
+	const advertised = Number(response.headers.get(STREAM_CHUNK_LIMIT_HEADER));
+	if (Number.isSafeInteger(advertised) && advertised > 32) advertisedChunkLimits.set(transport, Math.min(advertised, 512));
+	else advertisedChunkLimits.delete(transport);
+}
 function delayMs(ms, signal) {
 	if (!signal) return new Promise((resolve) => setTimeout(resolve, ms));
 	if (signal.aborted) return Promise.reject(aborted(signal));
@@ -202,7 +219,7 @@ function streamUrl(transport, name) {
 async function writeStreamChunks(transport, name, runId, chunks) {
 	const timeoutMs = resolveFleetTimeoutMs(transport);
 	const body = encodeStreamWriteBatch(chunks);
-	if (body.byteLength > 8389632) throw new Error("world-celld: encoded stream batch exceeds configured limit");
+	if (body.byteLength > 8391680) throw new Error("world-celld: encoded stream batch exceeds configured limit");
 	const url = new URL(streamUrl(transport, name));
 	url.searchParams.set("runId", runId);
 	const doFetch = transport.fetchImpl ?? fetch;
@@ -221,6 +238,7 @@ async function writeStreamChunks(transport, name, runId, chunks) {
 		throw new FleetTransportError(`world-celld: fleet unreachable at ${url.href}`, error);
 	}
 	if (!response.ok) throw await errorFromResponse(response);
+	recordStreamChunkLimit(transport, response);
 	try {
 		return decodeStreamWriteResult(await readBoundedResponse(response, MAX_WRITE_RESPONSE_BYTES));
 	} catch (error) {
@@ -257,13 +275,16 @@ async function readStreamChunks(transport, name, request, signal) {
 			await response.body?.cancel(aborted(signal)).catch(() => void 0);
 			throw aborted(signal);
 		}
-		if (response.ok) try {
-			return decodeStreamReadResult(await readBoundedResponse(response, MAX_READ_RESPONSE_BYTES));
-		} catch (error) {
-			if (signal?.aborted) throw aborted(signal);
-			lastError = error instanceof FleetTransportError ? error : new FleetTransportError(`world-celld: malformed stream response from ${url.href}`, error);
-			if (attempt < READ_ATTEMPTS) continue;
-			throw lastError;
+		if (response.ok) {
+			recordStreamChunkLimit(transport, response);
+			try {
+				return decodeStreamReadResult(await readBoundedResponse(response, MAX_READ_RESPONSE_BYTES));
+			} catch (error) {
+				if (signal?.aborted) throw aborted(signal);
+				lastError = error instanceof FleetTransportError ? error : new FleetTransportError(`world-celld: malformed stream response from ${url.href}`, error);
+				if (attempt < READ_ATTEMPTS) continue;
+				throw lastError;
+			}
 		}
 		let error;
 		try {
@@ -276,6 +297,12 @@ async function readStreamChunks(transport, name, request, signal) {
 			lastError = error;
 			continue;
 		}
+		if (request.maxChunks > 32 && isChunkLimitRejection(error) && attempt < READ_ATTEMPTS) {
+			resetStreamChunkLimit(transport);
+			url.searchParams.set("maxChunks", String(32));
+			lastError = error;
+			continue;
+		}
 		throw error;
 	}
 	throw lastError instanceof Error ? lastError : new FleetTransportError("world-celld: stream read failed", lastError);
@@ -335,6 +362,8 @@ function makeStreamNamespace(transport) {
 			const control = makeStub(transport, "streams", name, STREAMS);
 			control.writeChunks = (runId, chunks) => writeStreamChunks(transport, name, runId, chunks);
 			control.readChunks = (request, signal) => readStreamChunks(transport, name, request, signal);
+			control.streamChunkLimit = () => streamChunkLimit(transport);
+			control.resetStreamChunkLimit = () => resetStreamChunkLimit(transport);
 			return control;
 		}
 	};
@@ -382,6 +411,20 @@ const HOOK_IDS = {
 	],
 	mutating: /* @__PURE__ */ new Set()
 };
+/** Transports whose worker answered the fleet-side run listing with 404. */
+const legacyRunListing = /* @__PURE__ */ new WeakSet();
+async function listResolvedRuns(transport, request) {
+	if (legacyRunListing.has(transport)) return null;
+	try {
+		return await callFleetRoute(transport, "/v1/index/runs/list-resolved", [request], { idempotent: true });
+	} catch (error) {
+		if (error.status === 404) {
+			legacyRunListing.add(transport);
+			return null;
+		}
+		throw error;
+	}
+}
 function createRemoteEnv(transport) {
 	const runCatalog = makeNamespace(transport, "run-catalog", RUN_CATALOG);
 	const hookTokens = makeNamespace(transport, "hook-tokens", HOOK_TOKENS);
@@ -402,6 +445,7 @@ function createRemoteEnv(transport) {
 				publicationExpiresAt
 			], { idempotent: true }),
 			listRuns: (options) => callFleetRoute(transport, "/v1/index/runs/list", [options], { idempotent: true }),
+			listResolvedRuns: (request) => listResolvedRuns(transport, request),
 			expireRun: (request) => callFleetRoute(transport, "/v1/index/runs/expire", [request], { idempotent: true }),
 			reserveHook: (token, owner) => callFleetRoute(transport, "/v1/index/hooks/reserve", [token, owner], { idempotent: true }),
 			finalizeHookIndexes: (token, hookId, serializedHook, owner, reservation) => callFleetRoute(transport, "/v1/index/hooks/finalize", [
@@ -458,7 +502,7 @@ const debug = createDebugLogger("celld-world");
 * Vendored from vinnymac/worlds packages/world-cloudflare/src/queue.ts
 * (Apache-2.0, see NOTICE), modified for celld:
 *
-* - Production publishes a small pointer through celld v0.5.0 native Queues.
+* - Production publishes a small pointer through celld v0.6.0 native Queues.
 *   The deployed Queue consumer forwards deliveries to the same HTTP handler
 *   used by the in-process test pump.
 * - Run-bearing message bodies live in the fleet object store. This preserves
@@ -828,6 +872,7 @@ function parseApplyEventOutcome(value) {
 	for (const releasedHook of value.releasedHooks) if (!isRecord(releasedHook) || typeof releasedHook.hookId !== "string" || releasedHook.hookId.length === 0 || typeof releasedHook.token !== "string" || releasedHook.token.length === 0) malformedApplyEventOutcome("releasedHooks entries must contain hookId and token strings");
 	const event = parseSuccessEntity(value, "event", EventSchema);
 	const run = parseSuccessEntity(value, "run", WorkflowRunSchema);
+	const replayRun = parseSuccessEntity(value, "replayRun", WorkflowRunSchema);
 	const step = parseSuccessEntity(value, "step", StepSchema);
 	const hook = parseSuccessEntity(value, "hook", HookSchema);
 	const wait = parseSuccessEntity(value, "wait", WaitSchema);
@@ -851,6 +896,7 @@ function parseApplyEventOutcome(value) {
 	if (value.cursor !== void 0 && value.cursor !== null && typeof value.cursor !== "string") malformedApplyEventOutcome("cursor must be a string or null");
 	if (value.hasMore !== void 0 && typeof value.hasMore !== "boolean") malformedApplyEventOutcome("hasMore must be a boolean");
 	if (value.maxEvents !== void 0 && (typeof value.maxEvents !== "number" || !Number.isSafeInteger(value.maxEvents) || value.maxEvents < 0)) malformedApplyEventOutcome("maxEvents must be a non-negative safe integer");
+	for (const flag of ["runIndexPublished", "hookIndexesReleased"]) if (value[flag] !== void 0 && value[flag] !== true) malformedApplyEventOutcome(`${flag} must be true when present`);
 	if (run !== void 0 && value.indexPublicationExpiresAt === void 0) malformedApplyEventOutcome("indexPublicationExpiresAt is required when run is present");
 	if (value.indexPublicationExpiresAt !== void 0 && (typeof value.indexPublicationExpiresAt !== "number" || !Number.isFinite(value.indexPublicationExpiresAt))) malformedApplyEventOutcome("indexPublicationExpiresAt must be a finite number");
 	return {
@@ -859,6 +905,7 @@ function parseApplyEventOutcome(value) {
 			...value,
 			event,
 			run,
+			replayRun,
 			step,
 			hook,
 			wait,
@@ -951,19 +998,6 @@ function unwrapRead(outcome) {
 	if (!outcome.ok) throw new RunExpiredError(outcome.message);
 	return outcome.value;
 }
-/** Bound cross-run fanout so large list pages cannot create an RPC burst. */
-const RUN_LIST_CONCURRENCY = 8;
-/**
-* 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 createStorage(config) {
 	const { env } = config;
 	const cleanup = { retentionMs: config.runRetentionMs ?? 0 };
@@ -981,61 +1015,31 @@ function createStorage(config) {
 		runs: {
 			get: runsGet,
 			async list(params) {
-				const statuses = params?.status === void 0 ? void 0 : Array.isArray(params.status) ? params.status : [params.status];
-				const limit = params?.pagination?.limit ?? 20;
-				const prefix = params?.workflowName ? `run:${params.workflowName}:` : "runall:";
-				const reverse = params?.pagination?.sortOrder === "desc";
-				const matches = [];
-				let scanCursor = params?.pagination?.cursor;
-				let exhausted = false;
-				while (matches.length <= limit && !exhausted) {
-					const kvList = await env.WORKFLOW_INDEX.listRuns({
-						prefix,
-						limit: Math.min(1e3, 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(RUN_LIST_CONCURRENCY, needed));
-						const resolved = await Promise.all(batch.map(async ({ key, metadata }) => {
-							try {
-								const run = await runsGet(metadata.runId, { resolveData: params?.resolveData });
-								return statuses === void 0 || statuses.includes(run.status) ? {
-									key,
-									run
-								} : null;
-							} catch (error) {
-								if (!WorkflowRunNotFoundError.is(error) && !RunExpiredError.is(error)) throw error;
-								return 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 }) => run),
-					cursor: hasMore ? page.at(-1)?.key ?? null : null,
-					hasMore
+				const request = {
+					workflowName: params?.workflowName,
+					statuses: params?.status === void 0 ? void 0 : Array.isArray(params.status) ? params.status : [params.status],
+					limit: params?.pagination?.limit ?? 20,
+					cursor: params?.pagination?.cursor,
+					sortOrder: params?.pagination?.sortOrder,
+					resolveData: params?.resolveData
+				};
+				const fleetPage = Number.isSafeInteger(request.limit) && request.limit >= 1 && request.limit <= 1e3 ? await env.WORKFLOW_INDEX.listResolvedRuns?.(compact(request)) : void 0;
+				if (fleetPage) return {
+					data: fleetPage.data.map((run) => filterData(parseRun(run), params?.resolveData, ["input", "output"])),
+					cursor: fleetPage.cursor,
+					hasMore: fleetPage.hasMore
 				};
+				return await listRunsPage({
+					listRuns: (options) => env.WORKFLOW_INDEX.listRuns(options),
+					readRun: async (runId) => {
+						try {
+							return await runsGet(runId);
+						} catch (error) {
+							if (WorkflowRunNotFoundError.is(error) || RunExpiredError.is(error)) return null;
+							throw error;
+						}
+					}
+				}, request);
 			}
 		},
 		events: {
@@ -1095,20 +1099,18 @@ function createStorage(config) {
 					throwOutcomeError(parsedOutcome.outcome, effectiveRunId, data);
 				}
 				const outcome = parsedOutcome.outcome;
-				if (outcome.run) {
-					const meta = JSON.stringify({
-						runId: effectiveRunId,
-						createdAt: outcome.run.createdAt.toISOString(),
-						status: outcome.run.status
-					});
+				if (outcome.run && !outcome.runIndexPublished) {
 					if (outcome.indexPublicationExpiresAt === void 0) throw new Error("world-celld: authoritative run mutation omitted its index lease");
-					await env.WORKFLOW_INDEX.commitRun(outcome.run, meta, outcome.indexPublicationExpiresAt);
+					await env.WORKFLOW_INDEX.commitRun(outcome.run, runIndexMetadata({
+						...outcome.run,
+						runId: effectiveRunId
+					}), outcome.indexPublicationExpiresAt);
 				}
 				if (outcome.hookToIndex) {
 					const serialized = stringify(outcome.hookToIndex);
 					await env.WORKFLOW_INDEX.finalizeHookIndexes(outcome.hookToIndex.token, outcome.hookToIndex.hookId, serialized, hookOwner(outcome.hookToIndex), hookAdmission?.reservation);
 				} else if (hookAdmission) await env.WORKFLOW_INDEX.releaseHookReservation(hookAdmission.token, hookAdmission.owner, hookAdmission.reservation);
-				if (outcome.releasedHooks.length > 0) await env.WORKFLOW_INDEX.releaseHookIndexes({
+				if (outcome.releasedHooks.length > 0 && !outcome.hookIndexesReleased) await env.WORKFLOW_INDEX.releaseHookIndexes({
 					runId: effectiveRunId,
 					hooks: outcome.releasedHooks
 				});
@@ -1119,7 +1121,7 @@ function createStorage(config) {
 				};
 				return {
 					event: outcome.event,
-					run: outcome.run,
+					run: outcome.run ?? outcome.replayRun,
 					step: outcome.step,
 					hook: outcome.hook,
 					wait: outcome.wait,
@@ -1276,18 +1278,28 @@ function createStreamer(config) {
 		const chunks = input.map(toBytes);
 		for (const chunk of chunks) if (chunk.byteLength > 1048576) throw new Error(`Stream chunk exceeds ${MAX_STREAM_CHUNK_BYTES} bytes`);
 		await registerStreamForRun(name, resolvedRunId);
-		let batch = [];
-		let batchBytes = 0;
-		for (const chunk of chunks) {
-			if (batch.length > 0 && (batch.length === 32 || batchBytes + chunk.byteLength > 8388608)) {
-				await getStreamDO(name).writeChunks(resolvedRunId, batch);
-				batch = [];
-				batchBytes = 0;
+		const stub = getStreamDO(name);
+		let next = 0;
+		while (next < chunks.length) {
+			const chunkLimit = stub.streamChunkLimit?.() ?? 32;
+			let end = next;
+			let batchBytes = 0;
+			while (end < chunks.length && end - next < chunkLimit && (end === next || batchBytes + chunks[end].byteLength <= 8388608)) {
+				batchBytes += chunks[end].byteLength;
+				end++;
+			}
+			const batch = chunks.slice(next, end);
+			try {
+				await stub.writeChunks(resolvedRunId, batch);
+			} catch (error) {
+				if (batch.length > 32 && isChunkLimitRejection(error)) {
+					stub.resetStreamChunkLimit?.();
+					continue;
+				}
+				throw error;
 			}
-			batch.push(chunk);
-			batchBytes += chunk.byteLength;
+			next = end;
 		}
-		if (batch.length > 0) await getStreamDO(name).writeChunks(resolvedRunId, batch);
 	};
 	const writeToStream = (name, runId, chunk) => writeChunksToStream(name, runId, [chunk]);
 	const closeStream = async (name, runId) => {
@@ -1325,7 +1337,7 @@ function createStreamer(config) {
 						result = await stub.readChunks({
 							runId,
 							startIndex: nextIndex,
-							maxChunks: 32,
+							maxChunks: stub.streamChunkLimit?.() ?? 32,
 							maxBytes: MAX_STREAM_READ_BYTES,
 							waitMs: streamLongPollMs
 						}, abortController.signal);
@@ -1355,10 +1367,11 @@ function createStreamer(config) {
 	const getStreamChunks = async (name, runId, options) => {
 		const requestedLimit = options?.limit ?? DEFAULT_CHUNK_PAGE_SIZE;
 		if (!Number.isSafeInteger(requestedLimit) || requestedLimit < 1) throw new Error("Stream chunk limit must be a positive safe integer");
-		const limit = Math.min(requestedLimit, MAX_CHUNK_PAGE_SIZE);
+		const stub = getStreamDO(name);
+		const limit = Math.min(requestedLimit, stub.streamChunkLimit?.() ?? MAX_CHUNK_PAGE_SIZE);
 		const startIndex = options?.cursor ? Number.parseInt(options.cursor, 10) : 0;
 		if (Number.isNaN(startIndex) || startIndex < 0) throw new Error(`Invalid stream cursor: ${options?.cursor}`);
-		const result = await getStreamDO(name).readChunks({
+		const result = await stub.readChunks({
 			runId,
 			startIndex,
 			maxChunks: limit,