deepline 0.1.214 → 0.1.216

package/dist/bundling-sources/apps/play-runner-workers/src/child-manifest-resolver.ts

@@ -0,0 +1,108 @@
+import type {
+  PlayRuntimeManifest,
+  PlayRuntimeManifestMap,
+} from '../../../shared_libs/plays/compiler-manifest';
+import { createSingleFlight } from '../../../shared_libs/play-runtime/single-flight';
+
+type ChildManifestResolverInput = {
+  preloaded?: PlayRuntimeManifestMap | null;
+  resolveManifest: (playRef: string) => Promise<PlayRuntimeManifest | null>;
+};
+
+type ChildManifestResolutionState = {
+  resolved: Map<string, PlayRuntimeManifest>;
+  flights: ReturnType<
+    typeof createSingleFlight<string, PlayRuntimeManifest | null>
+  >;
+  lastAccessedAt: number;
+};
+
+const RUN_RESOLUTION_CACHE_TTL_MS = 10 * 60_000;
+const RUN_RESOLUTION_CACHE_MAX_ENTRIES = 128;
+const runResolutionStates = new Map<string, ChildManifestResolutionState>();
+
+function seedPreloadedManifests(
+  resolved: Map<string, PlayRuntimeManifest>,
+  preloaded?: PlayRuntimeManifestMap | null,
+): void {
+  for (const [playRef, manifest] of Object.entries(preloaded ?? {})) {
+    resolved.set(playRef, manifest);
+  }
+}
+
+function createResolutionState(
+  preloaded?: PlayRuntimeManifestMap | null,
+): ChildManifestResolutionState {
+  const resolved = new Map<string, PlayRuntimeManifest>(
+    Object.entries(preloaded ?? {}),
+  );
+  return {
+    resolved,
+    flights: createSingleFlight<string, PlayRuntimeManifest | null>(),
+    lastAccessedAt: Date.now(),
+  };
+}
+
+function resolveWithState(
+  state: ChildManifestResolutionState,
+  input: ChildManifestResolverInput,
+  playRef: string,
+): Promise<PlayRuntimeManifest | null> {
+  state.lastAccessedAt = Date.now();
+  seedPreloadedManifests(state.resolved, input.preloaded);
+  const cached = state.resolved.get(playRef);
+  if (cached) return Promise.resolve(cached);
+
+  return state.flights.run(playRef, async () => {
+    const cachedAfterAdmission = state.resolved.get(playRef);
+    if (cachedAfterAdmission) return cachedAfterAdmission;
+
+    const manifest = await input.resolveManifest(playRef);
+    if (manifest) state.resolved.set(playRef, manifest);
+    return manifest;
+  });
+}
+
+function pruneRunResolutionStates(now: number): void {
+  for (const [scopeKey, state] of runResolutionStates) {
+    if (
+      state.flights.activeCount() === 0 &&
+      now - state.lastAccessedAt >= RUN_RESOLUTION_CACHE_TTL_MS
+    ) {
+      runResolutionStates.delete(scopeKey);
+    }
+  }
+  if (runResolutionStates.size <= RUN_RESOLUTION_CACHE_MAX_ENTRIES) return;
+
+  const evictable = [...runResolutionStates.entries()]
+    .filter(([, state]) => state.flights.activeCount() === 0)
+    .sort((a, b) => a[1].lastAccessedAt - b[1].lastAccessedAt);
+  for (const [scopeKey] of evictable) {
+    if (runResolutionStates.size <= RUN_RESOLUTION_CACHE_MAX_ENTRIES) break;
+    runResolutionStates.delete(scopeKey);
+  }
+}
+
+export function createChildManifestResolver(
+  input: ChildManifestResolverInput,
+): (playRef: string) => Promise<PlayRuntimeManifest | null> {
+  const state = createResolutionState(input.preloaded);
+
+  return (playRef) => resolveWithState(state, input, playRef);
+}
+
+export function createRunScopedChildManifestResolver(
+  input: ChildManifestResolverInput & { scopeKey: string },
+): (playRef: string) => Promise<PlayRuntimeManifest | null> {
+  const now = Date.now();
+  pruneRunResolutionStates(now);
+  let state = runResolutionStates.get(input.scopeKey);
+  if (!state) {
+    state = createResolutionState(input.preloaded);
+    runResolutionStates.set(input.scopeKey, state);
+    pruneRunResolutionStates(now);
+  }
+  state.lastAccessedAt = now;
+
+  return (playRef) => resolveWithState(state, input, playRef);
+}

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

