deepline 0.1.77 → 0.1.79

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

@@ -113,6 +113,8 @@ type WorkflowRunMapping = {
 type WorkflowRunRetryState = {
   runId: string;
   params: unknown;
+  paramsRef?: unknown;
+  paramsBytes?: number;
   retryAttempts: number;
   updatedAt: number;
   expiresAt: number;
@@ -1059,8 +1061,10 @@ export class PlayDedup implements DurableObject {
       ttlMs?: unknown;
     } | null;
     const runId = typeof body?.runId === 'string' ? body.runId : '';
-    if (!runId || !body || !('params' in body)) {
-      return new Response('runId and params are required', { status: 400 });
+    if (!runId || !body || (!('params' in body) && !('paramsRef' in body))) {
+      return new Response('runId and params or paramsRef are required', {
+        status: 400,
+      });
     }
     const now = Date.now();
     const ttlMs =
@@ -1075,7 +1079,14 @@ export class PlayDedup implements DurableObject {
       const existing = await this.state.storage.get<WorkflowRunRetryState>(key);
       const retryState = {
         runId,
-        params: body.params,
+        params: 'params' in body ? body.params : null,
+        paramsRef: 'paramsRef' in body ? body.paramsRef : null,
+        paramsBytes:
+          typeof (body as { paramsBytes?: unknown }).paramsBytes ===
+            'number' &&
+          Number.isFinite((body as { paramsBytes?: number }).paramsBytes)
+            ? (body as { paramsBytes: number }).paramsBytes
+            : undefined,
         retryAttempts:
           existing?.runId === runId &&
           typeof existing.retryAttempts === 'number'
@@ -1128,6 +1139,8 @@ export class PlayDedup implements DurableObject {
           claimed: false,
           attempts: existing.retryAttempts,
           params: existing.params,
+          paramsRef: existing.paramsRef ?? null,
+          paramsBytes: existing.paramsBytes ?? null,
         };
         return;
       }
@@ -1142,6 +1155,8 @@ export class PlayDedup implements DurableObject {
         claimed: true,
         attempts: nextAttempts,
         params: existing.params,
+        paramsRef: existing.paramsRef ?? null,
+        paramsBytes: existing.paramsBytes ?? null,
       };
     });
     return new Response(JSON.stringify(response), {

package/dist/repo/apps/play-runner-workers/src/workflow-retry-state.ts

@@ -0,0 +1,203 @@
+import type { ExecutionPlan } from '../../../shared_libs/play-runtime/execution-plan';
+import type { PlayCallGovernanceSnapshot } from '../../../shared_libs/play-runtime/scheduler-backend';
+import type { PreloadedRuntimeDbSession } from '../../../shared_libs/play-runtime/db-session';
+import type {
+  PlayRuntimeManifest,
+  PlayRuntimeManifestMap,
+} from '../../../shared_libs/plays/compiler-manifest';
+
+export const WORKFLOW_RETRY_STATE_TARGET_BYTES = 100_000;
+export const WORKFLOW_RETRY_PARAMS_EXTERNALIZE_AFTER_BYTES =
+  WORKFLOW_RETRY_STATE_TARGET_BYTES;
+export const WORKFLOW_RETRY_PARAMS_MAX_BYTES = 1024 * 1024;
+
+export type WorkflowRetryParamsRef = {
+  storageKind: 'r2';
+  storageKey: string;
+  bytes: number;
+  hash: string;
+  expiresAt: number;
+};
+
+export type WorkflowRetryPlayParams = {
+  runId: string;
+  playId: string;
+  playName: string;
+  artifactStorageKey: string;
+  artifactHash: string;
+  graphHash: string;
+  input: Record<string, unknown>;
+  inputFile?: {
+    name?: string;
+    r2Key?: string;
+    storageKey?: string;
+    path?: string;
+    fileName?: string;
+    logicalPath?: string;
+    contentType?: string;
+    bytes?: number;
+  } | null;
+  inlineCsv?: { name: string; rows: Record<string, unknown>[] } | null;
+  packagedFiles?: Array<{
+    playPath: string;
+    storageKey: string;
+    contentType?: string;
+    bytes?: number;
+    inlineText?: string;
+  }> | null;
+  contractSnapshot?: unknown;
+  executionPlan?: ExecutionPlan | null;
+  childPlayManifests?: PlayRuntimeManifestMap | null;
+  playCallGovernance?: PlayCallGovernanceSnapshot | null;
+  preloadedDbSessions?: PreloadedRuntimeDbSession[] | null;
+  preloadedDbSessionRef?: {
+    runId: string;
+    sessionCount: number;
+    expiresAt: number;
+  } | null;
+  dynamicWorkerCode?: string | null;
+  executorToken: string;
+  baseUrl: string;
+  orgId: string;
+  userEmail: string;
+  userId?: string | null;
+  runtimeBackend: string;
+  dedupBackend: string;
+  totalRows?: number;
+  coordinatorUrl?: string | null;
+  coordinatorInternalToken?: string | null;
+};
+
+export type WorkflowRetryStatePayload<TParams = WorkflowRetryPlayParams> =
+  | {
+      params: TParams;
+      paramsRef?: null;
+      paramsBytes: number;
+    }
+  | {
+      params: null;
+      paramsRef: WorkflowRetryParamsRef;
+      paramsBytes: number;
+    };
+
+export function buildWorkflowRetryParams<
+  TParams extends WorkflowRetryPlayParams,
+>(params: TParams): TParams {
+  const retryParams = {
+    ...params,
+    dynamicWorkerCode: null,
+    contractSnapshot: stripRetrySourceSnapshot(params.contractSnapshot),
+    childPlayManifests: stripRetryChildManifestCode(params.childPlayManifests),
+    packagedFiles: stripRetryPackagedFiles(params.packagedFiles),
+  } satisfies WorkflowRetryPlayParams as TParams;
+  if (jsonByteLength(retryParams) <= WORKFLOW_RETRY_STATE_TARGET_BYTES) {
+    return retryParams;
+  }
+  return {
+    ...retryParams,
+    contractSnapshot: stripRetryContractSnapshotToArtifact(
+      retryParams.contractSnapshot,
+      params,
+    ),
+    childPlayManifests: stripRetryChildManifestToArtifact(
+      retryParams.childPlayManifests,
+    ),
+  } satisfies WorkflowRetryPlayParams as TParams;
+}
+
+export function jsonByteLength(value: unknown): number {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+
+export function workflowRetryParamsStorageKey(input: {
+  runId: string;
+  hash: string;
+}): string {
+  const safeRunId = input.runId
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .slice(0, 140);
+  return `plays/workflow-retry-params/${safeRunId || 'run'}/${input.hash}.json`;
+}
+
+function stripRetryPackagedFiles(
+  files: WorkflowRetryPlayParams['packagedFiles'],
+): WorkflowRetryPlayParams['packagedFiles'] {
+  return (
+    files?.map((file) => ({
+      playPath: file.playPath,
+      storageKey: file.storageKey,
+      contentType: file.contentType,
+      bytes: file.bytes,
+    })) ?? null
+  );
+}
+
+function stripRetrySourceSnapshot(snapshot: unknown): unknown {
+  if (!isRecord(snapshot)) return snapshot;
+  const rest = { ...snapshot };
+  delete rest.sourceCode;
+  delete rest.sourceFiles;
+  delete rest.bundledCode;
+  return rest;
+}
+
+function stripRetryContractSnapshotToArtifact(
+  snapshot: unknown,
+  params: WorkflowRetryPlayParams,
+): unknown {
+  if (!isRecord(snapshot)) return snapshot;
+  return {
+    source: snapshot.source ?? 'artifact',
+    revisionVersion: snapshot.revisionVersion ?? null,
+    staticPipeline: snapshot.staticPipeline ?? null,
+    billingLimit: snapshot.billingLimit ?? null,
+    artifactMetadata: {
+      storageKey: params.artifactStorageKey,
+      artifactHash: params.artifactHash,
+      graphHash: params.graphHash,
+    },
+    codeFormat: snapshot.codeFormat ?? null,
+    compatibility: snapshot.compatibility ?? null,
+  };
+}
+
+function stripRetryChildManifestCode(
+  manifests: PlayRuntimeManifestMap | null | undefined,
+): PlayRuntimeManifestMap | null {
+  if (!manifests) return null;
+  const stripped: PlayRuntimeManifestMap = {};
+  for (const [key, manifest] of Object.entries(manifests)) {
+    const rest = { ...manifest };
+    delete rest.bundledCode;
+    delete rest.sourceCode;
+    delete (rest as Record<string, unknown>).sourceMap;
+    stripped[key] = rest;
+  }
+  return stripped;
+}
+
+function stripRetryChildManifestToArtifact(
+  manifests: PlayRuntimeManifestMap | null | undefined,
+): PlayRuntimeManifestMap | null {
+  if (!manifests) return null;
+  const stripped: PlayRuntimeManifestMap = {};
+  for (const [key, manifest] of Object.entries(manifests)) {
+    stripped[key] = {
+      playName: manifest.playName,
+      graphHash: manifest.graphHash,
+      artifactStorageKey: manifest.artifactStorageKey,
+      artifactHash: manifest.artifactHash,
+      staticPipelineHash: manifest.staticPipelineHash,
+      staticPipeline: manifest.staticPipeline,
+      compiledAt: manifest.compiledAt,
+      compilerVersion: manifest.compilerVersion,
+      maxCreditsPerRun: manifest.maxCreditsPerRun,
+    };
+  }
+  return stripped;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/repo/sdk/src/client.ts

@@ -565,6 +565,13 @@ export class DeeplineClient {
       outputSchema: options?.compact
         ? this.compactSchema(play.outputSchema)
         : (play.outputSchema ?? null),
+      staticPipeline: isRecord(play.staticPipeline)
+        ? play.staticPipeline
+        : isRecord(play.currentRevision?.staticPipeline)
+          ? play.currentRevision.staticPipeline
+          : isRecord(play.liveRevision?.staticPipeline)
+            ? play.liveRevision.staticPipeline
+            : null,
       ...(csvInput ? { csvInput } : {}),
       ...(rowOutputSchema ? { rowOutputSchema } : {}),
       runCommand,

package/dist/repo/sdk/src/play.ts

@@ -540,7 +540,7 @@ export interface DeeplinePlayRuntimeContext {
    * @returns Program output.
    */
   runSteps<TInput extends Record<string, unknown>, TOutput>(
-    program: StepProgram<TInput, unknown, TOutput>,
+    program: StepProgram<TInput, any, TOutput>,
     input: TInput,
     options?: { description?: string },
   ): Promise<TOutput>;

package/dist/repo/sdk/src/release.ts

@@ -50,10 +50,10 @@ export type SdkRelease = {
 };
 
 export const SDK_RELEASE = {
-  version: '0.1.77',
+  version: '0.1.79',
   apiContract: '2026-06-dataset-column-cell-stale-hard-cutover',
   supportPolicy: {
-    latest: '0.1.77',
+    latest: '0.1.79',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
   },

package/dist/repo/sdk/src/types.ts

@@ -663,6 +663,9 @@ export interface PlayListItem {
   isDraftDirty?: boolean;
   inputSchema?: Record<string, unknown> | null;
   outputSchema?: Record<string, unknown> | null;
+  staticPipeline?: unknown;
+  currentRevision?: PlayRevisionSummary | null;
+  liveRevision?: PlayRevisionSummary | null;
   aliases?: string[];
 }
 
@@ -677,6 +680,7 @@ export interface PlayDescription {
   aliases: string[];
   inputSchema?: Record<string, unknown> | null;
   outputSchema?: Record<string, unknown> | null;
+  staticPipeline?: Record<string, unknown> | null;
   csvInput?: Record<string, unknown> | null;
   rowOutputSchema?: Record<string, unknown> | null;
   runCommand: string;

package/dist/repo/shared_libs/plays/dataset.ts

@@ -71,7 +71,9 @@ export type PlayDatasetTransformOptions = {
  * Deepline keeps row progress, retries, memory use, and table output under
  * runtime control. Use `count()` and `peek()` for bounded inspection. Use
  * `materialize(limit)` or async iteration only when the dataset is intentionally
- * small and bounded.
+ * small and bounded. `PlayDataset` intentionally does not expose `.rows`,
+ * `.toArray()`, or other array aliases; those hide the runtime cost of loading
+ * persisted rows into memory.
  */
 export interface PlayDataset<T> extends AsyncIterable<T> {
   readonly [PLAY_DATASET_BRAND]: true;

package/dist/repo/shared_libs/plays/static-pipeline.ts

@@ -3,6 +3,7 @@ import { normalizeTableNamespace } from './row-identity';
 export interface PlayStaticPipeline {
   tableNamespace?: string;
   inputFields?: string[];
+  rowKeyFields?: string[];
   csvArg?: string;
   hasInlineData?: boolean;
   csvDescription?: string;
@@ -32,6 +33,7 @@ export interface PlaySheetColumnContract {
   outputSqlName?: string;
   stepId?: string;
   toolId?: string;
+  isRowKey?: boolean;
 }
 
 export interface PlaySheetContract {
@@ -39,6 +41,40 @@ export interface PlaySheetContract {
   columns: PlaySheetColumnContract[];
 }
 
+export type PlayStaticColumnProducerKind =
+  | 'tool'
+  | 'waterfall'
+  | 'stepProgram'
+  | 'playCall'
+  | 'transform';
+
+export interface PlayStaticColumnProducer {
+  id: string;
+  kind: PlayStaticColumnProducerKind;
+  field: string;
+  toolId?: string;
+  playId?: string;
+  conditional?: boolean;
+  sourceRange?: PlayStaticSourceRange;
+  steps?: PlayStaticColumnProducer[];
+  substep: PlayStaticSubstep;
+}
+
+export interface PlayStaticDatasetColumn {
+  id: string;
+  source: PlaySheetColumnSource;
+  sqlName?: string;
+  producers: PlayStaticColumnProducer[];
+}
+
+export interface PlayCompiledStaticGraph {
+  topLevel: PlayStaticSubstep[];
+  datasets: Array<{
+    tableNamespace: string;
+    columns: PlayStaticDatasetColumn[];
+  }>;
+}
+
 export function ensureCompiledSheetContract(
   pipeline: PlayStaticPipeline | null | undefined,
 ): PlayStaticPipeline | null | undefined {
@@ -92,8 +128,27 @@ function truncateStaticSubstepsForStorage(
       return {
         ...base,
         inputFields: base.inputFields ? [...base.inputFields] : undefined,
+        rowKeyFields: base.rowKeyFields ? [...base.rowKeyFields] : undefined,
         outputFields: base.outputFields ? [...base.outputFields] : undefined,
+        columns: base.columns
+          ? base.columns.map((column) => ({
+              ...column,
+              producers: column.producers.map((producer) => ({
+                ...producer,
+                sourceRange: cloneStorageSafeSourceRange(producer.sourceRange),
+                steps: producer.steps
+                  ? producer.steps.map((stepProducer) => ({
+                      ...stepProducer,
+                      sourceRange: cloneStorageSafeSourceRange(
+                        stepProducer.sourceRange,
+                      ),
+                    }))
+                  : undefined,
+              })),
+            }))
+          : undefined,
         waterfallIds: base.waterfallIds ? [...base.waterfallIds] : undefined,
+        steps: truncateStaticSubstepsForStorage(base.steps, input),
         sheetContract: cloneStorageSafeSheetContract(base.sheetContract),
       };
     }
@@ -153,6 +208,9 @@ export function truncateStaticPipelineForStorage(
   return {
     ...pipeline,
     inputFields: pipeline.inputFields ? [...pipeline.inputFields] : undefined,
+    rowKeyFields: pipeline.rowKeyFields
+      ? [...pipeline.rowKeyFields]
+      : undefined,
     fields: [...(pipeline.fields ?? [])],
     stages: truncateStaticSubstepsForStorage(pipeline.stages, {
       embeddedPlayCallPipelineDepth,
@@ -198,8 +256,11 @@ export type PlayStaticSubstep = PlayStaticSubstepMetadata &
         name?: string;
         tableNamespace?: string;
         inputFields?: string[];
+        rowKeyFields?: string[];
         outputFields?: string[];
+        columns?: PlayStaticDatasetColumn[];
         waterfallIds?: string[];
+        steps?: PlayStaticSubstep[];
         sheetContract?: PlaySheetContract | null;
         description?: string;
         sourceRange?: PlayStaticSourceRange;
@@ -210,6 +271,8 @@ export type PlayStaticSubstep = PlayStaticSubstepMetadata &
         type: 'tool';
         toolId: string;
         field: string;
+        paramsSource?: string;
+        sourceText?: string;
         description?: string;
         inLoop?: boolean;
         isEventWait?: boolean;
@@ -263,6 +326,7 @@ export type PlayStaticSubstep = PlayStaticSubstepMetadata &
     | {
         type: 'run_javascript';
         alias: string;
+        sourceText?: string;
         description?: string;
         sourceRange?: PlayStaticSourceRange;
         callDepth?: number;
@@ -271,6 +335,7 @@ export type PlayStaticSubstep = PlayStaticSubstepMetadata &
     | {
         type: 'code';
         field: string;
+        sourceText?: string;
         description?: string;
         sourceRange?: PlayStaticSourceRange;
         callDepth?: number;
@@ -289,6 +354,12 @@ export function getCompiledPipelineSubsteps(
 
 export function getTopLevelPipelineSubsteps(
   pipeline: PlayStaticPipeline | null | undefined,
+): PlayStaticSubstep[] {
+  return compileStaticGraph(pipeline).topLevel;
+}
+
+function getRawTopLevelPipelineSubsteps(
+  pipeline: PlayStaticPipeline | null | undefined,
 ): PlayStaticSubstep[] {
   if (!pipeline) {
     return [];
@@ -328,6 +399,14 @@ export function flattenStaticSubsteps(
 
   for (const substep of substeps) {
     flattened.push(substep);
+    if (substep.type === 'dataset' && substep.steps?.length) {
+      flattened.push(...flattenStaticSubsteps(substep.steps));
+      continue;
+    }
+    if (substep.type === 'step_suite') {
+      flattened.push(...flattenStaticSubsteps(substep.steps));
+      continue;
+    }
     if (substep.type === 'play_call' && substep.pipeline) {
       const nestedSubsteps = getCompiledPipelineSubsteps(substep.pipeline);
       if (nestedSubsteps.length > 0) {
@@ -345,6 +424,137 @@ export function flattenStaticPipeline(
   return flattenStaticSubsteps(getCompiledPipelineSubsteps(pipeline));
 }
 
+export function compileStaticGraph(
+  pipeline: PlayStaticPipeline | null | undefined,
+): PlayCompiledStaticGraph {
+  const rawTopLevel = getRawTopLevelPipelineSubsteps(pipeline);
+  const datasets: PlayCompiledStaticGraph['datasets'] = [];
+  const topLevel = rawTopLevel.map((substep) => {
+    if (substep.type !== 'dataset') {
+      return substep;
+    }
+    const columns = compileDatasetColumns(substep);
+    const tableNamespace = (substep.tableNamespace ?? substep.field).trim();
+    if (tableNamespace) {
+      datasets.push({ tableNamespace, columns });
+    }
+    return {
+      ...substep,
+      columns,
+    } satisfies PlayStaticSubstep;
+  });
+  return { topLevel, datasets };
+}
+
+function compileDatasetColumns(
+  dataset: Extract<PlayStaticSubstep, { type: 'dataset' }>,
+): PlayStaticDatasetColumn[] {
+  const columnsById = new Map<string, PlayStaticDatasetColumn>();
+  const ensureColumn = (
+    id: string,
+    source: PlaySheetColumnSource,
+    sqlName?: string,
+  ) => {
+    const trimmed = id.trim();
+    if (!trimmed) return null;
+    const existing = columnsById.get(trimmed);
+    if (existing) {
+      if (!existing.sqlName && sqlName) existing.sqlName = sqlName;
+      return existing;
+    }
+    const column: PlayStaticDatasetColumn = {
+      id: trimmed,
+      source,
+      ...(sqlName ? { sqlName } : {}),
+      producers: [],
+    };
+    columnsById.set(trimmed, column);
+    return column;
+  };
+
+  for (const column of dataset.sheetContract?.columns ?? []) {
+    ensureColumn(column.id, column.source, column.sqlName);
+  }
+  for (const field of dataset.inputFields ?? []) {
+    ensureColumn(field, 'input', sqlSafePlayColumnName(field));
+  }
+  for (const field of dataset.outputFields ?? []) {
+    ensureColumn(field, 'datasetColumn', sqlSafePlayColumnName(field));
+  }
+
+  for (const substep of dataset.steps ?? []) {
+    const field = fieldForColumnProducer(substep);
+    if (!field) continue;
+    const column = ensureColumn(
+      field,
+      'datasetColumn',
+      sqlSafePlayColumnName(field),
+    );
+    if (!column) continue;
+    column.producers.push(columnProducerFromSubstep(substep, field));
+  }
+
+  return [...columnsById.values()];
+}
+
+function fieldForColumnProducer(substep: PlayStaticSubstep): string | null {
+  if ('field' in substep && typeof substep.field === 'string') {
+    return substep.field.trim() || null;
+  }
+  if (substep.type === 'run_javascript') {
+    return substep.alias.trim() || null;
+  }
+  return null;
+}
+
+function columnProducerFromSubstep(
+  substep: PlayStaticSubstep,
+  field: string,
+): PlayStaticColumnProducer {
+  const steps =
+    substep.type === 'step_suite'
+      ? substep.steps
+          .map((step) => {
+            const stepField = fieldForColumnProducer(step) ?? field;
+            return columnProducerFromSubstep(step, stepField);
+          })
+          .filter((producer) => producer.field.trim())
+      : undefined;
+  const kind: PlayStaticColumnProducerKind =
+    substep.type === 'tool'
+      ? 'tool'
+      : substep.type === 'waterfall'
+        ? 'waterfall'
+        : substep.type === 'step_suite'
+          ? 'stepProgram'
+          : substep.type === 'play_call'
+            ? 'playCall'
+            : 'transform';
+  return {
+    id: producerId(substep, field),
+    kind,
+    field,
+    ...(substep.type === 'tool' ? { toolId: substep.toolId } : {}),
+    ...(substep.type === 'play_call' ? { playId: substep.playId } : {}),
+    ...(substep.conditional ? { conditional: true } : {}),
+    ...(substep.sourceRange ? { sourceRange: substep.sourceRange } : {}),
+    ...(steps && steps.length > 0 ? { steps } : {}),
+    substep,
+  };
+}
+
+function producerId(substep: PlayStaticSubstep, field: string): string {
+  if (substep.type === 'tool') return `${field}:tool:${substep.toolId}`;
+  if (substep.type === 'waterfall') {
+    return `${field}:waterfall:${substep.id ?? substep.tool ?? 'unknown'}`;
+  }
+  if (substep.type === 'play_call') return `${field}:play:${substep.playId}`;
+  if (substep.type === 'step_suite') return `${field}:steps`;
+  if (substep.type === 'run_javascript')
+    return `${field}:transform:${substep.alias}`;
+  return `${field}:transform`;
+}
+
 export function resolveSheetContractForTableNamespace(
   pipeline: PlayStaticPipeline | null | undefined,
   tableNamespace: string | null | undefined,
@@ -400,6 +610,50 @@ export function resolveSheetContractForTableNamespace(
   return resolveFromPipeline(pipeline);
 }
 
+export function resolveStaticDatasetColumnsForTableNamespace(
+  pipeline: PlayStaticPipeline | null | undefined,
+  tableNamespace: string | null | undefined,
+): PlayStaticDatasetColumn[] {
+  const requestedNamespace = tableNamespace?.trim();
+  if (!pipeline || !requestedNamespace) {
+    return [];
+  }
+  const normalizedNamespace = normalizeTableNamespace(requestedNamespace);
+  const seen = new Set<PlayStaticPipeline>();
+
+  const resolveFromPipeline = (
+    currentPipeline: PlayStaticPipeline | null | undefined,
+  ): PlayStaticDatasetColumn[] | null => {
+    if (!currentPipeline || seen.has(currentPipeline)) {
+      return null;
+    }
+    seen.add(currentPipeline);
+
+    const compiled = compileStaticGraph(currentPipeline);
+    const matchingDataset = compiled.datasets.find(
+      (dataset) =>
+        normalizeTableNamespace(dataset.tableNamespace) ===
+        normalizedNamespace,
+    );
+    if (matchingDataset) {
+      return matchingDataset.columns;
+    }
+
+    for (const substep of getCompiledPipelineSubsteps(currentPipeline)) {
+      if (substep.type === 'play_call') {
+        const nestedColumns = resolveFromPipeline(substep.pipeline);
+        if (nestedColumns) {
+          return nestedColumns;
+        }
+      }
+    }
+
+    return null;
+  };
+
+  return resolveFromPipeline(pipeline) ?? [];
+}
+
 export function sqlSafePlayColumnName(id: string): string {
   const normalized = id
     .trim()
@@ -441,8 +695,14 @@ export function compileSheetContract(pipeline: PlayStaticPipeline): {
   const inputFields = pipeline.inputFields?.length
     ? pipeline.inputFields
     : [tableNamespace];
+  const rowKeyFieldSet = new Set(pipeline.rowKeyFields ?? []);
   for (const inputField of inputFields) {
-    addColumn({ id: inputField, source: 'input', field: inputField });
+    addColumn({
+      id: inputField,
+      source: 'input',
+      field: inputField,
+      ...(rowKeyFieldSet.has(inputField) ? { isRowKey: true } : {}),
+    });
   }
 
   for (const field of pipeline.fields) {

package/package.json

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