deepline 0.1.64 → 0.1.66

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

@@ -23,7 +23,23 @@ import {
 } from '@cloudflare/dynamic-workflows';
 import type { ExecutionPlan } from '../../../shared_libs/play-runtime/execution-plan';
 import type { PlayCallGovernanceSnapshot } from '../../../shared_libs/play-runtime/scheduler-backend';
-import type { PreloadedRuntimeDbSession } from '../../../shared_libs/play-runtime/db-session';
+import {
+  DB_SESSION_DEFAULT_TTL_SECONDS,
+  createDbSessionResponseSchema,
+  type CreateDbSessionResponse,
+  type PreloadedRuntimeDbSession,
+} from '../../../shared_libs/play-runtime/db-session';
+import {
+  dbSessionPostgresUrlAad,
+  decryptDbSessionPostgresUrlWithPrivateKey,
+  encryptDbSessionPostgresUrl,
+  generateDbSessionPostgresUrlDecryptionKey,
+  type PostgresUrlDecryptionKey,
+} from '../../../shared_libs/play-runtime/db-session-crypto';
+import {
+  planRuntimeDbSessionRequirements,
+  type RuntimeDbSessionRequirement,
+} from '../../../shared_libs/play-runtime/db-session-plan';
 import type {
   PlayRuntimeManifest,
   PlayRuntimeManifestMap,
@@ -72,6 +88,11 @@ export type PlayWorkflowParams = {
   childPlayManifests?: PlayRuntimeManifestMap | null;
   playCallGovernance?: PlayCallGovernanceSnapshot | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
+  preloadedDbSessionRef?: {
+    runId: string;
+    sessionCount: number;
+    expiresAt: number;
+  } | null;
   dynamicWorkerCode?: string | null;
   executorToken: string;
   baseUrl: string;
@@ -239,15 +260,12 @@ interface CoordinatorEnv {
    * helpers (runtime-API HTTP forwarder, Neon dataset IO, …) that we
    * deliberately keep OUT of every per-graphHash play bundle.
    *
-   * Optional: when missing (e.g. an older deploy that hasn't been wired
-   * yet, or a local dev environment running without the harness), the
-   * coordinator falls back to passing a `null` HARNESS into per-play
-   * Workers and the per-play stub throws a clear error if anyone tries
-   * to use it. Loud failures > silent fallbacks.
+   * 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;
+  HARNESS: import('../../play-harness-worker/src/rpc-types').PlayHarnessRpc;
 }
 
 const WORKFLOW_READ_ONLY_ACTIONS = new Set(['', 'result', 'status', 'tail']);
@@ -605,7 +623,7 @@ function readWorkflowTraceContext(event: unknown): {
 } {
   const record = isRecord(event) ? event : {};
   const payload = isRecord(record.payload) ? record.payload : {};
-  const params = isRecord(payload.params) ? payload.params : null;
+  const params = isRecord(payload.params) ? payload.params : payload;
   const metadata = isRecord(payload.__dispatcherMetadata)
     ? payload.__dispatcherMetadata
     : null;
@@ -706,6 +724,13 @@ function workflowPoolDurableObject(env: CoordinatorEnv): DurableObjectStub {
   );
 }
 
+function runScopedDurableObject(
+  env: CoordinatorEnv,
+  runId: string,
+): DurableObjectStub {
+  return env.PLAY_DEDUP.get(env.PLAY_DEDUP.idFromName(runId));
+}
+
 async function callWorkflowPool<T>(
   env: CoordinatorEnv,
   path: string,
@@ -762,6 +787,188 @@ async function callWorkflowPool<T>(
   }
 }
 
+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 persistWorkflowDbSessions(input: {
+  env: CoordinatorEnv;
+  runId: string;
+  sessions: PreloadedRuntimeDbSession[];
+}): Promise<NonNullable<PlayWorkflowParams['preloadedDbSessionRef']>> {
+  assertEncryptedPreloadedDbSessions(input.sessions);
+  const response = await runScopedDurableObject(input.env, input.runId).fetch(
+    'https://deepline.dedup.internal/db-sessions-put',
+    {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        runId: input.runId,
+        sessions: input.sessions,
+        ttlMs: DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
+      }),
+    },
+  );
+  if (!response.ok) {
+    throw new Error(
+      `workflow db session storage failed ${response.status}: ${(
+        await response.text().catch(() => '')
+      ).slice(0, 400)}`,
+    );
+  }
+  const body = (await response.json().catch(() => ({}))) as {
+    sessionCount?: unknown;
+    expiresAt?: unknown;
+  };
+  return {
+    runId: input.runId,
+    sessionCount:
+      typeof body.sessionCount === 'number' &&
+      Number.isFinite(body.sessionCount)
+        ? body.sessionCount
+        : input.sessions.length,
+    expiresAt:
+      typeof body.expiresAt === 'number' && Number.isFinite(body.expiresAt)
+        ? body.expiresAt
+        : Date.now() + DB_SESSION_DEFAULT_TTL_SECONDS * 1000,
+  };
+}
+
+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 externalizeWorkflowDbSessions(input: {
+  env: CoordinatorEnv;
+  params: PlayWorkflowParams;
+  recordSubmitTiming?: (timing: CoordinatorTiming) => void;
+}): Promise<PlayWorkflowParams> {
+  const sessions = Array.isArray(input.params.preloadedDbSessions)
+    ? input.params.preloadedDbSessions
+    : [];
+  if (sessions.length === 0) return input.params;
+  const startedAt = Date.now();
+  const ref = await persistWorkflowDbSessions({
+    env: input.env,
+    runId: input.params.runId,
+    sessions,
+  });
+  input.recordSubmitTiming?.({
+    phase: 'coordinator.workflow_db_sessions_externalized',
+    ms: Date.now() - startedAt,
+    graphHash: input.params.graphHash ?? null,
+    extra: {
+      sessions: sessions.length,
+      expiresAt: ref.expiresAt,
+    },
+  });
+  return {
+    ...input.params,
+    preloadedDbSessions: null,
+    preloadedDbSessionRef: 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 readWorkflowDbSessions({ 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,
+        },
+  };
+}
+
 type WorkflowPoolCounts = {
   available: number;
   warming: number;
@@ -1689,7 +1896,8 @@ async function submitViaPooledWorkflow(input: {
 function readWorkflowPayload(event: unknown): Record<string, unknown> | null {
   if (!isRecord(event)) return null;
   const payload = event.payload;
-  return isRecord(payload) ? payload : null;
+  if (!isRecord(payload)) return null;
+  return isRecord(payload.params) ? payload.params : payload;
 }
 
 async function markWorkflowRuntimeFailure(input: {
@@ -1833,6 +2041,185 @@ async function mintChildWorkflowExecutorToken(input: {
   return executorToken;
 }
 
+function stripDbSessionUrl(
+  session: CreateDbSessionResponse,
+): Omit<CreateDbSessionResponse, 'postgresUrl' | 'encryptedPostgresUrl'> {
+  const {
+    postgresUrl: _postgresUrl,
+    encryptedPostgresUrl: _encryptedPostgresUrl,
+    ...sessionWithoutUrl
+  } = session;
+  void _postgresUrl;
+  void _encryptedPostgresUrl;
+  return sessionWithoutUrl;
+}
+
+function assertChildDbSessionScope(input: {
+  session: CreateDbSessionResponse;
+  requirement: RuntimeDbSessionRequirement;
+  orgId: string;
+  childPlayName: string;
+}): void {
+  const { session, requirement, orgId, childPlayName } = input;
+  if (
+    session.playName !== childPlayName ||
+    session.target.orgId !== orgId ||
+    session.target.tableNamespace !== requirement.tableNamespace ||
+    session.target.logicalTable !== requirement.logicalTable
+  ) {
+    throw new Error(
+      'Runtime API returned a DB session outside the child play scope.',
+    );
+  }
+  const expectedOperations = [...requirement.operations].sort().join(',');
+  const actualOperations = [...session.operations].sort().join(',');
+  if (actualOperations !== expectedOperations) {
+    throw new Error(
+      'Runtime API returned a DB session with unexpected operations.',
+    );
+  }
+}
+
+async function reencryptChildDbSessionForExecutor(input: {
+  session: CreateDbSessionResponse;
+  decryptionKey: PostgresUrlDecryptionKey;
+  childExecutorToken: string;
+}): Promise<CreateDbSessionResponse> {
+  const sessionWithoutUrl = stripDbSessionUrl(input.session);
+  if (!input.session.encryptedPostgresUrl) {
+    throw new Error('Runtime API returned an unencrypted DB session URL.');
+  }
+  const postgresUrl = await decryptDbSessionPostgresUrlWithPrivateKey({
+    encrypted: input.session.encryptedPostgresUrl,
+    privateKey: input.decryptionKey.privateKey,
+    aad: dbSessionPostgresUrlAad(sessionWithoutUrl),
+  });
+  return {
+    ...sessionWithoutUrl,
+    encryptedPostgresUrl: await encryptDbSessionPostgresUrl({
+      postgresUrl,
+      secret: input.childExecutorToken,
+      aad: dbSessionPostgresUrlAad(sessionWithoutUrl),
+    }),
+  };
+}
+
+async function createChildRuntimeDbSession(input: {
+  env: CoordinatorEnv;
+  baseUrl: string;
+  childExecutorToken: string;
+  childPlayName: string;
+  requirement: RuntimeDbSessionRequirement;
+  userEmail: string;
+  orgId: string;
+}): Promise<CreateDbSessionResponse> {
+  const decryptionKey = await generateDbSessionPostgresUrlDecryptionKey();
+  const url = `${input.baseUrl.replace(/\/$/, '')}/api/v2/plays/internal/runtime`;
+  const headers = new Headers({
+    authorization: `Bearer ${input.childExecutorToken}`,
+    'content-type': 'application/json',
+    'x-deepline-request-id': crypto.randomUUID(),
+  });
+  if (input.env.VERCEL_PROTECTION_BYPASS_TOKEN?.trim()) {
+    headers.set(
+      'x-vercel-protection-bypass',
+      input.env.VERCEL_PROTECTION_BYPASS_TOKEN.trim(),
+    );
+  }
+  const response = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      action: 'create_db_session',
+      playName: input.childPlayName,
+      target: {
+        tableNamespace: input.requirement.tableNamespace,
+        logicalTable: input.requirement.logicalTable,
+      },
+      operations: input.requirement.operations,
+      limits: input.requirement.limits,
+      sheetContract: input.requirement.sheetContract ?? null,
+      ttlSeconds: DB_SESSION_DEFAULT_TTL_SECONDS,
+      userEmail: input.userEmail,
+      postgresUrlEncryption: decryptionKey.request,
+    }),
+  });
+  const text = await response.text().catch(() => '');
+  let parsed: unknown = {};
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    parsed = {};
+  }
+  if (!response.ok) {
+    const error =
+      isRecord(parsed) && isRecord(parsed.error) ? parsed.error : {};
+    const message =
+      (typeof error.message === 'string' && error.message.trim()) ||
+      (isRecord(parsed) &&
+      typeof parsed.error === 'string' &&
+      parsed.error.trim()
+        ? parsed.error.trim()
+        : '') ||
+      text.slice(0, 800) ||
+      `Origin DB session mint failed with ${response.status}.`;
+    throw new Error(message);
+  }
+  const session = createDbSessionResponseSchema.parse(parsed);
+  assertChildDbSessionScope({
+    session,
+    requirement: input.requirement,
+    orgId: input.orgId,
+    childPlayName: input.childPlayName,
+  });
+  return await reencryptChildDbSessionForExecutor({
+    session,
+    decryptionKey,
+    childExecutorToken: input.childExecutorToken,
+  });
+}
+
+async function preloadChildRuntimeDbSessions(input: {
+  env: CoordinatorEnv;
+  baseUrl: string;
+  childExecutorToken: string;
+  childRunId: string;
+  childPlayName: string;
+  manifest: PlayRuntimeManifest;
+  orgId: string;
+  userEmail: string;
+}): Promise<PreloadedRuntimeDbSession[]> {
+  const startedAt = Date.now();
+  const requirements = planRuntimeDbSessionRequirements(
+    input.manifest.staticPipeline ?? null,
+  );
+  const sessions = await Promise.all(
+    requirements.map(async (requirement) => ({
+      tableNamespace: requirement.tableNamespace,
+      logicalTable: requirement.logicalTable,
+      operations: requirement.operations,
+      ...(requirement.limits ? { limits: requirement.limits } : {}),
+      session: await createChildRuntimeDbSession({
+        env: input.env,
+        baseUrl: input.baseUrl,
+        childExecutorToken: input.childExecutorToken,
+        childPlayName: input.childPlayName,
+        requirement,
+        userEmail: input.userEmail,
+        orgId: input.orgId,
+      }),
+    })),
+  );
+  recordCoordinatorPerfTrace({
+    runId: input.childRunId,
+    phase: 'coordinator.child_db_session_preload',
+    ms: Date.now() - startedAt,
+    graphHash: input.manifest.graphHash,
+    extra: { sessions: sessions.length },
+  });
+  return sessions;
+}
+
 function buildChildRunId(playName: string): string {
   const slug =
     playName
@@ -1973,6 +2360,9 @@ function buildChildWorkflowParams(input: {
   childToken: string;
   orgId: string;
   coordinatorUrl: string | null;
+  runtimeBackend: string;
+  dynamicWorkerCode: string | null;
+  preloadedDbSessions: PreloadedRuntimeDbSession[] | null;
 }): PlayWorkflowParams {
   const {
     env,
@@ -1984,6 +2374,9 @@ function buildChildWorkflowParams(input: {
     childToken,
     orgId,
     coordinatorUrl,
+    runtimeBackend,
+    dynamicWorkerCode,
+    preloadedDbSessions,
   } = input;
   const baseUrl = resolveRuntimeBaseUrl(env, body);
   return {
@@ -2019,13 +2412,14 @@ function buildChildWorkflowParams(input: {
       ? (body.childPlayManifests as PlayRuntimeManifestMap)
       : null,
     playCallGovernance: governance,
-    dynamicWorkerCode: null,
+    preloadedDbSessions,
+    dynamicWorkerCode,
     executorToken: childToken,
     baseUrl,
     orgId,
     userEmail: typeof body.userEmail === 'string' ? body.userEmail : '',
     userId: typeof body.userId === 'string' ? body.userId : null,
-    runtimeBackend: 'cf_workflows_dynamic_worker_inline_child',
+    runtimeBackend,
     dedupBackend: 'in_memory',
     coordinatorUrl,
     coordinatorInternalToken: env.DEEPLINE_INTERNAL_TOKEN?.trim() || null,
@@ -2213,9 +2607,10 @@ async function executeChildInline(input: {
   });
 
   const tokenStartedAt = Date.now();
+  const baseUrl = resolveRuntimeBaseUrl(input.env, input.body);
   const childToken = await mintChildWorkflowExecutorToken({
     env: input.env,
-    baseUrl: resolveRuntimeBaseUrl(input.env, input.body),
+    baseUrl,
     parentExecutorToken,
     parentRunId: input.parentRunId,
     parentPlayName:
@@ -2229,6 +2624,22 @@ async function executeChildInline(input: {
   });
   trace('coordinator.inline_child_token', tokenStartedAt);
 
+  const dbSessionStartedAt = Date.now();
+  const preloadedDbSessions = await preloadChildRuntimeDbSessions({
+    env: input.env,
+    baseUrl,
+    childExecutorToken: childToken,
+    childRunId,
+    childPlayName,
+    manifest,
+    orgId,
+    userEmail:
+      typeof input.body.userEmail === 'string' ? input.body.userEmail : '',
+  });
+  trace('coordinator.inline_child_db_session_preload', dbSessionStartedAt, {
+    sessions: preloadedDbSessions.length,
+  });
+
   const params = buildChildWorkflowParams({
     env: input.env,
     body: input.body,
@@ -2239,6 +2650,10 @@ async function executeChildInline(input: {
     childToken,
     orgId,
     coordinatorUrl: null,
+    runtimeBackend: 'cf_workflows_dynamic_worker_inline_child',
+    dynamicWorkerCode: null,
+    preloadedDbSessions:
+      preloadedDbSessions.length > 0 ? preloadedDbSessions : null,
   });
   const loaderStartedAt = Date.now();
   const stub = loadDynamicPlayWorker(input.env, {
@@ -2630,6 +3045,11 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
         },
       });
     }
+    dispatchedEvent = await hydrateWorkflowDbSessions({
+      env: this.env,
+      event: dispatchedEvent,
+      trace,
+    });
     const dispatchTrace = readWorkflowTraceContext(dispatchedEvent);
     trace({
       runId: dispatchTrace.runId,
@@ -3152,6 +3572,8 @@ async function handleWorkflowRoute(input: {
       });
       const prewarmPromise = env.HARNESS.prewarmPostgresSessions({
         executorToken: params.executorToken,
+        orgId: params.orgId,
+        playName: params.playName,
         sessions: preloadedDbSessions,
       })
         .then((result) => {
@@ -3179,10 +3601,15 @@ async function handleWorkflowRoute(input: {
         });
       input.ctx?.waitUntil(prewarmPromise);
     }
+    const workflowParams = await externalizeWorkflowDbSessions({
+      env,
+      params,
+      recordSubmitTiming,
+    });
     await persistWorkflowRetryState({
       env,
       runId: submittedRunId,
-      params,
+      params: workflowParams,
     });
     let instance: WorkflowInstance | null = null;
     try {
@@ -3202,7 +3629,7 @@ async function handleWorkflowRoute(input: {
       const poolAttemptStartedAt = Date.now();
       instance = await submitViaPooledWorkflow({
         env,
-        params,
+        params: workflowParams,
         recordSubmitTiming,
       });
       recordSubmitTiming({
@@ -3219,7 +3646,7 @@ async function handleWorkflowRoute(input: {
         instance = await createDynamicWorkflowInstance({
           env,
           id: defaultInstanceId,
-          params,
+          params: workflowParams,
         });
         recordSubmitTiming({
           phase: 'coordinator.workflow_create',
@@ -3368,9 +3795,10 @@ async function handleWorkflowRoute(input: {
           { status: 400 },
         );
       }
+      const baseUrl = resolveRuntimeBaseUrl(env, body);
       const childToken = await mintChildWorkflowExecutorToken({
         env,
-        baseUrl: resolveRuntimeBaseUrl(env, body),
+        baseUrl,
         parentExecutorToken,
         parentRunId: runId,
         parentPlayName:
@@ -3381,6 +3809,34 @@ async function handleWorkflowRoute(input: {
         childPlayName,
         maxCreditsPerRun: manifest.maxCreditsPerRun ?? null,
       });
+      const preloadedDbSessions = await preloadChildRuntimeDbSessions({
+        env,
+        baseUrl,
+        childExecutorToken: childToken,
+        childRunId,
+        childPlayName,
+        manifest,
+        orgId,
+        userEmail: typeof body.userEmail === 'string' ? body.userEmail : '',
+      });
+      const params = buildChildWorkflowParams({
+        env,
+        body,
+        manifest,
+        governance,
+        childRunId,
+        childPlayName,
+        childToken,
+        orgId,
+        coordinatorUrl: new URL(request.url).origin,
+        runtimeBackend: 'cf_workflows_dynamic_worker',
+        dynamicWorkerCode:
+          typeof manifest.bundledCode === 'string'
+            ? manifest.bundledCode
+            : null,
+        preloadedDbSessions:
+          preloadedDbSessions.length > 0 ? preloadedDbSessions : null,
+      });
       const submitResponse = await handleWorkflowRoute({
         runId: childRunId,
         action: 'submit',
@@ -3391,55 +3847,7 @@ async function handleWorkflowRoute(input: {
           {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({
-              runId: childRunId,
-              playId: childRunId,
-              playName: childPlayName,
-              artifactStorageKey: manifest.artifactStorageKey,
-              artifactHash: manifest.artifactHash,
-              graphHash: manifest.graphHash,
-              input: isRecord(body.input) ? body.input : {},
-              contractSnapshot: {
-                source: 'published',
-                revisionVersion: null,
-                staticPipeline: manifest.staticPipeline,
-                billingLimit:
-                  typeof manifest.maxCreditsPerRun === 'number'
-                    ? { maxCreditsPerRun: manifest.maxCreditsPerRun }
-                    : null,
-                sourceCode: manifest.sourceCode ?? '',
-                artifactMetadata: {
-                  storageKey: manifest.artifactStorageKey,
-                  artifactHash: manifest.artifactHash,
-                  graphHash: manifest.graphHash,
-                },
-                codeFormat: 'cjs_module',
-                compatibility: {
-                  apiVersion: 2,
-                  runtimeBackend: 'workers_edge',
-                },
-              },
-              executionPlan: null,
-              childPlayManifests: isRecord(body.childPlayManifests)
-                ? (body.childPlayManifests as PlayRuntimeManifestMap)
-                : null,
-              playCallGovernance: governance,
-              dynamicWorkerCode:
-                typeof manifest.bundledCode === 'string'
-                  ? manifest.bundledCode
-                  : null,
-              executorToken: childToken,
-              baseUrl: resolveRuntimeBaseUrl(env, body),
-              orgId,
-              userEmail:
-                typeof body.userEmail === 'string' ? body.userEmail : '',
-              userId: typeof body.userId === 'string' ? body.userId : null,
-              runtimeBackend: 'cf_workflows_dynamic_worker',
-              dedupBackend: 'in_memory',
-              coordinatorUrl: new URL(request.url).origin,
-              coordinatorInternalToken:
-                env.DEEPLINE_INTERNAL_TOKEN?.trim() || null,
-            } satisfies PlayWorkflowParams),
+            body: JSON.stringify(params),
           },
         ),
         env,
@@ -3911,10 +4319,8 @@ function loadDynamicPlayWorkerSync(
       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. May be undefined in dev
-        // environments where the harness Worker isn't running yet, in
-        // which case the per-play stub throws a loud error on first use
-        // (no silent fallbacks — see harness-stub.ts → requireBinding).
+        // 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,
         // In-process runtime API bridge used by the play harness for status,