@@ -57,9 +57,13 @@ import {
   PLAY_RUNTIME_CONTRACT_HEADER,
 } from '../../../shared_libs/play-runtime/runtime-contract';
 import {
-  PLAY_RUNTIME_API_COMPAT_PATH,
-  PLAY_RUNTIME_TAIL_LOG_COMPAT_PATH,
+  PLAY_RUNTIME_API_CURRENT_PATH,
+  PLAY_RUNTIME_TAIL_LOG_CURRENT_PATH,
 } from '../../../shared_libs/play-runtime/runtime-api-paths';
+import {
+  executorTokenFromAuthorizationHeader,
+  isCoordinatorRuntimeProxyPath,
+} from './coordinator-runtime-proxy';
 import {
   decideWorkflowPlatformRetry,
   PLATFORM_DEPLOY_WORKFLOW_RETRY_LIMIT,
@@ -1331,7 +1335,7 @@ async function markWorkflowRuntimeFailure(input: {
       } satisfies PlayRunLedgerEvent,
     ],
   });
-  const url = `${baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_COMPAT_PATH}`;
+  const url = `${baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_CURRENT_PATH}`;
   const backoffMs = [200, 500, 1500];
   let lastError: unknown = null;
   for (let attempt = 0; attempt <= backoffMs.length; attempt += 1) {
@@ -1420,7 +1424,7 @@ async function appendWorkflowChildCompletedRunEvent(input: {
       } satisfies PlayRunLedgerEvent,
     ],
   });
