deepline 0.0.1 → 0.1.1

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

@@ -0,0 +1,710 @@
+/**
+ * PlayDedup Durable Object — cross-attempt idempotency cache for one play run.
+ *
+ * One DO instance per runId. Workers and queue-consumers fetch into it to:
+ *   - claim a hash to compute (atomic; first claimer wins)
+ *   - publish a result (unblocks awaiters)
+ *   - long-poll await for a result claimed by another caller
+ *
+ * Storage shape (DO storage):
+ *   key:  `${toolId}:${inputHash}`
+ *   value: DedupEntry
+ *
+ * The whole DO is evicted via `/finish` at run end. Storage is single-region
+ * but strongly-consistent within the DO instance — exactly what dedup needs.
+ *
+ * Latency: ~5ms per request (DO storage is sub-ms; HTTP add ~3-5ms).
+ */
+
+type DedupEntry =
+  | { status: 'in_flight'; claimedBy: string; claimedAt: number }
+  | { status: 'completed'; result: unknown; completedAt: number }
+  | { status: 'failed'; error: string; failedAt: number };
+
+type LookupOrClaimRequest = {
+  runId: string;
+  toolId: string;
+  inputHashes: string[];
+  /** Identifier for the caller — used as `claimedBy` for in-flight entries. */
+  callerId: string;
+};
+
+type LookupOrClaimResponse = {
+  hits: Record<string, unknown>;
+  claimed: string[];
+  inFlight: string[];
+};
+
+type PublishRequest = {
+  runId: string;
+  toolId: string;
+  results: Array<{ inputHash: string; result: unknown }>;
+};
+
+type AwaitRequest = {
+  runId: string;
+  toolId: string;
+  inputHashes: string[];
+  timeoutMs: number;
+};
+
+type WorkflowPoolEntry = {
+  id: string;
+  version: string;
+  createdAt: number;
+  readyAt: number | null;
+  expiresAt: number;
+};
+
+type WorkflowRunMapping = {
+  runId: string;
+  instanceId: string;
+  version: string;
+  createdAt: number;
+  expiresAt: number;
+};
+
+type CoordinatorTraceEntry = {
+  ts: number;
+  source: 'coordinator' | 'dynamic_worker';
+  runId: string;
+  phase: string;
+  ms: number;
+  graphHash?: string | null;
+  [key: string]: unknown;
+};
+
+type ReadyWorkflowPoolEntryRecord = {
+  key: string;
+  entry: WorkflowPoolEntry & { readyAt: number };
+};
+
+const DEDUP_KEY_PREFIX = 'd:';
+const WORKFLOW_POOL_KEY_PREFIX = 'p:';
+const WORKFLOW_POOL_RUN_KEY_PREFIX = 'm:';
+const COORDINATOR_TRACE_KEY_PREFIX = 't:';
+const COORDINATOR_TRACE_MAX_ENTRIES = 200;
+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;
+
+interface DedupEnv {
+  PLAY_DEDUP: DurableObjectNamespace;
+}
+
+export class PlayDedup implements DurableObject {
+  // Promises waiting on /await endpoints. Keyed by `${toolId}:${inputHash}`.
+  // Resolved by /publish; rejected on timeout.
+  private waiters: Map<string, Set<(value: unknown) => void>> = new Map();
+
+  constructor(
+    private readonly state: DurableObjectState,
+    private readonly env: DedupEnv,
+  ) {}
+
+  private storageKey(toolId: string, inputHash: string): string {
+    return `${DEDUP_KEY_PREFIX}${toolId}:${inputHash}`;
+  }
+
+  private traceKey(entry: CoordinatorTraceEntry): string {
+    return `${COORDINATOR_TRACE_KEY_PREFIX}${String(entry.ts).padStart(13, '0')}:${crypto.randomUUID().slice(0, 8)}`;
+  }
+
+  private waiterKey(toolId: string, inputHash: string): string {
+    return `${toolId}:${inputHash}`;
+  }
+
+  async fetch(req: Request): Promise<Response> {
+    const url = new URL(req.url);
+    try {
+      switch (url.pathname) {
+        case '/lookup-or-claim':
+          return await this.handleLookupOrClaim(req);
+        case '/publish':
+          return await this.handlePublish(req);
+        case '/await':
+          return await this.handleAwait(req);
+        case '/finish':
+          return await this.handleFinish(req);
+        case '/debug':
+          return await this.handleDebug(req);
+        case '/pool-add':
+          return await this.handlePoolAdd(req);
+        case '/pool-lease':
+          return await this.handlePoolLease(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-delete':
+          return await this.handlePoolDelete(req);
+        case '/pool-map-run':
+          return await this.handlePoolMapRun(req);
+        case '/pool-resolve-run':
+          return await this.handlePoolResolveRun(req);
+        case '/pool-clear':
+          return await this.handlePoolClear(req);
+        case '/trace-add':
+          return await this.handleTraceAdd(req);
+        case '/trace-list':
+          return await this.handleTraceList();
+        default:
+          return new Response('not found', { status: 404 });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return new Response(JSON.stringify({ error: message }), {
+        status: 500,
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+  }
+
+  async alarm(): Promise<void> {
+    // Fired after /finish was called. Evict storage and let the DO instance
+    // be garbage-collected by CF's hot pool.
+    await this.state.storage.deleteAll();
+    this.waiters.clear();
+  }
+
+  private async handleLookupOrClaim(req: Request): Promise<Response> {
+    const body = (await req.json()) as LookupOrClaimRequest;
+    const hits: Record<string, unknown> = {};
+    const claimed: string[] = [];
+    const inFlight: string[] = [];
+
+    // Atomic transaction: read all keys, decide outcome per hash, write claims
+    // back. DO storage transactions are serialized within the DO instance.
+    await this.state.blockConcurrencyWhile(async () => {
+      const keys = body.inputHashes.map((h) => this.storageKey(body.toolId, h));
+      const existing = (await this.state.storage.get<DedupEntry>(keys)) as Map<
+        string,
+        DedupEntry
+      >;
+      const now = Date.now();
+      const toWrite = new Map<string, DedupEntry>();
+
+      for (let i = 0; i < body.inputHashes.length; i += 1) {
+        const hash = body.inputHashes[i]!;
+        const key = keys[i]!;
+        const entry = existing.get(key);
+        if (!entry) {
+          // Claim it for the caller.
+          claimed.push(hash);
+          toWrite.set(key, {
+            status: 'in_flight',
+            claimedBy: body.callerId,
+            claimedAt: now,
+          });
+        } else if (entry.status === 'completed') {
+          hits[hash] = entry.result;
+        } else if (entry.status === 'failed') {
+          // Re-claim failed entries — the caller can retry.
+          claimed.push(hash);
+          toWrite.set(key, {
+            status: 'in_flight',
+            claimedBy: body.callerId,
+            claimedAt: now,
+          });
+        } else {
+          // Already in-flight by someone else; tell caller to await.
+          inFlight.push(hash);
+        }
+      }
+
+      if (toWrite.size > 0) {
+        await this.state.storage.put(Object.fromEntries(toWrite));
+      }
+    });
+
+    const response: LookupOrClaimResponse = { hits, claimed, inFlight };
+    return new Response(JSON.stringify(response), {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  private async handlePublish(req: Request): Promise<Response> {
+    const body = (await req.json()) as PublishRequest;
+    const now = Date.now();
+    const writes: Record<string, DedupEntry> = {};
+    for (const { inputHash, result } of body.results) {
+      writes[this.storageKey(body.toolId, inputHash)] = {
+        status: 'completed',
+        result,
+        completedAt: now,
+      };
+    }
+    await this.state.storage.put(writes);
+
+    // Wake any awaiters.
+    for (const { inputHash, result } of body.results) {
+      const key = this.waiterKey(body.toolId, inputHash);
+      const set = this.waiters.get(key);
+      if (set) {
+        for (const resolve of set) resolve(result);
+        this.waiters.delete(key);
+      }
+    }
+
+    return new Response('{}', { headers: { 'content-type': 'application/json' } });
+  }
+
+  private async handleAwait(req: Request): Promise<Response> {
+    const body = (await req.json()) as AwaitRequest;
+    const results: Record<string, unknown> = {};
+    const stillWaiting: string[] = [];
+
+    // Synchronous read first.
+    const keys = body.inputHashes.map((h) => this.storageKey(body.toolId, h));
+    const initial = (await this.state.storage.get<DedupEntry>(keys)) as Map<
+      string,
+      DedupEntry
+    >;
+    for (let i = 0; i < body.inputHashes.length; i += 1) {
+      const hash = body.inputHashes[i]!;
+      const entry = initial.get(keys[i]!);
+      if (entry?.status === 'completed') {
+        results[hash] = entry.result;
+      } else {
+        stillWaiting.push(hash);
+      }
+    }
+
+    if (stillWaiting.length === 0) {
+      return new Response(JSON.stringify({ results }), {
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+
+    // Long-poll. Register waiter promises; resolve via /publish or timeout.
+    const promises = stillWaiting.map(
+      (hash) =>
+        new Promise<{ hash: string; result: unknown }>((resolve, reject) => {
+          const wKey = this.waiterKey(body.toolId, hash);
+          if (!this.waiters.has(wKey)) this.waiters.set(wKey, new Set());
+          const onResolve = (result: unknown) => resolve({ hash, result });
+          this.waiters.get(wKey)!.add(onResolve);
+          setTimeout(() => {
+            this.waiters.get(wKey)?.delete(onResolve);
+            reject(new Error(`Dedup await timeout for ${hash}`));
+          }, body.timeoutMs);
+        }),
+    );
+
+    try {
+      const settled = await Promise.allSettled(promises);
+      for (const s of settled) {
+        if (s.status === 'fulfilled') {
+          results[s.value.hash] = s.value.result;
+        }
+      }
+    } catch {
+      // Individual timeouts are not fatal; return whatever resolved.
+    }
+
+    return new Response(JSON.stringify({ results }), {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  private async handleFinish(_req: Request): Promise<Response> {
+    // Schedule alarm to evict after a grace period (any straggler awaits
+    // get a chance to resolve). Grace = 60s.
+    await this.state.storage.setAlarm(Date.now() + FINISH_ALARM_DELAY_MS);
+    return new Response('{}', { headers: { 'content-type': 'application/json' } });
+  }
+
+  private async handleDebug(_req: Request): Promise<Response> {
+    const all = await this.state.storage.list({ prefix: DEDUP_KEY_PREFIX });
+    const dump: Record<string, DedupEntry> = {};
+    for (const [k, v] of all) dump[k] = v as DedupEntry;
+    return new Response(
+      JSON.stringify({ size: all.size, entries: dump, waiters: this.waiters.size }),
+      { headers: { 'content-type': 'application/json' } },
+    );
+  }
+
+  private workflowPoolVersion(req: Request): string {
+    return new URL(req.url).searchParams.get('version')?.trim() ?? '';
+  }
+
+  private isReadyWorkflowPoolEntry(
+    value: { key: string; entry: WorkflowPoolEntry | undefined },
+    version: string,
+    now: number,
+  ): value is ReadyWorkflowPoolEntryRecord {
+    return (
+      value.entry !== undefined &&
+      value.entry.version === version &&
+      value.entry.expiresAt > now &&
+      value.entry.readyAt !== null
+    );
+  }
+
+  private async gcWorkflowPool(
+    now = Date.now(),
+    version?: string,
+  ): Promise<void> {
+    const [pool, mappings] = await Promise.all([
+      this.state.storage.list<WorkflowPoolEntry>({
+        prefix: WORKFLOW_POOL_KEY_PREFIX,
+      }),
+      this.state.storage.list<WorkflowRunMapping>({
+        prefix: WORKFLOW_POOL_RUN_KEY_PREFIX,
+      }),
+    ]);
+    const expiredKeys: string[] = [];
+    for (const [key, entry] of pool) {
+      if (
+        !entry ||
+        entry.expiresAt <= now ||
+        (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);
+      }
+    }
+    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;
+    const writes: Record<string, WorkflowPoolEntry> = {};
+    for (const id of ids) {
+      writes[`${WORKFLOW_POOL_KEY_PREFIX}${id}`] = {
+        id,
+        version,
+        createdAt: now,
+        readyAt: ready ? readyAt : null,
+        expiresAt: now + ttlMs,
+      };
+    }
+    await this.state.blockConcurrencyWhile(async () => {
+      await this.gcWorkflowPool(now, version);
+      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 handlePoolLease(req: Request): Promise<Response> {
+    const version = this.workflowPoolVersion(req);
+    if (!version) {
+      return new Response('version is required', { status: 400 });
+    }
+    let leasedId: string | null = null;
+    await this.state.blockConcurrencyWhile(async () => {
+      const now = Date.now();
+      await this.gcWorkflowPool(now, version);
+      const entries = await this.state.storage.list<WorkflowPoolEntry>({
+        prefix: WORKFLOW_POOL_KEY_PREFIX,
+      });
+      const sorted = [...entries.entries()]
+        .map(([key, entry]) => ({ key, entry }))
+        .filter((entry) => this.isReadyWorkflowPoolEntry(entry, version, now))
+        .sort((a, b) => a.entry.readyAt - b.entry.readyAt);
+      const selected = sorted[0];
+      if (!selected) return;
+      leasedId = selected.entry.id;
+      await this.state.storage.delete(selected.key);
+    });
+    return new Response(JSON.stringify({ id: leasedId }), {
+      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 });
+    }
+    await this.gcWorkflowPool(Date.now(), version);
+    const entries = await this.state.storage.list<WorkflowPoolEntry>({
+      prefix: WORKFLOW_POOL_KEY_PREFIX,
+    });
+    let available = 0;
+    let warming = 0;
+    for (const entry of entries.values()) {
+      if (entry.version !== version) continue;
+      if (entry.readyAt === null) warming += 1;
+      else available += 1;
+    }
+    return new Response(JSON.stringify({ available, warming }), {
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  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,
+            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,
+          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 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> {
+    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();
+    await this.state.storage.put(
+      `${WORKFLOW_POOL_RUN_KEY_PREFIX}${runId}`,
+      {
+        runId,
+        instanceId,
+        version,
+        createdAt: now,
+        expiresAt: now + WORKFLOW_POOL_RUN_MAPPING_TTL_MS,
+      } satisfies WorkflowRunMapping,
+    );
+    return new Response('{}', { 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 }),
+      { headers: { 'content-type': 'application/json' } },
+    );
+  }
+
+  private async handlePoolClear(req: Request): Promise<Response> {
+    const version = this.workflowPoolVersion(req);
+    const [pool, mappings] = await Promise.all([
+      this.state.storage.list<WorkflowPoolEntry>({
+        prefix: WORKFLOW_POOL_KEY_PREFIX,
+      }),
+      this.state.storage.list<WorkflowRunMapping>({
+        prefix: WORKFLOW_POOL_RUN_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),
+    ];
+    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().catch(() => null)) as
+      | Partial<CoordinatorTraceEntry>
+      | null;
+    if (
+      !body ||
+      (body.source !== 'coordinator' && body.source !== 'dynamic_worker') ||
+      typeof body.runId !== 'string' ||
+      typeof body.phase !== 'string' ||
+      typeof body.ts !== 'number' ||
+      typeof body.ms !== 'number'
+    ) {
+      return new Response('invalid trace entry', { status: 400 });
+    }
+    const entry: CoordinatorTraceEntry = {
+      ...body,
+      source: body.source,
+      runId: body.runId,
+      phase: body.phase,
+      ts: body.ts,
+      ms: body.ms,
+      graphHash:
+        typeof body.graphHash === 'string' || body.graphHash === null
+          ? body.graphHash
+          : undefined,
+    };
+    await this.state.blockConcurrencyWhile(async () => {
+      await this.state.storage.put(this.traceKey(entry), entry);
+      const entries = await this.state.storage.list<CoordinatorTraceEntry>({
+        prefix: COORDINATOR_TRACE_KEY_PREFIX,
+      });
+      const overflow = entries.size - COORDINATOR_TRACE_MAX_ENTRIES;
+      if (overflow > 0) {
+        await this.state.storage.delete([...entries.keys()].slice(0, overflow));
+      }
+    });
+    return new Response('{}', { headers: { 'content-type': 'application/json' } });
+  }
+
+  private async handleTraceList(): Promise<Response> {
+    const entries = await this.state.storage.list<CoordinatorTraceEntry>({
+      prefix: COORDINATOR_TRACE_KEY_PREFIX,
+    });
+    return new Response(
+      JSON.stringify({
+        entries: [...entries.values()].sort((left, right) => left.ts - right.ts),
+      }),
+      { headers: { 'content-type': 'application/json' } },
+    );
+  }
+}