deepline 0.1.47 → 0.1.49

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

@@ -18,12 +18,12 @@
  *     bundled into the Worker script.
  *   - Workers don't have node:fs / source-map-support. Stack traces are raw.
  *   - Direct postgres (`pg` library) won't bundle for Workers. This harness
- *     uses HTTP-only ctx — every ctx.csv / ctx.tool / row write goes through
+ *     uses HTTP-only ctx — every ctx.csv / ctx.tools.execute / row write goes through
  *     the runtime API endpoint, not direct DB. That keeps the Worker bundle
  *     compatible with the V8 isolate runtime.
  *
  * Status: experimental. First cut targets tool-basic (ctx.csv + ctx.map +
- * ctx.tool). Plays that depend on the full ctx surface (durable sleep,
+ * ctx.tools.execute). Plays that depend on the full ctx surface (durable sleep,
  * checkpoints, batched waterfalls, etc.) will fall back to "not implemented"
  * rather than producing wrong results — opt-in via DEEPLINE_PLAY_RUNNER_BACKEND.
  */
@@ -217,7 +217,10 @@ function getStringField(value: unknown, key: string): string | null {
   return typeof field === 'string' && field.trim() ? field : null;
 }
 
-function getObjectField(value: unknown, key: string): Record<string, unknown> | null {
+function getObjectField(
+  value: unknown,
+  key: string,
+): Record<string, unknown> | null {
   if (!isRecord(value)) return null;
   const field = value[key];
   return isRecord(field) ? field : null;
@@ -269,10 +272,12 @@ function normalizeToolHttpErrorMessage(input: {
   const billing = getObjectField(parsed, 'billing');
   if (isInsufficientCreditsBilling(billing)) {
     return new ToolHttpError(
-      `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: ${formatInsufficientCreditsMessage({
-        billing,
-        toolId: input.toolId,
-      })}`,
+      `tool ${input.toolId} ${input.status} attempt ${input.attempt}/${input.maxAttempts}: ${formatInsufficientCreditsMessage(
+        {
+          billing,
+          toolId: input.toolId,
+        },
+      )}`,
       billing,
     );
   }
@@ -451,7 +456,10 @@ async function probeHarnessOnce(
  */
 const RUNTIME_API_TIMEOUT_MS = 30_000;
 const RUNTIME_API_PLAY_RUN_TIMEOUT_MS = 75_000;
-const RUNTIME_API_RETRY_DELAYS_MS = [250, 750, 1500, 3000, 5000, 10000] as const;
+const RUNTIME_API_INTEGRATION_EXECUTE_TIMEOUT_MS = 180_000;
+const RUNTIME_API_RETRY_DELAYS_MS = [
+  250, 750, 1500, 3000, 5000, 10000,
+] as const;
 let loggedMissingRuntimeApiBinding = false;
 
 async function fetchRuntimeApi(
@@ -462,6 +470,8 @@ async function fetchRuntimeApi(
   const timeoutMs =
     path === '/api/v2/plays/run'
       ? RUNTIME_API_PLAY_RUN_TIMEOUT_MS
+      : /^\/api\/v2\/integrations\/[^/]+\/execute$/.test(path)
+        ? RUNTIME_API_INTEGRATION_EXECUTE_TIMEOUT_MS
       : RUNTIME_API_TIMEOUT_MS;
   const controller = new AbortController();
   let timeout: ReturnType<typeof setTimeout> | null = null;
@@ -496,7 +506,21 @@ async function fetchRuntimeApi(
     const responsePromise = cachedRuntimeApiBinding.fetch(
       new Request(`${baseUrl.replace(/\/$/, '')}${path}`, mergedInit),
     );
-    return await Promise.race([responsePromise, timeoutPromise]);
+    const response = await Promise.race([responsePromise, timeoutPromise]);
+    if (await shouldFallbackRuntimeApiBindingResponse(response)) {
+      console.warn(
+        `[play-harness] RUNTIME_API binding returned coordinator not found; using public runtime API transport. path=${path}`,
+      );
+      return await Promise.race([
+        fetch(`${baseUrl.replace(/\/$/, '')}${path}`, {
+          ...init,
+          headers: runtimeApiHeaders(init.headers, true),
+          signal: controller.signal,
+        }),
+        timeoutPromise,
+      ]);
+    }
+    return response;
   } catch (err) {
     if (err instanceof Error && err.name === 'AbortError') {
       throw new Error(
@@ -509,6 +533,19 @@ async function fetchRuntimeApi(
   }
 }
 
+async function shouldFallbackRuntimeApiBindingResponse(
+  response: Response,
+): Promise<boolean> {
+  if (response.status !== 404) {
+    return false;
+  }
+  const body = await response
+    .clone()
+    .text()
+    .catch(() => '');
+  return body.trim().toLowerCase() === 'not found';
+}
+
 function runtimeApiHeaders(
   headers: HeadersInit | undefined,
   includeVercelBypass: boolean,
@@ -922,18 +959,20 @@ function extractChildPlayOutput(status: Record<string, unknown>): unknown {
   return result ?? null;
 }
 
-function hashChildPlayEventKey(input: string): string {
-  let hash = 2166136261;
-  for (let index = 0; index < input.length; index += 1) {
-    hash ^= input.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
+async function hashChildPlayEventKey(input: unknown): Promise<string> {
+  return (await hashJson(input)).slice(0, 32);
 }
 
-function childPlayEventKey(input: { key: string; workflowId: string }): string {
+async function childPlayEventKey(input: {
+  key: string;
+  workflowId: string;
+}): Promise<string> {
   const readableKey = workflowEventType(input.key).slice(0, 40);
-  return `child_play_${hashChildPlayEventKey(`${input.key}:${input.workflowId}`)}_${readableKey}`;
+  const digest = await hashChildPlayEventKey({
+    key: input.key,
+    workflowId: input.workflowId,
+  });
+  return `child_play_${digest}_${readableKey}`;
 }
 
 function workflowTimeoutFromMs(timeoutMs: number): string {
@@ -954,7 +993,7 @@ async function waitForChildPlayTerminalEvent(input: {
       'ctx.runPlay child waits require the cf-workflows runtime event scheduler.',
     );
   }
-  const eventKey = childPlayEventKey({
+  const eventKey = await childPlayEventKey({
     key: input.key,
     workflowId: input.workflowId,
   });
@@ -989,7 +1028,7 @@ async function signalParentPlayTerminal(input: {
 }): Promise<void> {
   const governance = input.req.playCallGovernance;
   if (!governance?.parentRunId || !governance.key) return;
-  const eventKey = childPlayEventKey({
+  const eventKey = await childPlayEventKey({
     key: governance.key,
     workflowId: input.req.runId,
   });
@@ -1098,9 +1137,12 @@ function isToolExecuteRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-function normalizeToolExecuteArgs(
-  request: unknown,
-): { id: string; toolId: string; input: Record<string, unknown> } {
+function normalizeToolExecuteArgs(request: unknown): {
+  id: string;
+  toolId: string;
+  input: Record<string, unknown>;
+  staleAfterSeconds?: number;
+} {
   if (!isToolExecuteRecord(request)) {
     throw new Error(
       'ctx.tools.execute requires a request object: ctx.tools.execute({ id, tool, input, description }).',
@@ -1117,7 +1159,14 @@ function normalizeToolExecuteArgs(
       'ctx.tools.execute({ id, tool, input }) requires a non-empty id, tool string, and input object.',
     );
   }
-  return { id: request.id.trim(), toolId: request.tool, input: request.input };
+  return {
+    id: request.id.trim(),
+    toolId: request.tool,
+    input: request.input,
+    ...(typeof request.staleAfterSeconds === 'number'
+      ? { staleAfterSeconds: request.staleAfterSeconds }
+      : {}),
+  };
 }
 
 function integrationEventType(eventKey: string): string {
@@ -1329,7 +1378,11 @@ function parseExtractorMetadata(
   }
   const entries = Object.entries(value as Record<string, unknown>).flatMap(
     ([key, descriptor]) => {
-      if (!descriptor || typeof descriptor !== 'object' || Array.isArray(descriptor)) {
+      if (
+        !descriptor ||
+        typeof descriptor !== 'object' ||
+        Array.isArray(descriptor)
+      ) {
         return [];
       }
       const record = descriptor as Record<string, unknown>;
@@ -1630,17 +1683,14 @@ type WorkerInlineWaterfallSpec = {
           input: Record<string, unknown>,
           ctx: {
             tools: {
-              execute(
-                key: string,
-                toolId: string,
-                input: Record<string, unknown>,
-              ): Promise<unknown>;
+              execute(request: {
+                id: string;
+                tool: string;
+                input: Record<string, unknown>;
+                description?: string;
+                staleAfterSeconds?: number;
+              }): Promise<unknown>;
             };
-            tool(
-              key: string,
-              toolId: string,
-              input: Record<string, unknown>,
-            ): Promise<unknown>;
           },
         ) => unknown | Promise<unknown>;
       }
@@ -1907,6 +1957,14 @@ function extractWorkerInlineCodeStepValue(
   return result ?? null;
 }
 
+function isCompletedWorkerFieldValue(value: unknown): boolean {
+  return (
+    value !== null &&
+    value !== undefined &&
+    !(typeof value === 'string' && value.length === 0)
+  );
+}
+
 type WorkerMapChunkSummary<T extends Record<string, unknown>> = {
   chunkIndex: number;
   rangeStart: number;
@@ -1929,7 +1987,9 @@ function serializeDurableStepValue<T>(value: T, depth = 0): T {
   if (isToolExecuteResult(value)) return serializeToolExecuteResult(value) as T;
   if (isDatasetHandle(value)) return serializeValue(value, depth) as T;
   if (Array.isArray(value)) {
-    return value.map((entry) => serializeDurableStepValue(entry, depth + 1)) as T;
+    return value.map((entry) =>
+      serializeDurableStepValue(entry, depth + 1),
+    ) as T;
   }
   if (typeof value !== 'object') return value;
   return Object.fromEntries(
@@ -2087,9 +2147,9 @@ async function executeWorkerStepProgram(
         recorder
           ? {
               ...recorder,
-            path: stepPath,
-          }
-        : undefined,
+              path: stepPath,
+            }
+          : undefined,
       );
       return {
         value: serializeDurableStepValue(resolution.value),
@@ -2160,13 +2220,6 @@ async function executeWorkerWaterfall(
                   callbacks,
                 ),
             },
-            tool: async (key, toolId, toolInput) =>
-              await executeToolWithLifecycle(
-                req,
-                { id: key, toolId, input: toolInput },
-                workflowStep,
-                callbacks,
-              ),
           });
         } else {
           result = await executeToolWithLifecycle(
@@ -2884,25 +2937,32 @@ function augmentSheetContractWithDatasetFields(input: {
     input.contract.columns.map((column) => column.sqlName),
   );
   const columns = [...input.contract.columns];
+  const candidateFields = new Set<string>();
   for (const row of input.rows) {
     for (const field of Object.keys(row)) {
-      if (!isDatasetPayloadField(field) || existingFields.has(field)) {
-        continue;
-      }
-      const sqlName = sqlSafePlayColumnName(field);
-      if (existingSqlNames.has(sqlName)) {
-        continue;
-      }
-      existingFields.add(field);
-      existingSqlNames.add(sqlName);
-      columns.push({
-        id: `runtime:${input.contract.tableNamespace}:${field}`,
-        sqlName,
-        source: outputFields.has(field) ? 'mapField' : 'input',
-        field,
-      });
+      candidateFields.add(field);
     }
   }
+  for (const field of outputFields) {
+    candidateFields.add(field);
+  }
+  for (const field of candidateFields) {
+    if (!isDatasetPayloadField(field) || existingFields.has(field)) {
+      continue;
+    }
+    const sqlName = sqlSafePlayColumnName(field);
+    if (existingSqlNames.has(sqlName)) {
+      continue;
+    }
+    existingFields.add(field);
+    existingSqlNames.add(sqlName);
+    columns.push({
+      id: `runtime:${input.contract.tableNamespace}:${field}`,
+      sqlName,
+      source: outputFields.has(field) ? 'mapField' : 'input',
+      field,
+    });
+  }
   return { ...input.contract, columns };
 }
 
@@ -2942,6 +3002,7 @@ async function prepareMapRows(input: {
   req: RunRequest;
   tableNamespace: string;
   rows: Record<string, unknown>[];
+  outputFields: string[];
 }): Promise<{
   inserted: number;
   skipped: number;
@@ -2960,6 +3021,7 @@ async function prepareMapRows(input: {
     sheetContract: augmentSheetContractWithDatasetFields({
       contract: requireSheetContract(input.req, input.tableNamespace),
       rows: input.rows,
+      outputFields: input.outputFields,
     }),
     rows: input.rows.map((row) => ({ ...row })),
     runId: input.req.runId,
@@ -3003,7 +3065,7 @@ async function prepareMapRows(input: {
  *   - ctx.log(msg)
  *   - ctx.csv(filename | inline rows)  (calls runtime API for file resolve)
  *   - ctx.map(name, rows, fields, opts)
- *   - ctx.tools.execute(namespace, op, input, opts)
+ *   - ctx.tools.execute({ id, tool, input, ... })
  *   - ctx.runPlay(key, playRef, input, opts)
  *
  * Not supported (will throw):
@@ -3128,16 +3190,32 @@ function createMinimalWorkerCtx(
   const executeWithRuntimeReceipt = async <T>(
     key: string,
     execute: () => Promise<T> | T,
-  ): Promise<T> =>
-    runWorkerRuntimeReceiptBoundary({
+  ): Promise<T> => {
+    const serialized = await runWorkerRuntimeReceiptBoundary<unknown>({
       baseUrl: req.baseUrl,
       executorToken: req.executorToken,
+      orgId: req.orgId,
       playName: req.playName,
       runId: req.runId,
       key,
       postRuntimeApi,
-      execute,
+      execute: async () => serializeDurableStepValue(await execute()),
     });
+    return deserializeDurableStepValue(serialized) as T;
+  };
+  const staleRuntimeSuffix = (staleAfterSeconds?: number): string => {
+    if (staleAfterSeconds === undefined) return '';
+    if (
+      !Number.isFinite(staleAfterSeconds) ||
+      !Number.isInteger(staleAfterSeconds) ||
+      staleAfterSeconds <= 0
+    ) {
+      throw new Error(
+        'staleAfterSeconds must be a positive whole number of seconds.',
+      );
+    }
+    return `:stale:${staleAfterSeconds}:${Math.floor(nowMs() / (staleAfterSeconds * 1000))}`;
+  };
   // Local ancestry chain that always ENDS with the currently-executing play
   // (req.playName). The /api/v2/plays/run lineage validator requires the
   // submitted ancestry's tail to equal the executor token's play name (i.e.
@@ -3253,7 +3331,6 @@ function createMinimalWorkerCtx(
           : JSON.stringify(normalizedParts);
       return keyValue;
     };
-    const mapLogicFingerprint = req.graphHash ?? null;
     const resolveRowKey = (
       row: Record<string, unknown>,
       index: number,
@@ -3261,12 +3338,8 @@ function createMinimalWorkerCtx(
       const inputRow = publicCsvInputRow(row);
       const explicitKeyValue = resolveExplicitKeyValue(row, index);
       return explicitKeyValue == null
-        ? derivePlayRowIdentity(inputRow, name, mapLogicFingerprint)
-        : derivePlayRowIdentityFromKey(
-            explicitKeyValue,
-            name,
-            mapLogicFingerprint,
-          );
+        ? derivePlayRowIdentity(inputRow, name)
+        : derivePlayRowIdentityFromKey(explicitKeyValue, name);
     };
     const assertUniqueExplicitRowKeys = (
       chunkRows: readonly Record<string, unknown>[],
@@ -3311,6 +3384,7 @@ function createMinimalWorkerCtx(
       const prepared = await prepareMapRows({
         req,
         tableNamespace: name,
+        outputFields,
         rows: chunkEntries.map(({ row, rowKey }) => ({
           ...row,
           __deeplineRowKey: rowKey,
@@ -3331,19 +3405,17 @@ function createMinimalWorkerCtx(
         },
       });
       const pendingKeys = new Set<string>();
+      const pendingRowsByKey = new Map<string, Record<string, unknown>>();
       const completedKeys = new Set<string>();
       const preparedKeys = new Set<string>();
       for (const row of prepared.pendingRows) {
         const key =
           typeof row.__deeplineRowKey === 'string'
             ? row.__deeplineRowKey
-            : derivePlayRowIdentity(
-                publicCsvInputRow(row),
-                name,
-                mapLogicFingerprint,
-              );
+            : derivePlayRowIdentity(publicCsvInputRow(row), name);
         if (key) {
           pendingKeys.add(key);
+          pendingRowsByKey.set(key, row);
           preparedKeys.add(key);
         }
       }
@@ -3351,11 +3423,7 @@ function createMinimalWorkerCtx(
         const key =
           typeof row.__deeplineRowKey === 'string'
             ? row.__deeplineRowKey
-            : derivePlayRowIdentity(
-                publicCsvInputRow(row),
-                name,
-                mapLogicFingerprint,
-              );
+            : derivePlayRowIdentity(publicCsvInputRow(row), name);
         if (key) {
           completedKeys.add(key);
           preparedKeys.add(key);
@@ -3388,7 +3456,16 @@ function createMinimalWorkerCtx(
         rowsToExecute.length,
       );
       const executedCellMetaPatches: Array<
-        Record<string, { status: 'skipped'; stage?: string | null }> | undefined
+        | Record<
+            string,
+            {
+              status: 'cached' | 'skipped';
+              stage?: string | null;
+              reused?: boolean;
+              runId?: string;
+            }
+          >
+        | undefined
       > = new Array(rowsToExecute.length);
       const toolBatchScheduler = new WorkerToolBatchScheduler(req);
       const generatedOutputFields = new Set<string>();
@@ -3402,31 +3479,28 @@ function createMinimalWorkerCtx(
               const myIndex = idx++;
               if (myIndex >= rowsToExecute.length) return;
               const entry = uniqueRowsToExecuteEntries[myIndex]!;
-              const row = entry.row;
+              const row = pendingRowsByKey.has(entry.rowKey)
+                ? ({
+                    ...entry.row,
+                    ...publicCsvInputRow(pendingRowsByKey.get(entry.rowKey)!),
+                  } as T & Record<string, unknown>)
+                : entry.row;
               const absoluteIndex = entry.absoluteIndex;
               const enriched: Record<string, unknown> = cloneCsvAliasedRow(row);
               const fieldOutputs: Record<string, unknown> = {};
               const cellMetaPatch: Record<
                 string,
-                { status: 'skipped'; stage?: string | null }
+                {
+                  status: 'cached' | 'skipped';
+                  stage?: string | null;
+                  reused?: boolean;
+                  runId?: string;
+                }
               > = {};
               const waterfallOutputs: RecordedWaterfallOutput[] = [];
               const stepProgramOutputs: RecordedStepProgramOutput[] = [];
               const rowCtx = {
                 ...(ctx as Record<string, unknown>),
-                tool: async (
-                  key: string,
-                  toolId: string,
-                  input: Record<string, unknown>,
-                ): Promise<unknown> => {
-                  assertNotAborted(abortSignal);
-                  return await toolBatchScheduler.execute(
-                    key,
-                    toolId,
-                    input,
-                    workflowStep,
-                  );
-                },
                 tools: {
                   ...((ctx as { tools?: Record<string, unknown> }).tools ?? {}),
                   execute: async (requestArg: unknown): Promise<unknown> => {
@@ -3456,6 +3530,15 @@ function createMinimalWorkerCtx(
                   ),
               };
               for (const [key, value] of fieldEntries) {
+                if (isCompletedWorkerFieldValue(enriched[key])) {
+                  cellMetaPatch[key] = {
+                    status: 'cached',
+                    stage: key,
+                    reused: true,
+                    runId: req.runId,
+                  };
+                  continue;
+                }
                 const resolved = await executeWorkerStepResolver(
                   value,
                   enriched,
@@ -3472,7 +3555,11 @@ function createMinimalWorkerCtx(
                 enriched[key] = resolved.value;
                 fieldOutputs[key] = resolved.value;
                 if (resolved.status === 'skipped') {
-                  cellMetaPatch[key] = { status: 'skipped', stage: key };
+                  cellMetaPatch[key] = {
+                    status: 'skipped',
+                    stage: key,
+                    runId: req.runId,
+                  };
                 }
               }
               for (const stepOutput of stepProgramOutputs) {
@@ -3483,6 +3570,7 @@ function createMinimalWorkerCtx(
                   cellMetaPatch[stepOutput.columnName] = {
                     status: 'skipped',
                     stage: stepOutput.stepId,
+                    runId: req.runId,
                   };
                 }
               }
@@ -3602,11 +3690,7 @@ function createMinimalWorkerCtx(
         const key =
           typeof completedRow.__deeplineRowKey === 'string'
             ? completedRow.__deeplineRowKey
-            : derivePlayRowIdentity(
-                publicCsvInputRow(completedRow),
-                name,
-                mapLogicFingerprint,
-              );
+            : derivePlayRowIdentity(publicCsvInputRow(completedRow), name);
         if (key) {
           const { __deeplineRowKey: _rowKey, ...cleanedRow } =
             publicCsvInputRow(completedRow);
@@ -3866,7 +3950,11 @@ function createMinimalWorkerCtx(
         ts: nowMs(),
       });
     },
-    async step<T>(name: string, callback: () => Promise<T> | T): Promise<T> {
+    async step<T>(
+      name: string,
+      callback: () => Promise<T> | T,
+      options?: { staleAfterSeconds?: number },
+    ): Promise<T> {
       assertNotAborted(abortSignal);
       const normalizedName = name.trim();
       if (!normalizedName) {
@@ -3875,7 +3963,10 @@ function createMinimalWorkerCtx(
       // Static pipeline JS blocks are already Workflow steps in the Workers
       // backend. Nesting another `step.do` here can leave preview runs parked
       // inside the JS stage before they reach subsequent event waits.
-      return await executeWithRuntimeReceipt(`step:${normalizedName}`, callback);
+      return await executeWithRuntimeReceipt(
+        `step:${normalizedName}${staleRuntimeSuffix(options?.staleAfterSeconds)}`,
+        callback,
+      );
     },
     async runSteps<T>(
       program: WorkerStepProgram,
@@ -4032,39 +4123,16 @@ function createMinimalWorkerCtx(
         'ctx.map(key, rows, fields, options) was removed. Use ctx.map(key, rows).step(...).run(options).',
       );
     },
-    tool: async (
-      key: string,
-      toolId: string,
-      input: Record<string, unknown>,
-    ): Promise<unknown> => {
-      assertNotAborted(abortSignal);
-      return await executeWithRuntimeReceipt(
-        deriveToolRequestIdentity({ toolId, requestInput: input }),
-        () =>
-          executeToolWithLifecycle(
-            req,
-            { id: key, toolId, input },
-            workflowStep,
-            callbacks,
-          ),
-      );
-    },
     tools: {
       async execute(requestArg: unknown): Promise<unknown> {
         assertNotAborted(abortSignal);
         const request = normalizeToolExecuteArgs(requestArg);
         return await executeWithRuntimeReceipt(
-          deriveToolRequestIdentity({
+          `tool:${request.id}:${deriveToolRequestIdentity({
             toolId: request.toolId,
             requestInput: request.input,
-          }),
-          () =>
-            executeToolWithLifecycle(
-              req,
-              request,
-              workflowStep,
-              callbacks,
-            ),
+          })}${staleRuntimeSuffix(request.staleAfterSeconds)}`,
+          () => executeToolWithLifecycle(req, request, workflowStep, callbacks),
         );
       },
     },
@@ -4123,13 +4191,21 @@ function createMinimalWorkerCtx(
       key: string,
       playRef: string | { playName?: string; name?: string },
       input: Record<string, unknown>,
-      options?: { description?: string; timeoutMs?: number },
+      options?: {
+        description?: string;
+        timeoutMs?: number;
+        staleAfterSeconds?: number;
+      },
     ): Promise<unknown> {
       const normalizedKey = normalizeContextKey(key, 'runPlay');
       const resolvedName = resolvePlayRefName(playRef);
       if (!resolvedName) {
         throw new Error('ctx.runPlay(...) requires a resolvable play name.');
       }
+      const receiptKey = `runPlay:${normalizedKey}:${await hashJson({
+        childPlayName: resolvedName,
+        input,
+      })}${staleRuntimeSuffix(options?.staleAfterSeconds)}`;
       if (ancestryPlayIds.includes(resolvedName)) {
         const chain = [...ancestryPlayIds, resolvedName].join(' -> ');
         throw new Error(`Recursive play graph detected: ${chain}`);
@@ -4154,163 +4230,180 @@ function createMinimalWorkerCtx(
           `Child play-call cap exceeded for ${req.playName} (${nextParentCalls}/${WORKER_PLAY_CALL_LIMITS.maxChildPlayCallsPerParent}).`,
         );
       }
-      playCallCount = nextPlayCallCount;
-      parentChildCalls[req.playName] = nextParentCalls;
+      return await executeWithRuntimeReceipt(receiptKey, async () => {
+        playCallCount = nextPlayCallCount;
+        parentChildCalls[req.playName] = nextParentCalls;
 
-      emitEvent({
-        type: 'log',
-        level: 'info',
-        message: `Starting child play ${resolvedName} (${normalizedKey})`,
-        ts: nowMs(),
-      });
-      const childManifest = req.childPlayManifests?.[resolvedName];
-      if (!childManifest) {
-        throw new Error(
-          `ctx.runPlay(${normalizedKey}) cannot start ${resolvedName}: missing trusted Cloudflare child manifest from top-level submit.`,
-        );
-      }
-      const childIsMapBacked = childPipelineUsesCtxMap(
-        childManifest.staticPipeline,
-      );
-      const childNeedsWorkflowScheduler = childPipelineNeedsWorkflowScheduler(
-        childManifest.staticPipeline,
-      );
-      let childConcurrencyAcquired = false;
-      let releaseChildPlaySlot: (() => void) | null = null;
-      if (childIsMapBacked) {
-        const nextInFlight =
-          (inFlightChildCallsByPlayName[resolvedName] ?? 0) + 1;
-        if (nextInFlight > 1) {
+        emitEvent({
+          type: 'log',
+          level: 'info',
+          message: `Starting child play ${resolvedName} (${normalizedKey})`,
+          ts: nowMs(),
+        });
+        const childManifest = req.childPlayManifests?.[resolvedName];
+        if (!childManifest) {
           throw new Error(
-            `Concurrent map-backed play call blocked for ${resolvedName}. ` +
-              'A child play that uses ctx.map() cannot run more than once at the same time because its map tables share durable row identity. ' +
-              'Run these child play calls sequentially, or give each concurrent branch a different child play/table contract.',
+            `ctx.runPlay(${normalizedKey}) cannot start ${resolvedName}: missing trusted Cloudflare child manifest from top-level submit.`,
           );
         }
-        inFlightChildCallsByPlayName[resolvedName] = nextInFlight;
-        childConcurrencyAcquired = true;
-      }
-      try {
-        releaseChildPlaySlot = await acquireChildPlaySlot();
-        const childSubmitStartedAt = nowMs();
-        let started: {
-          workflowId?: string;
-          runId?: string;
-          status?: string;
-          output?: unknown;
-          result?: unknown;
-          error?: unknown;
-        };
+        const childIsMapBacked = childPipelineUsesCtxMap(
+          childManifest.staticPipeline,
+        );
+        const childNeedsWorkflowScheduler = childPipelineNeedsWorkflowScheduler(
+          childManifest.staticPipeline,
+        );
+        let childConcurrencyAcquired = false;
+        let releaseChildPlaySlot: (() => void) | null = null;
+        if (childIsMapBacked) {
+          const nextInFlight =
+            (inFlightChildCallsByPlayName[resolvedName] ?? 0) + 1;
+          if (nextInFlight > 1) {
+            throw new Error(
+              `Concurrent map-backed play call blocked for ${resolvedName}. ` +
+                'A child play that uses ctx.map() cannot run more than once at the same time because its map tables share durable row identity. ' +
+                'Run these child play calls sequentially, or give each concurrent branch a different child play/table contract.',
+            );
+          }
+          inFlightChildCallsByPlayName[resolvedName] = nextInFlight;
+          childConcurrencyAcquired = true;
+        }
         try {
-          started = await submitChildPlayThroughCoordinator({
-            req,
-            allowInline:
-              options?.timeoutMs == null && !childNeedsWorkflowScheduler,
-            body: {
-              name: resolvedName,
-              input: isRecord(input) ? input : {},
-              orgId: req.orgId,
-              parentExecutorToken: req.executorToken,
-              userEmail: req.userEmail ?? '',
-              profile: 'workers_edge',
-              manifest: childManifest,
-              childPlayManifests: req.childPlayManifests ?? null,
-              internalRunPlay: {
-                rootRunId,
-                parentRunId: req.runId,
-                parentPlayName: req.playName,
-                key: normalizedKey,
-                // Per the lineage validator: ancestry tail must equal the
-                // executor token's play name (the parent making this call).
-                ancestryPlayIds,
-                callDepth: nextDepth,
-                description:
-                  typeof options?.description === 'string'
-                    ? options.description
-                    : null,
+          releaseChildPlaySlot = await acquireChildPlaySlot();
+          const childSubmitStartedAt = nowMs();
+          let started: {
+            workflowId?: string;
+            runId?: string;
+            status?: string;
+            output?: unknown;
+            result?: unknown;
+            error?: unknown;
+          };
+          try {
+            started = await submitChildPlayThroughCoordinator({
+              req,
+              allowInline:
+                options?.timeoutMs == null && !childNeedsWorkflowScheduler,
+              body: {
+                name: resolvedName,
+                input: isRecord(input) ? input : {},
+                orgId: req.orgId,
+                parentExecutorToken: req.executorToken,
+                userEmail: req.userEmail ?? '',
+                profile: 'workers_edge',
+                manifest: childManifest,
+                childPlayManifests: req.childPlayManifests ?? null,
+                internalRunPlay: {
+                  rootRunId,
+                  parentRunId: req.runId,
+                  parentPlayName: req.playName,
+                  key: normalizedKey,
+                  // Per the lineage validator: ancestry tail must equal the
+                  // executor token's play name (the parent making this call).
+                  ancestryPlayIds,
+                  callDepth: nextDepth,
+                  description:
+                    typeof options?.description === 'string'
+                      ? options.description
+                      : null,
+                },
               },
-            },
-          });
-        } catch (error) {
+            });
+          } catch (error) {
+            console.info('[play.runtime.span]', {
+              event: 'play.runtime.span',
+              phase: 'child_submit',
+              runId: req.runId,
+              parentRunId: req.runId,
+              playName: resolvedName,
+              graphHash: req.graphHash ?? null,
+              depth: nextDepth,
+              fanoutIndex: nextParentCalls - 1,
+              ms: nowMs() - childSubmitStartedAt,
+              status: 'failed',
+              errorCode: 'CHILD_SUBMIT_FAILED',
+            });
+            throw error;
+          }
+          const workflowId = started.workflowId ?? started.runId;
+          if (!workflowId) {
+            const startedError = isRecord(started.error)
+              ? started.error
+              : { message: started.error };
+            const startedErrorMessage =
+              typeof startedError.message === 'string' &&
+              startedError.message.trim()
+                ? startedError.message.trim()
+                : null;
+            throw new Error(
+              startedErrorMessage ??
+                `ctx.runPlay(${normalizedKey}) did not receive a child workflow id.`,
+            );
+          }
           console.info('[play.runtime.span]', {
             event: 'play.runtime.span',
             phase: 'child_submit',
             runId: req.runId,
             parentRunId: req.runId,
+            childRunId: workflowId,
             playName: resolvedName,
             graphHash: req.graphHash ?? null,
             depth: nextDepth,
             fanoutIndex: nextParentCalls - 1,
             ms: nowMs() - childSubmitStartedAt,
-            status: 'failed',
-            errorCode: 'CHILD_SUBMIT_FAILED',
+            status: 'ok',
           });
-          throw error;
-        }
-        const workflowId = started.workflowId ?? started.runId;
-        if (!workflowId) {
-          const startedError = isRecord(started.error)
-            ? started.error
-            : { message: started.error };
-          const startedErrorMessage =
-            typeof startedError.message === 'string' &&
-            startedError.message.trim()
-              ? startedError.message.trim()
-              : null;
-          throw new Error(
-            startedErrorMessage ??
-              `ctx.runPlay(${normalizedKey}) did not receive a child workflow id.`,
-          );
-        }
-        console.info('[play.runtime.span]', {
-          event: 'play.runtime.span',
-          phase: 'child_submit',
-          runId: req.runId,
-          parentRunId: req.runId,
-          childRunId: workflowId,
-          playName: resolvedName,
-          graphHash: req.graphHash ?? null,
-          depth: nextDepth,
-          fanoutIndex: nextParentCalls - 1,
-          ms: nowMs() - childSubmitStartedAt,
-          status: 'ok',
-        });
-        const startedStatus = String(started.status ?? '').toLowerCase();
-        if (startedStatus === 'completed') {
-          emitEvent({
-            type: 'log',
-            level: 'info',
-            message: `Completed child play ${resolvedName} (${normalizedKey})`,
-            ts: nowMs(),
-          });
-          return started.output ?? extractChildPlayOutput(started);
-        }
-        if (startedStatus === 'failed') {
-          const startedError = isRecord(started.error)
-            ? started.error
-            : { message: started.error };
-          const startedErrorMessage =
-            typeof startedError.message === 'string' &&
-            startedError.message.trim()
-              ? startedError.message.trim()
-              : `Child play ${resolvedName} (${workflowId}) failed.`;
-          throw new Error(startedErrorMessage);
-        }
-        const childWaitStartedAt = nowMs();
-        let result: unknown;
-        try {
-          result = await waitForChildPlayTerminalEvent({
-            req,
-            workflowStep,
-            workflowId,
-            playName: resolvedName,
-            key: normalizedKey,
-            timeoutMs: Math.max(
-              1_000,
-              Math.min(options?.timeoutMs ?? 5 * 60_000, 30 * 60_000),
-            ),
-          });
-        } catch (error) {
+          const startedStatus = String(started.status ?? '').toLowerCase();
+          if (startedStatus === 'completed') {
+            emitEvent({
+              type: 'log',
+              level: 'info',
+              message: `Completed child play ${resolvedName} (${normalizedKey})`,
+              ts: nowMs(),
+            });
+            return started.output ?? extractChildPlayOutput(started);
+          }
+          if (startedStatus === 'failed') {
+            const startedError = isRecord(started.error)
+              ? started.error
+              : { message: started.error };
+            const startedErrorMessage =
+              typeof startedError.message === 'string' &&
+              startedError.message.trim()
+                ? startedError.message.trim()
+                : `Child play ${resolvedName} (${workflowId}) failed.`;
+            throw new Error(startedErrorMessage);
+          }
+          const childWaitStartedAt = nowMs();
+          let result: unknown;
+          try {
+            result = await waitForChildPlayTerminalEvent({
+              req,
+              workflowStep,
+              workflowId,
+              playName: resolvedName,
+              key: normalizedKey,
+              timeoutMs: Math.max(
+                1_000,
+                Math.min(options?.timeoutMs ?? 5 * 60_000, 30 * 60_000),
+              ),
+            });
+          } catch (error) {
+            console.info('[play.runtime.span]', {
+              event: 'play.runtime.span',
+              phase: 'child_wait',
+              runId: req.runId,
+              parentRunId: req.runId,
+              childRunId: workflowId,
+              playName: resolvedName,
+              graphHash: req.graphHash ?? null,
+              depth: nextDepth,
+              fanoutIndex: nextParentCalls - 1,
+              ms: nowMs() - childWaitStartedAt,
+              status: 'failed',
+              errorCode: 'CHILD_WAIT_FAILED',
+            });
+            throw error;
+          }
           console.info('[play.runtime.span]', {
             event: 'play.runtime.span',
             phase: 'child_wait',
@@ -4322,40 +4415,25 @@ function createMinimalWorkerCtx(
             depth: nextDepth,
             fanoutIndex: nextParentCalls - 1,
             ms: nowMs() - childWaitStartedAt,
-            status: 'failed',
-            errorCode: 'CHILD_WAIT_FAILED',
+            status: 'ok',
           });
-          throw error;
-        }
-        console.info('[play.runtime.span]', {
-          event: 'play.runtime.span',
-          phase: 'child_wait',
-          runId: req.runId,
-          parentRunId: req.runId,
-          childRunId: workflowId,
-          playName: resolvedName,
-          graphHash: req.graphHash ?? null,
-          depth: nextDepth,
-          fanoutIndex: nextParentCalls - 1,
-          ms: nowMs() - childWaitStartedAt,
-          status: 'ok',
-        });
-        emitEvent({
-          type: 'log',
-          level: 'info',
-          message: `Completed child play ${resolvedName} (${normalizedKey})`,
-          ts: nowMs(),
-        });
-        return result;
-      } finally {
-        releaseChildPlaySlot?.();
-        if (childConcurrencyAcquired) {
-          releaseChildPlayConcurrency(
-            inFlightChildCallsByPlayName,
-            resolvedName,
-          );
+          emitEvent({
+            type: 'log',
+            level: 'info',
+            message: `Completed child play ${resolvedName} (${normalizedKey})`,
+            ts: nowMs(),
+          });
+          return result;
+        } finally {
+          releaseChildPlaySlot?.();
+          if (childConcurrencyAcquired) {
+            releaseChildPlayConcurrency(
+              inFlightChildCallsByPlayName,
+              resolvedName,
+            );
+          }
         }
-      }
+      });
     },
     fetch(): never {
       throw new Error(