deepline 0.1.78 → 0.1.80

package/dist/repo/apps/play-runner-workers/src/dedup-do.ts

@@ -85,35 +85,19 @@ type AwaitRequest = {
   timeoutMs: number;
 };
 
-type WorkflowPoolEntryState = 'warming' | 'ready';
-
-type WorkflowPoolEntry = {
-  id: string;
-  version: string;
-  state: WorkflowPoolEntryState;
-  createdAt: number;
-  readyAt: number | null;
-  expiresAt: number;
-};
-
-type WorkflowRunMappingState = 'claimed' | 'started' | 'blocked';
-
-type WorkflowRunMapping = {
+type WorkflowRunRetryState = {
   runId: string;
-  instanceId: string;
-  state: WorkflowRunMappingState;
-  blockedInstanceId?: string | null;
-  claimedAt?: number | null;
-  startedAt?: number | null;
-  version: string;
-  createdAt: number;
+  params: unknown;
+  paramsRef?: unknown;
+  paramsBytes?: number;
+  retryAttempts: number;
+  updatedAt: number;
   expiresAt: number;
 };
 
-type WorkflowRunRetryState = {
+type WorkflowInstanceState = {
   runId: string;
-  params: unknown;
-  retryAttempts: number;
+  instanceId: string;
   updatedAt: number;
   expiresAt: number;
 };
@@ -148,6 +132,12 @@ type CoordinatorTerminalState = {
   completedAt: number;
 };
 
+type CoordinatorChildTerminalState = {
+  eventKey: string;
+  data: unknown;
+  storedAt: number;
+};
+
 type CoordinatorRunEvent =
   | {
       seq: number;
@@ -194,31 +184,71 @@ type CoordinatorRunEvent =
 type OmitRunEventSequence<T> = T extends unknown ? Omit<T, 'seq'> : never;
 type CoordinatorRunEventInput = OmitRunEventSequence<CoordinatorRunEvent>;
 
-type ReadyWorkflowPoolEntryRecord = {
-  key: string;
-  entry: WorkflowPoolEntry & { state: 'ready'; readyAt: number };
+/**
+ * Per-(org,provider) rate-state for the distributed Rate State Backend.
+ *
+ * One PlayDedup DO instance is addressed per bucket via
+ * `idFromName('rate:<orgId>:<provider>')`, so a single instance owns the rate
+ * window for that bucket and is single-threaded — which is exactly why the
+ * in-process algorithm from `InMemoryRateStateBackend` is correct here. The
+ * coordinator RPCs `/rate-acquire` (lease N permits) and `/rate-penalize`
+ * (Retry-After cooldown) into it; the esm_workers runtime never blocks per call
+ * on a full round-trip because it leases small permit BLOCKS at a time.
+ *
+ * Rate windows are intentionally kept in DO memory (not durable storage): a
+ * window is sub-second-to-seconds ephemeral state, the DO instance outlives any
+ * single window, and persisting it would only add storage latency to the hot
+ * path. This mirrors the in-memory backend and the Redis sliding-window limiter
+ * (`src/lib/redis/customer-rate-limiter.ts`), which also keeps window state in a
+ * volatile store with TTL rather than durable rows.
+ */
+type RateRule = {
+  ruleId: string;
+  requestsPerWindow: number;
+  windowMs: number;
+  maxConcurrency: number | null;
+};
+
+type RateRuleWindowState = {
+  windowStartedAt: number;
+  startedInWindow: number;
+};
+
+type RateAcquireRequest = {
+  bucketId: string;
+  rules: RateRule[];
+  /** How many permits the caller wants to lease in this round-trip. */
+  requested: number;
+};
+
+type RateAcquireResponse = {
+  /** Permits actually granted (0..requested). */
+  granted: number;
+  /** Suggested wait before the next acquire when granted === 0. */
+  waitMs: number;
 };
 
-type WorkflowPoolCounts = {
-  available: number;
-  warming: number;
+type RatePenalizeRequest = {
+  bucketId: string;
+  cooldownMs: number;
 };
 
+const RATE_MIN_WAIT_MS = 10;
+const RATE_STATE_KEY = (bucketId: string, ruleId: string) =>
+  `${bucketId}::${ruleId}`;
+
 const DEDUP_KEY_PREFIX = 'd:';
-const WORKFLOW_POOL_KEY_PREFIX = 'p:';
-const WORKFLOW_POOL_RUN_KEY_PREFIX = 'm:';
 const WORKFLOW_RUN_RETRY_KEY_PREFIX = 'r:';
 const WORKFLOW_DB_SESSIONS_KEY = 'db-sessions';
 const COORDINATOR_TRACE_KEY_PREFIX = 't:';
 const COORDINATOR_RUN_EVENT_KEY_PREFIX = 'e:';
 const COORDINATOR_TERMINAL_KEY = 'terminal';
+const COORDINATOR_CHILD_TERMINAL_KEY_PREFIX = 'child-terminal:';
 const COORDINATOR_RUN_EVENT_SEQUENCE_KEY = 'event-seq';
 const COORDINATOR_TRACE_MAX_ENTRIES = 200;
 const COORDINATOR_RUN_EVENT_MAX_ENTRIES = 500;
 const FINISH_ALARM_DELAY_MS = 60_000; // self-evict 1 min after finish() called
-const WORKFLOW_POOL_DEFAULT_TTL_MS = 8 * 60 * 1000;
-const WORKFLOW_POOL_RUN_MAPPING_TTL_MS = 60 * 60 * 1000;
-const WORKFLOW_POOL_READY_MAX_AGE_MS = 7 * 60_000;
+const WORKFLOW_RUN_STATE_TTL_MS = 60 * 60 * 1000;
 const WORKFLOW_RUN_RETRY_STATE_MAX_BYTES = 110_000;
 const WORKFLOW_DB_SESSIONS_TTL_MS = 10 * 60_000;
 
@@ -251,6 +281,13 @@ export class PlayDedup implements DurableObject {
   private waiters: Map<string, Set<(value: unknown) => void>> = new Map();
   private runEventWaiters: Set<(value: CoordinatorRunEvent) => void> =
     new Set();
+  private childTerminalWaiters: Map<string, Set<() => void>> = new Map();
+  // Per-(bucketId, ruleId) request-window state for the rate-state backend.
+  // In-memory by design — see the RateRule doc block. Single-threaded DO access
+  // makes this the same sliding-window algorithm as InMemoryRateStateBackend.
+  private rateWindows: Map<string, RateRuleWindowState> = new Map();
+  // Per-bucket Retry-After cooldown floors (penalize()).
+  private rateCooldownUntil: Map<string, number> = new Map();
 
   constructor(
     private readonly state: DurableObjectState,
@@ -269,10 +306,35 @@ export class PlayDedup implements DurableObject {
     return `${COORDINATOR_RUN_EVENT_KEY_PREFIX}${String(event.seq).padStart(13, '0')}`;
   }
 
+  private runEventKeyForSeq(seq: number): string {
+    return `${COORDINATOR_RUN_EVENT_KEY_PREFIX}${String(seq).padStart(13, '0')}`;
+  }
+
   private waiterKey(toolId: string, inputHash: string): string {
     return `${toolId}:${inputHash}`;
   }
 
+  private childTerminalKey(eventKey: string): string {
+    return `${COORDINATOR_CHILD_TERMINAL_KEY_PREFIX}${eventKey}`;
+  }
+
+  private wakeChildTerminalWaiters(eventKey: string): void {
+    const waiters = this.childTerminalWaiters.get(eventKey);
+    if (!waiters) return;
+    for (const resolve of waiters) {
+      resolve();
+    }
+    this.childTerminalWaiters.delete(eventKey);
+  }
+
+  private async readChildTerminalState(
+    eventKey: string,
+  ): Promise<CoordinatorChildTerminalState | undefined> {
+    return await this.state.storage.get<CoordinatorChildTerminalState>(
+      this.childTerminalKey(eventKey),
+    );
+  }
+
   async fetch(req: Request): Promise<Response> {
     const url = new URL(req.url);
     try {
@@ -287,36 +349,20 @@ export class PlayDedup implements DurableObject {
           return await this.handleFinish(req);
         case '/debug':
           return await this.handleDebug(req);
-        case '/pool-add':
-          return await this.handlePoolAdd(req);
-        case '/pool-claim':
-          return await this.handlePoolClaim(req);
-        case '/pool-count':
-          return await this.handlePoolCount(req);
-        case '/pool-list':
-          return await this.handlePoolList(req);
-        case '/pool-promote':
-          return await this.handlePoolPromote(req);
-        case '/pool-ready':
-          return await this.handlePoolReady(req);
-        case '/pool-delete':
-          return await this.handlePoolDelete(req);
-        case '/pool-map-run':
-          return await this.handlePoolMapRun(req);
-        case '/pool-block-run':
-          return await this.handlePoolBlockRun(req);
-        case '/pool-resolve-run':
-          return await this.handlePoolResolveRun(req);
         case '/run-retry-state-put':
           return await this.handleRunRetryStatePut(req);
+        case '/run-launch-state-put':
+          return await this.handleRunLaunchStatePut(req);
+        case '/workflow-instance-put':
+          return await this.handleWorkflowInstancePut(req);
+        case '/workflow-instance-get':
+          return await this.handleWorkflowInstanceGet(req);
         case '/run-retry-claim':
           return await this.handleRunRetryClaim(req);
         case '/db-sessions-put':
           return await this.handleDbSessionsPut(req);
         case '/db-sessions-get':
           return await this.handleDbSessionsGet(req);
-        case '/pool-clear':
-          return await this.handlePoolClear(req);
         case '/trace-add':
           return await this.handleTraceAdd(req);
         case '/trace-list':
@@ -329,6 +375,16 @@ export class PlayDedup implements DurableObject {
           return await this.handleTerminalSet(req);
         case '/terminal-get':
           return await this.handleTerminalGet();
+        case '/child-terminal-set':
+          return await this.handleChildTerminalSet(req);
+        case '/child-terminal-get':
+          return await this.handleChildTerminalGet(req);
+        case '/child-terminal-await':
+          return await this.handleChildTerminalAwait(req);
+        case '/rate-acquire':
+          return await this.handleRateAcquire(req);
+        case '/rate-penalize':
+          return await this.handleRatePenalize(req);
         default:
           return new Response('not found', { status: 404 });
       }
@@ -343,10 +399,11 @@ export class PlayDedup implements DurableObject {
 
   async alarm(): Promise<void> {
     // Fired after /finish was called. Evict storage and let the DO instance
-    // be garbage-collected by CF's hot pool.
+    // be garbage-collected by Cloudflare.
     await this.state.storage.deleteAll();
     this.waiters.clear();
     this.runEventWaiters.clear();
+    this.childTerminalWaiters.clear();
   }
 
   private async handleLookupOrClaim(req: Request): Promise<Response> {
@@ -514,575 +571,125 @@ export class PlayDedup implements DurableObject {
     );
   }
 
-  private workflowPoolVersion(req: Request): string {
-    return new URL(req.url).searchParams.get('version')?.trim() ?? '';
-  }
-
-  private workflowPoolMinReadyAgeMs(req: Request): number {
-    const raw = Number(new URL(req.url).searchParams.get('minReadyAgeMs') ?? 0);
-    if (!Number.isFinite(raw) || raw <= 0) {
-      return 0;
-    }
-    return Math.min(Math.floor(raw), WORKFLOW_POOL_DEFAULT_TTL_MS);
-  }
-
-  private isReadyWorkflowPoolEntry(
-    value: { key: string; entry: WorkflowPoolEntry | undefined },
-    version: string,
-    now: number,
-    minReadyAgeMs = 0,
-  ): value is ReadyWorkflowPoolEntryRecord {
-    return (
-      value.entry !== undefined &&
-      value.entry.version === version &&
-      value.entry.expiresAt > now &&
-      value.entry.state === 'ready' &&
-      value.entry.readyAt !== null &&
-      now - value.entry.readyAt <= WORKFLOW_POOL_READY_MAX_AGE_MS &&
-      now - value.entry.readyAt >= minReadyAgeMs
-    );
-  }
-
-  private async gcWorkflowPool(
-    now = Date.now(),
-    version?: string,
-  ): Promise<void> {
-    const [pool, mappings, retries] = await Promise.all([
-      this.state.storage.list<WorkflowPoolEntry>({
-        prefix: WORKFLOW_POOL_KEY_PREFIX,
-      }),
-      this.state.storage.list<WorkflowRunMapping>({
-        prefix: WORKFLOW_POOL_RUN_KEY_PREFIX,
-      }),
-      this.state.storage.list<WorkflowRunRetryState>({
-        prefix: WORKFLOW_RUN_RETRY_KEY_PREFIX,
-      }),
-    ]);
-    const expiredKeys: string[] = [];
-    for (const [key, entry] of pool) {
-      if (
-        !entry ||
-        entry.expiresAt <= now ||
-        (entry.state === 'ready' &&
-          entry.readyAt !== null &&
-          now - entry.readyAt > WORKFLOW_POOL_READY_MAX_AGE_MS) ||
-        (version && entry.version !== version)
-      ) {
-        expiredKeys.push(key);
-      }
-    }
-    for (const [key, mapping] of mappings) {
-      if (
-        !mapping ||
-        mapping.expiresAt <= now ||
-        (version && mapping.version !== version)
-      ) {
-        expiredKeys.push(key);
-      }
-    }
-    for (const [key, retryState] of retries) {
-      if (!retryState || retryState.expiresAt <= now) {
-        expiredKeys.push(key);
-      }
-    }
-    if (expiredKeys.length > 0) {
-      await this.state.storage.delete(expiredKeys);
-    }
-  }
-
-  private async handlePoolAdd(req: Request): Promise<Response> {
-    const body = (await req.json().catch(() => null)) as {
-      ids?: unknown;
-      ttlMs?: unknown;
-      version?: unknown;
-      readyAt?: unknown;
-      ready?: unknown;
-    } | null;
-    const version =
-      typeof body?.version === 'string' ? body.version.trim() : '';
-    if (!version) {
-      return new Response('version is required', { status: 400 });
-    }
-    const ids = Array.isArray(body?.ids)
-      ? body.ids.filter(
-          (id): id is string => typeof id === 'string' && id.length > 0,
-        )
-      : [];
-    const now = Date.now();
-    const hasReadyAt =
-      typeof body?.readyAt === 'number' && Number.isFinite(body.readyAt);
-    const readyAt = hasReadyAt ? Math.max(0, body.readyAt as number) : now;
-    const ready = body?.ready === true || hasReadyAt;
-    const ttlMs =
-      typeof body?.ttlMs === 'number' &&
-      Number.isFinite(body.ttlMs) &&
-      body.ttlMs > 0
-        ? Math.min(body.ttlMs, WORKFLOW_POOL_DEFAULT_TTL_MS)
-        : WORKFLOW_POOL_DEFAULT_TTL_MS;
-    await this.state.blockConcurrencyWhile(async () => {
-      await this.gcWorkflowPool(now, version);
-      const writes: Record<string, WorkflowPoolEntry> = {};
-      const keys = ids.map((id) => `${WORKFLOW_POOL_KEY_PREFIX}${id}`);
-      const existing = (await this.state.storage.get<WorkflowPoolEntry>(
-        keys,
-      )) as Map<string, WorkflowPoolEntry>;
-      for (const id of ids) {
-        const key = `${WORKFLOW_POOL_KEY_PREFIX}${id}`;
-        const existingEntry = existing.get(key);
-        const existingReadyAt =
-          existingEntry?.version === version &&
-          existingEntry.expiresAt > now &&
-          existingEntry.state === 'ready' &&
-          existingEntry.readyAt !== null
-            ? existingEntry.readyAt
-            : null;
-        const nextReadyAt = ready ? readyAt : existingReadyAt;
-        writes[key] = {
-          id,
-          version,
-          state: nextReadyAt !== null ? 'ready' : 'warming',
-          createdAt:
-            existingEntry?.version === version ? existingEntry.createdAt : now,
-          readyAt: nextReadyAt,
-          expiresAt: now + ttlMs,
-        };
-      }
-      if (Object.keys(writes).length > 0) {
-        await this.state.storage.put(writes);
-      }
-    });
-    return new Response(JSON.stringify({ added: ids.length }), {
-      headers: { 'content-type': 'application/json' },
-    });
-  }
-
-  private async handlePoolClaim(req: Request): Promise<Response> {
-    const version = this.workflowPoolVersion(req);
-    if (!version) {
-      return new Response('version is required', { status: 400 });
-    }
-    const body = (await req.json().catch(() => null)) as {
-      runId?: unknown;
-    } | null;
-    const runId = typeof body?.runId === 'string' ? body.runId : '';
-    if (!runId) {
-      return new Response('runId is required', { status: 400 });
-    }
-    const minReadyAgeMs = this.workflowPoolMinReadyAgeMs(req);
-    let claimedId: string | null = null;
-    let counts: WorkflowPoolCounts = { available: 0, warming: 0 };
-    await this.state.blockConcurrencyWhile(async () => {
-      const now = Date.now();
-      await this.gcWorkflowPool(now, version);
-      const mappingKey = `${WORKFLOW_POOL_RUN_KEY_PREFIX}${runId}`;
-      const existingMapping =
-        await this.state.storage.get<WorkflowRunMapping>(mappingKey);
-      if (existingMapping?.version === version) {
-        if (
-          existingMapping.state === 'claimed' ||
-          existingMapping.state === 'started'
-        ) {
-          claimedId = existingMapping.instanceId || null;
-        }
-        return;
-      }
-      const entries = await this.state.storage.list<WorkflowPoolEntry>({
-        prefix: WORKFLOW_POOL_KEY_PREFIX,
-      });
-      counts = this.countWorkflowPoolEntries(
-        entries,
-        version,
-        now,
-        minReadyAgeMs,
-      );
-      const sorted = [...entries.entries()]
-        .map(([key, entry]) => ({ key, entry }))
-        .filter((entry) =>
-          this.isReadyWorkflowPoolEntry(entry, version, now, minReadyAgeMs),
-        )
-        .sort((a, b) => b.entry.readyAt - a.entry.readyAt);
-      const selected = sorted[0];
-      if (!selected) return;
-      claimedId = selected.entry.id;
-      await this.state.storage.delete(selected.key);
-      await this.state.storage.put(mappingKey, {
-        runId,
-        instanceId: claimedId,
-        state: 'claimed',
-        blockedInstanceId: null,
-        claimedAt: now,
-        startedAt: null,
-        version,
-        createdAt: now,
-        expiresAt: now + WORKFLOW_POOL_RUN_MAPPING_TTL_MS,
-      } satisfies WorkflowRunMapping);
-      counts = {
-        available: Math.max(0, counts.available - 1),
-        warming: counts.warming,
-      };
-    });
-    return new Response(JSON.stringify({ id: claimedId, ...counts }), {
-      headers: { 'content-type': 'application/json' },
-    });
-  }
-
-  private async handlePoolCount(req: Request): Promise<Response> {
-    const version = this.workflowPoolVersion(req);
-    if (!version) {
-      return new Response('version is required', { status: 400 });
-    }
-    const minReadyAgeMs = this.workflowPoolMinReadyAgeMs(req);
-    const now = Date.now();
-    await this.gcWorkflowPool(now, version);
-    const entries = await this.state.storage.list<WorkflowPoolEntry>({
-      prefix: WORKFLOW_POOL_KEY_PREFIX,
-    });
-    const counts = this.countWorkflowPoolEntries(
-      entries,
-      version,
-      now,
-      minReadyAgeMs,
-    );
-    return new Response(JSON.stringify(counts), {
-      headers: { 'content-type': 'application/json' },
-    });
-  }
-
-  private countWorkflowPoolEntries(
-    entries: Map<string, WorkflowPoolEntry>,
-    version: string,
-    now: number,
-    minReadyAgeMs: number,
-  ): WorkflowPoolCounts {
-    let available = 0;
-    let warming = 0;
-    for (const entry of entries.values()) {
-      if (entry.version !== version) continue;
-      if (
-        entry.state !== 'ready' ||
-        entry.readyAt === null ||
-        now - entry.readyAt > WORKFLOW_POOL_READY_MAX_AGE_MS ||
-        now - entry.readyAt < minReadyAgeMs
-      ) {
-        warming += 1;
-      } else {
-        available += 1;
-      }
-    }
-    return { available, warming };
-  }
-
-  private async handlePoolList(req: Request): Promise<Response> {
-    const version = this.workflowPoolVersion(req);
-    if (!version) {
-      return new Response('version is required', { status: 400 });
-    }
-    await this.gcWorkflowPool(Date.now(), version);
-    const entries = await this.state.storage.list<WorkflowPoolEntry>({
-      prefix: WORKFLOW_POOL_KEY_PREFIX,
-    });
-    return new Response(
-      JSON.stringify({
-        entries: [...entries.values()]
-          .filter((entry) => entry.version === version)
-          .map((entry) => ({
-            id: entry.id,
-            state: entry.state,
-            createdAt: entry.createdAt,
-            readyAt: entry.readyAt,
-            expiresAt: entry.expiresAt,
-          })),
-      }),
-      { headers: { 'content-type': 'application/json' } },
-    );
-  }
-
-  private async handlePoolPromote(req: Request): Promise<Response> {
-    const body = (await req.json().catch(() => null)) as {
-      ids?: unknown;
-      version?: unknown;
-    } | null;
-    const version =
-      typeof body?.version === 'string' ? body.version.trim() : '';
-    if (!version) {
-      return new Response('version is required', { status: 400 });
-    }
-    const ids = Array.isArray(body?.ids)
-      ? body.ids.filter(
-          (id): id is string => typeof id === 'string' && id.length > 0,
-        )
-      : [];
-    const now = Date.now();
-    const writes: Record<string, WorkflowPoolEntry> = {};
-    await this.state.blockConcurrencyWhile(async () => {
-      await this.gcWorkflowPool(now, version);
-      for (const id of ids) {
-        const key = `${WORKFLOW_POOL_KEY_PREFIX}${id}`;
-        const entry = await this.state.storage.get<WorkflowPoolEntry>(key);
-        if (!entry || entry.version !== version || entry.expiresAt <= now) {
-          continue;
-        }
-        writes[key] = {
-          ...entry,
-          state: 'ready',
-          readyAt: now,
-        };
-      }
-      if (Object.keys(writes).length > 0) {
-        await this.state.storage.put(writes);
-      }
-    });
-    return new Response(
-      JSON.stringify({ promoted: Object.keys(writes).length }),
-      {
-        headers: { 'content-type': 'application/json' },
-      },
-    );
-  }
-
-  private async handlePoolReady(req: Request): Promise<Response> {
-    const body = (await req.json().catch(() => null)) as {
-      poolId?: unknown;
-      version?: unknown;
-    } | null;
-    const poolId = typeof body?.poolId === 'string' ? body.poolId : '';
-    const version =
-      typeof body?.version === 'string' ? body.version.trim() : '';
-    if (!poolId || !version) {
-      return new Response('poolId and version are required', { status: 400 });
-    }
-    const now = Date.now();
-    let ready = false;
-    await this.state.blockConcurrencyWhile(async () => {
-      await this.gcWorkflowPool(now, version);
-      const key = `${WORKFLOW_POOL_KEY_PREFIX}${poolId}`;
-      const entry = await this.state.storage.get<WorkflowPoolEntry>(key);
-      if (!entry || entry.version !== version || entry.expiresAt <= now) {
-        return;
-      }
-      await this.state.storage.put(key, {
-        ...entry,
-        state: 'ready',
-        readyAt: entry.readyAt ?? now,
-      });
-      ready = true;
-    });
-    return new Response(JSON.stringify({ ready }), {
-      headers: { 'content-type': 'application/json' },
-    });
-  }
-
-  private async handlePoolDelete(req: Request): Promise<Response> {
-    const body = (await req.json().catch(() => null)) as {
-      ids?: unknown;
-      version?: unknown;
-    } | null;
-    const version =
-      typeof body?.version === 'string' ? body.version.trim() : '';
-    if (!version) {
-      return new Response('version is required', { status: 400 });
-    }
-    const ids = Array.isArray(body?.ids)
-      ? body.ids.filter(
-          (id): id is string => typeof id === 'string' && id.length > 0,
-        )
-      : [];
-    const keys: string[] = [];
-    await this.state.blockConcurrencyWhile(async () => {
-      await this.gcWorkflowPool(Date.now(), version);
-      for (const id of ids) {
-        const key = `${WORKFLOW_POOL_KEY_PREFIX}${id}`;
-        const entry = await this.state.storage.get<WorkflowPoolEntry>(key);
-        if (entry?.version === version) keys.push(key);
-      }
-      if (keys.length > 0) {
-        await this.state.storage.delete(keys);
-      }
-    });
-    return new Response(JSON.stringify({ deleted: keys.length }), {
-      headers: { 'content-type': 'application/json' },
-    });
-  }
-
-  private async handlePoolMapRun(req: Request): Promise<Response> {
+  private async handleRunRetryStatePut(req: Request): Promise<Response> {
     const body = (await req.json().catch(() => null)) as {
       runId?: unknown;
-      instanceId?: unknown;
-      version?: unknown;
-      started?: unknown;
+      params?: unknown;
+      ttlMs?: unknown;
     } | null;
     const runId = typeof body?.runId === 'string' ? body.runId : '';
-    const instanceId =
-      typeof body?.instanceId === 'string' ? body.instanceId : '';
-    const version =
-      typeof body?.version === 'string' ? body.version.trim() : '';
-    const started = body?.started === true;
-    if (!runId || !instanceId || !version) {
-      return new Response('runId, instanceId, and version are required', {
+    if (!runId || !body || (!('params' in body) && !('paramsRef' in body))) {
+      return new Response('runId and params or paramsRef are required', {
         status: 400,
       });
     }
     const now = Date.now();
-    let mapped = true;
-    const key = `${WORKFLOW_POOL_RUN_KEY_PREFIX}${runId}`;
+    const ttlMs =
+      typeof body.ttlMs === 'number' && Number.isFinite(body.ttlMs)
+        ? Math.max(60_000, Math.min(body.ttlMs, WORKFLOW_RUN_STATE_TTL_MS))
+        : WORKFLOW_RUN_STATE_TTL_MS;
+    const key = `${WORKFLOW_RUN_RETRY_KEY_PREFIX}${runId}`;
     await this.state.blockConcurrencyWhile(async () => {
-      const existing = await this.state.storage.get<WorkflowRunMapping>(key);
-      if (
-        existing?.version === version &&
-        existing.state === 'blocked' &&
-        existing.blockedInstanceId === instanceId
-      ) {
-        mapped = false;
-        return;
-      }
-      const alreadyStarted =
-        existing?.version === version &&
-        existing.instanceId === instanceId &&
-        existing.state === 'started' &&
-        typeof existing.startedAt === 'number';
-      const startedAt = started || alreadyStarted ? now : null;
-      await this.state.storage.put(key, {
+      const existing = await this.state.storage.get<WorkflowRunRetryState>(key);
+      const retryState = {
         runId,
-        instanceId,
-        state: startedAt !== null ? 'started' : 'claimed',
-        blockedInstanceId: null,
-        claimedAt:
-          existing?.version === version &&
-          typeof existing.claimedAt === 'number'
-            ? existing.claimedAt
-            : now,
-        startedAt,
-        version,
-        createdAt:
-          existing?.version === version && existing.createdAt
-            ? existing.createdAt
-            : now,
-        expiresAt: now + WORKFLOW_POOL_RUN_MAPPING_TTL_MS,
-      } satisfies WorkflowRunMapping);
-    });
-    return new Response(JSON.stringify({ mapped }), {
-      headers: { 'content-type': 'application/json' },
-    });
-  }
-
-  private async handlePoolBlockRun(req: Request): Promise<Response> {
-    const body = (await req.json().catch(() => null)) as {
-      runId?: unknown;
-      instanceId?: unknown;
-      version?: unknown;
-    } | null;
-    const runId = typeof body?.runId === 'string' ? body.runId : '';
-    const instanceId =
-      typeof body?.instanceId === 'string' ? body.instanceId : '';
-    const version =
-      typeof body?.version === 'string' ? body.version.trim() : '';
-    if (!runId || !instanceId || !version) {
-      return new Response('runId, instanceId, and version are required', {
-        status: 400,
-      });
-    }
-    const now = Date.now();
-    const key = `${WORKFLOW_POOL_RUN_KEY_PREFIX}${runId}`;
-    let started = false;
-    await this.state.blockConcurrencyWhile(async () => {
-      const existing = await this.state.storage.get<WorkflowRunMapping>(key);
-      if (
-        existing?.version === version &&
-        existing.instanceId === instanceId &&
-        existing.state === 'started' &&
-        typeof existing.startedAt === 'number'
-      ) {
-        started = true;
-        return;
+        params: 'params' in body ? body.params : null,
+        paramsRef: 'paramsRef' in body ? body.paramsRef : null,
+        paramsBytes:
+          typeof (body as { paramsBytes?: unknown }).paramsBytes === 'number' &&
+          Number.isFinite((body as { paramsBytes?: number }).paramsBytes)
+            ? (body as { paramsBytes: number }).paramsBytes
+            : undefined,
+        retryAttempts:
+          existing?.runId === runId &&
+          typeof existing.retryAttempts === 'number'
+            ? existing.retryAttempts
+            : 0,
+        updatedAt: now,
+        expiresAt: now + ttlMs,
+      } satisfies WorkflowRunRetryState;
+      const bytes = jsonByteLength(retryState);
+      if (bytes > WORKFLOW_RUN_RETRY_STATE_MAX_BYTES) {
+        throw new Error(
+          `workflow retry state too large: ${bytes} bytes exceeds ${WORKFLOW_RUN_RETRY_STATE_MAX_BYTES}`,
+        );
       }
-      await this.state.storage.put(key, {
-        runId,
-        instanceId: '',
-        state: 'blocked',
-        blockedInstanceId: instanceId,
-        claimedAt:
-          existing?.version === version &&
-          typeof existing.claimedAt === 'number'
-            ? existing.claimedAt
-            : now,
-        startedAt: null,
-        version,
-        createdAt: now,
-        expiresAt: now + WORKFLOW_POOL_RUN_MAPPING_TTL_MS,
-      } satisfies WorkflowRunMapping);
+      await this.state.storage.put(key, retryState);
     });
-    if (started) {
-      return new Response(JSON.stringify({ blocked: false, started: true }), {
-        headers: { 'content-type': 'application/json' },
-      });
-    }
-    return new Response(JSON.stringify({ blocked: true, started: false }), {
+    return new Response(JSON.stringify({ ok: true }), {
       headers: { 'content-type': 'application/json' },
     });
   }
 
-  private async handlePoolResolveRun(req: Request): Promise<Response> {
-    const url = new URL(req.url);
-    const runId = url.searchParams.get('runId') ?? '';
-    const version = url.searchParams.get('version')?.trim() ?? '';
-    if (!runId) {
-      return new Response('runId is required', { status: 400 });
-    }
-    if (!version) {
-      return new Response('version is required', { status: 400 });
-    }
-    await this.gcWorkflowPool(Date.now(), version);
-    const mapping = await this.state.storage.get<WorkflowRunMapping>(
-      `${WORKFLOW_POOL_RUN_KEY_PREFIX}${runId}`,
-    );
-    if (mapping && mapping.version !== version) {
-      await this.state.storage.delete(
-        `${WORKFLOW_POOL_RUN_KEY_PREFIX}${runId}`,
-      );
-      return new Response(JSON.stringify({ instanceId: null }), {
-        headers: { 'content-type': 'application/json' },
-      });
-    }
-    return new Response(
-      JSON.stringify({
-        instanceId: mapping?.instanceId || null,
-        startedAt: mapping?.startedAt ?? null,
-      }),
-      { headers: { 'content-type': 'application/json' } },
-    );
-  }
-
-  private async handleRunRetryStatePut(req: Request): Promise<Response> {
+  private async handleRunLaunchStatePut(req: Request): Promise<Response> {
     const body = (await req.json().catch(() => null)) as {
       runId?: unknown;
       params?: unknown;
-      ttlMs?: unknown;
+      paramsRef?: unknown;
+      paramsBytes?: unknown;
+      sessions?: unknown;
+      retryTtlMs?: unknown;
+      dbSessionsTtlMs?: unknown;
     } | null;
     const runId = typeof body?.runId === 'string' ? body.runId : '';
-    if (!runId || !body || !('params' in body)) {
-      return new Response('runId and params are required', { status: 400 });
+    const sessions = Array.isArray(body?.sessions)
+      ? (body.sessions as PreloadedRuntimeDbSession[])
+      : null;
+    if (
+      !runId ||
+      !body ||
+      (!('params' in body) && !('paramsRef' in body)) ||
+      !sessions
+    ) {
+      return new Response(
+        'runId, params or paramsRef, and sessions are required',
+        {
+          status: 400,
+        },
+      );
     }
+    assertEncryptedDbSessionsForStorage(sessions);
     const now = Date.now();
-    const ttlMs =
-      typeof body.ttlMs === 'number' && Number.isFinite(body.ttlMs)
-        ? Math.max(
-            60_000,
-            Math.min(body.ttlMs, WORKFLOW_POOL_RUN_MAPPING_TTL_MS),
+    const retryTtlMs =
+      typeof body.retryTtlMs === 'number' && Number.isFinite(body.retryTtlMs)
+        ? Math.max(60_000, Math.min(body.retryTtlMs, WORKFLOW_RUN_STATE_TTL_MS))
+        : WORKFLOW_RUN_STATE_TTL_MS;
+    const dbSessionsTtlMs =
+      typeof body.dbSessionsTtlMs === 'number' &&
+      Number.isFinite(body.dbSessionsTtlMs) &&
+      body.dbSessionsTtlMs > 0
+        ? Math.min(
+            Math.max(Math.floor(body.dbSessionsTtlMs), 60_000),
+            30 * 60_000,
           )
-        : WORKFLOW_POOL_RUN_MAPPING_TTL_MS;
-    const key = `${WORKFLOW_RUN_RETRY_KEY_PREFIX}${runId}`;
+        : WORKFLOW_DB_SESSIONS_TTL_MS;
+    const retryKey = `${WORKFLOW_RUN_RETRY_KEY_PREFIX}${runId}`;
+    const dbSessionsState: WorkflowDbSessionsState = {
+      runId,
+      sessions,
+      storedAt: now,
+      expiresAt: now + dbSessionsTtlMs,
+    };
+    let retryStateExpiresAt = now + retryTtlMs;
     await this.state.blockConcurrencyWhile(async () => {
-      const existing = await this.state.storage.get<WorkflowRunRetryState>(key);
+      const existing =
+        await this.state.storage.get<WorkflowRunRetryState>(retryKey);
       const retryState = {
         runId,
-        params: body.params,
+        params: 'params' in body ? body.params : null,
+        paramsRef: 'paramsRef' in body ? body.paramsRef : null,
+        paramsBytes:
+          typeof body.paramsBytes === 'number' &&
+          Number.isFinite(body.paramsBytes)
+            ? body.paramsBytes
+            : undefined,
         retryAttempts:
           existing?.runId === runId &&
           typeof existing.retryAttempts === 'number'
             ? existing.retryAttempts
             : 0,
         updatedAt: now,
-        expiresAt: now + ttlMs,
+        expiresAt: retryStateExpiresAt,
       } satisfies WorkflowRunRetryState;
       const bytes = jsonByteLength(retryState);
       if (bytes > WORKFLOW_RUN_RETRY_STATE_MAX_BYTES) {
@@ -1090,11 +697,19 @@ export class PlayDedup implements DurableObject {
           `workflow retry state too large: ${bytes} bytes exceeds ${WORKFLOW_RUN_RETRY_STATE_MAX_BYTES}`,
         );
       }
-      await this.state.storage.put(key, retryState);
-    });
-    return new Response(JSON.stringify({ ok: true }), {
-      headers: { 'content-type': 'application/json' },
+      retryStateExpiresAt = retryState.expiresAt;
+      await this.state.storage.put(retryKey, retryState);
+      await this.state.storage.put(WORKFLOW_DB_SESSIONS_KEY, dbSessionsState);
     });
+    return new Response(
+      JSON.stringify({
+        ok: true,
+        sessionCount: sessions.length,
+        retryExpiresAt: retryStateExpiresAt,
+        dbSessionsExpiresAt: dbSessionsState.expiresAt,
+      }),
+      { headers: { 'content-type': 'application/json' } },
+    );
   }
 
   private async handleRunRetryClaim(req: Request): Promise<Response> {
@@ -1128,6 +743,8 @@ export class PlayDedup implements DurableObject {
           claimed: false,
           attempts: existing.retryAttempts,
           params: existing.params,
+          paramsRef: existing.paramsRef ?? null,
+          paramsBytes: existing.paramsBytes ?? null,
         };
         return;
       }
@@ -1136,12 +753,14 @@ export class PlayDedup implements DurableObject {
         ...existing,
         retryAttempts: nextAttempts,
         updatedAt: now,
-        expiresAt: now + WORKFLOW_POOL_RUN_MAPPING_TTL_MS,
+        expiresAt: now + WORKFLOW_RUN_STATE_TTL_MS,
       } satisfies WorkflowRunRetryState);
       response = {
         claimed: true,
         attempts: nextAttempts,
         params: existing.params,
+        paramsRef: existing.paramsRef ?? null,
+        paramsBytes: existing.paramsBytes ?? null,
       };
     });
     return new Response(JSON.stringify(response), {
@@ -1149,6 +768,59 @@ export class PlayDedup implements DurableObject {
     });
   }
 
+  private async handleWorkflowInstancePut(req: Request): Promise<Response> {
+    const body = (await req.json().catch(() => null)) as {
+      runId?: unknown;
+      instanceId?: unknown;
+      ttlMs?: unknown;
+    } | null;
+    const runId = typeof body?.runId === 'string' ? body.runId : '';
+    const instanceId =
+      typeof body?.instanceId === 'string' ? body.instanceId : '';
+    if (!runId || !instanceId) {
+      return new Response('runId and instanceId are required', { status: 400 });
+    }
+    const now = Date.now();
+    const ttlMs =
+      typeof body?.ttlMs === 'number' &&
+      Number.isFinite(body.ttlMs) &&
+      body.ttlMs > 0
+        ? Math.max(60_000, Math.min(body.ttlMs, WORKFLOW_RUN_STATE_TTL_MS))
+        : WORKFLOW_RUN_STATE_TTL_MS;
+    await this.state.storage.put('workflow-instance', {
+      runId,
+      instanceId,
+      updatedAt: now,
+      expiresAt: now + ttlMs,
+    } satisfies WorkflowInstanceState);
+    return new Response(JSON.stringify({ ok: true }), {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  private async handleWorkflowInstanceGet(req: Request): Promise<Response> {
+    const runId = new URL(req.url).searchParams.get('runId') ?? '';
+    if (!runId) {
+      return new Response('runId is required', { status: 400 });
+    }
+    const state =
+      await this.state.storage.get<WorkflowInstanceState>('workflow-instance');
+    if (!state || state.runId !== runId) {
+      return new Response(JSON.stringify({ instanceId: null }), {
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+    if (state.expiresAt <= Date.now()) {
+      await this.state.storage.delete('workflow-instance');
+      return new Response(JSON.stringify({ instanceId: null }), {
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+    return new Response(JSON.stringify({ instanceId: state.instanceId }), {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
   private async handleDbSessionsPut(req: Request): Promise<Response> {
     const body = (await req.json().catch(() => null)) as {
       runId?: unknown;
@@ -1220,36 +892,6 @@ export class PlayDedup implements DurableObject {
     );
   }
 
-  private async handlePoolClear(req: Request): Promise<Response> {
-    const version = this.workflowPoolVersion(req);
-    const [pool, mappings, retries] = await Promise.all([
-      this.state.storage.list<WorkflowPoolEntry>({
-        prefix: WORKFLOW_POOL_KEY_PREFIX,
-      }),
-      this.state.storage.list<WorkflowRunMapping>({
-        prefix: WORKFLOW_POOL_RUN_KEY_PREFIX,
-      }),
-      this.state.storage.list<WorkflowRunRetryState>({
-        prefix: WORKFLOW_RUN_RETRY_KEY_PREFIX,
-      }),
-    ]);
-    const keys = [
-      ...[...pool.entries()]
-        .filter(([, entry]) => !version || entry.version === version)
-        .map(([key]) => key),
-      ...[...mappings.entries()]
-        .filter(([, entry]) => !version || entry.version === version)
-        .map(([key]) => key),
-      ...[...retries.keys()],
-    ];
-    if (keys.length > 0) {
-      await this.state.storage.delete(keys);
-    }
-    return new Response(JSON.stringify({ deleted: keys.length }), {
-      headers: { 'content-type': 'application/json' },
-    });
-  }
-
   private async handleTraceAdd(req: Request): Promise<Response> {
     const body = (await req
       .json()
@@ -1365,6 +1007,226 @@ export class PlayDedup implements DurableObject {
     });
   }
 
+  private async handleChildTerminalSet(req: Request): Promise<Response> {
+    const body = (await req.json().catch(() => null)) as {
+      eventKey?: unknown;
+      data?: unknown;
+      storedAt?: unknown;
+    } | null;
+    const eventKey =
+      typeof body?.eventKey === 'string' && body.eventKey.trim()
+        ? body.eventKey.trim()
+        : '';
+    if (!eventKey) {
+      return new Response('eventKey is required', { status: 400 });
+    }
+    const state: CoordinatorChildTerminalState = {
+      eventKey,
+      data: body?.data ?? null,
+      storedAt:
+        typeof body?.storedAt === 'number' && Number.isFinite(body.storedAt)
+          ? body.storedAt
+          : Date.now(),
+    };
+    await this.state.storage.put(this.childTerminalKey(eventKey), state);
+    this.wakeChildTerminalWaiters(eventKey);
+    return new Response('{}', {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  private async handleChildTerminalGet(req: Request): Promise<Response> {
+    const eventKey = new URL(req.url).searchParams.get('eventKey')?.trim();
+    if (!eventKey) {
+      return new Response('eventKey is required', { status: 400 });
+    }
+    const state = await this.readChildTerminalState(eventKey);
+    return new Response(JSON.stringify({ state: state ?? null }), {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  private async handleChildTerminalAwait(req: Request): Promise<Response> {
+    const url = new URL(req.url);
+    const eventKey = url.searchParams.get('eventKey')?.trim();
+    if (!eventKey) {
+      return new Response('eventKey is required', { status: 400 });
+    }
+    const timeoutMs = Math.min(
+      Math.max(Number(url.searchParams.get('timeoutMs') ?? '0'), 0),
+      30_000,
+    );
+    let state = await this.readChildTerminalState(eventKey);
+    if (!state && timeoutMs > 0) {
+      await new Promise<void>((resolve) => {
+        let settled = false;
+        let timeout: ReturnType<typeof setTimeout>;
+        const finish = () => {
+          if (settled) return;
+          settled = true;
+          this.childTerminalWaiters.get(eventKey)?.delete(finish);
+          if (this.childTerminalWaiters.get(eventKey)?.size === 0) {
+            this.childTerminalWaiters.delete(eventKey);
+          }
+          clearTimeout(timeout);
+          resolve();
+        };
+        timeout = setTimeout(finish, timeoutMs);
+        if (!this.childTerminalWaiters.has(eventKey)) {
+          this.childTerminalWaiters.set(eventKey, new Set());
+        }
+        this.childTerminalWaiters.get(eventKey)!.add(finish);
+      });
+      state = await this.readChildTerminalState(eventKey);
+    }
+    return new Response(JSON.stringify({ state: state ?? null }), {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  /**
+   * Lease up to `requested` request-window permits for `bucketId` under all
+   * `rules`. Single-threaded DO access means this is the same sliding-window
+   * math as InMemoryRateStateBackend.acquire, generalized to grant a BLOCK of
+   * permits at once so the runtime amortizes the round-trip across many calls.
+   *
+   * Concurrency rules (`maxConcurrency`) are NOT enforced here: simultaneous
+   * in-flight tracking across isolates needs a reliable release signal, which a
+   * dying isolate cannot guarantee. The Governor's global tool-concurrency
+   * semaphore is the cross-call concurrency backstop; this DO owns the
+   * cross-isolate REQUEST RATE, which is the throughput governor.
+   */
+  private async handleRateAcquire(req: Request): Promise<Response> {
+    const body = (await req
+      .json()
+      .catch(() => null)) as RateAcquireRequest | null;
+    if (
+      !body ||
+      typeof body.bucketId !== 'string' ||
+      !body.bucketId.trim() ||
+      !Array.isArray(body.rules)
+    ) {
+      return new Response('bucketId and rules are required', { status: 400 });
+    }
+    const requested =
+      typeof body.requested === 'number' && Number.isFinite(body.requested)
+        ? Math.max(1, Math.floor(body.requested))
+        : 1;
+    const result = this.computeRateAcquire(
+      body.bucketId,
+      body.rules,
+      requested,
+    );
+    return new Response(JSON.stringify(result), {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  private computeRateAcquire(
+    bucketId: string,
+    rules: RateRule[],
+    requested: number,
+  ): RateAcquireResponse {
+    const now = Date.now();
+    const usableRules = rules.filter(
+      (rule) =>
+        rule &&
+        typeof rule.ruleId === 'string' &&
+        typeof rule.requestsPerWindow === 'number' &&
+        rule.requestsPerWindow > 0 &&
+        typeof rule.windowMs === 'number',
+    );
+    if (usableRules.length === 0) {
+      return { granted: requested, waitMs: 0 };
+    }
+
+    let waitMs = 0;
+    const cooldownUntil = this.rateCooldownUntil.get(bucketId) ?? 0;
+    if (cooldownUntil > now) waitMs = Math.max(waitMs, cooldownUntil - now);
+
+    // The grant is the min remaining capacity across every rule's window. A
+    // single round-trip can never debit more than the tightest rule allows.
+    let grantable = requested;
+    for (const rule of usableRules) {
+      const state = this.getRateWindowState(bucketId, rule, now);
+      this.resetExpiredRateWindow(state, rule.windowMs, now);
+      const remaining = rule.requestsPerWindow - state.startedInWindow;
+      grantable = Math.min(grantable, Math.max(0, remaining));
+      if (remaining <= 0) {
+        waitMs = Math.max(
+          waitMs,
+          rule.windowMs > 0
+            ? state.windowStartedAt + rule.windowMs - now
+            : RATE_MIN_WAIT_MS,
+        );
+      }
+    }
+
+    if (waitMs > 0 || grantable <= 0) {
+      return { granted: 0, waitMs: Math.max(RATE_MIN_WAIT_MS, waitMs) };
+    }
+
+    for (const rule of usableRules) {
+      const state = this.getRateWindowState(bucketId, rule, now);
+      state.startedInWindow += grantable;
+    }
+    return { granted: grantable, waitMs: 0 };
+  }
+
+  private async handleRatePenalize(req: Request): Promise<Response> {
+    const body = (await req
+      .json()
+      .catch(() => null)) as RatePenalizeRequest | null;
+    if (!body || typeof body.bucketId !== 'string' || !body.bucketId.trim()) {
+      return new Response('bucketId is required', { status: 400 });
+    }
+    const cooldownMs =
+      typeof body.cooldownMs === 'number' && Number.isFinite(body.cooldownMs)
+        ? Math.floor(body.cooldownMs)
+        : 0;
+    if (cooldownMs > 0) {
+      const until = Date.now() + cooldownMs;
+      const existing = this.rateCooldownUntil.get(body.bucketId) ?? 0;
+      this.rateCooldownUntil.set(body.bucketId, Math.max(existing, until));
+    }
+    return new Response('{}', {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  private getRateWindowState(
+    bucketId: string,
+    rule: RateRule,
+    now: number,
+  ): RateRuleWindowState {
+    const key = RATE_STATE_KEY(bucketId, rule.ruleId);
+    const existing = this.rateWindows.get(key);
+    if (existing) return existing;
+    const created: RateRuleWindowState = {
+      windowStartedAt: now,
+      startedInWindow: 0,
+    };
+    this.rateWindows.set(key, created);
+    return created;
+  }
+
+  private resetExpiredRateWindow(
+    state: RateRuleWindowState,
+    windowMs: number,
+    now: number,
+  ): void {
+    if (windowMs <= 0) {
+      state.windowStartedAt = now;
+      state.startedInWindow = 0;
+      return;
+    }
+    if (now - state.windowStartedAt < windowMs) return;
+    const elapsed = Math.floor((now - state.windowStartedAt) / windowMs);
+    state.windowStartedAt += elapsed * windowMs;
+    state.startedInWindow = 0;
+    if (now - state.windowStartedAt >= windowMs) state.windowStartedAt = now;
+  }
+
   private async storeRunEvent(
     input: CoordinatorRunEventInput,
   ): Promise<CoordinatorRunEvent> {
@@ -1380,12 +1242,9 @@ export class PlayDedup implements DurableObject {
         [COORDINATOR_RUN_EVENT_SEQUENCE_KEY]: seq,
         [this.runEventKey(event)]: event,
       });
-      const entries = await this.state.storage.list<CoordinatorRunEvent>({
-        prefix: COORDINATOR_RUN_EVENT_KEY_PREFIX,
-      });
-      const overflow = entries.size - COORDINATOR_RUN_EVENT_MAX_ENTRIES;
-      if (overflow > 0) {
-        await this.state.storage.delete([...entries.keys()].slice(0, overflow));
+      const pruneSeq = seq - COORDINATOR_RUN_EVENT_MAX_ENTRIES;
+      if (pruneSeq > 0) {
+        await this.state.storage.delete(this.runEventKeyForSeq(pruneSeq));
       }
     });
     if (!event) {
@@ -1482,15 +1341,26 @@ export class PlayDedup implements DurableObject {
       Math.max(Number(url.searchParams.get('timeoutMs') ?? '0'), 0),
       30_000,
     );
-    const readEvents = async () => {
-      const entries = await this.state.storage.list<CoordinatorRunEvent>({
-        prefix: COORDINATOR_RUN_EVENT_KEY_PREFIX,
-      });
-      return [...entries.values()]
-        .filter((event) => event.seq > afterSeq)
-        .sort((left, right) => left.seq - right.seq);
+    const readLatestSeq = async () =>
+      (await this.state.storage.get<number>(
+        COORDINATOR_RUN_EVENT_SEQUENCE_KEY,
+      )) ?? afterSeq;
+    const readEvents = async (latestSeq: number) => {
+      const firstAvailableSeq = Math.max(
+        1,
+        latestSeq - COORDINATOR_RUN_EVENT_MAX_ENTRIES + 1,
+      );
+      const startSeq = Math.max(afterSeq + 1, firstAvailableSeq);
+      if (latestSeq < startSeq) return [];
+      const keys: string[] = [];
+      for (let seq = startSeq; seq <= latestSeq; seq += 1) {
+        keys.push(this.runEventKeyForSeq(seq));
+      }
+      const entries = await this.state.storage.get<CoordinatorRunEvent>(keys);
+      return [...entries.values()].sort((left, right) => left.seq - right.seq);
     };
-    let events = await readEvents();
+    let latestSeq = await readLatestSeq();
+    let events = await readEvents(latestSeq);
     if (events.length === 0 && timeoutMs > 0) {
       await new Promise<void>((resolve) => {
         let settled = false;
@@ -1505,12 +1375,9 @@ export class PlayDedup implements DurableObject {
         const timeout = setTimeout(finish, timeoutMs);
         this.runEventWaiters.add(onEvent);
       });
-      events = await readEvents();
+      latestSeq = await readLatestSeq();
+      events = await readEvents(latestSeq);
     }
-    const latestSeq =
-      (await this.state.storage.get<number>(
-        COORDINATOR_RUN_EVENT_SEQUENCE_KEY,
-      )) ?? afterSeq;
     return new Response(JSON.stringify({ events, latestSeq }), {
       headers: { 'content-type': 'application/json' },
     });