deepline 0.1.209 → 0.1.210

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

@@ -2445,8 +2445,6 @@ function runRequestFromPlayWorkflowParams(
     preloadedDbSessions: params.preloadedDbSessions ?? null,
     runtimeTestFaultHeader: params.runtimeTestFaultHeader ?? null,
     testPolicyOverrides: params.testPolicyOverrides ?? null,
-    inlineChildRunRegistered:
-      params.runtimeBackend === 'cf_workflows_dynamic_worker_inline_child',
     coordinatorUrl: params.coordinatorUrl ?? null,
     coordinatorInternalToken: params.coordinatorInternalToken ?? null,
     totalRows: params.totalRows,

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

@@ -32,6 +32,7 @@ import {
   type WorkflowEvent,
   type WorkflowStep,
 } from 'cloudflare:workers';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import {
   deterministicMapChunkStepName,
   type ExecutionPlan,
@@ -40,7 +41,6 @@ import {
   STANDARD_PLAY_RUNTIME_LIMIT_LABEL,
   STANDARD_PLAY_RUNTIME_LIMIT_SECONDS,
 } from '../../../shared_libs/play-runtime/runtime-constants';
-import { childSubmitIdempotencyKey } from '../../../shared_libs/play-runtime/child-run-id';
 import {
   createPlayExecutionGovernor,
   type GovernanceSnapshot,
@@ -104,7 +104,7 @@ import {
 import { createDeferredPlayDataset } from '../../../shared_libs/plays/dataset';
 import {
   buildDurableCtxCallCacheKey,
-  buildDurableRunPlaySemanticKey,
+  buildDurableRunPlayInvocationScope,
 } from '../../../shared_libs/play-runtime/durable-call-cache';
 import {
   resolveRuntimeToolReceiptWaitMaxAttempts,
@@ -368,8 +368,6 @@ type RunRequest = {
   /** Internal ctx.runPlay lineage. Public SDK/users never see this. */
   playCallGovernance?: PlayCallGovernanceSnapshot | null;
   preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
-  /** Coordinator already created the child run row before invoking /run-inline. */
-  inlineChildRunRegistered?: boolean | null;
   /** Cloudflare coordinator URL for direct Workflow control-plane signals. */
   coordinatorUrl?: string | null;
   /** Request-scoped coordinator auth token for preview/dev direct control calls. */
@@ -1148,11 +1146,29 @@ async function drainRunnerPerfTraces(req: RunRequest): Promise<void> {
 
 let workerRequestSequence = 0;
 
+const workerRunPlayRowContext = new AsyncLocalStorage<{
+  tableNamespace: string;
+  rowKey: string;
+  fieldName: string;
+}>();
+
 function makeRequestId(): string {
   workerRequestSequence = (workerRequestSequence + 1) % Number.MAX_SAFE_INTEGER;
   return `worker-request-${workerRequestSequence}`;
 }
 
+async function executeFreshChildInvocation<T>(
+  input: {
+    parentRunId: string;
+    key: string;
+    invocationScope: string;
+  },
+  execute: (invocationId: string) => Promise<T>,
+): Promise<T> {
+  const invocationId = `${input.parentRunId}:runPlay:${input.key}:${input.invocationScope}`;
+  return await execute(invocationId);
+}
+
 function makeRuntimeSheetAttempt(input: {
   runId: string;
   runAttempt?: number | null;
@@ -1665,27 +1681,6 @@ async function hashChildPlayEventKey(input: unknown): Promise<string> {
   return (await hashJson(input)).slice(0, 32);
 }
 
-function workerChildRevisionFingerprint(input: {
-  playName: string;
-  manifest: PlayRuntimeManifest | null | undefined;
-}): string | null {
-  const manifest = input.manifest;
-  if (!manifest) return null;
-  return sha256Hex(
-    stableStringify({
-      playId: manifest.playName?.trim() || input.playName,
-      codeFormat: 'cjs_module',
-      artifactHash: manifest.artifactHash ?? null,
-      graphHash: manifest.graphHash ?? null,
-      sourceHash: null,
-      sourceCodeHash:
-        typeof manifest.sourceCode === 'string'
-          ? sha256Hex(manifest.sourceCode)
-          : null,
-    }),
-  );
-}
-
 type RuntimeResolvedPlayResponse = {
   manifest?: PlayRuntimeManifest | null;
 };
@@ -5580,37 +5575,49 @@ function createMinimalWorkerCtx(
                             })
                           : null,
                     });
-                    const resolved = await executeWorkerStepResolver(
-                      value,
-                      enriched,
-                      rowCtx,
-                      absoluteIndex,
-                      previousCell,
-                      isWorkerStepProgram(value)
-                        ? {
-                            parentField: key,
-                            path: [],
-                            outputs: stepProgramOutputs,
-                            onOutput: async (stepOutput) => {
-                              generatedOutputFields.add(stepOutput.columnName);
-                              const status = stepOutput.status ?? 'completed';
-                              if (status === 'skipped') stepCellsSkipped += 1;
-                              else stepCellsCompleted += 1;
-                              await enqueueLiveRowUpdate({
-                                key: entry.rowKey,
-                                dataPatch: {
-                                  [stepOutput.columnName]: stepOutput.value,
-                                },
-                                cellMetaPatch: {
-                                  [stepOutput.columnName]: {
-                                    status,
-                                    stage: stepOutput.stepId,
-                                  },
+                    const resolved = await workerRunPlayRowContext.run(
+                      {
+                        tableNamespace: name,
+                        rowKey: entry.rowKey,
+                        fieldName: key,
+                      },
+                      () =>
+                        executeWorkerStepResolver(
+                          value,
+                          enriched,
+                          rowCtx,
+                          absoluteIndex,
+                          previousCell,
+                          isWorkerStepProgram(value)
+                            ? {
+                                parentField: key,
+                                path: [],
+                                outputs: stepProgramOutputs,
+                                onOutput: async (stepOutput) => {
+                                  generatedOutputFields.add(
+                                    stepOutput.columnName,
+                                  );
+                                  const status =
+                                    stepOutput.status ?? 'completed';
+                                  if (status === 'skipped')
+                                    stepCellsSkipped += 1;
+                                  else stepCellsCompleted += 1;
+                                  await enqueueLiveRowUpdate({
+                                    key: entry.rowKey,
+                                    dataPatch: {
+                                      [stepOutput.columnName]: stepOutput.value,
+                                    },
+                                    cellMetaPatch: {
+                                      [stepOutput.columnName]: {
+                                        status,
+                                        stage: stepOutput.stepId,
+                                      },
+                                    },
+                                  });
                                 },
-                              });
-                            },
-                          }
-                        : undefined,
+                              }
+                            : undefined,
+                        ),
                     );
                     enriched[key] = resolved.value;
                     fieldOutputs[key] = resolved.value;
@@ -6933,7 +6940,6 @@ function createMinimalWorkerCtx(
       options?: {
         description?: string;
         timeoutMs?: number;
-        staleAfterSeconds?: number;
       },
     ): Promise<unknown> {
       const normalizedKey = normalizeContextKey(key, 'runPlay');
@@ -6947,34 +6953,49 @@ function createMinimalWorkerCtx(
         playRef: resolvedName,
         cache: childManifestCache,
       });
-      const receiptKey = buildDurableCtxCallCacheKey({
-        orgId: req.orgId,
-        playId: req.playName,
-        kind: 'runPlay',
-        id: normalizedKey,
-        semanticKey: buildDurableRunPlaySemanticKey({
-          childPlayName: resolvedName,
-          childRevisionFingerprint: workerChildRevisionFingerprint({
-            playName: resolvedName,
-            manifest: childManifest,
-          }),
-          input,
-        }),
-        staleAfterSeconds: options?.staleAfterSeconds,
+      const rowScope = workerRunPlayRowContext.getStore();
+      const invocationScope = buildDurableRunPlayInvocationScope({
+        childPlayName: resolvedName,
+        input,
+        rowScope: rowScope
+          ? {
+              fieldName: rowScope.fieldName,
+              rowKey: rowScope.rowKey,
+              tableNamespace: rowScope.tableNamespace,
+            }
+          : null,
       });
-      return await executeWithRuntimeReceipt(
-        receiptKey,
-        async (receiptContext, wasFailed) => {
+      return await executeFreshChildInvocation(
+        {
+          parentRunId: req.runId,
+          key: normalizedKey,
+          invocationScope,
+        },
+        async (childInvocationId) => {
           // The Governor owns the play-call lineage: forkChild does the cycle
           // guard, depth/per-parent/playCall/descendant budget charges, and
           // returns the snapshot to thread into the child so budgets accumulate
-          // across isolates. Charged inside the receipt boundary so a replay
-          // (cache hit) never double-charges.
-          const childRunId = `${req.runId}:child:${normalizedKey}`;
-          const childGovernance = await governor.forkChild({
-            childPlayName: resolvedName,
-            childRunId,
-          });
+          // across isolates. Every ctx.runPlay call is a fresh child invocation.
+          const childRunId = `${req.runId}:child:${childInvocationId}`;
+          // Checkpoint governance admission separately from the child result.
+          // Workflow replay reuses this admission and the coordinator's stable
+          // child launch identity, but ctx.runPlay never caches child output.
+          const forkChild = () =>
+            governor.forkChild({
+              childPlayName: resolvedName,
+              childRunId,
+            });
+          const childGovernance = workflowStep
+            ? await (
+                workflowStep.do as unknown as <T>(
+                  name: string,
+                  callback: () => Promise<T>,
+                ) => Promise<T>
+              )(
+                `runPlay-governance:${sha256Hex(childInvocationId).slice(0, 24)}`,
+                forkChild,
+              )
+            : await forkChild();
           const nextDepth = childGovernance.callDepth;
           const nextParentCalls =
             governor.snapshot().parentChildCalls[req.playName] ?? 0;
@@ -7047,11 +7068,7 @@ function createMinimalWorkerCtx(
                   options?.timeoutMs == null && !childNeedsWorkflowScheduler,
                 body: {
                   name: resolvedName,
-                  childIdempotencyKey: childSubmitIdempotencyKey({
-                    receiptKey,
-                    wasFailed,
-                    leaseId: receiptContext.leaseId,
-                  }),
+                  childIdempotencyKey: childInvocationId,
                   input: isRecord(input) ? input : {},
                   orgId: req.orgId,
                   callbackUrl: req.callbackUrl,
@@ -7329,12 +7346,6 @@ function createMinimalWorkerCtx(
             childPlaySlot?.release();
           }
         },
-        {
-          forceFailedRefresh: true,
-          repairRunningReceiptForSameRunAfterWaitTimeout: true,
-          runningReceiptWaitMaxAttempts:
-            resolveRuntimeToolReceiptWaitMaxAttempts(input),
-        },
       );
     },
     async fetch(
@@ -7615,13 +7626,6 @@ async function handleRunInline(
     const probeStartedAt = nowMs();
     await probeHarnessOnce(env, runPrefix);
     traceInline('inline.probe_harness', probeStartedAt);
-    if (!req.inlineChildRunRegistered) {
-      const registerStartedAt = nowMs();
-      await registerInlineChildRun(req);
-      traceInline('inline.register_child_run', registerStartedAt);
-    } else {
-      traceInline('inline.register_child_run', nowMs(), { skipped: true });
-    }
     const executeStartedAt = nowMs();
     const output = await executeRunRequest(
       req,
@@ -7667,46 +7671,6 @@ async function handleRunInline(
   }
 }
 
-async function registerInlineChildRun(req: RunRequest): Promise<void> {
-  const snapshot = isRecord(req.contractSnapshot) ? req.contractSnapshot : {};
-  const artifactMetadata = isRecord(snapshot.artifactMetadata)
-    ? snapshot.artifactMetadata
-    : {};
-  const governance = req.playCallGovernance;
-  await postRuntimeApi(req.baseUrl, req.executorToken, {
-    action: 'start_inline_child_run',
-    playName: req.playName,
-    runId: req.runId,
-    parentRunId: governance?.parentRunId,
-    rootRunId: governance?.rootRunId,
-    workflowFamilyKey:
-      governance?.rootRunId ?? governance?.parentRunId ?? req.runId,
-    artifactStorageKey:
-      typeof artifactMetadata.storageKey === 'string'
-        ? artifactMetadata.storageKey
-        : undefined,
-    artifactHash:
-      typeof artifactMetadata.artifactHash === 'string'
-        ? artifactMetadata.artifactHash
-        : undefined,
-    graphHash:
-      typeof artifactMetadata.graphHash === 'string'
-        ? artifactMetadata.graphHash
-        : undefined,
-    runtimeBackend: 'workers_edge',
-    schedulerBackend: 'inline_child',
-    executionProfile: 'workers_edge',
-    maxCreditsPerRun: extractMaxCreditsPerRun(req.contractSnapshot),
-    staticPipeline: snapshot.staticPipeline ?? null,
-    source:
-      snapshot.source === 'published' ||
-      snapshot.source === 'ad_hoc' ||
-      snapshot.source === 'draft'
-        ? snapshot.source
-        : 'published',
-  });
-}
-
 /** Cap on run log lines retained in the terminal output compatibility shape. */
 const RUN_LOG_BUFFER_LIMIT = 500;
 /** Min wall-clock interval between live run-ledger flushes during a run. */

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-dispatch.ts

@@ -54,6 +54,7 @@ import {
   markWorkerToolReceiptResultCached,
   markWorkerToolReceiptResultExecution,
   planWorkerToolReceiptGroups,
+  resolveRunningReceiptWaitMaxAttempts,
   resolveWorkerToolReceiptGroupWaitMaxAttempts,
   resolveWorkerToolRuntimeTimeoutMs,
 } from './tool-receipts';
@@ -1232,10 +1233,17 @@ export class WorkerToolBatchScheduler {
               try {
                 const result = await this.waitForDurableToolReceipt({
                   receiptKey,
-                  maxAttempts: resolveWorkerToolReceiptGroupWaitMaxAttempts(
-                    group,
-                    (request) => request.receiptWaitMaxAttempts,
-                  ),
+                  maxAttempts: resolveRunningReceiptWaitMaxAttempts({
+                    ownerRunId: claim.receipt.runId,
+                    currentRunId: this.options.req.runId,
+                    updatedAt: claim.receipt.updatedAt,
+                    requestedMaxAttempts:
+                      resolveWorkerToolReceiptGroupWaitMaxAttempts(
+                        group,
+                        (request) => request.receiptWaitMaxAttempts,
+                      ),
+                    nowMs: this.options.nowMs(),
+                  }),
                 });
                 if (groupState.forceDurableRefresh) {
                   return await this.claimForcedDurableToolReceiptGroupAfterWait(

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-receipts.ts

@@ -39,106 +39,39 @@ export function canReclaimTimedOutWorkerToolReceipt(input: {
  * conservative constant, not a heartbeat multiple.
  */
 export const RUNNING_RECEIPT_DEAD_OWNER_STALENESS_MS = 60_000;
+export const RUNNING_RECEIPT_POLL_INTERVAL_MS = 250;
 
-/**
- * Decide whether a `running` receipt should be reclaimed IMMEDIATELY, skipping
- * the completion poll.
- *
- * The poll (`waitForCompletedRuntimeReceipt`) issues one service-binding
- * subrequest per 250ms tick, up to the receipt's wait budget (~1320 ticks for a
- * 5.5-minute default). On resume, a map can carry many receipts left `running`
- * by a DEAD prior run; polling each one burns its full tick budget waiting on a
- * receipt no live worker will complete, which blows Cloudflare's ~1000
- * subrequests-per-invocation budget and kills the resume with
- * "Too many subrequests by single Worker invocation" (prod resume deaths
- * 20260703t230209 / 20260703t232104).
- *
- * A receipt is a dead-owner orphan when it is owned by a DIFFERENT run (a
- * same-run `running` is this run replaying — its owner may still be live) and
- * its last write is stale (or missing entirely — a live owner would carry a
- * recent claim timestamp). Those reclaim immediately, matching the dispatch
- * code's own contract ("on resume it reclaims and re-executes"). A live or
- * freshly-claimed owner keeps the poll.
- */
-export function shouldReclaimRunningReceiptWithoutPolling(input: {
+/** Bound a follower poll by when a different-run owner becomes reclaimable. */
+export function resolveRunningReceiptWaitMaxAttempts(input: {
   ownerRunId?: string | null;
   currentRunId: string;
   updatedAt?: string | null;
+  requestedMaxAttempts: number;
   nowMs?: number;
   stalenessFloorMs?: number;
-}): boolean {
-  const currentRunId = input.currentRunId.trim();
+  pollIntervalMs?: number;
+}): number {
+  const requested = Math.max(1, Math.floor(input.requestedMaxAttempts));
   const ownerRunId = input.ownerRunId?.trim() ?? '';
-  // Only a receipt owned by a different run can be a dead prior-run orphan.
-  if (!currentRunId || !ownerRunId || ownerRunId === currentRunId) return false;
-  const floorMs =
-    input.stalenessFloorMs ?? RUNNING_RECEIPT_DEAD_OWNER_STALENESS_MS;
-  // No freshness signal at all: treat as stale. A live owner would carry a
-  // recent claim timestamp; an orphan from a dead run may carry none.
-  if (!input.updatedAt) return true;
-  const updatedAtMs = Date.parse(input.updatedAt);
-  if (!Number.isFinite(updatedAtMs)) return true;
-  const now = input.nowMs ?? Date.now();
-  return now - updatedAtMs >= floorMs;
-}
-
-/** Metadata a `running` receipt carries about its owner and last write. */
-export interface RunningReceiptOwnershipInput {
-  ownerRunId?: string | null;
-  currentRunId: string;
-  updatedAt?: string | null;
-  nowMs?: number;
-  stalenessFloorMs?: number;
-}
-
-/** Outcome of polling a `running` receipt for completion. */
-export type RunningReceiptPollOutcome =
-  /** The poll saw the receipt complete and already resolved the group. */
-  | { kind: 'completed' }
-  /** The poll timed out; the receipt is still `running`. */
-  | { kind: 'timed_out'; error: unknown }
-  /** The poll failed for a non-timeout reason (e.g. the receipt failed). */
-  | { kind: 'errored'; error: unknown };
-
-/**
- * Orchestrate the resume-time handling of a `running` receipt: reclaim it
- * immediately when it is a dead-owner orphan, otherwise poll for completion and
- * only reclaim after the poll times out. Kept as a pure, dependency-injected
- * function (the poll and reclaim side effects are passed in) so the
- * "skip the poll for a dead owner" decision is unit-testable with a poll counter
- * — the Worker scheduler that owns the real effects imports `cloudflare:workers`
- * and cannot be loaded under vitest.
- *
- * Behavior (must match the scheduler's prior inline logic exactly):
- * - dead-owner + reclaim-eligible → `reclaim` now, never polling;
- * - otherwise `poll`; on `completed` the group is already resolved (return []);
- *   on a non-timeout error `reject` and stop; on timeout, `reclaim` if still
- *   eligible else `reject` with the timeout error.
- */
-export async function reclaimRunningReceiptGroupAfterWait<TClaimed>(input: {
-  ownership: RunningReceiptOwnershipInput;
-  timeoutError: unknown;
-  poll: () => Promise<RunningReceiptPollOutcome>;
-  reclaim: (rejectionOnFallthrough: unknown) => Promise<TClaimed[]>;
-  reject: (error: unknown) => void;
-}): Promise<TClaimed[]> {
-  if (
-    shouldReclaimRunningReceiptWithoutPolling(input.ownership) &&
-    canReclaimTimedOutWorkerToolReceipt(input.ownership)
-  ) {
-    return await input.reclaim(input.timeoutError);
-  }
-  const outcome = await input.poll();
-  if (outcome.kind === 'completed') return [];
-  if (outcome.kind === 'errored') {
-    input.reject(outcome.error);
-    return [];
-  }
-  if (!canReclaimTimedOutWorkerToolReceipt(input.ownership)) {
-    input.reject(outcome.error);
-    return [];
+  const currentRunId = input.currentRunId.trim();
+  if (!ownerRunId || !currentRunId || ownerRunId === currentRunId) {
+    return requested;
   }
-  return await input.reclaim(outcome.error);
+  const updatedAtMs = input.updatedAt ? Date.parse(input.updatedAt) : NaN;
+  if (!Number.isFinite(updatedAtMs)) return 1;
+  const remainingMs = Math.max(
+    0,
+    updatedAtMs +
+      (input.stalenessFloorMs ?? RUNNING_RECEIPT_DEAD_OWNER_STALENESS_MS) -
+      (input.nowMs ?? Date.now()),
+  );
+  const attemptsUntilReclaim = Math.max(
+    1,
+    Math.floor(
+      remainingMs / (input.pollIntervalMs ?? RUNNING_RECEIPT_POLL_INTERVAL_MS),
+    ) + 1,
+  );
+  return Math.min(requested, attemptsUntilReclaim);
 }
 
 export function canReclaimFailedWorkerToolReceipt(input: {

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

@@ -400,7 +400,7 @@ export type StepOptions<Row, Value = unknown> = {
    * Legacy dataset-column recompute flag accepted for older authored plays.
    *
    * Prefer putting freshness on the actual reusable call
-   * (`ctx.tools.execute`, `ctx.step`, `ctx.fetch`, or `ctx.runPlay`).
+   * (`ctx.tools.execute`, `ctx.step`, or `ctx.fetch`).
    */
   readonly recompute?: boolean;
   /** Legacy error-recompute flag accepted for older authored plays. */
@@ -889,7 +889,7 @@ export interface DeeplinePlayRuntimeContext {
     key: string,
     playRef: string | PlayReferenceLike,
     input: Record<string, unknown>,
-    options: { description: string; staleAfterSeconds?: number },
+    options: { description: string },
   ): Promise<TOutput>;
 
   /**

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.209',
+  version: '0.1.210',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.209',
+    latest: '0.1.210',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/shared_libs/play-runtime/child-run-id.ts

@@ -44,8 +44,7 @@ export interface ChildRunIdInputs {
   key?: string | null;
   /**
    * Canonical durable runPlay semantic key when the launching substrate has one.
-   * In-process runtimes pass the same key used by durable receipts so row-scoped
-   * receipt identity and child run identity cannot drift apart.
+   * This scopes each fresh child invocation to its parent call site and row.
    */
   runPlaySemanticKey?: string | null;
   /** Child input payload (semantic-fallback input). */
@@ -57,9 +56,9 @@ export interface ChildRunIdInputs {
 }
 
 /**
- * A failed durable runPlay receipt must launch a fresh child attempt while
- * ordinary submit retries keep attaching to the original child. The receipt
- * lease is the attempt fence, so it is the only extra identity required.
+ * A failed child launch must use a fresh attempt identity while ordinary
+ * transport retries keep attaching to the original child. The caller-provided
+ * lease is the attempt fence.
  */
 export function childSubmitIdempotencyKey(input: {
   receiptKey: string;

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -107,7 +107,7 @@ import {
 } from './tool-execute-retry-policy';
 import {
   buildDurableCtxCallCacheKey,
-  buildDurableRunPlaySemanticKey,
+  buildDurableRunPlayInvocationScope,
   buildDurableToolAggregateProviderIdempotencyKey,
   buildDurableToolAggregateReceiptKey,
   buildDurableToolCallAuthScopeDigest,
@@ -819,7 +819,7 @@ function stableDigest(value: string): string {
   return sha256Hex(value);
 }
 
-type DurableCtxOperation = 'step' | 'tool' | 'fetch' | 'runPlay';
+type DurableCtxOperation = 'step' | 'tool' | 'fetch';
 
 function durableCtxKey(input: {
   orgId?: string | null;
@@ -6370,8 +6370,6 @@ export class PlayContextImpl {
           `Unable to resolve play "${resolvedName}" for ctx.runPlay(...).`,
         );
       }
-      const childRevisionFingerprint =
-        resolvedPlayRevisionFingerprint(resolvedPlay);
       const childExecutionDecision = resolveChildExecutionStrategy({
         pipeline: resolvedPlay.staticPipeline,
       });
@@ -6413,14 +6411,12 @@ export class PlayContextImpl {
           ),
         );
       }
-      const runPlaySemanticKey = buildDurableRunPlaySemanticKey({
+      const runPlayInvocationScope = buildDurableRunPlayInvocationScope({
         childPlayName: resolvedName,
-        childRevisionFingerprint,
         input,
         rowScope: runPlayRowScope
           ? {
               fieldName: runPlayRowScope.fieldName,
-              rowId: runPlayRowScope.rowId,
               rowKey: runPlayRowScope.rowKey ?? null,
               tableNamespace: runPlayRowScope.tableNamespace ?? null,
             }
@@ -6458,7 +6454,7 @@ export class PlayContextImpl {
                 parentRunId: this.currentRunId,
                 parentPlayName: this.#options.playName,
                 key: normalizedKey,
-                runPlaySemanticKey,
+                runPlaySemanticKey: runPlayInvocationScope,
                 input,
                 graphHash: null,
               }),
@@ -6700,24 +6696,7 @@ export class PlayContextImpl {
         }
       };
 
-      return await this.executeWithRuntimeReceipt<TOutput>(
-        'runPlay',
-        normalizedKey,
-        this.currentRunId,
-        {
-          semanticKey: runPlaySemanticKey,
-          staleAfterSeconds: options?.staleAfterSeconds,
-          markSkipped: () => {
-            this.log(
-              `ctx.runPlay(${normalizedKey}): no-op due completed receipt`,
-            );
-          },
-          repairRunningReceiptForSameRunAfterWaitTimeout: true,
-          runningReceiptWaitMaxAttempts:
-            resolveRuntimeToolReceiptWaitMaxAttempts(input),
-          execute: executePlayCall,
-        },
-      );
+      return await executePlayCall();
     } finally {
       scheduledChildPlayCall?.release();
     }

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -281,7 +281,6 @@ export type CustomerDbQueryHandler = (
 
 export interface PlayCallOptions {
   description?: string;
-  staleAfterSeconds?: number;
 }
 
 export interface StepOptions {
@@ -591,7 +590,7 @@ export interface ContextOptions {
   runId?: string;
   /** Physical executor run that owns leases for an inline child context. */
   runtimeReceiptOwnerRunId?: string;
-  /** Logical invocation scope for nested step/fetch/runPlay receipt identity. */
+  /** Logical invocation scope for receipts created inside an inline child. */
   runtimeReceiptScope?: string;
   runAttempt?: number | null;
   /**

package/dist/bundling-sources/shared_libs/play-runtime/durable-call-cache.ts

@@ -9,7 +9,7 @@ import {
 
 export const DURABLE_CALL_CACHE_POLICY_VERSION = 'call-cache-v1';
 
-export type DurableCallKind = 'tool' | 'step' | 'fetch' | 'runPlay';
+export type DurableCallKind = 'tool' | 'step' | 'fetch';
 
 function validateStaleAfterSeconds(staleAfterSeconds?: number | null): void {
   if (staleAfterSeconds === undefined || staleAfterSeconds === null) {
@@ -121,16 +121,14 @@ export function buildDurableCtxCallCacheKey(input: {
   return `ctx:${orgId}:call:${input.kind}:${normalizedId}:${digest}`;
 }
 
-export function buildDurableRunPlaySemanticKey(input: {
+export function buildDurableRunPlayInvocationScope(input: {
   childPlayName: string;
   input: Record<string, unknown>;
-  childRevisionFingerprint?: string | null;
   rowScope?: Record<string, unknown> | null;
 }): string {
   return sha256Hex(
     stableStringify({
       childPlayName: input.childPlayName.trim(),
-      childRevisionFingerprint: input.childRevisionFingerprint ?? null,
       input: input.input,
       rowScope: input.rowScope ?? null,
     }),

package/dist/cli/index.js

@@ -623,10 +623,10 @@ var 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.209",
+  version: "0.1.210",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.209",
+    latest: "0.1.210",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -17215,12 +17215,9 @@ function renderColumnRunIfFunction(command) {
   if (!command.run_if_js) {
     return null;
   }
-  if (command.play) {
-    return `(__dlRawRow) => { const row = __dlPrepareEnrichRow(__dlRawRow, [${stringLiteral(command.alias)}]); const input = row; const context = row;
+  return `(__dlRawRow) => { const row = __dlPrepareEnrichRow(__dlRawRow, [${stringLiteral(command.alias)}]); const input = row; const context = row;
 ${indent(renderJavascriptBody(command.run_if_js), 6)}
     }`;
-  }
-  return renderRunIfFunction(command);
 }
 function renderCombinedRunIfFunction(precheck, runIfSource) {
   if (!runIfSource) {

package/dist/cli/index.mjs

@@ -608,10 +608,10 @@ var 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.209",
+  version: "0.1.210",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.209",
+    latest: "0.1.210",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -17244,12 +17244,9 @@ function renderColumnRunIfFunction(command) {
   if (!command.run_if_js) {
     return null;
   }
-  if (command.play) {
-    return `(__dlRawRow) => { const row = __dlPrepareEnrichRow(__dlRawRow, [${stringLiteral(command.alias)}]); const input = row; const context = row;
+  return `(__dlRawRow) => { const row = __dlPrepareEnrichRow(__dlRawRow, [${stringLiteral(command.alias)}]); const input = row; const context = row;
 ${indent(renderJavascriptBody(command.run_if_js), 6)}
     }`;
-  }
-  return renderRunIfFunction(command);
 }
 function renderCombinedRunIfFunction(precheck, runIfSource) {
   if (!runIfSource) {

package/dist/index.d.mts

@@ -3219,7 +3219,7 @@ type StepOptions<Row, Value = unknown> = {
      * Legacy dataset-column recompute flag accepted for older authored plays.
      *
      * Prefer putting freshness on the actual reusable call
-     * (`ctx.tools.execute`, `ctx.step`, `ctx.fetch`, or `ctx.runPlay`).
+     * (`ctx.tools.execute`, `ctx.step`, or `ctx.fetch`).
      */
     readonly recompute?: boolean;
     /** Legacy error-recompute flag accepted for older authored plays. */
@@ -3607,7 +3607,6 @@ interface DeeplinePlayRuntimeContext {
      */
     runPlay<TOutput = unknown>(key: string, playRef: string | PlayReferenceLike, input: Record<string, unknown>, options: {
         description: string;
-        staleAfterSeconds?: number;
     }): Promise<TOutput>;
     /**
      * Emit a log line visible in `play tail` and the play's progress logs.

package/dist/index.d.ts

@@ -3219,7 +3219,7 @@ type StepOptions<Row, Value = unknown> = {
      * Legacy dataset-column recompute flag accepted for older authored plays.
      *
      * Prefer putting freshness on the actual reusable call
-     * (`ctx.tools.execute`, `ctx.step`, `ctx.fetch`, or `ctx.runPlay`).
+     * (`ctx.tools.execute`, `ctx.step`, or `ctx.fetch`).
      */
     readonly recompute?: boolean;
     /** Legacy error-recompute flag accepted for older authored plays. */
@@ -3607,7 +3607,6 @@ interface DeeplinePlayRuntimeContext {
      */
     runPlay<TOutput = unknown>(key: string, playRef: string | PlayReferenceLike, input: Record<string, unknown>, options: {
         description: string;
-        staleAfterSeconds?: number;
     }): Promise<TOutput>;
     /**
      * Emit a log line visible in `play tail` and the play's progress logs.

package/dist/index.js

@@ -422,10 +422,10 @@ var 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.209",
+  version: "0.1.210",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.209",
+    latest: "0.1.210",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/index.mjs

@@ -352,10 +352,10 @@ var 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.209",
+  version: "0.1.210",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.209",
+    latest: "0.1.210",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.209",
+  "version": "0.1.210",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {