deepline 0.1.243 → 0.1.244

package/dist/bundling-sources/apps/play-runner-workers/src/coordinator-entry.ts

@@ -1,4504 +0,0 @@
-/**
- * Coordinator Worker entry — main module exported by wrangler.toml.
- *
- * Hosts:
- *   - DynamicWorkflow (native Cloudflare Dynamic Workflows)
- *   - PlayDedup DO      (default export class)
- *   - HTTP fetch handler for /api/v2/plays/run dispatch (Vercel forwards to here)
- *   - WorkerLoader-backed dynamic play Workers
- */
-
-export { PlayDedup } from './dedup-do';
-
-import {
-  WorkerEntrypoint,
-  WorkflowEntrypoint,
-  exports as workersExports,
-} from 'cloudflare:workers';
-import {
-  createWorkerTelemetry,
-  type TelemetryEvent,
-  type TelemetryFields,
-  type TelemetryScalar,
-} from '../../../shared_libs/observability/worker-telemetry';
-import { createSecretRedactionContext } from '../../../shared_libs/play-runtime/secret-redaction';
-import {
-  _dispatcherBindingImpl as createDispatcherWorkflowBinding,
-  dispatchWorkflow,
-  DynamicWorkflowBinding,
-  type WorkflowRunner,
-} from '@cloudflare/dynamic-workflows';
-import type { ExecutionPlan } from '../../../shared_libs/play-runtime/execution-plan';
-import type { PlayRunInputPayload } from '../../../shared_libs/play-runtime/scheduler-backend';
-import type { RuntimeTestPolicyOverrides } from '../../../shared_libs/play-runtime/test-runtime-seams';
-import { DYNAMIC_PLAY_WORKER_ARTIFACT_VERSION } from '../../../shared_libs/play-runtime/dynamic-worker-version';
-import {
-  DB_SESSION_DEFAULT_TTL_SECONDS,
-  type PreloadedRuntimeDbSession,
-} from '../../../shared_libs/play-runtime/db-session';
-import {
-  dbSessionPostgresUrlAad,
-  encryptDbSessionPostgresUrl,
-} from '../../../shared_libs/play-runtime/db-session-crypto';
-import { planRuntimeDbSessionRequirements } from '../../../shared_libs/play-runtime/db-session-plan';
-import type { PlayRuntimeManifest } from '../../../shared_libs/plays/compiler-manifest';
-import {
-  WORKSPACE_STORAGE_NOT_READY_CODE,
-  WORKSPACE_STORAGE_NOT_READY_MESSAGE,
-  normalizePlayRunFailure,
-} from '../../../shared_libs/play-runtime/run-failure';
-import type { PlayRunLedgerEvent } from '../../../shared_libs/play-runtime/run-ledger';
-import {
-  COORDINATOR_INTERNAL_TOKEN_HEADER,
-  COORDINATOR_RUN_SCOPE_HEADER,
-} from '../../../shared_libs/play-runtime/coordinator-headers';
-import {
-  PLAY_RUNTIME_API_COMPAT_PATH,
-  PLAY_RUNTIME_TAIL_LOG_COMPAT_PATH,
-} from '../../../shared_libs/play-runtime/runtime-api-paths';
-import {
-  decideWorkflowPlatformRetry,
-  PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
-  shouldPublishWorkflowRuntimeFailure,
-} from './workflow-retry';
-import {
-  WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES,
-  WORKFLOW_RETRY_PARAMS_MAX_BYTES,
-  buildWorkflowRetryParams,
-  jsonByteLength,
-  workflowRetryParamsStorageKey,
-  type WorkflowRetryParamsRef,
-} from './workflow-retry-state';
-import { createOrAttachWorkflowInstance } from './workflow-instance-create';
-import { sanitizeLiveLogLines } from './runtime/live-progress';
-import {
-  DURABLE_OBJECT_DEPLOY_HANDOFF_RETRY_DELAYS_MS,
-  durableObjectDeployHandoffMessage,
-  sleepForDurableObjectDeployHandoffRetry,
-} from './durable-object-deploy-handoff';
-
-export { DynamicWorkflowBinding };
-
-const coordinatorTelemetry = createWorkerTelemetry({
-  service: 'play-runtime',
-  component: 'coordinator',
-});
-const coordinatorStorageRedactor = createSecretRedactionContext();
-const coordinatorPerfTelemetry = createWorkerTelemetry({
-  service: 'play-runtime',
-  component: 'coordinator',
-  adapter: {
-    emit(event: TelemetryEvent) {
-      console.log(`[perf-trace] ${JSON.stringify(event)}`);
-    },
-  },
-});
-
-function coordinatorTelemetryFields(input: object): TelemetryFields {
-  const fields: Record<string, TelemetryScalar> = {};
-  for (const [key, value] of Object.entries(input)) {
-    if (
-      value === undefined ||
-      value === null ||
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      typeof value === 'boolean'
-    ) {
-      fields[key] = value;
-    }
-  }
-  return fields;
-}
-
-function recordCoordinatorEvent(
-  level: 'info' | 'warn' | 'error',
-  event: string,
-  tag: string,
-  input: Record<string, unknown> = {},
-): void {
-  const telemetry = coordinatorTelemetry.child({
-    context: {
-      runId: typeof input.runId === 'string' ? input.runId : null,
-      orgId: typeof input.orgId === 'string' ? input.orgId : null,
-      playName: typeof input.playName === 'string' ? input.playName : null,
-      requestId: typeof input.requestId === 'string' ? input.requestId : null,
-    },
-  });
-  const fields = coordinatorTelemetryFields(input);
-  if (level === 'error') {
-    void telemetry.error(event, input.error ?? input.message, fields, { tag });
-  } else {
-    void telemetry[level](event, fields, { tag });
-  }
-}
-
-export type PlayWorkflowParams = {
-  runId: string;
-  playId: string;
-  playName: string;
-  artifactStorageKey: string;
-  artifactHash: string;
-  graphHash: string;
-  input: PlayRunInputPayload;
-  force?: boolean;
-  runAttempt?: number;
-  inputFile?: {
-    name?: string;
-    r2Key?: string;
-    storageKey?: string;
-    path?: string;
-    fileName?: string;
-    logicalPath?: string;
-    contentType?: string;
-    bytes?: number;
-  } | null;
-  inlineCsv?: { name: string; rows: Record<string, unknown>[] } | null;
-  packagedFiles?: Array<{
-    playPath: string;
-    storageKey: string;
-    contentType?: string;
-    bytes?: number;
-    inlineText?: string;
-  }> | null;
-  contractSnapshot?: unknown;
-  executionPlan?: ExecutionPlan | null;
-  forceToolRefresh?: boolean | null;
-  preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
-  preloadedDbSessionRef?: {
-    runId: string;
-    sessionCount: number;
-    expiresAt: number;
-  } | null;
-  dynamicWorkerCode?: string | null;
-  executorToken: string;
-  baseUrl: string;
-  integrationMode?: 'live' | 'eval_stub' | 'fixture' | null;
-  orgId: string;
-  userEmail: string;
-  userId?: string | null;
-  runtimeBackend: string;
-  dedupBackend: string;
-  totalRows?: number;
-  coordinatorUrl?: string | null;
-  coordinatorInternalToken?: string | null;
-  runtimeTestFaultHeader?: string | null;
-  testPolicyOverrides?: RuntimeTestPolicyOverrides | null;
-  submittedAt?: number | null;
-};
-
-type CoordinatorTiming = {
-  phase: string;
-  ms: number;
-  graphHash?: string | null;
-  extra?: Record<string, unknown>;
-};
-
-type CoordinatorPerfTracePayload = {
-  ts: number;
-  source: 'coordinator' | 'dynamic_worker';
-  runId: string;
-  phase: string;
-  ms: number;
-  graphHash?: string | null;
-  [key: string]: unknown;
-};
-
-type CoordinatorPerfTraceInput = {
-  runId: string;
-  phase: string;
-  ms: number;
-  graphHash?: string | null;
-  extra?: Record<string, unknown>;
-};
-
-type CoordinatorPerfTraceSink = (event: CoordinatorPerfTraceInput) => void;
-
-type CoordinatorTerminalState = {
-  runId: string;
-  status: 'completed' | 'failed' | 'cancelled';
-  result?: unknown;
-  error?: string | null;
-  totalRows?: unknown;
-  durationMs?: unknown;
-  playName?: string | null;
-  liveLogs?: string[] | null;
-  liveNodeProgress?: unknown;
-  completedAt?: number;
-};
-
-type CoordinatorRunEvent =
-  | {
-      seq?: number;
-      runId: string;
-      type: 'status';
-      status: string;
-      ts: number;
-      logs?: string[];
-    }
-  | {
-      seq?: number;
-      runId: string;
-      type: 'log';
-      line: string;
-      ts: number;
-    }
-  | {
-      seq?: number;
-      runId: string;
-      type: 'progress';
-      status: string;
-      ts: number;
-      logs?: string[];
-      activeNodeId?: string | null;
-      activeArtifactTableNamespace?: string | null;
-      updatedAt?: number | null;
-      liveNodeProgress?: unknown;
-    }
-  | {
-      seq?: number;
-      runId: string;
-      type: 'terminal';
-      status: 'completed' | 'failed' | 'cancelled';
-      ts: number;
-      result?: unknown;
-      error?: string | null;
-      totalRows?: unknown;
-      durationMs?: unknown;
-      playName?: string | null;
-      liveLogs?: string[] | null;
-      liveNodeProgress?: unknown;
-    };
-
-type InlineWorkerRunResponse = {
-  status?: 'completed' | 'failed';
-  result?: unknown;
-  outputRows?: number;
-  durationMs?: number;
-  parseMs?: number;
-  timings?: Array<{
-    phase?: unknown;
-    ms?: unknown;
-    extra?: unknown;
-  }>;
-  events?: Array<
-    | { type: 'log'; message?: string; level?: string; ts?: number }
-    | { type: 'result'; result?: unknown; outputRows?: number; ts?: number }
-    | { type: 'error'; message?: string; stack?: string; ts?: number }
-    | Record<string, unknown>
-  >;
-  error?: { message?: string; stack?: string | null };
-};
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-
-interface CoordinatorEnv {
-  PLAY_WORKFLOW: Workflow<PlayWorkflowParams>;
-  PLAY_DEDUP: DurableObjectNamespace;
-  LOADER?: {
-    get(
-      id: string,
-      load: () => Promise<{
-        compatibilityDate: string;
-        compatibilityFlags?: string[];
-        mainModule: string;
-        modules: Record<string, string>;
-        env?: Record<string, unknown>;
-        globalOutbound?: Fetcher | null;
-      }>,
-    ): {
-      getEntrypoint(name?: string): Fetcher & WorkflowRunner;
-    };
-  };
-  PLAYS_BUCKET: R2Bucket;
-  DEEPLINE_API_BASE_URL: string;
-  DEEPLINE_INTERNAL_TOKEN?: string;
-  DEEPLINE_TAIL_LOG_TOKEN?: string;
-  DEEPLINE_COORDINATOR_DEPLOY_MARKER?: string;
-  CF_VERSION_METADATA?: WorkerVersionMetadata;
-  VERCEL_PROTECTION_BYPASS_TOKEN?: string;
-  DEEPLINE_PLAY_PREVIEW_SLUG?: string;
-  /**
-   * Service binding to the long-lived Play Harness Worker
-   * (apps/play-harness-worker). Provides typed RPC access to leaf-level
-   * helpers (runtime-API HTTP forwarder, Neon dataset IO, …) that we
-   * deliberately keep OUT of every per-graphHash play bundle.
-   *
-   * Required in every Cloudflare play environment. The coordinator fails
-   * submit/load before handing a per-play Worker an unwired harness binding.
-   *
-   * Wired in wrangler.toml as `[[services]] binding = "HARNESS"`.
-   */
-  HARNESS: import('../../play-harness-worker/src/rpc-types').PlayHarnessRpc;
-}
-
-const WORKFLOW_READ_ONLY_ACTIONS = new Set(['', 'result', 'status', 'tail']);
-
-function authorizeCoordinatorControlRequest(input: {
-  request: Request;
-  env: CoordinatorEnv;
-  runId?: string;
-  requireRunScope?: boolean;
-}): Response | null {
-  const expectedToken = input.env.DEEPLINE_INTERNAL_TOKEN?.trim();
-  if (!expectedToken) {
-    return new Response('coordinator internal token is not configured', {
-      status: 503,
-    });
-  }
-  const actualToken =
-    input.request.headers.get(COORDINATOR_INTERNAL_TOKEN_HEADER)?.trim() ?? '';
-  if (actualToken !== expectedToken) {
-    return new Response('unauthorized', { status: 401 });
-  }
-  if (input.requireRunScope) {
-    const actualRunScope =
-      input.request.headers.get(COORDINATOR_RUN_SCOPE_HEADER)?.trim() ?? '';
-    if (!input.runId || actualRunScope !== input.runId) {
-      return new Response('run scope mismatch', { status: 403 });
-    }
-  }
-  return null;
-}
-
-function isWorkflowMutatingAction(action: string): boolean {
-  return !WORKFLOW_READ_ONLY_ACTIONS.has(action);
-}
-
-/**
- * Best-effort disposal of an RPC stub. Workers' RPC machinery emits
- * "stub not disposed" warnings (and, under stress, contributes to V8
- * deopt failures in `wrangler dev` local mode) when these are GC'd
- * instead of explicitly released. Optional chaining keeps this safe
- * for non-stub values.
- */
-function disposeRpcStub(value: unknown): void {
-  if (value == null) return;
-  const disposable = value as { [Symbol.dispose]?: () => void };
-  try {
-    disposable[Symbol.dispose]?.();
-  } catch {
-    // intentional no-op — disposal is best-effort
-  }
-}
-
-/**
- * Structured perf trace for the coordinator. Emits one [perf-trace] JSON
- * line that downstream tooling (tests/v2-plays/runner.ts --perf-summary)
- * scrapes from logs/coordinator.log / logs/cf-coordinator-tail.log.
- *
- * Workerd has no filesystem; this is stdout-only. Stays additive next to
- * the existing `[coordinator] ...` logs.
- */
-function buildCoordinatorPerfTracePayload(
-  event: CoordinatorPerfTraceInput,
-): CoordinatorPerfTracePayload | null {
-  if (!event.runId || !event.phase) return null;
-  return {
-    ts: Date.now(),
-    source: 'coordinator',
-    runId: event.runId,
-    phase: event.phase,
-    ms: event.ms,
-    ...(event.graphHash ? { graphHash: event.graphHash } : {}),
-    ...(event.extra ?? {}),
-  };
-}
-
-function logCoordinatorPerfTrace(payload: CoordinatorPerfTracePayload): void {
-  void coordinatorPerfTelemetry
-    .child({ context: { runId: payload.runId } })
-    .info(payload.phase, coordinatorTelemetryFields(payload), {
-      tag: '[perf-trace]',
-    });
-}
-
-function recordCoordinatorPerfTrace(event: CoordinatorPerfTraceInput): void {
-  const payload = buildCoordinatorPerfTracePayload(event);
-  if (!payload) return;
-  logCoordinatorPerfTrace(payload);
-}
-
-function safeOrigin(value: string | null | undefined): string | null {
-  if (!value?.trim()) return null;
-  try {
-    return new URL(value).origin;
-  } catch {
-    return '<invalid>';
-  }
-}
-
-async function appendCoordinatorPerfTrace(
-  env: CoordinatorEnv,
-  payload: CoordinatorPerfTracePayload,
-): Promise<void> {
-  const stub = env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(payload.runId));
-  const response = await stub.fetch(
-    'https://deepline.dedup.internal/trace-add',
-    {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(coordinatorStorageRedactor.redact(payload)),
-    },
-  );
-  if (!response.ok) {
-    throw new Error(
-      `coordinator trace append failed ${response.status}: ${(
-        await response.text().catch(() => '')
-      ).slice(0, 200)}`,
-    );
-  }
-}
-
-function recordCoordinatorPerfTraceBuffered(
-  env: CoordinatorEnv,
-  ctx: ExecutionContext | null | undefined,
-  event: CoordinatorPerfTraceInput,
-): void {
-  const payload = buildCoordinatorPerfTracePayload(event);
-  if (!payload) return;
-  logCoordinatorPerfTrace(payload);
-  const append = appendCoordinatorPerfTrace(env, payload).catch((error) => {
-    return coordinatorTelemetry
-      .child({ context: { runId: payload.runId } })
-      .warn(
-        'coordinator.perf_trace.buffer_failed',
-        {
-          phase: payload.phase,
-          error: error instanceof Error ? error.message : String(error),
-        },
-        { tag: '[coordinator] failed to buffer perf trace' },
-      );
-  });
-  if (typeof ctx?.waitUntil === 'function') {
-    ctx.waitUntil(append);
-  }
-}
-
-async function listCoordinatorPerfTrace(
-  env: CoordinatorEnv,
-  runId: string,
-): Promise<CoordinatorPerfTracePayload[]> {
-  const stub = env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(runId));
-  const response = await stub.fetch(
-    'https://deepline.dedup.internal/trace-list',
-  );
-  if (!response.ok) {
-    throw new Error(`coordinator trace list failed ${response.status}`);
-  }
-  const body = (await response.json().catch(() => ({}))) as {
-    entries?: unknown;
-  };
-  if (!Array.isArray(body.entries)) return [];
-  return body.entries.filter(
-    (entry): entry is CoordinatorPerfTracePayload =>
-      isRecord(entry) &&
-      (entry.source === 'coordinator' || entry.source === 'dynamic_worker') &&
-      typeof entry.runId === 'string' &&
-      typeof entry.phase === 'string' &&
-      typeof entry.ts === 'number' &&
-      typeof entry.ms === 'number',
-  );
-}
-
-async function writeCoordinatorTerminalState(
-  env: CoordinatorEnv,
-  state: CoordinatorTerminalState,
-): Promise<void> {
-  const stub = env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(state.runId));
-  const response = await stub.fetch(
-    'https://deepline.dedup.internal/terminal-set',
-    {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({
-        ...state,
-        completedAt: state.completedAt ?? Date.now(),
-      }),
-    },
-  );
-  if (!response.ok) {
-    throw new Error(`coordinator terminal set failed ${response.status}`);
-  }
-}
-
-async function appendCoordinatorRunEvent(
-  env: CoordinatorEnv,
-  event: CoordinatorRunEvent,
-): Promise<void> {
-  const stub = env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(event.runId));
-  const response = await stub.fetch(
-    'https://deepline.dedup.internal/event-add',
-    {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(event),
-    },
-  );
-  if (!response.ok) {
-    throw new Error(`coordinator event append failed ${response.status}`);
-  }
-}
-
-async function listCoordinatorRunEvents(input: {
-  env: CoordinatorEnv;
-  runId: string;
-  afterSeq: number;
-  timeoutMs: number;
-}): Promise<{ events: CoordinatorRunEvent[]; latestSeq: number }> {
-  const stub = input.env.PLAY_DEDUP.get(
-    input.env.PLAY_DEDUP.idFromName(input.runId),
-  );
-  const response = await stub.fetch(
-    `https://deepline.dedup.internal/event-list?afterSeq=${encodeURIComponent(
-      String(Math.max(0, Math.floor(input.afterSeq))),
-    )}&timeoutMs=${encodeURIComponent(
-      String(Math.max(0, Math.floor(input.timeoutMs))),
-    )}`,
-  );
-  if (!response.ok) {
-    throw new Error(`coordinator event list failed ${response.status}`);
-  }
-  const body = (await response.json().catch(() => ({}))) as {
-    events?: unknown;
-    latestSeq?: unknown;
-  };
-  return {
-    events: Array.isArray(body.events)
-      ? body.events.filter(
-          (event): event is CoordinatorRunEvent =>
-            isRecord(event) &&
-            typeof event.runId === 'string' &&
-            event.runId === input.runId &&
-            typeof event.type === 'string' &&
-            typeof event.ts === 'number',
-        )
-      : [],
-    latestSeq:
-      typeof body.latestSeq === 'number' ? body.latestSeq : input.afterSeq,
-  };
-}
-
-async function readCoordinatorTerminalState(
-  env: CoordinatorEnv,
-  runId: string,
-): Promise<CoordinatorTerminalState | null> {
-  const stub = env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(runId));
-  const response = await stub.fetch(
-    'https://deepline.dedup.internal/terminal-get',
-  );
-  if (!response.ok) {
-    throw new Error(`coordinator terminal get failed ${response.status}`);
-  }
-  const body = (await response.json().catch(() => ({}))) as {
-    state?: unknown;
-  };
-  const state = body.state;
-  if (!isRecord(state) || state.runId !== runId) return null;
-  if (
-    state.status !== 'completed' &&
-    state.status !== 'failed' &&
-    state.status !== 'cancelled'
-  ) {
-    return null;
-  }
-  return state as CoordinatorTerminalState;
-}
-
-function workflowEventType(name: string): string {
-  const normalized = name
-    .trim()
-    .replace(/[^A-Za-z0-9_-]+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    .slice(0, 100);
-  return normalized || 'deepline_event';
-}
-
-type DynamicWorkflowMetadata = {
-  runId?: string | null;
-  graphHash: string;
-  artifactStorageKey: string;
-  artifactHash?: string | null;
-  dynamicWorkerCode?: string | null;
-  dynamicWorkerCodeHash?: string | null;
-  integrationMode?: 'live' | 'eval_stub' | 'fixture' | null;
-  packagedFiles?: Array<{
-    playPath: string;
-    storageKey: string;
-    contentType?: string;
-    bytes?: number;
-    inlineText?: string;
-  }> | null;
-};
-
-const SUBMIT_INITIAL_STATE_MAX_WAIT_MS = 0;
-const SUBMIT_INITIAL_STATE_POLL_MS = 50;
-const WORKFLOW_RETRY_STATE_TTL_MS = 60 * 60 * 1000;
-const WORKFLOW_SUBMIT_DUPLICATE_WAIT_MS = 55_000;
-const WORKFLOW_SUBMIT_DUPLICATE_POLL_MS = 250;
-const CHILD_WORKFLOW_SUBMIT_RETRY_DELAYS_MS = [
-  250, 750, 1500, 3000, 5000, 10000,
-] as const;
-const COORDINATOR_WORKER_MEMORY_LIMIT_MESSAGE =
-  'Worker memory limit hit before the run could finish. For CSV enrich, use --output or --in-place for automatic batches; otherwise rerun smaller --rows ranges.';
-
-function normalizeIntegrationMode(
-  value: unknown,
-): 'live' | 'eval_stub' | 'fixture' | null {
-  return value === 'live' || value === 'eval_stub' || value === 'fixture'
-    ? value
-    : null;
-}
-
-function buildDynamicWorkflowMetadata(
-  params: PlayWorkflowParams,
-): DynamicWorkflowMetadata {
-  const dynamicWorkerCodeHash =
-    typeof params.dynamicWorkerCode === 'string' &&
-    params.dynamicWorkerCode.length > 0
-      ? stableHash(params.dynamicWorkerCode)
-      : null;
-  return {
-    runId: params.runId ?? null,
-    graphHash: params.graphHash,
-    artifactStorageKey: params.artifactStorageKey,
-    artifactHash: params.artifactHash ?? null,
-    dynamicWorkerCode: null,
-    dynamicWorkerCodeHash,
-    integrationMode: normalizeIntegrationMode(params.integrationMode),
-    packagedFiles: normalizePackagedFiles(params.packagedFiles),
-  };
-}
-
-function readWorkflowTraceContext(event: unknown): {
-  runId: string;
-  graphHash: string | null;
-  instanceId: string | null;
-  submittedAt: number | null;
-} {
-  const record = isRecord(event) ? event : {};
-  const payload = isRecord(record.payload) ? record.payload : {};
-  const params = isRecord(payload.params) ? payload.params : payload;
-  const metadata = isRecord(payload.__dispatcherMetadata)
-    ? payload.__dispatcherMetadata
-    : null;
-  const runId =
-    (typeof params?.runId === 'string' && params.runId) ||
-    (typeof metadata?.runId === 'string' && metadata.runId) ||
-    (typeof record.instanceId === 'string' && record.instanceId) ||
-    'unknown-workflow-run';
-  const graphHash =
-    (typeof params?.graphHash === 'string' && params.graphHash) ||
-    (typeof metadata?.graphHash === 'string' && metadata.graphHash) ||
-    null;
-  return {
-    runId,
-    graphHash,
-    instanceId:
-      typeof record.instanceId === 'string' && record.instanceId
-        ? record.instanceId
-        : null,
-    submittedAt:
-      typeof params?.submittedAt === 'number' &&
-      Number.isFinite(params.submittedAt)
-        ? params.submittedAt
-        : null,
-  };
-}
-
-async function waitForSubmitInitialState(input: {
-  instance: WorkflowInstance;
-  runId: string;
-  waitMs: number;
-}): Promise<Record<string, unknown> | null> {
-  const waitMs = Math.max(
-    0,
-    Math.min(Math.floor(input.waitMs), SUBMIT_INITIAL_STATE_MAX_WAIT_MS),
-  );
-  if (waitMs <= 0) return null;
-  const startedAt = Date.now();
-  let status = await input.instance.status();
-  while (Date.now() - startedAt < waitMs) {
-    const result = mapWorkflowResult(input.runId, status);
-    if (
-      result.status === 'completed' ||
-      result.status === 'failed' ||
-      result.status === 'cancelled'
-    ) {
-      return result as unknown as Record<string, unknown>;
-    }
-    await sleep(SUBMIT_INITIAL_STATE_POLL_MS);
-    status = await input.instance.status();
-  }
-  const result = mapWorkflowResult(input.runId, status);
-  return result.status === 'completed' ||
-    result.status === 'failed' ||
-    result.status === 'cancelled'
-    ? (result as unknown as Record<string, unknown>)
-    : null;
-}
-
-async function createDynamicWorkflowInstance(input: {
-  env: CoordinatorEnv;
-  id: string;
-  params: PlayWorkflowParams;
-  metadataParams?: PlayWorkflowParams;
-}): Promise<WorkflowInstance> {
-  const workflow = createDispatcherWorkflowBinding(
-    () => input.env.PLAY_WORKFLOW as unknown as Workflow,
-    buildDynamicWorkflowMetadata(input.metadataParams ?? input.params),
-  );
-  return workflow.create({
-    id: input.id,
-    params: input.params,
-  });
-}
-
-function runScopedDurableObject(
-  env: CoordinatorEnv,
-  runId: string,
-): DurableObjectStub {
-  return env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(runId));
-}
-
-/**
- * Address the rate-state Durable Object for a single `<orgId>:<provider>`
- * bucket. Keying the DO by the bucket id (not the run id) makes one
- * single-threaded instance own that bucket's request window across every
- * isolate of every run in the org — which is exactly what the distributed Rate
- * State Backend needs. Reuses the PlayDedup namespace (the DO already hosts the
- * token-bucket handlers) so no extra binding is required.
- */
-function rateBucketDurableObject(
-  env: CoordinatorEnv,
-  bucketId: string,
-): DurableObjectStub {
-  return env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(`rate:${bucketId}`));
-}
-
-async function callRateBucketControl<T>(
-  env: CoordinatorEnv,
-  bucketId: string,
-  path: string,
-  body: unknown,
-): Promise<T> {
-  const response = await rateBucketDurableObject(env, bucketId).fetch(
-    `https://deepline.rate-state.internal${path}`,
-    {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(body),
-    },
-  );
-  if (!response.ok) {
-    throw new Error(
-      `rate state ${path} failed ${response.status}: ${(
-        await response.text().catch(() => '')
-      ).slice(0, 400)}`,
-    );
-  }
-  return (await response.json()) as T;
-}
-
-async function callRunScopedControl<T>(
-  env: CoordinatorEnv,
-  runId: string,
-  path: string,
-  init?: RequestInit,
-): Promise<T> {
-  const maxAttempts = DURABLE_OBJECT_DEPLOY_HANDOFF_RETRY_DELAYS_MS.length + 1;
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    let response: Response;
-    try {
-      response = await runScopedDurableObject(env, runId).fetch(
-        `https://deepline.run-state.internal${path}`,
-        {
-          ...(init ?? {}),
-          headers: {
-            'content-type': 'application/json',
-            ...(init?.headers ?? {}),
-          },
-        },
-      );
-    } catch (error) {
-      const handoffMessage = durableObjectDeployHandoffMessage(error);
-      if (handoffMessage && attempt < maxAttempts) {
-        recordCoordinatorEvent(
-          'warn',
-          'coordinator.run_state.handoff_retry',
-          '[coordinator] run state DO deploy handoff retry',
-          {
-            runId,
-            path,
-            attempt,
-            error: handoffMessage,
-          },
-        );
-        await sleepForDurableObjectDeployHandoffRetry(attempt - 1);
-        continue;
-      }
-      throw error;
-    }
-
-    if (response.ok) {
-      return (await response.json()) as T;
-    }
-
-    const responseText = (await response.text().catch(() => '')).slice(0, 400);
-    const handoffMessage = durableObjectDeployHandoffMessage(responseText);
-    if (handoffMessage && attempt < maxAttempts) {
-      recordCoordinatorEvent(
-        'warn',
-        'coordinator.run_state.handoff_retry',
-        '[coordinator] run state DO deploy handoff retry',
-        {
-          runId,
-          path,
-          attempt,
-          status: response.status,
-          error: handoffMessage,
-        },
-      );
-      await sleepForDurableObjectDeployHandoffRetry(attempt - 1);
-      continue;
-    }
-
-    throw new Error(
-      `run state ${path} failed ${response.status}: ${responseText}`,
-    );
-  }
-  throw new Error(`run state ${path} failed after deploy handoff retries`);
-}
-
-async function recordWorkflowInstanceId(input: {
-  env: CoordinatorEnv;
-  runId: string;
-  instanceId: string;
-}): Promise<void> {
-  await callRunScopedControl<{ ok?: unknown }>(
-    input.env,
-    input.runId,
-    '/workflow-instance-put',
-    {
-      method: 'POST',
-      body: JSON.stringify({
-        runId: input.runId,
-        instanceId: input.instanceId,
-        ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
-      }),
-    },
-  );
-}
-
-async function resolveWorkflowInstanceIdForRun(
-  env: CoordinatorEnv,
-  runId: string,
-): Promise<string> {
-  const body = await callRunScopedControl<{ instanceId?: unknown }>(
-    env,
-    runId,
-    `/workflow-instance-get?runId=${encodeURIComponent(runId)}`,
-  ).catch(() => ({ instanceId: null }));
-  return typeof body.instanceId === 'string' && body.instanceId
-    ? body.instanceId
-    : workflowInstanceId(runId);
-}
-
-async function claimWorkflowSubmit(input: {
-  env: CoordinatorEnv;
-  runId: string;
-}): Promise<{
-  claimed: boolean;
-  status: 'creating' | 'created' | null;
-  instanceId: string | null;
-}> {
-  const body = await callRunScopedControl<{
-    claimed?: unknown;
-    status?: unknown;
-    instanceId?: unknown;
-  }>(input.env, input.runId, '/workflow-submit-claim', {
-    method: 'POST',
-    body: JSON.stringify({
-      runId: input.runId,
-      ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
-    }),
-  });
-  return {
-    claimed: body.claimed === true,
-    status:
-      body.status === 'creating' || body.status === 'created'
-        ? body.status
-        : null,
-    instanceId: typeof body.instanceId === 'string' ? body.instanceId : null,
-  };
-}
-
-async function releaseWorkflowSubmitClaim(input: {
-  env: CoordinatorEnv;
-  runId: string;
-}): Promise<void> {
-  await callRunScopedControl<{ ok?: unknown }>(
-    input.env,
-    input.runId,
-    '/workflow-submit-release',
-    {
-      method: 'POST',
-      body: JSON.stringify({ runId: input.runId }),
-    },
-  );
-}
-
-async function waitForWorkflowSubmitCreated(input: {
-  env: CoordinatorEnv;
-  runId: string;
-  initialClaim: Awaited<ReturnType<typeof claimWorkflowSubmit>>;
-  timeoutMs: number;
-  pollMs: number;
-}): Promise<Awaited<ReturnType<typeof claimWorkflowSubmit>>> {
-  let claim = input.initialClaim;
-  const deadline = Date.now() + input.timeoutMs;
-  while (claim.status !== 'created' || !claim.instanceId) {
-    if (Date.now() >= deadline) {
-      return claim;
-    }
-    await sleep(input.pollMs);
-    claim = await claimWorkflowSubmit({
-      env: input.env,
-      runId: input.runId,
-    });
-  }
-  return claim;
-}
-
-function assertEncryptedPreloadedDbSessions(
-  sessions: PreloadedRuntimeDbSession[],
-): void {
-  for (const session of sessions) {
-    if (session.session.postgresUrl) {
-      throw new Error(
-        'Preloaded Runtime DB sessions must not carry raw Postgres URLs.',
-      );
-    }
-    if (!session.session.encryptedPostgresUrl) {
-      throw new Error(
-        'Preloaded Runtime DB sessions must carry encrypted Postgres URLs.',
-      );
-    }
-  }
-}
-
-async function readWorkflowDbSessions(input: {
-  env: CoordinatorEnv;
-  ref: NonNullable<PlayWorkflowParams['preloadedDbSessionRef']>;
-}): Promise<PreloadedRuntimeDbSession[]> {
-  const response = await runScopedDurableObject(
-    input.env,
-    input.ref.runId,
-  ).fetch(
-    `https://deepline.dedup.internal/db-sessions-get?runId=${encodeURIComponent(
-      input.ref.runId,
-    )}`,
-  );
-  if (!response.ok) {
-    throw new Error(
-      `workflow db session lookup failed ${response.status}: ${(
-        await response.text().catch(() => '')
-      ).slice(0, 400)}`,
-    );
-  }
-  const body = (await response.json().catch(() => ({}))) as {
-    sessions?: unknown;
-  };
-  if (!Array.isArray(body.sessions)) {
-    throw new Error('workflow db session lookup returned no sessions.');
-  }
-  const sessions = body.sessions as PreloadedRuntimeDbSession[];
-  assertEncryptedPreloadedDbSessions(sessions);
-  return sessions;
-}
-
-async function readWorkflowDbSessionsWithRetry(input: {
-  env: CoordinatorEnv;
-  ref: NonNullable<PlayWorkflowParams['preloadedDbSessionRef']>;
-}): Promise<PreloadedRuntimeDbSession[]> {
-  const delays = [25, 50, 100, 200] as const;
-  let lastError: unknown = null;
-  for (let attempt = 0; attempt <= delays.length; attempt += 1) {
-    try {
-      return await readWorkflowDbSessions(input);
-    } catch (error) {
-      lastError = error;
-      const message = error instanceof Error ? error.message : String(error);
-      if (
-        !message.includes('workflow db session lookup failed 404') ||
-        attempt >= delays.length
-      ) {
-        throw error;
-      }
-      await sleep(delays[attempt]);
-    }
-  }
-  throw lastError instanceof Error ? lastError : new Error(String(lastError));
-}
-
-function externalizedWorkflowDbSessionParams(input: {
-  params: PlayWorkflowParams;
-}): {
-  params: PlayWorkflowParams;
-  sessions: PreloadedRuntimeDbSession[];
-  ref: NonNullable<PlayWorkflowParams['preloadedDbSessionRef']> | null;
-} {
-  const sessions = Array.isArray(input.params.preloadedDbSessions)
-    ? input.params.preloadedDbSessions
-    : [];
-  if (sessions.length === 0) {
-    return { params: input.params, sessions, ref: null };
-  }
-  const ref: NonNullable<PlayWorkflowParams['preloadedDbSessionRef']> = {
-    runId: input.params.runId,
-    sessionCount: sessions.length,
-    expiresAt: Date.now() + DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
-  };
-  return {
-    params: {
-      ...input.params,
-      preloadedDbSessions: null,
-      preloadedDbSessionRef: ref,
-    },
-    sessions,
-    ref,
-  };
-}
-
-function readPreloadedDbSessionRef(
-  value: unknown,
-): NonNullable<PlayWorkflowParams['preloadedDbSessionRef']> | null {
-  if (!isRecord(value)) return null;
-  const runId = typeof value.runId === 'string' ? value.runId : '';
-  const sessionCount =
-    typeof value.sessionCount === 'number' &&
-    Number.isFinite(value.sessionCount)
-      ? value.sessionCount
-      : 0;
-  const expiresAt =
-    typeof value.expiresAt === 'number' && Number.isFinite(value.expiresAt)
-      ? value.expiresAt
-      : 0;
-  if (!runId || sessionCount <= 0 || expiresAt <= 0) return null;
-  return { runId, sessionCount, expiresAt };
-}
-
-async function hydrateWorkflowDbSessions(input: {
-  env: CoordinatorEnv;
-  event: unknown;
-  trace: CoordinatorPerfTraceSink;
-}): Promise<unknown> {
-  if (!isRecord(input.event)) return input.event;
-  const payload = isRecord(input.event.payload) ? input.event.payload : null;
-  const envelopeParams = isRecord(payload?.params) ? payload.params : null;
-  const params = envelopeParams ?? payload;
-  if (!payload || !params || Array.isArray(params.preloadedDbSessions)) {
-    return input.event;
-  }
-  const ref = readPreloadedDbSessionRef(params.preloadedDbSessionRef);
-  if (!ref) return input.event;
-  const startedAt = Date.now();
-  const sessions = await readWorkflowDbSessionsWithRetry({
-    env: input.env,
-    ref,
-  });
-  input.trace({
-    runId: ref.runId,
-    phase: 'coordinator.workflow_db_sessions_hydrated',
-    ms: Date.now() - startedAt,
-    graphHash: typeof params.graphHash === 'string' ? params.graphHash : null,
-    extra: {
-      sessions: sessions.length,
-      refSessionCount: ref.sessionCount,
-    },
-  });
-  return {
-    ...input.event,
-    payload: envelopeParams
-      ? {
-          ...payload,
-          params: {
-            ...params,
-            preloadedDbSessions: sessions,
-          },
-        }
-      : {
-          ...payload,
-          preloadedDbSessions: sessions,
-        },
-  };
-}
-
-async function hydrateWorkflowLaunchParams(input: {
-  env: CoordinatorEnv;
-  event: unknown;
-  trace: CoordinatorPerfTraceSink;
-}): Promise<unknown> {
-  if (!isRecord(input.event)) return input.event;
-  const payload = isRecord(input.event.payload) ? input.event.payload : null;
-  const envelopeParams = isRecord(payload?.params) ? payload.params : null;
-  const params = envelopeParams ?? payload;
-  if (
-    !payload ||
-    !params ||
-    (!isRecord(params.workflowParams) && !isRecord(params.workflowParamsRef))
-  ) {
-    return input.event;
-  }
-  const startedAt = Date.now();
-  const hydrated = await hydrateWorkflowRetryParams({
-    env: input.env,
-    params: params.workflowParams,
-    paramsRef: params.workflowParamsRef,
-  });
-  if (!hydrated) return input.event;
-  const submittedAt =
-    typeof params.submittedAt === 'number' &&
-    Number.isFinite(params.submittedAt)
-      ? params.submittedAt
-      : hydrated.submittedAt;
-  const hydratedParams = {
-    ...hydrated,
-    submittedAt,
-  };
-  input.trace({
-    runId:
-      typeof hydratedParams.runId === 'string'
-        ? hydratedParams.runId
-        : 'unknown-workflow-run',
-    phase: 'coordinator.workflow_launch_params_hydrated',
-    ms: Date.now() - startedAt,
-    graphHash:
-      typeof hydratedParams.graphHash === 'string'
-        ? hydratedParams.graphHash
-        : null,
-    extra: {
-      paramsBytes: isRecord(params.workflowParamsRef)
-        ? typeof params.workflowParamsRef.bytes === 'number'
-          ? params.workflowParamsRef.bytes
-          : null
-        : jsonByteLength(params.workflowParams),
-      paramsStorage: isRecord(params.workflowParamsRef) ? 'r2' : 'inline',
-    },
-  });
-  return {
-    ...input.event,
-    payload: envelopeParams
-      ? {
-          ...payload,
-          params: hydratedParams,
-        }
-      : {
-          ...payload,
-          ...hydratedParams,
-        },
-  };
-}
-
-function workflowCreateParams(
-  params: PlayWorkflowParams,
-  launchState: {
-    params?: PlayWorkflowParams;
-    paramsRef?: WorkflowRetryParamsRef;
-  },
-): PlayWorkflowParams {
-  const launchParams = launchState.params ?? params;
-  const envelope: Record<string, unknown> = {
-    runId: params.runId,
-    playName: params.playName,
-    graphHash: params.graphHash,
-    artifactStorageKey: params.artifactStorageKey,
-    artifactHash: params.artifactHash,
-    submittedAt: params.submittedAt,
-  };
-  if (launchState.paramsRef) {
-    envelope.workflowParamsRef = launchState.paramsRef;
-  } else {
-    envelope.workflowParams = launchParams;
-  }
-  return envelope as unknown as PlayWorkflowParams;
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function readWorkflowPayload(event: unknown): Record<string, unknown> | null {
-  if (!isRecord(event)) return null;
-  const payload = event.payload;
-  if (!isRecord(payload)) return null;
-  return isRecord(payload.params) ? payload.params : payload;
-}
-
-function isCoordinatorWorkerMemoryLimitError(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error);
-  return message.toLowerCase().includes('worker exceeded memory limit');
-}
-
-function normalizeCoordinatorWorkflowRuntimeFailure(
-  error: unknown,
-): ReturnType<typeof normalizePlayRunFailure> {
-  const failure = normalizePlayRunFailure(error);
-  if (!isCoordinatorWorkerMemoryLimitError(error)) {
-    return failure;
-  }
-  return {
-    ...failure,
-    code: 'WORKER_MEMORY_LIMIT_EXCEEDED',
-    message: COORDINATOR_WORKER_MEMORY_LIMIT_MESSAGE,
-    retryable: false,
-    cause: failure.message,
-  };
-}
-
-async function markWorkflowRuntimeFailure(input: {
-  env: CoordinatorEnv;
-  event: unknown;
-  error: unknown;
-}): Promise<void> {
-  const payload = readWorkflowPayload(input.event);
-  if (!payload) return;
-  const runId = typeof payload.runId === 'string' ? payload.runId : null;
-  const baseUrl = typeof payload.baseUrl === 'string' ? payload.baseUrl : null;
-  const executorToken =
-    typeof payload.executorToken === 'string' ? payload.executorToken : null;
-  if (!runId || !baseUrl || !executorToken) return;
-  const errorName =
-    input.error instanceof Error && input.error.name
-      ? input.error.name
-      : 'Error';
-  const errorMessage =
-    input.error instanceof Error ? input.error.message : String(input.error);
-  const errorStack =
-    input.error instanceof Error && typeof input.error.stack === 'string'
-      ? input.error.stack.split('\n').slice(0, 12).join('\n')
-      : null;
-  const failure = normalizeCoordinatorWorkflowRuntimeFailure(input.error);
-  const shouldPreserveRawError =
-    failure.code === 'RUN_FAILED' ||
-    (failure.cause !== undefined && failure.message === failure.cause);
-  const normalizedError = shouldPreserveRawError
-    ? `DynamicWorkflow runner failed: ${errorName}: ${errorMessage}${
-        errorStack ? `\n${errorStack}` : ''
-      }`
-    : `DynamicWorkflow runner failed: ${failure.message}`;
-  const headers = new Headers({
-    authorization: `Bearer ${executorToken}`,
-    'content-type': 'application/json',
-  });
-  const bypass = input.env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim();
-  if (bypass) headers.set('x-vercel-protection-bypass', bypass);
-  const body = JSON.stringify({
-    action: 'append_run_events',
-    playId: runId,
-    events: [
-      {
-        type: 'run.failed',
-        runId,
-        source: 'coordinator',
-        occurredAt: Date.now(),
-        error: normalizedError,
-      } satisfies PlayRunLedgerEvent,
-    ],
-  });
-  const url = `${baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_COMPAT_PATH}`;
-  const backoffMs = [200, 500, 1500];
-  let lastError: unknown = null;
-  for (let attempt = 0; attempt <= backoffMs.length; attempt += 1) {
-    const requestId = crypto.randomUUID();
-    try {
-      headers.set('x-deepline-request-id', requestId);
-      const response = await fetch(url, { method: 'POST', headers, body });
-      if (response.ok) {
-        if (attempt > 0) {
-          recordCoordinatorEvent(
-            'info',
-            'coordinator.runtime_api.retry',
-            '[coordinator.runtime_api.retry]',
-            {
-              action: 'append_run_events',
-              status: 'ok',
-              attempt,
-              runId,
-              requestId,
-              baseOrigin: safeOrigin(baseUrl),
-            },
-          );
-        }
-        return;
-      }
-      lastError = new Error(
-        `runtime API responded ${response.status}: ${(await response.text().catch(() => '')).slice(0, 400)}`,
-      );
-      if (
-        response.status >= 400 &&
-        response.status < 500 &&
-        response.status !== 408 &&
-        response.status !== 429
-      ) {
-        break;
-      }
-    } catch (error) {
-      lastError = error;
-    }
-    if (attempt < backoffMs.length) {
-      recordCoordinatorEvent(
-        'warn',
-        'coordinator.runtime_api.retry',
-        '[coordinator.runtime_api.retry]',
-        {
-          action: 'append_run_events',
-          status: 'retry',
-          attempt: attempt + 1,
-          retryDelayMs: backoffMs[attempt],
-          runId,
-          requestId,
-          baseOrigin: safeOrigin(baseUrl),
-          error:
-            lastError instanceof Error
-              ? lastError.message.slice(0, 300)
-              : String(lastError).slice(0, 300),
-        },
-      );
-      await new Promise((resolve) => setTimeout(resolve, backoffMs[attempt]));
-    }
-  }
-  recordCoordinatorEvent(
-    'error',
-    'coordinator.workflow_runtime_failure.mark_failed',
-    '[coordinator] failed to mark workflow runtime failure',
-    {
-      runId,
-      message:
-        lastError instanceof Error ? lastError.message : String(lastError),
-    },
-  );
-}
-
-type StoredPlayArtifactPayload = {
-  artifact?: {
-    bundledCode?: string;
-    artifactKind?: string;
-  };
-};
-
-const DYNAMIC_WORKER_COMPATIBILITY_DATE = '2026-05-01';
-
-async function persistWorkflowRetryState(input: {
-  env: CoordinatorEnv;
-  runId: string;
-  params: PlayWorkflowParams;
-}): Promise<{
-  params?: PlayWorkflowParams;
-  paramsRef?: WorkflowRetryParamsRef;
-}> {
-  const retryParams = buildWorkflowRetryParams(input.params);
-  const paramsBytes = jsonByteLength(retryParams);
-  if (paramsBytes > WORKFLOW_RETRY_PARAMS_MAX_BYTES) {
-    throw new Error(
-      `workflow retry params too large: ${paramsBytes} bytes exceeds ${WORKFLOW_RETRY_PARAMS_MAX_BYTES}. Pass large payloads as staged files or ctx.csv inputs instead of inline JSON.`,
-    );
-  }
-  let body: {
-    runId: string;
-    params?: PlayWorkflowParams;
-    paramsRef?: WorkflowRetryParamsRef;
-    paramsBytes: number;
-    ttlMs: number;
-  };
-  if (paramsBytes > WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES) {
-    const serialized = JSON.stringify(retryParams);
-    const hash = stableHash(serialized);
-    const storageKey = workflowRetryParamsStorageKey({
-      runId: input.runId,
-      hash,
-    });
-    const paramsRef: WorkflowRetryParamsRef = {
-      storageKind: 'r2',
-      storageKey,
-      bytes: paramsBytes,
-      hash,
-      expiresAt: Date.now() + WORKFLOW_RETRY_STATE_TTL_MS,
-    };
-    await input.env.PLAYS_BUCKET.put(storageKey, serialized, {
-      httpMetadata: { contentType: 'application/json' },
-    });
-    body = {
-      runId: input.runId,
-      paramsRef,
-      paramsBytes,
-      ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
-    };
-    await callRunScopedControl<{ ok?: unknown }>(
-      input.env,
-      input.runId,
-      '/run-retry-state-put',
-      {
-        method: 'POST',
-        body: JSON.stringify(body),
-      },
-    );
-    return { paramsRef };
-  } else {
-    body = {
-      runId: input.runId,
-      params: retryParams,
-      paramsBytes,
-      ttlMs: WORKFLOW_RETRY_STATE_TTL_MS,
-    };
-  }
-  await callRunScopedControl<{ ok?: unknown }>(
-    input.env,
-    input.runId,
-    '/run-retry-state-put',
-    {
-      method: 'POST',
-      body: JSON.stringify(body),
-    },
-  );
-  return { params: retryParams };
-}
-
-async function persistWorkflowLaunchState(input: {
-  env: CoordinatorEnv;
-  runId: string;
-  params: PlayWorkflowParams;
-  sessions: PreloadedRuntimeDbSession[];
-}): Promise<{
-  retryExpiresAt?: number;
-  dbSessionsExpiresAt?: number;
-  sessionCount?: number;
-  params?: PlayWorkflowParams;
-  paramsRef?: WorkflowRetryParamsRef;
-}> {
-  if (input.sessions.length === 0) {
-    const state = await persistWorkflowRetryState({
-      env: input.env,
-      runId: input.runId,
-      params: input.params,
-    });
-    return state;
-  }
-  const retryParams = buildWorkflowRetryParams(input.params);
-  const paramsBytes = jsonByteLength(retryParams);
-  let body: {
-    runId: string;
-    params?: PlayWorkflowParams;
-    paramsRef?: WorkflowRetryParamsRef;
-    paramsBytes: number;
-    sessions: PreloadedRuntimeDbSession[];
-    retryTtlMs: number;
-    dbSessionsTtlMs: number;
-  };
-  if (paramsBytes > WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES) {
-    const serialized = JSON.stringify(retryParams);
-    const hash = stableHash(serialized);
-    const storageKey = workflowRetryParamsStorageKey({
-      runId: input.runId,
-      hash,
-    });
-    const paramsRef: WorkflowRetryParamsRef = {
-      storageKind: 'r2',
-      storageKey,
-      bytes: paramsBytes,
-      hash,
-      expiresAt: Date.now() + WORKFLOW_RETRY_STATE_TTL_MS,
-    };
-    await input.env.PLAYS_BUCKET.put(storageKey, serialized, {
-      httpMetadata: { contentType: 'application/json' },
-    });
-    body = {
-      runId: input.runId,
-      paramsRef,
-      paramsBytes,
-      sessions: input.sessions,
-      retryTtlMs: WORKFLOW_RETRY_STATE_TTL_MS,
-      dbSessionsTtlMs: DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
-    };
-  } else {
-    body = {
-      runId: input.runId,
-      params: retryParams,
-      paramsBytes,
-      sessions: input.sessions,
-      retryTtlMs: WORKFLOW_RETRY_STATE_TTL_MS,
-      dbSessionsTtlMs: DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
-    };
-  }
-  const response = await callRunScopedControl<{
-    ok?: unknown;
-    retryExpiresAt?: unknown;
-    dbSessionsExpiresAt?: unknown;
-    sessionCount?: unknown;
-  }>(input.env, input.runId, '/run-launch-state-put', {
-    method: 'POST',
-    body: JSON.stringify(body),
-  });
-  return {
-    retryExpiresAt:
-      typeof response.retryExpiresAt === 'number'
-        ? response.retryExpiresAt
-        : undefined,
-    dbSessionsExpiresAt:
-      typeof response.dbSessionsExpiresAt === 'number'
-        ? response.dbSessionsExpiresAt
-        : undefined,
-    sessionCount:
-      typeof response.sessionCount === 'number'
-        ? response.sessionCount
-        : undefined,
-    params: body.params,
-    paramsRef: body.paramsRef,
-  };
-}
-
-function parseWorkflowRetryParamsRef(
-  paramsRef: unknown,
-): WorkflowRetryParamsRef | null {
-  if (!isRecord(paramsRef)) {
-    return null;
-  }
-  const storageKind = paramsRef.storageKind;
-  const storageKey = paramsRef.storageKey;
-  const expectedBytes = paramsRef.bytes;
-  const expectedHash = paramsRef.hash;
-  const expiresAt = paramsRef.expiresAt;
-  if (
-    storageKind !== 'r2' ||
-    typeof storageKey !== 'string' ||
-    !storageKey.startsWith('plays/workflow-retry-params/') ||
-    typeof expectedBytes !== 'number' ||
-    !Number.isFinite(expectedBytes) ||
-    typeof expectedHash !== 'string' ||
-    !expectedHash ||
-    typeof expiresAt !== 'number' ||
-    !Number.isFinite(expiresAt)
-  ) {
-    throw new Error('Invalid workflow retry params reference.');
-  }
-  return {
-    storageKind,
-    storageKey,
-    bytes: expectedBytes,
-    hash: expectedHash,
-    expiresAt,
-  };
-}
-
-async function hydrateWorkflowRetryParams(input: {
-  env: CoordinatorEnv;
-  params: unknown;
-  paramsRef: unknown;
-}): Promise<PlayWorkflowParams | null> {
-  if (isRecord(input.params)) {
-    return input.params as PlayWorkflowParams;
-  }
-  const paramsRef = parseWorkflowRetryParamsRef(input.paramsRef);
-  if (!paramsRef) return null;
-  const storageKey = paramsRef.storageKey;
-  const expectedBytes = paramsRef.bytes;
-  const expectedHash = paramsRef.hash;
-  if (paramsRef.expiresAt <= Date.now()) {
-    throw new Error('Workflow retry params reference expired.');
-  }
-  const object = await input.env.PLAYS_BUCKET.get(storageKey);
-  if (!object) {
-    throw new Error(`Workflow retry params missing from R2: ${storageKey}`);
-  }
-  const text = await object.text();
-  const actualBytes = new TextEncoder().encode(text).length;
-  if (actualBytes !== expectedBytes) {
-    throw new Error(
-      `Workflow retry params byte length mismatch: expected ${expectedBytes}, got ${actualBytes}.`,
-    );
-  }
-  const actualHash = stableHash(text);
-  if (actualHash !== expectedHash) {
-    throw new Error('Workflow retry params hash mismatch.');
-  }
-  const parsed = JSON.parse(text) as unknown;
-  return isRecord(parsed) ? (parsed as PlayWorkflowParams) : null;
-}
-
-function workflowRetryStatePersistenceErrorResponse(input: {
-  runId: string;
-  error: unknown;
-}): Response {
-  const message =
-    input.error instanceof Error ? input.error.message : String(input.error);
-  return Response.json(
-    {
-      error: {
-        code: 'WORKFLOW_RETRY_STATE_PERSISTENCE_FAILED',
-        message:
-          'Failed to persist workflow retry state before dispatching the play run.',
-        phase: 'coordinator_retry_state_persistence',
-        runId: input.runId,
-        cause: message,
-      },
-    },
-    { status: 503 },
-  );
-}
-
-async function claimWorkflowPlatformRetry(input: {
-  env: CoordinatorEnv;
-  runId: string;
-}): Promise<{
-  claimed: boolean;
-  attempts: number;
-  params: PlayWorkflowParams | null;
-  paramsRef?: WorkflowRetryParamsRef;
-}> {
-  const body = await callRunScopedControl<{
-    claimed?: unknown;
-    attempts?: unknown;
-    params?: unknown;
-    paramsRef?: unknown;
-  }>(input.env, input.runId, '/run-retry-claim', {
-    method: 'POST',
-    body: JSON.stringify({
-      runId: input.runId,
-      maxAttempts: PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
-    }),
-  });
-  const params = await hydrateWorkflowRetryParams({
-    env: input.env,
-    params: body.params,
-    paramsRef: body.paramsRef,
-  });
-  const paramsRef = parseWorkflowRetryParamsRef(body.paramsRef) ?? undefined;
-  return {
-    claimed: body.claimed === true,
-    attempts: typeof body.attempts === 'number' ? body.attempts : 0,
-    params,
-    paramsRef,
-  };
-}
-
-function workflowRetryInstanceId(runId: string, attempt: number): string {
-  const suffix = `retry-${attempt}-${stableHash(`${runId}:${attempt}`).slice(0, 8)}`;
-  const base = workflowInstanceId(runId);
-  const maxBaseLength = Math.max(1, 100 - suffix.length - 1);
-  return `${base.slice(0, maxBaseLength)}-${suffix}`;
-}
-
-function normalizeWorkflowRunAttempt(value: unknown): number {
-  return typeof value === 'number' && Number.isFinite(value)
-    ? Math.max(0, Math.floor(value))
-    : 0;
-}
-
-async function restartWorkflowAfterPlatformReset(input: {
-  env: CoordinatorEnv;
-  ctx?: ExecutionContext;
-  runId: string;
-  oldInstance: WorkflowInstance;
-  error: string;
-  status: InstanceStatus;
-}): Promise<{
-  retried: boolean;
-  result: Record<string, unknown> | null;
-}> {
-  const decision = decideWorkflowPlatformRetry({
-    workflowStatus: String(input.status.status ?? ''),
-    error: input.error,
-    retryAttempts: 0,
-  });
-  if (decision.action !== 'retry') {
-    return { retried: false, result: null };
-  }
-  const claim = await claimWorkflowPlatformRetry({
-    env: input.env,
-    runId: input.runId,
-  }).catch((error) => {
-    recordCoordinatorEvent(
-      'warn',
-      'coordinator.workflow_platform_retry.claim_failed',
-      '[coordinator] workflow platform retry claim failed',
-      {
-        runId: input.runId,
-        error: error instanceof Error ? error.message : String(error),
-      },
-    );
-    return null;
-  });
-  if (!claim?.claimed || !claim.params) {
-    return { retried: false, result: null };
-  }
-  const retryInstanceId = workflowRetryInstanceId(input.runId, claim.attempts);
-  const retryStartedAt = Date.now();
-  let retryInstance: WorkflowInstance | null = null;
-  const retryParams = { ...claim.params, runAttempt: claim.attempts };
-  try {
-    retryInstance = await createDynamicWorkflowInstance({
-      env: input.env,
-      id: retryInstanceId,
-      params: workflowCreateParams(retryParams, {
-        params: retryParams,
-        paramsRef: claim.paramsRef,
-      }),
-      metadataParams: retryParams,
-    });
-    await recordWorkflowInstanceId({
-      env: input.env,
-      runId: input.runId,
-      instanceId: retryInstance.id,
-    });
-    input.ctx?.waitUntil(input.oldInstance.terminate().catch(() => undefined));
-    recordCoordinatorPerfTraceBuffered(input.env, input.ctx, {
-      runId: input.runId,
-      phase: 'coordinator.platform_deploy_retry',
-      ms: Date.now() - retryStartedAt,
-      graphHash: claim.params.graphHash ?? null,
-      extra: {
-        retryAttempt: claim.attempts,
-        retryInstanceId: retryInstance.id,
-        reason: decision.reason,
-      },
-    });
-    return {
-      retried: true,
-      result: {
-        runId: input.runId,
-        playName: claim.params.playName,
-        status: 'running',
-        result: null,
-        error: null,
-        retry: {
-          reason: decision.reason,
-          attempt: claim.attempts,
-          message: decision.message,
-        },
-      },
-    };
-  } finally {
-    disposeRpcStub(retryInstance);
-  }
-}
-
-export class CoordinatorControl extends WorkerEntrypoint<
-  CoordinatorEnv,
-  undefined
-> {
-  async signal(
-    runId: string,
-    body: Record<string, unknown>,
-  ): Promise<Record<string, unknown>> {
-    const response = await handleWorkflowRoute({
-      runId,
-      action: 'signal',
-      request: new Request(
-        `https://deepline.coordinator.internal/workflow/${encodeURIComponent(
-          runId,
-        )}/signal`,
-        {
-          method: 'POST',
-          headers: {
-            'content-type': 'application/json',
-            'x-deepline-request-id': crypto.randomUUID(),
-          },
-          body: JSON.stringify(body),
-        },
-      ),
-      env: this.env,
-    });
-    const text = await response.text().catch(() => '');
-    let parsed: Record<string, unknown> = {};
-    try {
-      parsed = text ? (JSON.parse(text) as Record<string, unknown>) : {};
-    } catch {
-      parsed = { error: text };
-    }
-    if (!response.ok) {
-      const error = isRecord(parsed.error) ? parsed.error : null;
-      const message =
-        (typeof error?.message === 'string' && error.message.trim()) ||
-        (typeof parsed.error === 'string' && parsed.error.trim()) ||
-        text.slice(0, 800) ||
-        `Coordinator signal failed with ${response.status}.`;
-      throw new Error(message);
-    }
-    return parsed;
-  }
-
-  async recordPerfTrace(
-    runId: string,
-    payload: CoordinatorPerfTracePayload,
-  ): Promise<void> {
-    if (!runId || payload.runId !== runId) {
-      throw new Error('Trace runId mismatch.');
-    }
-    await appendCoordinatorPerfTrace(this.env, payload);
-  }
-
-  async recordRunEvent(
-    runId: string,
-    event: CoordinatorRunEvent,
-  ): Promise<void> {
-    if (!runId || event.runId !== runId) {
-      throw new Error('Run event runId mismatch.');
-    }
-    await appendCoordinatorRunEvent(this.env, event);
-  }
-
-  async readTerminalState(
-    runId: string,
-  ): Promise<CoordinatorTerminalState | null> {
-    if (!runId) {
-      throw new Error('runId is required.');
-    }
-    return await readCoordinatorTerminalState(this.env, runId);
-  }
-
-  /**
-   * Distributed Rate State Backend acquire: lease up to `requested` request-
-   * window permits for `bucketId` (`<orgId>:<provider>`) from the per-bucket
-   * rate-state Durable Object. See CoordinatorRateStateBackend + dedup-do.ts.
-   */
-  async rateAcquire(input: {
-    bucketId: string;
-    rules: Array<{
-      ruleId: string;
-      requestsPerWindow: number;
-      windowMs: number;
-      maxConcurrency: number | null;
-    }>;
-    requested: number;
-  }): Promise<{ granted: number; waitMs: number }> {
-    if (!input.bucketId || !input.bucketId.trim()) {
-      throw new Error('bucketId is required.');
-    }
-    return await callRateBucketControl<{ granted: number; waitMs: number }>(
-      this.env,
-      input.bucketId,
-      '/rate-acquire',
-      input,
-    );
-  }
-
-  async ratePenalize(input: {
-    bucketId: string;
-    cooldownMs: number;
-  }): Promise<void> {
-    if (!input.bucketId || !input.bucketId.trim()) {
-      throw new Error('bucketId is required.');
-    }
-    await callRateBucketControl<{ ok?: unknown }>(
-      this.env,
-      input.bucketId,
-      '/rate-penalize',
-      input,
-    );
-  }
-}
-
-/**
- * Custom DynamicWorkflow class — replaces createDynamicWorkflowEntrypoint
- * so we can wrap the framework's runner.run(innerEvent, step) RPC in a
- * try/catch and surface the underlying error. The library's helper hides
- * that call inside dispatchWorkflow which we now invoke directly with
- * extra instrumentation around the inner runner call.
- */
-export class DynamicWorkflow extends WorkflowEntrypoint<
-  CoordinatorEnv,
-  Record<string, unknown>
-> {
-  async run(event: unknown, step: unknown): Promise<unknown> {
-    const trace: CoordinatorPerfTraceSink = (traceEvent) =>
-      recordCoordinatorPerfTraceBuffered(this.env, this.ctx, traceEvent);
-    const workflowEvent = event as {
-      payload?: unknown;
-      timestamp?: Date;
-      instanceId?: string;
-    };
-    const entryTrace = readWorkflowTraceContext(event);
-    trace({
-      runId: entryTrace.runId,
-      phase: 'coordinator.workflow_run_entry',
-      ms: 0,
-      graphHash: entryTrace.graphHash,
-      extra: {
-        instanceId: entryTrace.instanceId,
-      },
-    });
-    if (entryTrace.runId) {
-      this.ctx.waitUntil(
-        appendCoordinatorRunEvent(this.env, {
-          runId: entryTrace.runId,
-          type: 'status',
-          status: 'running',
-          ts: Date.now(),
-        }).catch((error) => {
-          recordCoordinatorEvent(
-            'warn',
-            'coordinator.workflow_entry.status_event_failed',
-            '[coordinator] workflow entry status event failed',
-            {
-              runId: entryTrace.runId,
-              error: error instanceof Error ? error.message : String(error),
-            },
-          );
-        }),
-      );
-    }
-    if (entryTrace.submittedAt !== null) {
-      trace({
-        runId: entryTrace.runId,
-        phase: 'coordinator.workflow_start_gap',
-        ms: Math.max(0, Date.now() - entryTrace.submittedAt),
-        graphHash: entryTrace.graphHash,
-        extra: {
-          instanceId: entryTrace.instanceId,
-        },
-      });
-    }
-    let dispatchedEvent = event;
-    dispatchedEvent = await hydrateWorkflowLaunchParams({
-      env: this.env,
-      event: dispatchedEvent,
-      trace,
-    });
-    try {
-      dispatchedEvent = await hydrateWorkflowDbSessions({
-        env: this.env,
-        event: dispatchedEvent,
-        trace,
-      });
-    } catch (hydrateError) {
-      // The workflow re-entered but cannot read its externalized DB sessions.
-      // A 410 (expired retention window) is known-permanent: the sessions are
-      // stored once at submit and never re-minted here, so the workflow can
-      // only keep failing. Publish a clean run.failed instead of letting the
-      // raw transport error escape uncaught — this call sits OUTSIDE the
-      // dispatchWorkflow try/catch that authors run.failed.
-      //
-      // A 404 that survived the read-retry ladder (`workflow db session
-      // lookup failed 404`) rethrows WITHOUT marking, like every other error:
-      // sessions are persisted (awaited) before the instance is created, so a
-      // 404 here is anomalous — most plausibly a framework re-entry against an
-      // ALREADY-TERMINAL run whose DO state the post-finish alarm cleaned up.
-      // Authoring run.failed there could flip a completed (billed + durable)
-      // run to failed via newest-terminal-wins. Only the 410 is safe to mark.
-      const hydrateMessage =
-        hydrateError instanceof Error
-          ? hydrateError.message
-          : String(hydrateError);
-      if (hydrateMessage.includes('workflow db session lookup failed 410')) {
-        await markWorkflowRuntimeFailure({
-          env: this.env,
-          event: dispatchedEvent,
-          error: hydrateError,
-        }).catch((markError) => {
-          recordCoordinatorEvent(
-            'error',
-            'coordinator.db_session_expired.failure_forward_failed',
-            '[coordinator] failed to forward expired-db-session run failure',
-            {
-              runId: entryTrace.runId,
-              message:
-                markError instanceof Error
-                  ? markError.message
-                  : String(markError),
-            },
-          );
-        });
-        if (entryTrace.runId) {
-          await writeCoordinatorTerminalState(this.env, {
-            runId: entryTrace.runId,
-            status: 'failed',
-            error:
-              normalizeCoordinatorWorkflowRuntimeFailure(hydrateError).message,
-          }).catch(() => undefined);
-        }
-      }
-      throw hydrateError;
-    }
-    const dispatchTrace = readWorkflowTraceContext(dispatchedEvent);
-    trace({
-      runId: dispatchTrace.runId,
-      phase: 'coordinator.dispatch_workflow_entry',
-      ms: 0,
-      graphHash: dispatchTrace.graphHash,
-      extra: {
-        instanceId: dispatchTrace.instanceId,
-      },
-    });
-
-    const dispatchWorkflowStartedAt = Date.now();
-    try {
-      return await dispatchWorkflow(
-        { env: this.env, ctx: this.ctx },
-        dispatchedEvent as Parameters<typeof dispatchWorkflow>[1],
-        step as Parameters<typeof dispatchWorkflow>[2],
-        async ({ metadata, env }) => {
-          const graphHash = readMetadataString(metadata, 'graphHash');
-          const artifactStorageKey = readMetadataString(
-            metadata,
-            'artifactStorageKey',
-          );
-          const runIdForTrace =
-            typeof (metadata as Record<string, unknown>).runId === 'string'
-              ? ((metadata as Record<string, unknown>).runId as string)
-              : graphHash;
-          const loaderStartedAt = Date.now();
-          trace({
-            runId: runIdForTrace,
-            phase: 'coordinator.loader_callback_entry',
-            ms: 0,
-            graphHash,
-            extra: { artifactStorageKey },
-          });
-          const stub = loadDynamicPlayWorkerSync(
-            env,
-            {
-              runId: runIdForTrace,
-              graphHash,
-              artifactStorageKey,
-              artifactHash:
-                typeof metadata.artifactHash === 'string'
-                  ? metadata.artifactHash
-                  : null,
-              dynamicWorkerCode:
-                typeof metadata.dynamicWorkerCode === 'string'
-                  ? metadata.dynamicWorkerCode
-                  : null,
-              dynamicWorkerCodeHash:
-                typeof metadata.dynamicWorkerCodeHash === 'string'
-                  ? metadata.dynamicWorkerCodeHash
-                  : null,
-              integrationMode: normalizeIntegrationMode(
-                metadata.integrationMode,
-              ),
-              packagedFiles: normalizePackagedFiles(metadata.packagedFiles),
-            },
-            trace,
-          );
-          const entrypointStartedAt = Date.now();
-          const entrypoint = stub.getEntrypoint(
-            'TenantWorkflow',
-          ) as unknown as WorkflowRunner;
-          trace({
-            runId: runIdForTrace,
-            phase: 'coordinator.loader_get_entrypoint',
-            ms: Date.now() - entrypointStartedAt,
-            graphHash,
-          });
-          trace({
-            runId: runIdForTrace,
-            phase: 'coordinator.loader_compile',
-            ms: Date.now() - loaderStartedAt,
-            graphHash,
-          });
-          // Wrap the entrypoint so its run() failure surfaces here rather
-          // than disappearing into the framework's silent rpcMethod=run
-          // exception path.
-          return {
-            run: async (innerEvent: unknown, innerStep: unknown) => {
-              const innerStartedAt = Date.now();
-              trace({
-                runId: runIdForTrace,
-                phase: 'coordinator.runner_run_start',
-                ms: 0,
-                graphHash,
-              });
-              try {
-                const result = await (
-                  entrypoint as unknown as {
-                    run(e: unknown, s: unknown): Promise<unknown>;
-                  }
-                ).run(innerEvent, innerStep);
-                const output = isRecord(result) ? result : null;
-                const terminalResult = output?.result ?? result;
-                const terminalStartedAt = Date.now();
-                try {
-                  await writeCoordinatorTerminalState(env, {
-                    runId: runIdForTrace,
-                    status: 'completed',
-                    result: terminalResult,
-                    totalRows: output?.totalRows ?? output?.outputRows ?? null,
-                    durationMs: output?.durationMs ?? null,
-                    playName:
-                      typeof output?.playName === 'string'
-                        ? output.playName
-                        : null,
-                    liveLogs: sanitizeLiveLogLines(output?.liveLogs),
-                    liveNodeProgress: output?.liveNodeProgress ?? null,
-                  });
-                  trace({
-                    runId: runIdForTrace,
-                    phase: 'coordinator.terminal_state_write',
-                    ms: Date.now() - terminalStartedAt,
-                    graphHash,
-                    extra: { status: 'completed' },
-                  });
-                } catch (terminalError) {
-                  console.warn(
-                    '[coordinator] completed terminal cache write failed; preserving completed run',
-                    {
-                      graphHash,
-                      runId: runIdForTrace,
-                      error:
-                        terminalError instanceof Error
-                          ? terminalError.message
-                          : String(terminalError),
-                    },
-                  );
-                }
-                trace({
-                  runId: runIdForTrace,
-                  phase: 'coordinator.runner_run',
-                  ms: Date.now() - innerStartedAt,
-                  graphHash,
-                });
-                return result;
-              } catch (innerError) {
-                const failure =
-                  normalizeCoordinatorWorkflowRuntimeFailure(innerError);
-                recordCoordinatorEvent(
-                  'error',
-                  'coordinator.dynamic_workflow.runner_failed',
-                  '[coordinator] DynamicWorkflow runner.run threw',
-                  {
-                    graphHash,
-                    message:
-                      innerError instanceof Error
-                        ? innerError.message
-                        : String(innerError),
-                    name: innerError instanceof Error ? innerError.name : null,
-                    stack:
-                      innerError instanceof Error &&
-                      typeof innerError.stack === 'string'
-                        ? innerError.stack.split('\n').slice(0, 12).join('\n')
-                        : null,
-                  },
-                );
-                if (
-                  shouldPublishWorkflowRuntimeFailure({
-                    error: innerError,
-                    retryAttempts: 0,
-                  })
-                ) {
-                  await markWorkflowRuntimeFailure({
-                    env,
-                    event: innerEvent,
-                    error: innerError,
-                  }).catch((markError) => {
-                    recordCoordinatorEvent(
-                      'error',
-                      'coordinator.dynamic_workflow.failure_forward_failed',
-                      '[coordinator] failed to forward DynamicWorkflow runner error',
-                      {
-                        graphHash,
-                        message:
-                          markError instanceof Error
-                            ? markError.message
-                            : String(markError),
-                      },
-                    );
-                  });
-                  await writeCoordinatorTerminalState(env, {
-                    runId: runIdForTrace,
-                    status: 'failed',
-                    error: failure.message,
-                  }).catch(() => undefined);
-                } else {
-                  recordCoordinatorEvent(
-                    'warn',
-                    'coordinator.dynamic_workflow.platform_reset_retrying',
-                    '[coordinator] DynamicWorkflow platform reset will be retried; not publishing durable run.failed',
-                    {
-                      graphHash,
-                      runId: runIdForTrace,
-                      errorCode: failure.code,
-                      retryLimit: PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
-                    },
-                  );
-                }
-                throw innerError;
-              }
-            },
-          };
-        },
-      );
-    } finally {
-      trace({
-        runId: dispatchTrace.runId,
-        phase: 'coordinator.dispatch_workflow_total',
-        ms: Date.now() - dispatchWorkflowStartedAt,
-        graphHash: dispatchTrace.graphHash,
-        extra: {
-          instanceId: dispatchTrace.instanceId,
-        },
-      });
-    }
-  }
-}
-
-const coordinatorEntrypoint = {
-  /**
-   * HTTP entrypoint for the Vercel app to dispatch into. Routes:
-   *   POST /workflow/{runId}/submit     → PLAY_WORKFLOW.create({ id, params })
-   *   GET  /workflow/{runId}/tail       → ordered live run events after a cursor
-   *   POST /workflow/{runId}/cancel     → Workflow instance terminate
-   *   POST /workflow/{runId}/signal     → integration_event
-   *   GET  /workflow/{runId}/result     → terminal envelope
-   *   GET  /health                      → liveness
-   */
-  async fetch(
-    request: Request,
-    env: CoordinatorEnv,
-    ctx?: ExecutionContext,
-  ): Promise<Response> {
-    // Top-level guard: no coordinator route may let an exception escape to
-    // Cloudflare's default "Worker threw exception" HTML error page. Each
-    // route group below additionally wraps itself for precise phase/runId
-    // context; this outer catch is the backstop for URL parsing, route
-    // matching, and any future route added without its own envelope.
-    try {
-      return await coordinatorRouteFetch(request, env, ctx);
-    } catch (error) {
-      return coordinatorRouteErrorResponse({
-        logTag: '[coordinator.fetch.error]',
-        code: 'COORDINATOR_ROUTE_FAILED',
-        phase: 'coordinator.fetch',
-        runId: null,
-        error,
-      });
-    }
-  },
-  async tail(events: unknown[], env: CoordinatorEnv): Promise<void> {
-    await flushTailRunLogs(events, env);
-  },
-  async scheduled(
-    _controller: unknown,
-    _env: CoordinatorEnv,
-    _ctx?: ExecutionContext,
-  ): Promise<void> {},
-};
-
-export default coordinatorEntrypoint;
-
-/**
- * Route dispatcher for the coordinator fetch handler. Extracted as a standalone
- * function so the outer {@link coordinatorEntrypoint.fetch} try/catch backstop
- * is not coupled to `this` binding. Every route group wraps itself with a JSON
- * envelope; the outer catch covers URL parsing / route matching escapes.
- */
-async function coordinatorRouteFetch(
-  request: Request,
-  env: CoordinatorEnv,
-  ctx?: ExecutionContext,
-): Promise<Response> {
-  const url = new URL(request.url);
-  if (url.pathname === '/health') {
-    const headers = new Headers();
-    headers.set(
-      'x-deepline-runtime-deploy-version',
-      env.CF_VERSION_METADATA?.id ??
-        env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
-        '',
-    );
-    if (env.DEEPLINE_COORDINATOR_DEPLOY_MARKER) {
-      headers.set(
-        'x-deepline-deploy-marker',
-        env.DEEPLINE_COORDINATOR_DEPLOY_MARKER,
-      );
-    }
-    return new Response('ok', { status: 200, headers });
-  }
-  if (url.pathname === '/internal-token/probe') {
-    const authError = authorizeCoordinatorControlRequest({ request, env });
-    if (authError) return authError;
-    return Response.json({
-      ok: true,
-      deployMarker: env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ?? null,
-      runtimeDeployVersion:
-        env.CF_VERSION_METADATA?.id ??
-        env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
-        null,
-    });
-  }
-  if (url.pathname === '/warmup/submit') {
-    const authError = authorizeCoordinatorControlRequest({ request, env });
-    if (authError) return authError;
-    try {
-      return await handleCoordinatorWarmup(request, env, ctx);
-    } catch (error) {
-      return coordinatorRouteErrorResponse({
-        logTag: '[coordinator.warmup.error]',
-        code: 'COORDINATOR_WARMUP_FAILED',
-        phase: 'coordinator.warmup',
-        runId: null,
-        error,
-      });
-    }
-  }
-  if (url.pathname === '/tail-log-token/probe') {
-    const authError = authorizeCoordinatorControlRequest({ request, env });
-    if (authError) return authError;
-    const expectedTailLogToken = env.DEEPLINE_TAIL_LOG_TOKEN?.trim();
-    if (!expectedTailLogToken) {
-      return Response.json(
-        { ok: false, error: 'tail log token is not configured' },
-        { status: 503 },
-      );
-    }
-    const actualTailLogToken =
-      request.headers.get('x-deepline-tail-log-token')?.trim() ?? '';
-    if (actualTailLogToken !== expectedTailLogToken) {
-      return Response.json(
-        { ok: false, error: 'tail log token mismatch' },
-        { status: 401 },
-      );
-    }
-    return Response.json({
-      ok: true,
-      deployMarker: env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ?? null,
-      runtimeDeployVersion:
-        env.CF_VERSION_METADATA?.id ??
-        env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
-        null,
-    });
-  }
-  if (url.pathname === '/harness/probe') {
-    const authError = authorizeCoordinatorControlRequest({ request, env });
-    if (authError) return authError;
-    try {
-      const harness = await env.HARNESS.ping();
-      return Response.json({
-        ok: true,
-        coordinatorDeployMarker: env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ?? null,
-        coordinatorRuntimeDeployVersion:
-          env.CF_VERSION_METADATA?.id ??
-          env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
-          null,
-        harnessDeployMarker: harness.deployMarker,
-        harnessRuntimeDeployVersion: harness.runtimeDeployVersion,
-        harnessTs: harness.ts,
-      });
-    } catch (error) {
-      return coordinatorRouteErrorResponse({
-        logTag: '[coordinator.harness_probe.error]',
-        code: 'COORDINATOR_HARNESS_PROBE_FAILED',
-        phase: 'coordinator.harness_probe',
-        runId: null,
-        error,
-      });
-    }
-  }
-  if (url.pathname === '/staged-files/put') {
-    const authError = authorizeCoordinatorControlRequest({ request, env });
-    if (authError) return authError;
-    try {
-      return await handleStagedFilePut(request, env);
-    } catch (error) {
-      return coordinatorRouteErrorResponse({
-        logTag: '[coordinator.staged_file_put.error]',
-        code: 'COORDINATOR_STAGED_FILE_PUT_FAILED',
-        phase: 'coordinator.staged_files_put',
-        runId: null,
-        error,
-      });
-    }
-  }
-  if (url.pathname === '/rate-acquire') {
-    const authError = authorizeCoordinatorControlRequest({ request, env });
-    if (authError) return authError;
-    try {
-      const body = (await request.json().catch(() => null)) as {
-        bucketId?: unknown;
-        rules?: unknown;
-        requested?: unknown;
-      } | null;
-      const bucketId = typeof body?.bucketId === 'string' ? body.bucketId : '';
-      if (!bucketId.trim()) {
-        return Response.json(
-          { error: 'bucketId is required.' },
-          { status: 400 },
-        );
-      }
-      const result = await callRateBucketControl<{
-        granted: number;
-        waitMs: number;
-      }>(env, bucketId, '/rate-acquire', body);
-      return Response.json(result);
-    } catch (error) {
-      return coordinatorRouteErrorResponse({
-        logTag: '[coordinator.rate_acquire.error]',
-        code: 'COORDINATOR_RATE_ROUTE_FAILED',
-        phase: 'coordinator.rate.acquire',
-        runId: null,
-        error,
-      });
-    }
-  }
-  if (url.pathname === '/rate-penalize') {
-    const authError = authorizeCoordinatorControlRequest({ request, env });
-    if (authError) return authError;
-    try {
-      const body = (await request.json().catch(() => null)) as {
-        bucketId?: unknown;
-        cooldownMs?: unknown;
-      } | null;
-      const bucketId = typeof body?.bucketId === 'string' ? body.bucketId : '';
-      if (!bucketId.trim()) {
-        return Response.json(
-          { error: 'bucketId is required.' },
-          { status: 400 },
-        );
-      }
-      await callRateBucketControl<{ ok?: unknown }>(
-        env,
-        bucketId,
-        '/rate-penalize',
-        body,
-      );
-      return Response.json({ ok: true });
-    } catch (error) {
-      return coordinatorRouteErrorResponse({
-        logTag: '[coordinator.rate_penalize.error]',
-        code: 'COORDINATOR_RATE_ROUTE_FAILED',
-        phase: 'coordinator.rate.penalize',
-        runId: null,
-        error,
-      });
-    }
-  }
-  // Workflow routes: /workflow/{runId}/{action}
-  const wfMatch = url.pathname.match(/^\/workflow\/([^/]+)(?:\/(.+))?$/);
-  if (wfMatch) {
-    const runId = decodeURIComponent(wfMatch[1]!);
-    const action = wfMatch[2] ?? '';
-    const authError = authorizeCoordinatorControlRequest({
-      request,
-      env,
-      runId,
-      requireRunScope: isWorkflowMutatingAction(action),
-    });
-    if (authError) return authError;
-    try {
-      return await handleWorkflowRoute({ runId, action, request, env, ctx });
-    } catch (error) {
-      return coordinatorWorkflowRouteErrorResponse({
-        runId,
-        action,
-        error,
-      });
-    }
-  }
-
-  // Dedup routes: /dedup/{runId}/{action}
-  const dedupMatch = url.pathname.match(/^\/dedup\/([^/]+)(?:\/(.+))?$/);
-  if (dedupMatch) {
-    const runId = decodeURIComponent(dedupMatch[1]!);
-    const action = dedupMatch[2] ?? '';
-    const authError = authorizeCoordinatorControlRequest({
-      request,
-      env,
-      runId,
-      requireRunScope: request.method !== 'GET' && request.method !== 'HEAD',
-    });
-    if (authError) return authError;
-    try {
-      const doId = env.PLAY_DEDUP.idFromName(runId);
-      const stub = env.PLAY_DEDUP.get(doId);
-      const internalUrl = `https://internal/${action}`;
-      return await stub.fetch(internalUrl, {
-        method: request.method,
-        headers: request.headers,
-        body:
-          request.method === 'GET' || request.method === 'HEAD'
-            ? undefined
-            : request.body,
-      });
-    } catch (error) {
-      return coordinatorRouteErrorResponse({
-        logTag: '[coordinator.dedup_route.error]',
-        code: 'COORDINATOR_DEDUP_ROUTE_FAILED',
-        phase: `coordinator.dedup.${action || 'unknown'}`,
-        runId,
-        error,
-      });
-    }
-  }
-
-  return new Response('not found', { status: 404 });
-}
-
-const RUN_LOG_PREFIX_RE = /\[deepline-run:([^\]]+)\]\s*(.*)/;
-const RUN_ID_RE = /\bplay\/[^/\s]+\/run\/[0-9a-zTt-]+/;
-
-async function flushTailRunLogs(
-  events: unknown[],
-  env: CoordinatorEnv,
-): Promise<void> {
-  const token = env.DEEPLINE_TAIL_LOG_TOKEN?.trim();
-  if (!token) {
-    return;
-  }
-  const grouped = new Map<string, string[]>();
-  for (const event of events) {
-    for (const line of extractTailLogLines(event)) {
-      const parsed = parseRunLogLine(line);
-      if (!parsed) {
-        continue;
-      }
-      const existing = grouped.get(parsed.runId) ?? [];
-      existing.push(parsed.line);
-      grouped.set(parsed.runId, existing);
-    }
-  }
-  await Promise.all(
-    [...grouped.entries()].map(async ([runId, lines]) => {
-      if (lines.length === 0) {
-        return;
-      }
-      await fetch(
-        `${env.DEEPLINE_API_BASE_URL}${PLAY_RUNTIME_TAIL_LOG_COMPAT_PATH}`,
-        {
-          method: 'POST',
-          headers: {
-            'content-type': 'application/json',
-            'x-deepline-tail-log-token': token,
-          },
-          body: JSON.stringify({
-            runId,
-            lines: lines.slice(-100),
-          }),
-        },
-      ).catch(() => null);
-    }),
-  );
-}
-
-function extractTailLogLines(event: unknown): string[] {
-  const lines: string[] = [];
-  const record =
-    event && typeof event === 'object' && !Array.isArray(event)
-      ? (event as Record<string, unknown>)
-      : {};
-  const logs = Array.isArray(record.logs) ? record.logs : [];
-  for (const log of logs) {
-    if (typeof log === 'string') {
-      lines.push(log);
-      continue;
-    }
-    if (!log || typeof log !== 'object' || Array.isArray(log)) {
-      continue;
-    }
-    const logRecord = log as Record<string, unknown>;
-    const message = logRecord.message;
-    if (Array.isArray(message)) {
-      lines.push(message.map(formatTailLogPart).join(' '));
-    } else if (typeof message === 'string') {
-      lines.push(message);
-    }
-  }
-  const exceptions = Array.isArray(record.exceptions) ? record.exceptions : [];
-  for (const exception of exceptions) {
-    lines.push(formatTailLogPart(exception));
-  }
-  return lines.map((line) => line.trim()).filter(Boolean);
-}
-
-function formatTailLogPart(value: unknown): string {
-  if (typeof value === 'string') {
-    return value;
-  }
-  if (value instanceof Error) {
-    return value.stack ?? value.message;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-/**
- * Recognize the tenant-Postgres degradation signatures that used to escape the
- * coordinator submit path as an opaque 500 "internal error" with no repair
- * instruction: revoked CONNECT / grant drift, connect stalls, and NeonDbError.
- * Conservative on purpose — anything not matched stays a generic internal
- * error (with its phase) so we do not mislabel unrelated failures.
- */
-function isTenantStorageDegradationError(error: unknown): boolean {
-  const message = error instanceof Error ? error.message : String(error);
-  return (
-    /permission denied (?:for|to grant) (?:schema|table|relation|database|sequence|role)\b/i.test(
-      message,
-    ) ||
-    /must be owner of (?:table|relation|sequence|schema|database|function|procedure|routine|type)\b/i.test(
-      message,
-    ) ||
-    /Runtime Postgres connection timed out/i.test(message) ||
-    /\bNeonDbError\b/i.test(message) ||
-    /timeout exceeded when trying to connect/i.test(message) ||
-    /connection terminated unexpectedly/i.test(message)
-    // Deliberately NOT matching bare socket/DNS codes (ECONNRESET, ETIMEDOUT,
-    // ECONNREFUSED, EAI_AGAIN): those are thrown by Cloudflare service bindings,
-    // the Workflow API, and Durable Object fetches too, not just tenant
-    // Postgres. Matching them here would mislabel a transient CF-infra blip as
-    // WORKSPACE_STORAGE_NOT_READY ("run db repair"). Every remaining pattern
-    // carries explicit Postgres/Neon context.
-  );
-}
-
-function coordinatorWorkflowRouteErrorResponse(input: {
-  runId: string;
-  action: string;
-  error: unknown;
-}): Response {
-  const message =
-    input.error instanceof Error ? input.error.message : String(input.error);
-  const phase = `coordinator.${input.action || 'unknown'}`;
-  recordCoordinatorEvent(
-    'error',
-    'coordinator.workflow_route.error',
-    '[coordinator.workflow_route.error]',
-    {
-      runId: input.runId,
-      action: input.action,
-      error: message,
-    },
-  );
-  if (
-    input.action === 'submit' &&
-    isTenantStorageDegradationError(input.error)
-  ) {
-    // De-redact: a tenant-storage failure gets the loud, actionable
-    // WORKSPACE_STORAGE_NOT_READY message + repair instruction instead of the
-    // generic "internal error". Same contract as the runtime route.
-    //
-    // Scoped to `submit` on purpose: the message states "nothing was billed",
-    // which is only true in the pre-run submit phase. The other workflow
-    // actions (status/result/tail/cancel/signal) run against an already-active,
-    // possibly-billing run, so surfacing "storage not ready, nothing billed,
-    // run db repair" there would be false and alarming on a healthy run.
-    recordCoordinatorEvent(
-      'error',
-      'coordinator.workflow_route.storage_not_ready',
-      '[coordinator.workflow_route.storage_not_ready]',
-      {
-        runId: input.runId,
-        action: input.action,
-        phase,
-        error: message,
-      },
-    );
-    return Response.json(
-      {
-        error: {
-          code: WORKSPACE_STORAGE_NOT_READY_CODE,
-          message: WORKSPACE_STORAGE_NOT_READY_MESSAGE,
-          phase,
-          runId: input.runId,
-        },
-      },
-      { status: 503 },
-    );
-  }
-  return Response.json(
-    {
-      error: {
-        code: 'COORDINATOR_WORKFLOW_ROUTE_FAILED',
-        message,
-        phase,
-        runId: input.runId,
-      },
-    },
-    { status: 500 },
-  );
-}
-
-/**
- * Generic JSON envelope for any thrown error escaping a coordinator fetch route.
- * Mirrors {@link coordinatorWorkflowRouteErrorResponse} so that NO route group
- * in the fetch handler can leak Cloudflare's raw "Worker threw exception" HTML
- * page to clients/agents. Keep the envelope shape `{ error: { code, message,
- * phase, runId } }` and the console.error logging convention identical.
- */
-function coordinatorRouteErrorResponse(input: {
-  logTag: string;
-  code: string;
-  phase: string;
-  runId: string | null;
-  error: unknown;
-}): Response {
-  const message =
-    input.error instanceof Error ? input.error.message : String(input.error);
-  recordCoordinatorEvent('error', 'coordinator.route.error', input.logTag, {
-    runId: input.runId,
-    phase: input.phase,
-    error: message,
-  });
-  return Response.json(
-    {
-      error: {
-        code: input.code,
-        message,
-        phase: input.phase,
-        runId: input.runId,
-      },
-    },
-    { status: 500 },
-  );
-}
-
-// Operator-diagnostic console lines that carry the [deepline-run:] prefix but
-// are not user-facing run output. The console scrape fans run-prefixed lines
-// back into the run's durable Run Log Stream ('system' channel), so harness/
-// coordinator plumbing noise is filtered at ingestion, never at read time.
-// User play log lines (runner-event echoes) intentionally pass through.
-const OPERATOR_NOISE_LOG_PATTERNS: readonly RegExp[] = [
-  /\[perf-trace\]/,
-  /\[harness-probe\]/,
-  /TenantWorkflow\.run entered/,
-  /TenantWorkflow\.run threw/,
-  /failed to forward runner perf trace/,
-  /failed to forward TenantWorkflow\.run error/,
-];
-
-function parseRunLogLine(line: string): { runId: string; line: string } | null {
-  if (OPERATOR_NOISE_LOG_PATTERNS.some((pattern) => pattern.test(line))) {
-    return null;
-  }
-  const prefixed = line.match(RUN_LOG_PREFIX_RE);
-  if (prefixed?.[1]) {
-    const message = prefixed[2]?.trim() ?? '';
-    return {
-      runId: prefixed[1],
-      line: message || line,
-    };
-  }
-  const runId = line.match(RUN_ID_RE)?.[0];
-  if (!runId) {
-    return null;
-  }
-  return { runId, line };
-}
-
-async function handleWorkflowRoute(input: {
-  runId: string;
-  action: string;
-  request: Request;
-  env: CoordinatorEnv;
-  ctx?: ExecutionContext;
-}): Promise<Response> {
-  const { runId, action, request, env } = input;
-  const defaultInstanceId = workflowInstanceId(runId);
-  if (action === 'submit') {
-    const submitStartedAt = Date.now();
-    const coordinatorTimings: CoordinatorTiming[] = [];
-    let submittedRunId = runId;
-    const recordSubmitTiming = (timing: CoordinatorTiming): void => {
-      coordinatorTimings.push(timing);
-      recordCoordinatorPerfTraceBuffered(env, input.ctx, {
-        runId: submittedRunId,
-        phase: timing.phase,
-        ms: timing.ms,
-        graphHash: timing.graphHash ?? null,
-        extra: timing.extra,
-      });
-    };
-    const parseStartedAt = Date.now();
-    const params = (await request.json()) as PlayWorkflowParams;
-    submittedRunId = params.runId ?? runId;
-    recordSubmitTiming({
-      phase: 'coordinator.submit_received',
-      ms: Date.now() - submitStartedAt,
-      graphHash: params.graphHash ?? null,
-      extra: {
-        integrationMode: normalizeIntegrationMode(params.integrationMode),
-        hasDynamicWorkerCode: Boolean(params.dynamicWorkerCode),
-        dynamicWorkerBytes:
-          typeof params.dynamicWorkerCode === 'string'
-            ? params.dynamicWorkerCode.length
-            : 0,
-      },
-    });
-    recordSubmitTiming({
-      phase: 'coordinator.submit_parse_body',
-      ms: Date.now() - parseStartedAt,
-      graphHash: params.graphHash ?? null,
-      extra: {
-        integrationMode: normalizeIntegrationMode(params.integrationMode),
-        hasDynamicWorkerCode: Boolean(params.dynamicWorkerCode),
-        dynamicWorkerBytes:
-          typeof params.dynamicWorkerCode === 'string'
-            ? params.dynamicWorkerCode.length
-            : 0,
-      },
-    });
-    if (!env.LOADER) {
-      throw new Error(
-        'Cloudflare Dynamic Workflows require a Worker Loader binding named LOADER.',
-      );
-    }
-    if (!env.HARNESS) {
-      throw new Error(
-        'Cloudflare Dynamic Workflows require a service binding named HARNESS. ' +
-          'Start apps/play-harness-worker before the coordinator or fix wrangler.toml services.',
-      );
-    }
-    const preloadedDbSessions = Array.isArray(params.preloadedDbSessions)
-      ? params.preloadedDbSessions
-      : [];
-    if (preloadedDbSessions.length > 0 && params.executorToken) {
-      const prewarmStartedAt = Date.now();
-      recordSubmitTiming({
-        phase: 'coordinator.harness_prewarm_postgres_start',
-        ms: 0,
-        graphHash: params.graphHash ?? null,
-        extra: { sessions: preloadedDbSessions.length },
-      });
-      const prewarmPromise = env.HARNESS.prewarmPostgresSessions({
-        executorToken: params.executorToken,
-        orgId: params.orgId,
-        playName: params.playName,
-        sessions: preloadedDbSessions,
-      })
-        .then((result) => {
-          recordSubmitTiming({
-            phase: 'coordinator.harness_prewarm_postgres',
-            ms: Date.now() - prewarmStartedAt,
-            graphHash: params.graphHash ?? null,
-            extra: {
-              status: 'ok',
-              sessions: result.sessions,
-            },
-          });
-        })
-        .catch((error: unknown) => {
-          const storageNotReady = isTenantStorageDegradationError(error);
-          recordSubmitTiming({
-            phase: 'coordinator.harness_prewarm_postgres',
-            ms: Date.now() - prewarmStartedAt,
-            graphHash: params.graphHash ?? null,
-            extra: {
-              status: 'failed',
-              sessions: preloadedDbSessions.length,
-              error: error instanceof Error ? error.message : String(error),
-              storageNotReady,
-            },
-          });
-          // The prewarm runs in waitUntil, so it cannot fail the already-issued
-          // submit. But its cause used to be fully redacted in coordinator
-          // logs. Log the tenant-storage classification loudly so the real
-          // cause (and the WORKSPACE_STORAGE_NOT_READY repair path) is visible.
-          if (storageNotReady) {
-            recordCoordinatorEvent(
-              'error',
-              'coordinator.harness_prewarm_postgres.storage_not_ready',
-              '[coordinator.harness_prewarm_postgres.storage_not_ready]',
-              {
-                runId: submittedRunId,
-                playName: params.playName,
-                code: WORKSPACE_STORAGE_NOT_READY_CODE,
-                error: error instanceof Error ? error.message : String(error),
-              },
-            );
-          }
-        });
-      input.ctx?.waitUntil(prewarmPromise);
-    }
-    const dbSessionExternalization = externalizedWorkflowDbSessionParams({
-      params,
-    });
-    const workflowParams = dbSessionExternalization.params;
-    workflowParams.submittedAt = Date.now();
-    let launchState: Awaited<ReturnType<typeof persistWorkflowLaunchState>> =
-      {};
-    try {
-      const retryStateStartedAt = Date.now();
-      launchState = await persistWorkflowLaunchState({
-        env,
-        runId: submittedRunId,
-        params: workflowParams,
-        sessions: dbSessionExternalization.sessions,
-      });
-      const persistedAt = Date.now();
-      if (dbSessionExternalization.sessions.length > 0) {
-        recordSubmitTiming({
-          phase: 'coordinator.workflow_db_sessions_externalized',
-          ms: persistedAt - retryStateStartedAt,
-          graphHash: params.graphHash ?? null,
-          extra: {
-            sessions:
-              launchState.sessionCount ??
-              dbSessionExternalization.sessions.length,
-            expiresAt:
-              launchState.dbSessionsExpiresAt ??
-              dbSessionExternalization.ref?.expiresAt,
-            combinedLaunchState: true,
-          },
-        });
-      }
-      recordSubmitTiming({
-        phase: 'coordinator.retry_state_persistence',
-        ms: persistedAt - retryStateStartedAt,
-        graphHash: params.graphHash ?? null,
-        extra: {
-          combinedLaunchState: dbSessionExternalization.sessions.length > 0,
-        },
-      });
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      recordCoordinatorEvent(
-        'error',
-        'coordinator.workflow_retry_state.persistence_failed',
-        '[coordinator] workflow retry state persistence failed',
-        {
-          code: 'WORKFLOW_RETRY_STATE_PERSISTENCE_FAILED',
-          runId: submittedRunId,
-          error: errorMessage,
-        },
-      );
-      recordSubmitTiming({
-        phase: 'coordinator.retry_state_persistence',
-        ms: 0,
-        graphHash: params.graphHash ?? null,
-        extra: {
-          status: 'failed',
-          error: errorMessage,
-        },
-      });
-      return workflowRetryStatePersistenceErrorResponse({
-        runId: submittedRunId,
-        error,
-      });
-    }
-    const createParams = workflowCreateParams(workflowParams, launchState);
-    let instance: WorkflowInstance | null = null;
-    try {
-      const submitClaimStartedAt = Date.now();
-      const submitClaim = await claimWorkflowSubmit({
-        env,
-        runId: submittedRunId,
-      });
-      recordSubmitTiming({
-        phase: 'coordinator.workflow_submit_claim',
-        ms: Date.now() - submitClaimStartedAt,
-        graphHash: params.graphHash ?? null,
-        extra: {
-          claimed: submitClaim.claimed,
-          status: submitClaim.status,
-          instanceId: submitClaim.instanceId ?? defaultInstanceId,
-        },
-      });
-      if (!submitClaim.claimed) {
-        const duplicateWaitStartedAt = Date.now();
-        const resolvedSubmitClaim = await waitForWorkflowSubmitCreated({
-          env,
-          runId: submittedRunId,
-          initialClaim: submitClaim,
-          timeoutMs: WORKFLOW_SUBMIT_DUPLICATE_WAIT_MS,
-          pollMs: WORKFLOW_SUBMIT_DUPLICATE_POLL_MS,
-        });
-        recordSubmitTiming({
-          phase: 'coordinator.workflow_submit_duplicate_wait',
-          ms: Date.now() - duplicateWaitStartedAt,
-          graphHash: params.graphHash ?? null,
-          extra: {
-            status: resolvedSubmitClaim.status,
-            instanceId: resolvedSubmitClaim.instanceId ?? null,
-          },
-        });
-        const totalMs = Date.now() - submitStartedAt;
-        if (
-          resolvedSubmitClaim.status !== 'created' ||
-          !resolvedSubmitClaim.instanceId
-        ) {
-          recordSubmitTiming({
-            phase: 'coordinator.submit_total',
-            ms: totalMs,
-            graphHash: params.graphHash ?? null,
-            extra: { duplicate: true, pending: true },
-          });
-          return Response.json(
-            {
-              runId,
-              status: 'pending',
-              workflowInstanceId: null,
-              instanceState: {
-                status: resolvedSubmitClaim.status ?? 'creating',
-              },
-              retryAfterMs: 250,
-              runtimeDeployVersion:
-                env.CF_VERSION_METADATA?.id ??
-                env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
-                null,
-              coordinatorTimings,
-            },
-            { status: 503, headers: { 'retry-after': '1' } },
-          );
-        }
-        recordSubmitTiming({
-          phase: 'coordinator.submit_total',
-          ms: totalMs,
-          graphHash: params.graphHash ?? null,
-          extra: { duplicate: true },
-        });
-        recordSubmitTiming({
-          phase: 'coordinator.submit_accepted',
-          ms: totalMs,
-          graphHash: params.graphHash ?? null,
-          extra: { duplicate: true },
-        });
-        return Response.json({
-          runId,
-          status: 'submitted',
-          workflowInstanceId: resolvedSubmitClaim.instanceId,
-          instanceState: { status: resolvedSubmitClaim.status },
-          runtimeDeployVersion:
-            env.CF_VERSION_METADATA?.id ??
-            env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
-            null,
-          coordinatorTimings,
-        });
-      }
-      const dispatchStartedAt = Date.now();
-      const createStartedAt = Date.now();
-      recordSubmitTiming({
-        phase: 'coordinator.workflow_create_start',
-        ms: 0,
-        graphHash: params.graphHash ?? null,
-        extra: { instanceId: defaultInstanceId },
-      });
-      const createResult = await createOrAttachWorkflowInstance({
-        create: () =>
-          createDynamicWorkflowInstance({
-            env,
-            id: defaultInstanceId,
-            params: createParams,
-            metadataParams: workflowParams,
-          }),
-        getExisting: () => env.PLAY_WORKFLOW.get(defaultInstanceId),
-        onCreateFailure: async () => {
-          await releaseWorkflowSubmitClaim({
-            env,
-            runId: submittedRunId,
-          });
-        },
-      });
-      instance = createResult.instance;
-      const workflowCreatedAt = Date.now();
-      recordSubmitTiming({
-        phase: 'coordinator.workflow_create',
-        ms: workflowCreatedAt - createStartedAt,
-        graphHash: params.graphHash ?? null,
-        extra: { instanceId: instance.id, startMode: createResult.startMode },
-      });
-      try {
-        await recordWorkflowInstanceId({
-          env,
-          runId: submittedRunId,
-          instanceId: instance.id,
-        });
-      } catch (error) {
-        recordCoordinatorEvent(
-          'warn',
-          'coordinator.workflow_instance_id.record_failed',
-          '[coordinator] workflow instance id record failed',
-          {
-            runId: submittedRunId,
-            instanceId: instance?.id ?? null,
-            error: error instanceof Error ? error.message : String(error),
-          },
-        );
-        await releaseWorkflowSubmitClaim({
-          env,
-          runId: submittedRunId,
-        }).catch((releaseError) => {
-          recordCoordinatorEvent(
-            'warn',
-            'coordinator.workflow_submit_claim.release_failed',
-            '[coordinator] workflow submit claim release after instance record failure failed',
-            {
-              runId: submittedRunId,
-              error:
-                releaseError instanceof Error
-                  ? releaseError.message
-                  : String(releaseError),
-            },
-          );
-        });
-        throw error;
-      }
-      recordSubmitTiming({
-        phase: 'coordinator.dispatch_workflow',
-        ms: Date.now() - dispatchStartedAt,
-        graphHash: params.graphHash ?? null,
-        extra: {
-          startMode: 'direct_workflow_create',
-          workflowCreateMode: createResult.startMode,
-          instanceIdRecord: 'recorded',
-        },
-      });
-      const initialWaitMsRaw = Number(
-        new URL(request.url).searchParams.get('initialWaitMs') ?? '0',
-      );
-      const initialStateStartedAt = Date.now();
-      const instanceState = await waitForSubmitInitialState({
-        instance,
-        runId: submittedRunId,
-        waitMs: Number.isFinite(initialWaitMsRaw) ? initialWaitMsRaw : 0,
-      });
-      recordSubmitTiming({
-        phase: 'coordinator.submit_initial_state',
-        ms: Date.now() - initialStateStartedAt,
-        graphHash: params.graphHash ?? null,
-        extra: {
-          waitMs: Number.isFinite(initialWaitMsRaw) ? initialWaitMsRaw : 0,
-          status:
-            typeof instanceState?.status === 'string'
-              ? instanceState.status
-              : null,
-        },
-      });
-      const totalMs = Date.now() - submitStartedAt;
-      recordSubmitTiming({
-        phase: 'coordinator.submit_total',
-        ms: totalMs,
-        graphHash: params.graphHash ?? null,
-      });
-      recordSubmitTiming({
-        phase: 'coordinator.submit_accepted',
-        ms: totalMs,
-        graphHash: params.graphHash ?? null,
-      });
-      return Response.json({
-        runId,
-        status: 'submitted',
-        workflowInstanceId: instance.id,
-        instanceState,
-        runtimeDeployVersion:
-          env.CF_VERSION_METADATA?.id ??
-          env.DEEPLINE_COORDINATOR_DEPLOY_MARKER ??
-          null,
-        coordinatorTimings,
-      });
-    } finally {
-      disposeRpcStub(instance);
-    }
-  }
-
-  if (action === 'tail') {
-    const url = new URL(request.url);
-    const waitMs = Math.min(
-      Math.max(Number(url.searchParams.get('waitMs') ?? '0'), 0),
-      30_000,
-    );
-    const afterSeq = Math.max(
-      0,
-      Math.floor(Number(url.searchParams.get('afterSeq') ?? '0')),
-    );
-    const includeTrace = url.searchParams.get('trace') === '1';
-    const statusStartedAt = Date.now();
-    const eventResult = await listCoordinatorRunEvents({
-      env,
-      runId,
-      afterSeq,
-      timeoutMs: waitMs,
-    }).catch(() => null);
-    const rawEvents = eventResult?.events ?? [];
-    const terminalEventIndex = rawEvents.findIndex(
-      (event) => event.type === 'terminal',
-    );
-    const events =
-      terminalEventIndex >= 0
-        ? rawEvents.slice(0, terminalEventIndex + 1)
-        : rawEvents;
-    const coordinatorTrace =
-      includeTrace && events.length
-        ? await listCoordinatorPerfTrace(env, runId).catch(() => [])
-        : [];
-    const terminalEvent = events.find(
-      (event): event is Extract<CoordinatorRunEvent, { type: 'terminal' }> =>
-        event.type === 'terminal',
-    );
-    if (terminalEvent) {
-      return Response.json({
-        runId,
-        ...(terminalEvent.playName ? { playName: terminalEvent.playName } : {}),
-        status: terminalEvent.status,
-        result: terminalEvent.result ?? null,
-        error: terminalEvent.error ?? null,
-        totalRows: terminalEvent.totalRows ?? null,
-        durationMs: terminalEvent.durationMs ?? null,
-        completedAt: terminalEvent.ts,
-        liveLogs: sanitizeLiveLogLines(terminalEvent.liveLogs),
-        liveNodeProgress: terminalEvent.liveNodeProgress ?? null,
-        events,
-        latestSeq: eventResult?.latestSeq ?? afterSeq,
-        wait: null,
-        coordinatorObserve: {
-          ms: Date.now() - statusStartedAt,
-          waitMs,
-          workflowStatus: 'terminal-event',
-          statusPolls: 0,
-          instanceId: null,
-        },
-        ...(includeTrace ? { coordinatorTrace } : {}),
-      });
-    }
-    return Response.json({
-      runId,
-      status: 'running',
-      events,
-      latestSeq: eventResult?.latestSeq ?? afterSeq,
-      wait: null,
-      coordinatorObserve: {
-        ms: Date.now() - statusStartedAt,
-        waitMs,
-        workflowStatus: eventResult?.events.length ? 'event' : 'event-timeout',
-        statusPolls: 0,
-        instanceId: null,
-      },
-      ...(includeTrace ? { coordinatorTrace } : {}),
-    });
-  }
-
-  // get() throws if the instance doesn't exist (Workflows local-mode wipes
-  // state on wrangler dev reload, and superseded `--force` runs may target
-  // an instance that was never created). Treat that as a no-op cancel.
-  let instance: WorkflowInstance | null = null;
-  try {
-    const requestedInstanceId = new URL(request.url).searchParams
-      .get('instanceId')
-      ?.trim();
-    const instanceId =
-      requestedInstanceId &&
-      isWorkflowInstanceIdForRun(runId, requestedInstanceId)
-        ? requestedInstanceId
-        : await resolveWorkflowInstanceIdForRun(env, runId);
-    instance = await env.PLAY_WORKFLOW.get(instanceId);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (
-      !/not[ _]found|not_found|does not exist|no such instance|404/i.test(
-        message,
-      )
-    ) {
-      throw error;
-    }
-  }
-  try {
-    if (action === 'cancel') {
-      if (instance) {
-        try {
-          await instance.terminate();
-        } catch (error) {
-          const message =
-            error instanceof Error ? error.message : String(error);
-          // Tolerate four classes of error here:
-          //   - already-terminal (complete / errored / terminated)
-          //   - "Cannot terminate instance since its on a finite state"
-          //     (the runtime's wording for "already finished")
-          //   - "not implemented" (wrangler dev local mode doesn't support
-          //     instance.terminate() yet — silently no-op there)
-          //   - "not found" (instance never existed)
-          if (
-            !/complete|terminated|errored|finite state|cannot[ _]terminate|not[ _]implemented|not[ _]found|404/i.test(
-              message,
-            )
-          ) {
-            throw error;
-          }
-        }
-      }
-      // terminate() kills the dynamic worker before its run() wrapper can
-      // write terminal state (the only place completed/failed land), so
-      // without this write /tail reports 'running' forever and any
-      // start-stream watcher hangs after a cancel. Land the cancelled
-      // terminal state here — terminal-set appends a 'terminal' run event
-      // and wakes the dedup DO's long-poll waiters, which unblocks tails.
-      //
-      // Idempotency: first-wins from this side — if the run already went
-      // terminal (completed/failed/cancelled) we keep that state. The DO
-      // stores the cached terminal state under a single storage key
-      // (last-wins on raw writes), but the run-event log is append-only
-      // and /tail truncates at the FIRST terminal event, so a racing
-      // completed/failed write from a dying worker can at worst replace
-      // the cached key with another terminal status — it can never
-      // resurrect 'running'.
-      const existingTerminal = await readCoordinatorTerminalState(
-        env,
-        runId,
-      ).catch((error: unknown) => {
-        // Tolerated: better to risk a harmless terminal-over-terminal
-        // overwrite than to skip the cancelled write and hang watchers.
-        recordCoordinatorEvent(
-          'warn',
-          'coordinator.cancel.terminal_state_read_failed',
-          '[coordinator] terminal state read before cancel failed',
-          {
-            runId,
-            error: error instanceof Error ? error.message : String(error),
-          },
-        );
-        return null;
-      });
-      if (!existingTerminal) {
-        try {
-          await writeCoordinatorTerminalState(env, {
-            runId,
-            status: 'cancelled',
-            error: 'Run cancelled',
-          });
-        } catch (error) {
-          // Fail loudly: the workflow was terminated but watchers would
-          // hang on 'running' forever without the terminal event.
-          const message =
-            error instanceof Error ? error.message : String(error);
-          recordCoordinatorEvent(
-            'error',
-            'coordinator.cancel.terminal_state_write_failed',
-            '[coordinator] cancel terminal state write failed',
-            {
-              runId,
-              error: message,
-            },
-          );
-          return Response.json(
-            {
-              runId,
-              status: 'error',
-              error: `workflow terminated but cancelled terminal state write failed: ${message}`,
-            },
-            { status: 500 },
-          );
-        }
-      }
-      return Response.json({ runId, status: 'cancelled' });
-    }
-    if (action === 'signal') {
-      if (!instance) {
-        return new Response('not found', { status: 404 });
-      }
-      const body = (await request.json().catch(() => ({}))) as Record<
-        string,
-        unknown
-      >;
-      const eventKey =
-        typeof body.eventKey === 'string' && body.eventKey.trim()
-          ? body.eventKey.trim()
-          : typeof body.event_key === 'string' && body.event_key.trim()
-            ? body.event_key.trim()
-            : '';
-      const eventType =
-        typeof body.type === 'string' && body.type.trim()
-          ? body.type.trim()
-          : eventKey
-            ? `integration_event_${eventKey}`
-            : 'integration_event';
-      await instance.sendEvent({
-        type: workflowEventType(eventType),
-        payload: body,
-      });
-      return Response.json({
-        runId,
-        status: mapWorkflowStatus(await instance.status()),
-      });
-    }
-    if (action === 'result' || action === 'status' || action === '') {
-      const includeTrace =
-        new URL(request.url).searchParams.get('trace') === '1';
-      const statusStartedAt = Date.now();
-      const terminalState = await readCoordinatorTerminalState(
-        env,
-        runId,
-      ).catch(() => null);
-      if (terminalState) {
-        const coordinatorTrace = includeTrace
-          ? await listCoordinatorPerfTrace(env, runId).catch(() => [])
-          : [];
-        return Response.json({
-          runId,
-          ...(terminalState.playName
-            ? { playName: terminalState.playName }
-            : {}),
-          status: terminalState.status,
-          result: terminalState.result ?? null,
-          error: terminalState.error ?? null,
-          totalRows: terminalState.totalRows ?? null,
-          durationMs: terminalState.durationMs ?? null,
-          completedAt: terminalState.completedAt ?? null,
-          liveLogs: sanitizeLiveLogLines(terminalState.liveLogs),
-          liveNodeProgress: terminalState.liveNodeProgress ?? null,
-          wait: null,
-          coordinatorObserve: {
-            ms: Date.now() - statusStartedAt,
-            waitMs: 0,
-            workflowStatus: 'terminal-cache',
-            statusPolls: 0,
-            instanceId: instance?.id ?? null,
-          },
-          ...(includeTrace ? { coordinatorTrace } : {}),
-        });
-      }
-      if (!instance) {
-        return new Response('not found', { status: 404 });
-      }
-      const status = await instance.status();
-      const workflowError = readWorkflowError(status);
-      if (workflowError) {
-        const retry = await restartWorkflowAfterPlatformReset({
-          env,
-          ctx: input.ctx,
-          runId,
-          oldInstance: instance,
-          error: workflowError,
-          status,
-        });
-        if (retry.retried && retry.result) {
-          const coordinatorTrace = includeTrace
-            ? await listCoordinatorPerfTrace(env, runId).catch(() => [])
-            : [];
-          return Response.json({
-            ...retry.result,
-            coordinatorObserve: {
-              ms: Date.now() - statusStartedAt,
-              waitMs: 0,
-              workflowStatus: 'retrying',
-              statusPolls: 1,
-              instanceId: instance.id,
-            },
-            ...(includeTrace ? { coordinatorTrace } : {}),
-          });
-        }
-      }
-      const result = mapWorkflowResult(runId, status);
-      const observeMs = Date.now() - statusStartedAt;
-      // If we forced a permanent-error fail-fast (status='failed' even
-      // though the underlying instance is still 'running' mid-retry),
-      // terminate on the CF side once so the retry loop stops burning
-      // compute. Best-effort: tolerate races where the instance has
-      // already gone terminal between our status() and terminate().
-      if (
-        result.status === 'failed' &&
-        status.status !== 'errored' &&
-        status.status !== 'terminated' &&
-        status.status !== 'complete'
-      ) {
-        await instance.terminate().catch((error: unknown) => {
-          const message =
-            error instanceof Error ? error.message : String(error);
-          if (
-            !/complete|terminated|errored|finite state|cannot[ _]terminate|not[ _]implemented|not[ _]found|404/i.test(
-              message,
-            )
-          ) {
-            recordCoordinatorEvent(
-              'warn',
-              'coordinator.permanent_error.terminate_failed',
-              '[coordinator] terminate-after-permanent-error failed',
-              {
-                runId,
-                error: message,
-              },
-            );
-          }
-        });
-      }
-      const coordinatorTrace = includeTrace
-        ? await listCoordinatorPerfTrace(env, runId).catch(() => [])
-        : [];
-      return Response.json({
-        ...result,
-        coordinatorObserve: {
-          ms: observeMs,
-          waitMs: 0,
-          workflowStatus: status.status,
-          statusPolls: 1,
-          instanceId: instance.id,
-        },
-        ...(includeTrace ? { coordinatorTrace } : {}),
-      });
-    }
-    return new Response('not found', { status: 404 });
-  } finally {
-    disposeRpcStub(instance);
-  }
-}
-
-function workflowInstanceId(runId: string): string {
-  const normalized = runId.toLowerCase().replace(/[^a-z0-9_-]+/g, '-');
-  if (normalized.length > 0 && normalized.length <= 100) {
-    return normalized;
-  }
-  return `run-${stableHash(runId)}`;
-}
-
-function isWorkflowInstanceIdForRun(
-  runId: string,
-  instanceId: string,
-): boolean {
-  const canonical = workflowInstanceId(runId);
-  return (
-    instanceId === canonical || instanceId.startsWith(`${canonical}-retry-`)
-  );
-}
-
-function stableHash(value: string): string {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-
-const DYNAMIC_PLAY_WORKER_HARNESS_VERSION =
-  DYNAMIC_PLAY_WORKER_ARTIFACT_VERSION;
-const DYNAMIC_WORKER_BUNDLED_CODE_CACHE_MAX_ENTRIES = 64;
-const dynamicWorkerBundledCodeCache = new Map<string, string>();
-
-function dynamicPlayWorkerCacheKey(input: {
-  env: CoordinatorEnv;
-  graphHash: string;
-  artifactIdentity: string;
-}): string {
-  const deployMarker =
-    input.env.DEEPLINE_COORDINATOR_DEPLOY_MARKER?.trim() || 'local';
-  return [
-    'play',
-    input.graphHash,
-    input.artifactIdentity,
-    `harness=${DYNAMIC_PLAY_WORKER_HARNESS_VERSION}`,
-    `deploy=${deployMarker}`,
-  ].join(':');
-}
-
-function dynamicPlayWorkerArtifactIdentity(
-  metadata: Pick<
-    DynamicWorkflowMetadata,
-    | 'artifactHash'
-    | 'artifactStorageKey'
-    | 'dynamicWorkerCode'
-    | 'dynamicWorkerCodeHash'
-  >,
-): string {
-  const artifactHash = metadata.artifactHash?.trim();
-  const inlineCodeHash =
-    typeof metadata.dynamicWorkerCodeHash === 'string' &&
-    metadata.dynamicWorkerCodeHash.length > 0
-      ? metadata.dynamicWorkerCodeHash
-      : typeof metadata.dynamicWorkerCode === 'string' &&
-          metadata.dynamicWorkerCode.length > 0
-        ? stableHash(metadata.dynamicWorkerCode)
-        : null;
-  if (artifactHash && inlineCodeHash) {
-    return `${artifactHash}:inline=${inlineCodeHash}`;
-  }
-  if (artifactHash) {
-    return artifactHash;
-  }
-  if (inlineCodeHash) {
-    return `inline=${inlineCodeHash}`;
-  }
-  return stableHash(metadata.artifactStorageKey);
-}
-
-function dynamicWorkerBundledCodeCacheKey(input: {
-  artifactStorageKey: string;
-  artifactHash?: string | null;
-}): string {
-  return `${input.artifactHash?.trim() || 'no-hash'}:${input.artifactStorageKey}`;
-}
-
-function readDynamicWorkerBundledCodeCache(key: string): string | null {
-  const cached = dynamicWorkerBundledCodeCache.get(key);
-  if (cached === undefined) return null;
-  dynamicWorkerBundledCodeCache.delete(key);
-  dynamicWorkerBundledCodeCache.set(key, cached);
-  return cached;
-}
-
-function writeDynamicWorkerBundledCodeCache(key: string, code: string): void {
-  dynamicWorkerBundledCodeCache.set(key, code);
-  while (
-    dynamicWorkerBundledCodeCache.size >
-    DYNAMIC_WORKER_BUNDLED_CODE_CACHE_MAX_ENTRIES
-  ) {
-    const oldestKey = dynamicWorkerBundledCodeCache.keys().next().value;
-    if (typeof oldestKey !== 'string') break;
-    dynamicWorkerBundledCodeCache.delete(oldestKey);
-  }
-}
-
-/**
- * Synchronous wrapper around env.LOADER.get for use inside the
- * createDynamicWorkflowEntrypoint loader callback. The framework's loader
- * type allows async, but the official example
- * (cloudflare/dynamic-workflows repo) uses sync; the microtask hop a
- * top-level `await` introduces appears to interact badly with how the
- * framework wires up the returned entrypoint stub for runner.run() RPC.
- */
-function loadDynamicPlayWorkerSync(
-  env: CoordinatorEnv,
-  metadata: DynamicWorkflowMetadata,
-  trace: CoordinatorPerfTraceSink = recordCoordinatorPerfTrace,
-): {
-  getEntrypoint(name?: string): Fetcher & WorkflowRunner;
-} {
-  if (!env.LOADER) {
-    throw new Error(
-      'Cloudflare Dynamic Workflows require a Worker Loader binding named LOADER.',
-    );
-  }
-  if (!env.HARNESS) {
-    throw new Error(
-      'Cloudflare Dynamic Workflows require a service binding named HARNESS. ' +
-        'Start apps/play-harness-worker before the coordinator or fix wrangler.toml services.',
-    );
-  }
-  const graphHash = metadata.graphHash.trim();
-  if (!graphHash) {
-    throw new Error('Dynamic play worker requires graphHash metadata.');
-  }
-  const artifactStorageKey = metadata.artifactStorageKey.trim();
-  if (!artifactStorageKey) {
-    throw new Error(
-      'Dynamic play worker requires artifactStorageKey metadata.',
-    );
-  }
-  const artifactIdentity = dynamicPlayWorkerArtifactIdentity(metadata);
-  const workerCacheKey = dynamicPlayWorkerCacheKey({
-    env,
-    graphHash,
-    artifactIdentity,
-  });
-  const runIdForTrace = metadata.runId ?? graphHash;
-  const loaderGetStartedAt = Date.now();
-  const stub = env.LOADER.get(workerCacheKey, async () => {
-    const bundledCode = await loadDynamicWorkerBundledCode({
-      env,
-      metadata,
-      graphHash,
-      artifactStorageKey,
-      workerCacheKey,
-      runIdForTrace,
-      trace,
-    });
-    return {
-      compatibilityDate: DYNAMIC_WORKER_COMPATIBILITY_DATE,
-      compatibilityFlags: ['nodejs_compat'],
-      mainModule: 'index.js',
-      modules: { 'index.js': bundledCode },
-      env: {
-        // Service binding to the long-lived Play Harness Worker.
-        // Per-play code reaches this via `env.HARNESS.<method>(...)` —
-        // see sdk/src/plays/harness-stub.ts. This binding is required;
-        // miswired environments fail before user code starts.
-        HARNESS: env.HARNESS,
-        VERCEL_PROTECTION_BYPASS_TOKEN: env.VERCEL_PROTECTION_BYPASS_TOKEN,
-        // Runtime API bridge used by the play harness for status, tool
-        // execution, DB session, and artifact callbacks. This uses the
-        // long-lived HARNESS service binding, avoiding public callback HTTP
-        // without relying on dynamic-worker access to named exports.
-        ...makeRuntimeApiEnvBinding(env),
-        // In-process coordinator control bridge used by ctx.runPlay and
-        // parent terminal signals. This keeps scalar child plays inline with
-        // the parent instead of round-tripping through nested Workflow waits.
-        ...makeCoordinatorControlBinding(),
-        // NOTE: We intentionally do NOT pass `env.PLAYS_BUCKET` (an R2Bucket
-        // binding) through to the per-play Worker's env. Including a raw
-        // R2Bucket in the dynamically-loaded Worker's env makes Cloudflare
-        // Workflows fail at workflow init with
-        //   "Could not serialize object of type 'R2Bucket'."
-        // because the framework persists workflow state through a JSDevalue
-        // path that R2Bucket bindings do not support. Per-play harness reads
-        // (CSVs, packaged imports) go through the long-lived HARNESS Worker.
-      },
-    };
-  });
-  trace({
-    runId: runIdForTrace,
-    phase: 'coordinator.loader_get_call',
-    ms: Date.now() - loaderGetStartedAt,
-    graphHash,
-    extra: { workerCacheKey },
-  });
-  return stub;
-}
-
-async function loadDynamicPlayWorker(
-  env: CoordinatorEnv,
-  metadata: DynamicWorkflowMetadata,
-  trace: CoordinatorPerfTraceSink = recordCoordinatorPerfTrace,
-): Promise<{
-  getEntrypoint(name?: string): Fetcher & WorkflowRunner;
-}> {
-  if (!env.LOADER) {
-    throw new Error(
-      'Cloudflare Dynamic Workflows require a Worker Loader binding named LOADER.',
-    );
-  }
-  if (!env.HARNESS) {
-    throw new Error(
-      'Cloudflare Dynamic Workflows require a service binding named HARNESS. ' +
-        'Start apps/play-harness-worker before the coordinator or fix wrangler.toml services.',
-    );
-  }
-  const graphHash = metadata.graphHash.trim();
-  if (!graphHash) {
-    throw new Error('Dynamic play worker requires graphHash metadata.');
-  }
-  const artifactStorageKey = metadata.artifactStorageKey.trim();
-  if (!artifactStorageKey) {
-    throw new Error(
-      'Dynamic play worker requires artifactStorageKey metadata.',
-    );
-  }
-  const artifactIdentity = dynamicPlayWorkerArtifactIdentity(metadata);
-  const workerCacheKey = dynamicPlayWorkerCacheKey({
-    env,
-    graphHash,
-    artifactIdentity,
-  });
-  const runIdForTrace = metadata.runId ?? graphHash;
-  const loaderGetStartedAt = Date.now();
-  const stub = env.LOADER.get(workerCacheKey, async () => {
-    const bundledCode = await loadDynamicWorkerBundledCode({
-      env,
-      metadata,
-      graphHash,
-      artifactStorageKey,
-      workerCacheKey,
-      runIdForTrace,
-      trace,
-    });
-    return {
-      compatibilityDate: DYNAMIC_WORKER_COMPATIBILITY_DATE,
-      compatibilityFlags: ['nodejs_compat'],
-      mainModule: 'index.js',
-      modules: { 'index.js': bundledCode },
-      env: {
-        // Mirror of the sync loader (above) — see that copy for the
-        // architectural rationale. The dynamic worker env is intentionally
-        // minimal; runtime callbacks use RUNTIME_API, file reads go through
-        // HARNESS, and child workflow control uses the COORDINATOR binding.
-        HARNESS: env.HARNESS,
-        VERCEL_PROTECTION_BYPASS_TOKEN: env.VERCEL_PROTECTION_BYPASS_TOKEN,
-        ...makeRuntimeApiEnvBinding(env),
-        ...makeCoordinatorControlBinding(),
-      },
-    };
-  });
-  trace({
-    runId: runIdForTrace,
-    phase: 'coordinator.loader_get_call',
-    ms: Date.now() - loaderGetStartedAt,
-    graphHash,
-    extra: { workerCacheKey },
-  });
-  return stub;
-}
-
-async function loadDynamicWorkerBundledCode(input: {
-  env: CoordinatorEnv;
-  metadata: DynamicWorkflowMetadata;
-  graphHash: string;
-  artifactStorageKey: string;
-  workerCacheKey: string;
-  runIdForTrace: string;
-  trace: CoordinatorPerfTraceSink;
-}): Promise<string> {
-  const callbackStartedAt = Date.now();
-  let codeSource: 'inline' | 'r2' | 'memory' = 'inline';
-  let r2Ms = 0;
-  const codeCacheKey = dynamicWorkerBundledCodeCacheKey({
-    artifactStorageKey: input.artifactStorageKey,
-    artifactHash: input.metadata.artifactHash,
-  });
-  let bundledCode = input.metadata.dynamicWorkerCode ?? null;
-  if (!bundledCode) {
-    bundledCode = readDynamicWorkerBundledCodeCache(codeCacheKey);
-    if (bundledCode) {
-      codeSource = 'memory';
-    }
-  }
-  if (!bundledCode) {
-    codeSource = 'r2';
-    const r2StartedAt = Date.now();
-    try {
-      const artifact = await loadStoredPlayArtifactFromR2(
-        input.env,
-        input.artifactStorageKey,
-      );
-      bundledCode = artifact?.artifact?.bundledCode ?? null;
-      if (typeof bundledCode === 'string' && bundledCode.length > 0) {
-        writeDynamicWorkerBundledCodeCache(codeCacheKey, bundledCode);
-      }
-    } finally {
-      r2Ms = Date.now() - r2StartedAt;
-      input.trace({
-        runId: input.runIdForTrace,
-        phase: 'coordinator.loader_code_r2_get',
-        ms: r2Ms,
-        graphHash: input.graphHash,
-        extra: { artifactStorageKey: input.artifactStorageKey },
-      });
-    }
-  }
-  if (typeof bundledCode !== 'string' || bundledCode.length === 0) {
-    throw new Error(
-      `Stored play artifact ${input.artifactStorageKey} does not contain bundledCode.`,
-    );
-  }
-  input.trace({
-    runId: input.runIdForTrace,
-    phase: 'coordinator.loader_code_callback',
-    ms: Date.now() - callbackStartedAt,
-    graphHash: input.graphHash,
-    extra: {
-      codeSource,
-      r2Ms,
-      workerCacheKey: input.workerCacheKey,
-      bundledCodeBytes: bundledCode.length,
-    },
-  });
-  return bundledCode;
-}
-
-function normalizePackagedFiles(
-  value: unknown,
-): NonNullable<DynamicWorkflowMetadata['packagedFiles']> {
-  if (!Array.isArray(value)) return [];
-  return value
-    .filter((entry): entry is Record<string, unknown> =>
-      Boolean(entry && typeof entry === 'object' && !Array.isArray(entry)),
-    )
-    .map((entry) => ({
-      playPath: String(entry.playPath ?? '').replace(/^\.\//, ''),
-      storageKey: String(entry.storageKey ?? ''),
-      contentType:
-        typeof entry.contentType === 'string' ? entry.contentType : undefined,
-      bytes:
-        typeof entry.bytes === 'number' &&
-        Number.isSafeInteger(entry.bytes) &&
-        entry.bytes >= 0
-          ? entry.bytes
-          : undefined,
-      inlineText:
-        typeof entry.inlineText === 'string' ? entry.inlineText : undefined,
-    }))
-    .filter(
-      (entry) => entry.playPath.length > 0 && entry.storageKey.length > 0,
-    );
-}
-
-const COORDINATOR_WARMUP_DYNAMIC_WORKER_CODE = `
-import { WorkflowEntrypoint } from "cloudflare:workers";
-
-export class TenantWorkflow extends WorkflowEntrypoint {
-  async run(event) {
-    const payload = event && typeof event === "object" ? event.payload : null;
-    const runId = payload && typeof payload.runId === "string" ? payload.runId : "warmup";
-    const startedAt = Date.now();
-    if (this.env.RUNTIME_API) {
-      await this.env.RUNTIME_API.fetch(new Request("https://deepline.runtime.internal${PLAY_RUNTIME_API_COMPAT_PATH}", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: "{}"
-      })).catch(() => null);
-    }
-    console.log("[perf-trace] " + JSON.stringify({
-      telemetrySchemaVersion: 1,
-      timestamp: new Date().toISOString(),
-      service: "play-runtime",
-      component: "coordinator-warmup",
-      event: "dynamic_worker.warmup_run",
-      tag: "[perf-trace]",
-      ts: Date.now(),
-      source: "dynamic_worker",
-      runId,
-      phase: "dynamic_worker.warmup_run",
-      ms: Date.now() - startedAt,
-      graphHash: "coordinator-warmup-v1",
-      telemetryKind: "log",
-      telemetryLevel: "info"
-    }));
-    return { ok: true, warmup: true };
-  }
-}
-
-export default {
-  async fetch(request, env) {
-    const url = new URL(request.url);
-    if (request.method === "POST" && url.pathname === "/start") {
-      const body = await request.json().catch(() => null);
-      if (!body || typeof body.id !== "string" || !body.payload || typeof body.payload !== "object") {
-        return new Response("invalid workflow start body", { status: 400 });
-      }
-      const createStartedAt = Date.now();
-      const instance = await env.WORKFLOWS.create({ id: body.id, params: body.payload });
-      const workflowCreateMs = Date.now() - createStartedAt;
-      return Response.json({
-        id: instance.id,
-        status: "submitted",
-        timingsMs: { workflowCreate: workflowCreateMs }
-      });
-    }
-    if (request.method === "GET" && url.pathname === "/health") {
-      return new Response("ok", { status: 200 });
-    }
-    return new Response("not found", { status: 404 });
-  }
-};
-`;
-
-function isAllowedStagedFileStorageKey(key: string): boolean {
-  if (!key || key.length > 2_048) return false;
-  if (key.startsWith('/') || key.includes('..') || key.includes('\\')) {
-    return false;
-  }
-  return key.startsWith('plays/v2/orgs/') || key.includes('/plays/v2/orgs/');
-}
-
-function decodeBase64ToUint8Array(value: string): Uint8Array {
-  const binary = atob(value);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index += 1) {
-    bytes[index] = binary.charCodeAt(index);
-  }
-  return bytes;
-}
-
-async function handleStagedFilePut(
-  request: Request,
-  env: CoordinatorEnv,
-): Promise<Response> {
-  if (request.method !== 'POST') {
-    return new Response('method not allowed', { status: 405 });
-  }
-  const url = new URL(request.url);
-  const rawKey = url.searchParams.get('key')?.trim() ?? '';
-  if (rawKey) {
-    const key = rawKey;
-    const contentType =
-      url.searchParams.get('contentType')?.trim() || 'application/octet-stream';
-    const expectedBytes = Number(url.searchParams.get('bytes') ?? 'NaN');
-    if (!isAllowedStagedFileStorageKey(key)) {
-      return Response.json(
-        { error: 'invalid staged file key' },
-        { status: 400 },
-      );
-    }
-    if (!Number.isSafeInteger(expectedBytes) || expectedBytes < 0) {
-      return Response.json({ error: 'bytes is required' }, { status: 400 });
-    }
-    const existing = await headExistingStagedFile(env, key, expectedBytes);
-    if (existing.exists) {
-      recordCoordinatorEvent(
-        'info',
-        'coordinator.staged_file_put',
-        '[perf][coordinator.staged_file_put]',
-        {
-          key,
-          bytes: expectedBytes,
-          headMs: existing.ms,
-          putMs: 0,
-          ms: existing.ms,
-          transport: 'raw',
-          skipped: true,
-        },
-      );
-      return Response.json({
-        ok: true,
-        key,
-        bytes: expectedBytes,
-        existed: true,
-        timingsMs: { head: existing.ms, put: 0 },
-      });
-    }
-    const readStartedAt = Date.now();
-    const bytes = new Uint8Array(await request.arrayBuffer());
-    const readMs = Date.now() - readStartedAt;
-    if (bytes.byteLength !== expectedBytes) {
-      return Response.json(
-        { error: 'staged file byte length mismatch' },
-        { status: 400 },
-      );
-    }
-    const putStartedAt = Date.now();
-    await env.PLAYS_BUCKET.put(key, bytes, {
-      httpMetadata: { contentType },
-    });
-    const putMs = Date.now() - putStartedAt;
-    recordCoordinatorEvent(
-      'info',
-      'coordinator.staged_file_put',
-      '[perf][coordinator.staged_file_put]',
-      {
-        key,
-        bytes: bytes.byteLength,
-        readMs,
-        putMs,
-        ms: readMs + putMs,
-        transport: 'raw',
-      },
-    );
-    return Response.json({
-      ok: true,
-      key,
-      bytes: bytes.byteLength,
-      timingsMs: { read: readMs, put: putMs },
-    });
-  }
-  const body = (await request.json().catch(() => null)) as {
-    key?: unknown;
-    contentBase64?: unknown;
-    contentType?: unknown;
-    bytes?: unknown;
-  } | null;
-  const key = typeof body?.key === 'string' ? body.key.trim() : '';
-  const contentBase64 =
-    typeof body?.contentBase64 === 'string' ? body.contentBase64 : '';
-  const contentType =
-    typeof body?.contentType === 'string' && body.contentType.trim()
-      ? body.contentType.trim()
-      : 'application/octet-stream';
-  const expectedBytes = typeof body?.bytes === 'number' ? body.bytes : NaN;
-  if (!isAllowedStagedFileStorageKey(key)) {
-    return Response.json({ error: 'invalid staged file key' }, { status: 400 });
-  }
-  if (
-    !contentBase64 ||
-    !Number.isSafeInteger(expectedBytes) ||
-    expectedBytes < 0
-  ) {
-    return Response.json(
-      { error: 'contentBase64 and bytes are required' },
-      { status: 400 },
-    );
-  }
-  const existing = await headExistingStagedFile(env, key, expectedBytes);
-  if (existing.exists) {
-    recordCoordinatorEvent(
-      'info',
-      'coordinator.staged_file_put',
-      '[perf][coordinator.staged_file_put]',
-      {
-        key,
-        bytes: expectedBytes,
-        headMs: existing.ms,
-        putMs: 0,
-        ms: existing.ms,
-        transport: 'base64',
-        skipped: true,
-      },
-    );
-    return Response.json({
-      ok: true,
-      key,
-      bytes: expectedBytes,
-      existed: true,
-      timingsMs: { head: existing.ms, put: 0 },
-    });
-  }
-  const decodeStartedAt = Date.now();
-  const bytes = decodeBase64ToUint8Array(contentBase64);
-  const decodeMs = Date.now() - decodeStartedAt;
-  if (bytes.byteLength !== expectedBytes) {
-    return Response.json(
-      { error: 'staged file byte length mismatch' },
-      { status: 400 },
-    );
-  }
-  const putStartedAt = Date.now();
-  await env.PLAYS_BUCKET.put(key, bytes, {
-    httpMetadata: { contentType },
-  });
-  const putMs = Date.now() - putStartedAt;
-  recordCoordinatorEvent(
-    'info',
-    'coordinator.staged_file_put',
-    '[perf][coordinator.staged_file_put]',
-    {
-      key,
-      bytes: bytes.byteLength,
-      decodeMs,
-      putMs,
-      ms: decodeMs + putMs,
-    },
-  );
-  return Response.json({
-    ok: true,
-    key,
-    bytes: bytes.byteLength,
-    timingsMs: { decode: decodeMs, put: putMs },
-  });
-}
-
-async function headExistingStagedFile(
-  env: CoordinatorEnv,
-  key: string,
-  expectedBytes: number,
-): Promise<{ exists: boolean; ms: number }> {
-  const startedAt = Date.now();
-  const object = await env.PLAYS_BUCKET.head(key).catch(() => null);
-  const ms = Date.now() - startedAt;
-  if (!object) {
-    return { exists: false, ms };
-  }
-  if (typeof object.size === 'number' && object.size !== expectedBytes) {
-    return { exists: false, ms };
-  }
-  return { exists: true, ms };
-}
-
-async function handleCoordinatorWarmup(
-  request: Request,
-  env: CoordinatorEnv,
-  ctx?: ExecutionContext,
-): Promise<Response> {
-  if (request.method !== 'POST') {
-    return new Response('method not allowed', { status: 405 });
-  }
-  const warmupToken = env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim();
-  if (
-    warmupToken &&
-    request.headers.get('x-vercel-protection-bypass') !== warmupToken
-  ) {
-    return new Response('unauthorized', { status: 401 });
-  }
-  const url = new URL(request.url);
-  const label = url.searchParams.get('label')?.trim() || 'warmup';
-  const runId = `coordinator/warmup/${label}/${Date.now().toString(36)}`;
-  const artifactHash = `coordinator-warmup-${stableHash(COORDINATOR_WARMUP_DYNAMIC_WORKER_CODE)}`;
-  const artifactStorageKey = `coordinator-warmup/${artifactHash}.json`;
-  await env.PLAYS_BUCKET.put(
-    artifactStorageKey,
-    JSON.stringify({
-      artifact: {
-        artifactKind: 'esm_workers',
-        bundledCode: COORDINATOR_WARMUP_DYNAMIC_WORKER_CODE,
-      },
-    } satisfies StoredPlayArtifactPayload),
-    {
-      httpMetadata: {
-        contentType: 'application/json',
-      },
-    },
-  );
-  const params: PlayWorkflowParams = {
-    runId,
-    playId: runId,
-    playName: 'coordinator-warmup',
-    artifactStorageKey,
-    artifactHash,
-    graphHash: artifactHash,
-    input: {},
-    inputFile: null,
-    inlineCsv: null,
-    packagedFiles: null,
-    contractSnapshot: null,
-    executionPlan: null,
-    dynamicWorkerCode: null,
-    executorToken: 'coordinator-warmup',
-    baseUrl: env.DEEPLINE_API_BASE_URL,
-    orgId: 'coordinator-warmup',
-    userEmail: 'coordinator-warmup@deepline.local',
-    userId: 'coordinator-warmup',
-    runtimeBackend: 'cf_workflows_dynamic_worker',
-    dedupBackend: 'durable_object',
-  };
-  const startedAt = Date.now();
-  const response = await handleWorkflowRoute({
-    runId,
-    action: 'submit',
-    request: new Request(
-      `https://deepline.coordinator.internal/workflow/${encodeURIComponent(runId)}/submit`,
-      {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          [COORDINATOR_INTERNAL_TOKEN_HEADER]:
-            env.DEEPLINE_INTERNAL_TOKEN?.trim() ?? '',
-        },
-        body: JSON.stringify(params),
-      },
-    ),
-    env,
-  });
-  const text = await response.text().catch(() => '');
-  const terminalWaitStartedAt = Date.now();
-  let terminalState: Record<string, unknown> | null = null;
-  if (response.ok) {
-    const instance = await env.PLAY_WORKFLOW.get(
-      await resolveWorkflowInstanceIdForRun(env, runId),
-    );
-    try {
-      while (Date.now() - terminalWaitStartedAt < 10_000) {
-        const status = await instance.status();
-        terminalState = mapWorkflowResult(runId, status);
-        const mappedStatus = String(terminalState.status ?? '');
-        if (
-          mappedStatus === 'completed' ||
-          mappedStatus === 'failed' ||
-          mappedStatus === 'cancelled'
-        ) {
-          break;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-    } finally {
-      disposeRpcStub(instance);
-    }
-  }
-  recordCoordinatorPerfTrace({
-    runId,
-    phase: 'coordinator.warmup_terminal_wait',
-    ms: Date.now() - terminalWaitStartedAt,
-    graphHash: params.graphHash,
-    extra: { status: terminalState?.status ?? null, label },
-  });
-  recordCoordinatorPerfTrace({
-    runId,
-    phase: 'coordinator.warmup_submit_total',
-    ms: Date.now() - startedAt,
-    graphHash: params.graphHash,
-    extra: { status: response.status, label },
-  });
-  let body: unknown = null;
-  try {
-    body = text ? JSON.parse(text) : null;
-  } catch {
-    body = text;
-  }
-  const terminalStatus = String(terminalState?.status ?? '');
-  const warmupCompleted = response.ok && terminalStatus === 'completed';
-  const responseStatus = warmupCompleted
-    ? 200
-    : terminalStatus === 'running' || terminalStatus === 'sleeping'
-      ? 504
-      : response.ok
-        ? 500
-        : response.status;
-  return Response.json(
-    {
-      ok: warmupCompleted,
-      runId,
-      status: response.status,
-      body,
-      terminalState,
-    },
-    { status: responseStatus },
-  );
-}
-
-/**
- * Returns a structured-cloneable runtime API binding for the per-graphHash
- * play Worker's `env.RUNTIME_API`. We intentionally pass the long-lived
- * HARNESS WorkerEntrypoint service binding instead of a plain closure: the
- * dynamic Worker env is serialized by Cloudflare Workflows, and service
- * bindings are cloneable while closures are not. The per-play runtime accepts
- * this binding via `runtimeApiCall(...)`, so callbacks still stay on
- * service bindings and never fall back to public HTTP.
- */
-let loggedMissingCoordinatorControlExport = false;
-
-function makeRuntimeApiEnvBinding(env: CoordinatorEnv): {
-  RUNTIME_API: CoordinatorEnv['HARNESS'];
-} {
-  return { RUNTIME_API: env.HARNESS };
-}
-
-function makeCoordinatorControlBinding():
-  | {
-      COORDINATOR: {
-        signal(
-          runId: string,
-          body: Record<string, unknown>,
-        ): Promise<Record<string, unknown>>;
-        recordPerfTrace(
-          runId: string,
-          payload: CoordinatorPerfTracePayload,
-        ): Promise<void>;
-        recordRunEvent(
-          runId: string,
-          event: CoordinatorRunEvent,
-        ): Promise<void>;
-        readTerminalState(
-          runId: string,
-        ): Promise<CoordinatorTerminalState | null>;
-        rateAcquire(input: {
-          bucketId: string;
-          rules: Array<{
-            ruleId: string;
-            requestsPerWindow: number;
-            windowMs: number;
-            maxConcurrency: number | null;
-          }>;
-          requested: number;
-        }): Promise<{ granted: number; waitMs: number }>;
-        ratePenalize(input: {
-          bucketId: string;
-          cooldownMs: number;
-        }): Promise<void>;
-      };
-    }
-  | Record<string, never> {
-  const exports = workersExports as unknown as {
-    CoordinatorControl?: (init: { props: undefined }) => {
-      signal(
-        runId: string,
-        body: Record<string, unknown>,
-      ): Promise<Record<string, unknown>>;
-      recordPerfTrace(
-        runId: string,
-        payload: CoordinatorPerfTracePayload,
-      ): Promise<void>;
-      recordRunEvent(runId: string, event: CoordinatorRunEvent): Promise<void>;
-      readTerminalState(
-        runId: string,
-      ): Promise<CoordinatorTerminalState | null>;
-      rateAcquire(input: {
-        bucketId: string;
-        rules: Array<{
-          ruleId: string;
-          requestsPerWindow: number;
-          windowMs: number;
-          maxConcurrency: number | null;
-        }>;
-        requested: number;
-      }): Promise<{ granted: number; waitMs: number }>;
-      ratePenalize(input: {
-        bucketId: string;
-        cooldownMs: number;
-      }): Promise<void>;
-    };
-  };
-  const ctor = exports.CoordinatorControl;
-  if (typeof ctor !== 'function') {
-    if (!loggedMissingCoordinatorControlExport) {
-      loggedMissingCoordinatorControlExport = true;
-      recordCoordinatorEvent(
-        'warn',
-        'coordinator.control_export.missing',
-        '[coordinator] CoordinatorControl is not registered on cloudflare:workers exports; using public coordinator transport.',
-      );
-    }
-    return {};
-  }
-  return { COORDINATOR: ctor({ props: undefined }) };
-}
-
-async function loadStoredPlayArtifactFromR2(
-  env: CoordinatorEnv,
-  storageKey: string,
-): Promise<StoredPlayArtifactPayload> {
-  const object = await env.PLAYS_BUCKET.get(storageKey);
-  if (!object) {
-    throw new Error(`Stored play artifact missing from R2: ${storageKey}`);
-  }
-  return JSON.parse(await object.text()) as StoredPlayArtifactPayload;
-}
-
-function readMetadataString(
-  metadata: Record<string, unknown>,
-  key: keyof DynamicWorkflowMetadata,
-): string {
-  const value = metadata[key];
-  if (typeof value !== 'string' || !value.trim()) {
-    throw new Error(`Dynamic workflow metadata missing ${key}.`);
-  }
-  return value;
-}
-
-function mapWorkflowResult(
-  runId: string,
-  status: InstanceStatus,
-): Record<string, unknown> {
-  const rawError = readWorkflowError(status);
-  const mapped = resolveTerminalStatus(status, rawError);
-  const error =
-    rawError ??
-    (mapped === 'failed'
-      ? `Cloudflare workflow reported ${String(status.status ?? 'failed')} without an error payload.`
-      : null);
-  const output =
-    status.output && typeof status.output === 'object'
-      ? (status.output as Record<string, unknown>)
-      : null;
-  return {
-    runId,
-    ...(typeof output?.playName === 'string' && output.playName.trim()
-      ? { playName: output.playName.trim() }
-      : {}),
-    status: mapped,
-    result: output?.result ?? status.output ?? null,
-    error,
-    totalRows: output?.totalRows ?? output?.outputRows ?? null,
-    durationMs: output?.durationMs ?? null,
-    liveLogs: sanitizeLiveLogLines(output?.liveLogs),
-    liveNodeProgress: output?.liveNodeProgress ?? null,
-    wait:
-      mapped === 'sleeping'
-        ? {
-            kind: 'integration_event_batch',
-          }
-        : null,
-  };
-}
-
-function mapWorkflowStatus(
-  status: InstanceStatus,
-): 'running' | 'sleeping' | 'completed' | 'failed' | 'cancelled' {
-  if (status.status === 'complete') return 'completed';
-  if (status.status === 'errored') return 'failed';
-  if (status.status === 'terminated') return 'cancelled';
-  if (status.status === 'waiting' || status.status === 'paused')
-    return 'sleeping';
-  return 'running';
-}
-
-/**
- * CF Dynamic Workflows retries failed workflow bodies silently for ~3
- * minutes before transitioning the instance to `errored`. During that
- * retry window `status.status` stays `running`/`paused`/`waiting`, but
- * **`status.error`** gets populated as soon as the first attempt fails —
- * with CF's generic `"internal error; reference = <id>"` (they never
- * surface the actual JS error message via this API). That's enough
- * signal: any error presence on a non-terminal instance means at least
- * one attempt has thrown, and the user is better served by failing fast
- * than by waiting 3 minutes for CF's retry budget to exhaust.
- *
- * If the failure was actually transient and the next retry would have
- * succeeded, the user can re-run. The previous "match on permanent-
- * error patterns" approach didn't help because the error message we
- * see from CF is never a JS error name — it's always the generic
- * reference id.
- */
-function resolveTerminalStatus(
-  status: InstanceStatus,
-  error: string | null,
-): 'running' | 'sleeping' | 'completed' | 'failed' | 'cancelled' {
-  const mapped = mapWorkflowStatus(status);
-  if ((mapped === 'running' || mapped === 'sleeping') && error) {
-    return 'failed';
-  }
-  return mapped;
-}
-
-function readWorkflowError(status: InstanceStatus): string | null {
-  const error = status.error as unknown;
-  if (!error) return null;
-  if (typeof error === 'string') return error.trim() || null;
-  if (typeof error === 'object' && 'message' in error) {
-    const message = String((error as { message?: unknown }).message ?? '');
-    return message.trim() || null;
-  }
-  const message = String(error);
-  return message.trim() || null;
-}