-  const url = `${baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_COMPAT_PATH}`;
+  const url = `${baseUrl.replace(/\/$/, '')}${PLAY_RUNTIME_API_CURRENT_PATH}`;
   const response = await fetch(url, { method: 'POST', headers, body });
   if (!response.ok) {
     throw new Error(
@@ -1840,7 +1844,7 @@ async function markRegisteredChildRunFailed(input: {
     contract: PLAY_RUNTIME_CONTRACT,
     executorToken: input.childExecutorToken,
     baseUrl: input.baseUrl,
-    path: PLAY_RUNTIME_API_COMPAT_PATH,
+    path: PLAY_RUNTIME_API_CURRENT_PATH,
     headers: {
       'x-deepline-request-id': crypto.randomUUID(),
       [PLAY_RUNTIME_CONTRACT_HEADER]: String(PLAY_RUNTIME_CONTRACT),
@@ -1897,7 +1901,7 @@ async function appendRegisteredChildRunTerminal(input: {
     contract: PLAY_RUNTIME_CONTRACT,
     executorToken: input.childExecutorToken,
     baseUrl: input.baseUrl,
-    path: PLAY_RUNTIME_API_COMPAT_PATH,
+    path: PLAY_RUNTIME_API_CURRENT_PATH,
     headers: {
       'x-deepline-request-id': crypto.randomUUID(),
       [PLAY_RUNTIME_CONTRACT_HEADER]: String(PLAY_RUNTIME_CONTRACT),
@@ -1979,7 +1983,7 @@ async function callRuntimeApiFromCoordinator(input: {
     contract: PLAY_RUNTIME_CONTRACT,
     executorToken: input.executorToken,
     baseUrl: input.baseUrl,
-    path: PLAY_RUNTIME_API_COMPAT_PATH,
+    path: PLAY_RUNTIME_API_CURRENT_PATH,
     body,
     headers: {
       'x-deepline-request-id': requestId,
@@ -3118,7 +3122,8 @@ async function submitChildWorkflowThroughCoordinator(input: {
  * Workflows serializes the dynamic Worker's `env` map when it persists
  * workflow state. WorkerEntrypoint stubs ARE cloneable.
  *
- * Path allowlist: only `/api/v2/plays/*` and `/api/v2/integrations/*`.
+ * Path allowlist: the current runtime endpoint plus `/api/v2/plays/*` and
+ * `/api/v2/integrations/*`.
  * Anything else is a sandbox-escape attempt and gets a loud 403 — the
  * coordinator must NOT proxy a play's request to internal admin routes
  * even if the play tries to construct such a URL.
@@ -3127,6 +3132,7 @@ export class RuntimeApi extends WorkerEntrypoint<CoordinatorEnv, undefined> {
   async fetch(request: Request): Promise<Response> {
     const incoming = new URL(request.url);
     const allowed =
+      incoming.pathname === PLAY_RUNTIME_API_CURRENT_PATH ||
       incoming.pathname.startsWith('/api/v2/plays/') ||
       incoming.pathname.startsWith('/api/v2/integrations/');
     if (!allowed) {
@@ -3759,6 +3765,62 @@ const coordinatorEntrypoint = {
 
 export default coordinatorEntrypoint;
 
+const COORDINATOR_RUNTIME_PROXY_MAX_BODY_BYTES = 16 * 1024 * 1024;
+
+async function proxyCoordinatorRuntimeApiRequest(input: {
+  request: Request;
+  env: CoordinatorEnv;
+  url: URL;
+}): Promise<Response> {
+  const { request, env, url } = input;
+  if (request.method !== 'GET' && request.method !== 'POST') {
+    return new Response('method not allowed', { status: 405 });
+  }
+  const executorToken = executorTokenFromAuthorizationHeader(
+    request.headers.get('authorization'),
+  );
+  if (!executorToken) {
+    return Response.json(
+      { error: 'Runtime gateway requires a bearer executor token.' },
+      { status: 401 },
+    );
+  }
+  const contentLength = Number(request.headers.get('content-length') ?? '0');
+  if (
+    Number.isFinite(contentLength) &&
+    contentLength > COORDINATOR_RUNTIME_PROXY_MAX_BODY_BYTES
+  ) {
+    return Response.json(
+      { error: 'Runtime gateway request body exceeds the 16 MiB limit.' },
+      { status: 413 },
+    );
+  }
+  let body: unknown = {};
+  if (request.method === 'POST') {
+    try {
+      body = await request.json();
+    } catch {
+      return Response.json(
+        { error: 'Runtime gateway requires a JSON request body.' },
+        { status: 400 },
+      );
+    }
+  }
+  const upstream = await env.HARNESS.runtimeApiCall({
+    contract: PLAY_RUNTIME_CONTRACT,
+    executorToken,
+    method: request.method,
+    path: `${url.pathname}${url.search}`,
+    body,
+    headers: Object.fromEntries(request.headers.entries()),
+  });
+  const headers = new Headers(upstream.headers);
+  // The harness materializes the upstream response body as a string. Let this
+  // Response calculate its own byte length instead of forwarding a stale one.
+  headers.delete('content-length');
+  return new Response(upstream.body, { status: upstream.status, headers });
+}
+
 /**
  * Route dispatcher for the coordinator fetch handler. Extracted as a standalone
  * function so the outer {@link coordinatorEntrypoint.fetch} try/catch backstop
@@ -3787,6 +3849,19 @@ async function coordinatorRouteFetch(
     }
     return new Response('ok', { status: 200, headers });
   }
+  if (isCoordinatorRuntimeProxyPath(url.pathname)) {
+    try {
+      return await proxyCoordinatorRuntimeApiRequest({ request, env, url });
+    } catch (error) {
+      return coordinatorRouteErrorResponse({
+        logTag: '[coordinator.runtime_proxy.error]',
+        code: 'COORDINATOR_RUNTIME_PROXY_FAILED',
+        phase: 'coordinator.runtime_proxy',
+        runId: null,
+        error,
+      });
+    }
+  }
   if (url.pathname === '/internal-token/probe') {
     const authError = authorizeCoordinatorControlRequest({ request, env });
     if (authError) return authError;
@@ -4035,7 +4110,7 @@ async function flushTailRunLogs(
         return;
       }
       await fetch(
-        `${env.DEEPLINE_API_BASE_URL}${PLAY_RUNTIME_TAIL_LOG_COMPAT_PATH}`,
+        `${env.DEEPLINE_API_BASE_URL}${PLAY_RUNTIME_TAIL_LOG_CURRENT_PATH}`,
         {
           method: 'POST',
           headers: {
@@ -5455,7 +5530,7 @@ export class TenantWorkflow extends WorkflowEntrypoint {
     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}", {
+      await this.env.RUNTIME_API.fetch(new Request("https://deepline.runtime.internal${PLAY_RUNTIME_API_CURRENT_PATH}", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: "{}"

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

@@ -0,0 +1,34 @@
+import {
+  PLAY_RUNTIME_API_CURRENT_PATH,
+  PLAY_RUNTIME_CHILD_EXECUTOR_TOKEN_CURRENT_PATH,
+  PLAY_RUNTIME_EGRESS_FETCH_CURRENT_PATH,
+} from '../../../shared_libs/play-runtime/runtime-api-paths';
+
+/**
+ * Paths a credential-isolated Daytona sandbox may send through the
+ * coordinator. The sandbox receives the coordinator as its runtime origin so
+ * it never holds the Vercel protection-bypass credential; the harness owns the
+ * protected upstream hop. Keep this deliberately narrower than the harness
+ * allowlist: a coordinator URL is public, while the harness is a service
+ * binding.
+ */
+export function isCoordinatorRuntimeProxyPath(pathname: string): boolean {
+  return (
+    pathname === PLAY_RUNTIME_API_CURRENT_PATH ||
+    pathname === PLAY_RUNTIME_CHILD_EXECUTOR_TOKEN_CURRENT_PATH ||
+    pathname === PLAY_RUNTIME_EGRESS_FETCH_CURRENT_PATH ||
+    pathname === '/api/v2/plays/run' ||
+    /^\/api\/v2\/plays\/runtime-tools\/[^/]+(?:\/(?:auth-scope|event-wait))?$/.test(
+      pathname,
+    ) ||
+    /^\/api\/v2\/integrations\/[^/]+\/(?:execute|stream)$/.test(pathname)
+  );
+}
+
+export function executorTokenFromAuthorizationHeader(
+  authorization: string | null,
+): string | null {
+  const match = /^Bearer\s+(.+)$/i.exec(authorization?.trim() ?? '');
+  const token = match?.[1]?.trim();
+  return token || null;
+}

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

@@ -67,6 +67,7 @@ import {
   type WorkflowStepLike,
 } from './child-play-await';
 import { submitChildPlayThroughCoordinator } from './child-play-submit';
+import { createRunScopedChildManifestResolver } from './child-manifest-resolver';
 import { isRetryableWorkerRuntimeApiError } from './runtime-api-retry';
 import { formatCustomerConsoleValue } from './runtime/customer-console';
 import {
@@ -184,8 +185,8 @@ import {
   PLAY_RUNTIME_CONTRACT_HEADER,
 } from '../../../shared_libs/play-runtime/runtime-contract';
 import {
-  PLAY_RUNTIME_API_COMPAT_PATH,
-  PLAY_RUNTIME_EGRESS_FETCH_COMPAT_PATH,
+  PLAY_RUNTIME_API_CURRENT_PATH,
+  PLAY_RUNTIME_EGRESS_FETCH_CURRENT_PATH,
 } from '../../../shared_libs/play-runtime/runtime-api-paths';
 import { DYNAMIC_PLAY_WORKER_ARTIFACT_VERSION } from '../../../shared_libs/play-runtime/dynamic-worker-version';
 import {
@@ -859,7 +860,7 @@ async function fetchRuntimeApi(
       ? Math.max(1, Math.ceil(options.timeoutMsOverride))
       : path === '/api/v2/plays/run'
         ? RUNTIME_API_PLAY_RUN_TIMEOUT_MS
-        : path === PLAY_RUNTIME_EGRESS_FETCH_COMPAT_PATH
+        : path === PLAY_RUNTIME_EGRESS_FETCH_CURRENT_PATH
           ? RUNTIME_API_EGRESS_FETCH_TIMEOUT_MS
           : /^\/api\/v2\/integrations\/[^/]+\/execute$/.test(path)
             ? RUNTIME_API_INTEGRATION_EXECUTE_TIMEOUT_MS
@@ -1315,7 +1316,7 @@ async function postRuntimeApi<T>(
     try {
       res = await fetchRuntimeApi(
         baseUrl,
-        PLAY_RUNTIME_API_COMPAT_PATH,
+        PLAY_RUNTIME_API_CURRENT_PATH,
         {
           method: 'POST',
           headers: {
@@ -1619,15 +1620,7 @@ type RuntimeResolvedPlayResponse = {
 async function resolveAuthorizedWorkerChildManifest(input: {
   req: RunRequest;
   playRef: string;
-  cache: Map<string, PlayRuntimeManifest>;
 }): Promise<PlayRuntimeManifest | null> {
-  const cached = input.cache.get(input.playRef);
-  if (cached) return cached;
-  const preloaded = input.req.childPlayManifests?.[input.playRef];
-  if (preloaded) {
-    input.cache.set(input.playRef, preloaded);
-    return preloaded;
-  }
   const response = await postRuntimeApi<RuntimeResolvedPlayResponse>(
     input.req.baseUrl,
     input.req.executorToken,
@@ -1641,11 +1634,7 @@ async function resolveAuthorizedWorkerChildManifest(input: {
       timeoutMsOverride: 30_000,
     },
   );
-  const manifest = response.manifest ?? null;
-  if (manifest) {
-    input.cache.set(input.playRef, manifest);
-  }
-  return manifest;
+  return response.manifest ?? null;
 }
 
 async function childPlayEventKey(input: {
@@ -2497,6 +2486,10 @@ function deserializeDurableStepValue<T>(value: T, depth = 0): T {
   ) as T;
 }
 
+function decodeLegacyWorkflowStepCheckpoint<T>(checkpoint: unknown): T {
+  return deserializeDurableStepValue(checkpoint) as T;
+}
+
 type WorkerStepResolver = (
   row: Record<string, unknown>,
   ctx: unknown,
@@ -2897,7 +2890,7 @@ async function postRuntimeEgressFetch(
   ) {
     const response = await fetchRuntimeApi(
       req.baseUrl,
-      PLAY_RUNTIME_EGRESS_FETCH_COMPAT_PATH,
+      PLAY_RUNTIME_EGRESS_FETCH_CURRENT_PATH,
       {
         method: 'POST',
         headers: {
@@ -4258,14 +4251,19 @@ function createMinimalWorkerCtx(
   // lineage snapshot are owned by the Governor (createGovernorForRun above).
   // The worker keeps only substrate mechanism here.
   const stepCallCounts: Record<string, number> = {};
-  const childManifestCache = new Map<string, PlayRuntimeManifest>();
+  const resolveChildManifest = createRunScopedChildManifestResolver({
+    scopeKey: `${req.orgId}:${req.runId}:${req.runAttempt}`,
+    preloaded: req.childPlayManifests,
+    resolveManifest: (playRef) =>
+      resolveAuthorizedWorkerChildManifest({ req, playRef }),
+  });
   const secretRedactor = createSecretRedactionContext();
 
   const resolveSecretAuth = async (auth?: SecretAuth) => {
     if (!auth) return {};
     const response = await fetchRuntimeApi(
       req.baseUrl,
-      PLAY_RUNTIME_API_COMPAT_PATH,
+      PLAY_RUNTIME_API_CURRENT_PATH,
       {
         method: 'POST',
         headers: {
@@ -4375,22 +4373,42 @@ function createMinimalWorkerCtx(
     });
     return deserializeDurableStepValue(serialized) as T;
   };
-  const executeWithWorkflowStep = async <T>(
+  const executeWithDurableStepReceipt = async <T>(
     name: string,
     execute: () => Promise<T> | T,
   ): Promise<T> => {
     if (!workflowStep) {
       return await executeWithRuntimeReceipt(name, execute);
     }
-    return await executeWithRuntimeReceipt(name, async () => {
-      const serialized = await (
-        workflowStep.do as unknown as (
-          name: string,
-          callback: () => Promise<unknown>,
-        ) => Promise<unknown>
-      )(name, async () => serializeDurableStepValue(await execute()));
-      return deserializeDurableStepValue(serialized) as T;
+    let liveValue: T | undefined;
+    let executedLive = false;
+    const checkpoint = await (
+      workflowStep.do as unknown as (
+        name: string,
+        callback: () => Promise<{ receiptCompleted: true }>,
+      ) => Promise<unknown>
+    )(name, async () => {
+      liveValue = await executeWithRuntimeReceipt(name, execute);
+      executedLive = true;
+      return { receiptCompleted: true };
     });
+    if (executedLive) return liveValue as T;
+    if (
+      checkpoint !== null &&
+      typeof checkpoint === 'object' &&
+      !Array.isArray(checkpoint) &&
+      (checkpoint as { receiptCompleted?: unknown }).receiptCompleted === true
+    ) {
+      return await executeWithRuntimeReceipt(name, () => {
+        throw new Error(
+          `Workflow step ${name} replayed without its completed runtime receipt.`,
+        );
+      });
+    }
+    // Runs started before runtime contract 3 checkpointed the full serialized
+    // value in Cloudflare Workflow. Accept that legacy value only on replay;
+    // new executions above always persist the compact receipt marker.
+    return decodeLegacyWorkflowStepCheckpoint<T>(checkpoint);
   };
   const nextCtxStepReceiptKey = (
     name: string,
@@ -6694,7 +6712,7 @@ function createMinimalWorkerCtx(
       if (!normalizedName) {
         throw new Error('ctx.step(name, callback) requires a name.');
       }
-      return await executeWithWorkflowStep(
+      return await executeWithDurableStepReceipt(
         nextCtxStepReceiptKey(normalizedName, options?.staleAfterSeconds),
         callback,
       );
@@ -6914,11 +6932,7 @@ function createMinimalWorkerCtx(
       if (!resolvedName) {
         throw new Error('ctx.runPlay(...) requires a resolvable play name.');
       }
-      const childManifest = await resolveAuthorizedWorkerChildManifest({
-        req,
-        playRef: resolvedName,
-        cache: childManifestCache,
-      });
+      const childManifest = await resolveChildManifest(resolvedName);
       const rowScope = workerRunPlayRowContext.getStore();
       const invocationScope = buildDurableRunPlayInvocationScope({
         childPlayName: resolvedName,
@@ -8928,7 +8942,7 @@ export class TenantWorkflow extends WorkflowEntrypoint<
         try {
           const response = await fetchRuntimeApi(
             req.baseUrl,
-            PLAY_RUNTIME_API_COMPAT_PATH,
+            PLAY_RUNTIME_API_CURRENT_PATH,
             {
               method: 'POST',
               headers: {

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/harness-receipt-store.ts

@@ -11,6 +11,7 @@ import {
   harnessReleaseRuntimeReceipt,
 } from '../../../../sdk/src/plays/harness-stub';
 import type { PreloadedRuntimeDbSessionInput } from '../../../play-harness-worker/src/rpc-types';
+import { PLAY_RUNTIME_CONTRACT } from '../../../../shared_libs/play-runtime/runtime-contract';
 import type { WorkerRuntimeReceiptStore } from './receipts';
 
 const RUNTIME_TEST_FAULT_NAMES = new Set([
@@ -79,6 +80,7 @@ export function createHarnessWorkerReceiptStore(input: {
       ? Math.max(0, Math.floor(input.runAttempt))
       : null;
   const runAttemptField = runAttempt == null ? {} : { runAttempt };
+  const runtimeContractField = { contract: PLAY_RUNTIME_CONTRACT };
   const leaseTtlField =
     typeof input.receiptLeaseTtlMs === 'number' &&
     Number.isFinite(input.receiptLeaseTtlMs) &&
@@ -92,6 +94,7 @@ export function createHarnessWorkerReceiptStore(input: {
     getReceipt(command) {
       return harnessGetRuntimeReceipt({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -104,6 +107,7 @@ export function createHarnessWorkerReceiptStore(input: {
     claimReceipt(command) {
       return harnessClaimRuntimeReceipt({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -116,6 +120,7 @@ export function createHarnessWorkerReceiptStore(input: {
     claimReceipts(command) {
       return harnessClaimRuntimeReceipts({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -128,6 +133,7 @@ export function createHarnessWorkerReceiptStore(input: {
     markReceiptsRunning(command) {
       return harnessMarkRuntimeReceiptsRunning({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -143,6 +149,7 @@ export function createHarnessWorkerReceiptStore(input: {
     completeReceipt(command) {
       return harnessCompleteRuntimeReceipt({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -154,6 +161,7 @@ export function createHarnessWorkerReceiptStore(input: {
     completeReceipts(command) {
       return harnessCompleteRuntimeReceipts({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -168,6 +176,7 @@ export function createHarnessWorkerReceiptStore(input: {
     failReceipt(command) {
       return harnessFailRuntimeReceipt({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -179,6 +188,7 @@ export function createHarnessWorkerReceiptStore(input: {
     releaseReceipt(command) {
       return harnessReleaseRuntimeReceipt({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -190,6 +200,7 @@ export function createHarnessWorkerReceiptStore(input: {
     failReceipts(command) {
       return harnessFailRuntimeReceipts({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,
@@ -204,6 +215,7 @@ export function createHarnessWorkerReceiptStore(input: {
     heartbeatReceipts(command) {
       return harnessHeartbeatRuntimeReceipts({
         executorToken: input.executorToken,
+        ...runtimeContractField,
         orgId: input.orgId,
         preloadedDbSessions: input.preloadedDbSessions ?? null,
         userEmail: input.userEmail ?? null,

package/dist/bundling-sources/apps/play-runner-workers/src/workflow-retry.ts

@@ -19,6 +19,9 @@ function workflowRetryReasonForFailure(failure: {
   code: string;
   cause?: string;
 }): string {
+  if (failure.code === 'PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED') {
+    return 'cloudflare_workflow_endpoint_unavailable';
+  }
   if (failure.code === 'PLATFORM_WORKER_SUBREQUEST_INTERRUPTED') {
     return 'cloudflare_worker_subrequest_limit';
   }
@@ -51,6 +54,7 @@ export function decideWorkflowPlatformRetry(input: {
   const failure = normalizePlayRunFailure(input.error);
   const retryablePlatformReset =
     failure.code === 'PLATFORM_DEPLOY_INTERRUPTED' ||
+    failure.code === 'PLATFORM_WORKFLOW_ENDPOINT_INTERRUPTED' ||
     failure.code === 'PLATFORM_WORKER_SUBREQUEST_INTERRUPTED';
   if (
     retryablePlatformReset &&

package/dist/bundling-sources/sdk/src/client.ts

@@ -1563,8 +1563,7 @@ export class DeeplineClient {
           ? { waitForCompletionMs: request.waitForCompletionMs }
           : {}),
         // Profile selection is the API's job, not the CLI's. The server
-        // defaults to absurd; callers that need workers_edge pass
-        // `request.profile` explicitly.
+        // defaults to absurd; callers normally omit this field.
         ...(request.profile ? { profile: request.profile } : {}),
         ...(integrationMode ? { integrationMode } : {}),
         ...(testPolicyOverrides ? { testPolicyOverrides } : {}),

package/dist/bundling-sources/sdk/src/release.ts

@@ -106,10 +106,10 @@ export const SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: '0.1.214',
+  version: '0.1.216',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.214',
+    latest: '0.1.216',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/sdk/src/types.ts

@@ -1138,9 +1138,8 @@ export interface StartPlayRunRequest {
   /** Optionally let the start request wait briefly and return a terminal result. */
   waitForCompletionMs?: number;
   /**
-   * Per-run execution profile override. The server defaults to absurd;
-   * callers that need workers_edge can pass it here. Most callers should leave
-   * this unset.
+   * Per-run execution profile override. The server defaults to absurd. The
+   * workers_edge profile is disabled; most callers should leave this unset.
    */
   profile?: string;
   /** Optional per-run provider execution mode for eval/smoke runs. */