deepline 0.2.49 → 0.2.51

package/dist/bundling-sources/shared_libs/plays/enrich-play-compiler.ts

@@ -0,0 +1,1555 @@
+import {
+  getterFromLegacyExtractJs,
+  renderExtractedValueGetterExpression,
+  renderToolPayloadExpression,
+} from './tool-codegen';
+import { buildEnrichCompatibilityPlan } from './enrich-compat-adapter';
+import { assertUserCodeIsSafe } from './user-code-safety';
+
+export type EnrichStepCommand = {
+  alias: string;
+  tool: string;
+  operation?: string;
+  play?: {
+    ref: string;
+    mode?: 'scalar';
+    execution?: 'child' | 'inline';
+    inline?: {
+      exportName: string;
+      functionExpressionSource: string;
+      sourceHash: string;
+      typeImports: string[];
+      runtimeImports?: string[];
+    };
+  };
+  payload: Record<string, unknown>;
+  extract_js?: string;
+  run_if_js?: string;
+  description?: string;
+  disabled?: boolean;
+};
+
+export type EnrichWaterfallCommand = {
+  with_waterfall: string;
+  min_results?: number;
+  commands: EnrichCommand[];
+  description?: string;
+};
+
+export type EnrichCommand = EnrichStepCommand | EnrichWaterfallCommand;
+
+export type EnrichCompiledConfig = {
+  version: 1;
+  commands: EnrichCommand[];
+  cost_cap_usd_per_run?: number;
+  _comments?: Array<{ path: string; lines: string[] }>;
+  _expansion_preview?: {
+    plays: Array<{
+      alias: string;
+      tool_id: string;
+      template_group: string;
+      runtime_group: string;
+      estimated_credits_range: string;
+      steps: Array<Record<string, unknown>>;
+    }>;
+  };
+};
+
+export type EnrichPlaySourceOptions = {
+  playName?: string;
+  mapName?: string;
+  forceAliases?: Iterable<string>;
+  /** Hard Deepline-credit ceiling enforced by the play runtime. */
+  maxCreditsPerRun?: number;
+  /**
+   * Inline `run_javascript` steps as code instead of emitting a (runtime-
+   * rejected) `run_javascript` tool call, and emit the play with `// @ts-nocheck`.
+   * Off by default — used by the workflows→plays migration, not enrich-compat.
+   */
+  inlineRunJavascript?: boolean;
+  /**
+   * Emit clean, idiomatic step code — a direct `ctx.tools.execute(...)` call
+   * plus native `result.extractedValues.<field>?.get()` extraction — instead of
+   * the `__dlRunCommand`/`__dlExtract` wrappers. A localized `as any` at the
+   * loose V1-payload boundary keeps it typechecking. Off by default (enrich-
+   * compat keeps the wrappers + its tests); the workflows→plays migration opts in.
+   */
+  idiomaticGetters?: boolean;
+  failFast?: boolean;
+};
+
+function isWaterfall(
+  command: EnrichCommand,
+): command is EnrichWaterfallCommand {
+  return 'with_waterfall' in command;
+}
+
+/**
+ * True if the config contains any `run_javascript` step (including inside
+ * waterfalls). Those steps are inlined as arbitrary customer code, which cannot
+ * be strictly typechecked, so plays that contain them are emitted with
+ * `// @ts-nocheck` (they still bundle + run; non-JS plays stay strictly typed).
+ */
+function configHasRunJavascript(config: EnrichCompiledConfig): boolean {
+  const walk = (commands: EnrichCommand[]): boolean =>
+    commands.some((command) =>
+      isWaterfall(command)
+        ? walk(command.commands)
+        : command.tool === 'run_javascript',
+    );
+  return walk(config.commands ?? []);
+}
+
+function stringLiteral(value: string): string {
+  return JSON.stringify(value);
+}
+
+function stableJson(value: unknown): string {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableJson).join(',')}]`;
+  }
+  if (value && typeof value === 'object') {
+    const entries = Object.entries(value as Record<string, unknown>).sort(
+      ([left], [right]) => left.localeCompare(right),
+    );
+    return `{${entries
+      .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function indent(source: string, spaces: number): string {
+  const pad = ' '.repeat(spaces);
+  return source
+    .split('\n')
+    .map((line) => (line ? `${pad}${line}` : line))
+    .join('\n');
+}
+
+function commandCallId(command: EnrichStepCommand): string {
+  return `${command.alias}__${command.tool}`;
+}
+
+function normalizeAlias(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
+function renderExecuteStep(
+  command: EnrichStepCommand,
+  options: {
+    force: boolean;
+    precheck?: string;
+    legacyEnvelope?: boolean;
+    inlineRunJavascript?: boolean;
+    idiomaticGetters?: boolean;
+    nativeRunIf?: boolean;
+  } = {
+    force: false,
+  },
+): string {
+  if (
+    command.tool === 'run_javascript' &&
+    options.inlineRunJavascript &&
+    canInlineRunJavascript(command)
+  ) {
+    return renderInlineJavascriptStep(command, options);
+  }
+  if (command.play) {
+    return renderPlayStep(command, options);
+  }
+  if (options.idiomaticGetters) {
+    return renderIdiomaticExecuteStep(command, options);
+  }
+  const alias = stringLiteral(command.alias);
+  const callId = stringLiteral(commandCallId(command));
+  const tool = stringLiteral(command.tool);
+  const payload = stableJson(command.payload ?? {});
+  const extractJs = renderExtractFunction(command, 6);
+  const runIfJs = options.nativeRunIf
+    ? 'null'
+    : (renderRunIfFunction(command) ?? 'null');
+  const description = command.description
+    ? `,\n      description: ${stringLiteral(command.description)}`
+    : '';
+  const force = options.force ? `,\n    force: true` : '';
+  const legacyEnvelope = options.legacyEnvelope
+    ? `,\n    legacyEnvelope: true`
+    : '';
+
+  return [
+    `async (row, stepCtx) => {`,
+    ...(options.precheck ? [`  if (${options.precheck}) return null;`] : []),
+    `  return __dlRunCommand({`,
+    `    alias: ${alias},`,
+    `    callId: ${callId},`,
+    `    tool: ${tool},`,
+    `    payload: ${payload},`,
+    `    extract: ${extractJs},`,
+    `    runIf: ${runIfJs},`,
+    `    row,`,
+    `    stepCtx${description}${force}${legacyEnvelope}`,
+    `  });`,
+    `}`,
+  ].join('\n');
+}
+
+function canInlineRunJavascript(command: EnrichStepCommand): boolean {
+  const code =
+    typeof command.payload?.code === 'string' ? command.payload.code : '';
+  if (/\btriggerWorkflow\b/.test(code)) {
+    return false;
+  }
+  try {
+    assertUserCodeIsSafe(code, `run_javascript step "${command.alias}"`);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+function renderExtractFunction(
+  command: EnrichStepCommand,
+  indentSpaces: number,
+): string {
+  return command.extract_js
+    ? `({ row, result, data, raw, pick, extract, extractList, target, get }) => { const input = row; const context = row; const output_data = __dlLegacyOutputData(result, raw);\n${indent(renderJavascriptBody(command.extract_js), indentSpaces)}\n    }`
+    : 'null';
+}
+
+function renderRunIfFunction(command: EnrichStepCommand): string | null {
+  return command.run_if_js
+    ? `(row) => { const input = row; const context = row;\n${indent(renderJavascriptBody(command.run_if_js), 6)}\n    }`
+    : null;
+}
+
+function renderColumnRunIfFunction(command: EnrichStepCommand): string | null {
+  if (!command.run_if_js) {
+    return null;
+  }
+  // Runtime-sheet rows keep source CSV values in the projected-value envelope.
+  // Gate every column against the same prepared row used by templating and
+  // extraction, regardless of whether the column invokes a play or a tool.
+  return `(__dlRawRow) => { const row = __dlPrepareEnrichRow(__dlRawRow, [${stringLiteral(command.alias)}]); const input = row; const context = row;\n${indent(renderJavascriptBody(command.run_if_js), 6)}\n    }`;
+}
+
+function renderCombinedRunIfFunction(
+  precheck: string | null | undefined,
+  runIfSource: string | null,
+): string | null {
+  if (!runIfSource) {
+    return null;
+  }
+  return precheck
+    ? `(row) => { if (${precheck}) return false; return (${runIfSource})(row); }`
+    : runIfSource;
+}
+
+/**
+ * Emit a clean, idiomatic step: a direct `ctx.tools.execute(...)` call plus a
+ * native `result.extractedValues.<field>?.get()` extraction — no
+ * `__dlRunCommand`/`__dlExtract` wrappers. The execute argument is cast `as any`
+ * (V1 payloads are loose/templated and can't satisfy each tool's strict
+ * per-tool input type) and `result` is `any`, so it typechecks cleanly.
+ */
+function renderIdiomaticExecuteStep(
+  command: EnrichStepCommand,
+  options: {
+    force: boolean;
+    precheck?: string;
+    nativeRunIf?: boolean;
+  },
+): string {
+  const callId = stringLiteral(commandCallId(command));
+  const tool = stringLiteral(command.tool);
+  const input = renderToolPayloadExpression(command.payload ?? {});
+  const getter = getterFromLegacyExtractJs(command.extract_js, command.alias);
+  const extraction = getter
+    ? `${renderExtractedValueGetterExpression('result', getter)} ?? null`
+    : 'result';
+  const runIfLines =
+    command.run_if_js && !options.nativeRunIf
+      ? [
+          `  if (`,
+          `    !((row: Record<string, any>) => {`,
+          `      const input = row;`,
+          `      const context = row;`,
+          indent(renderJavascriptBody(command.run_if_js), 6),
+          `    })(row as Record<string, any>)`,
+          `  ) return null;`,
+        ]
+      : [];
+  return [
+    `async (row, ctx) => {`,
+    ...(options.precheck ? [`  if (${options.precheck}) return null;`] : []),
+    ...runIfLines,
+    `  const result: any = await ctx.tools.execute({`,
+    `    id: ${callId},`,
+    `    tool: ${tool},`,
+    `    input: ${input} as any,`,
+    `    description: ${stringLiteral((command.description ?? '').trim() || `Run ${command.alias} via ${command.tool}.`)},`,
+    ...(options.force ? [`      force: true,`] : []),
+    `  });`,
+    `  __dlAssertSuccessfulToolResult(result);`,
+    `  return ${extraction};`,
+    `}`,
+  ].join('\n');
+}
+
+function renderPlayStep(
+  command: EnrichStepCommand,
+  options: {
+    force: boolean;
+    precheck?: string;
+    legacyEnvelope?: boolean;
+    nativeRunIf?: boolean;
+  },
+): string {
+  const alias = stringLiteral(command.alias);
+  const callId = stringLiteral(commandCallId(command));
+  const playRef = stringLiteral(command.play?.ref ?? command.tool);
+  const payload = stableJson(command.payload ?? {});
+  const runIfJs = renderRunIfFunction(command) ?? 'null';
+  const runIfLines =
+    command.run_if_js && !options.nativeRunIf
+      ? [
+          `  const __dlRunIf = ${runIfJs};`,
+          `  if (!__dlRunIf(templateRow)) return null;`,
+        ]
+      : [];
+  const inline = command.play?.inline;
+  const inlineHandler = inline
+    ? `__dlInlinePlay_${inline.sourceHash.slice(0, 16)}`
+    : null;
+  return [
+    `async (row, stepCtx) => {`,
+    ...(options.precheck ? [`  if (${options.precheck}) return null;`] : []),
+    `  const templateRow = __dlPrepareEnrichRow(row, [${alias}]);`,
+    ...runIfLines,
+    `  const payload = __dlTemplate(${payload}, templateRow) as Record<string, unknown>;`,
+    `  if (__dlShouldSkipBlankPlayPayload(payload)) return null;`,
+    `  const result: unknown = `,
+    ...(inlineHandler
+      ? [
+          // Enrich validates and normalizes this payload against the certified
+          // prebuilt contract before code generation. The attachment retains
+          // its concrete input type, while generated payloads are records.
+          `    await __dlRunInlinePlay(${inlineHandler}, stepCtx, payload as never, ${options.force});`,
+        ]
+      : [
+          `    await stepCtx.runPlay(${callId}, ${playRef}, payload, {`,
+          `      description: ${stringLiteral(command.description ?? command.alias)}`,
+          `    });`,
+        ]),
+    ``,
+    `  __dlAssertSuccessfulToolResult(result);`,
+    `  return __dlPlayResultValue(${alias}, result);`,
+    `}`,
+  ].join('\n');
+}
+
+function collectInlinePlayHandlers(
+  commands: readonly EnrichCommand[],
+): Array<NonNullable<NonNullable<EnrichStepCommand['play']>['inline']>> {
+  const handlers = new Map<
+    string,
+    NonNullable<NonNullable<EnrichStepCommand['play']>['inline']>
+  >();
+  const visit = (command: EnrichCommand): void => {
+    if (isWaterfall(command)) {
+      command.commands.forEach(visit);
+      return;
+    }
+    const inline = command.play?.inline;
+    if (inline) handlers.set(inline.sourceHash, inline);
+  };
+  commands.forEach(visit);
+  return [...handlers.values()];
+}
+
+function renderInlineJavascriptStep(
+  command: EnrichStepCommand,
+  options: {
+    force: boolean;
+    precheck?: string;
+    legacyEnvelope?: boolean;
+    nativeRunIf?: boolean;
+  },
+): string {
+  const alias = stringLiteral(command.alias);
+  const extractJs = renderExtractFunction(command, 4);
+  const legacyEnvelope = options.legacyEnvelope ? 'true' : 'false';
+  const resultExpression = command.extract_js
+    ? `__dlExtract(${alias}, result, row as Record<string, unknown>, ${extractJs}, ${legacyEnvelope})`
+    : 'result';
+  const payload = stableJson(command.payload ?? {});
+  const code =
+    typeof command.payload?.code === 'string'
+      ? command.payload.code
+      : 'return null;';
+  const runIfLines =
+    command.run_if_js && !options.nativeRunIf
+      ? [
+          `  if (!((row: Record<string, any>) => { const input = row; const context = row;`,
+          indent(renderJavascriptBody(command.run_if_js), 4),
+          `  })(row as Record<string, any>)) return null;`,
+        ]
+      : [];
+  return [
+    `async (row) => {`,
+    ...(options.precheck ? [`  if (${options.precheck}) return null;`] : []),
+    ...runIfLines,
+    `  const __dlPayload = __dlRuntimePayload('run_javascript', __dlTemplate(${payload}, row as Record<string, unknown>) as Record<string, unknown>, row as Record<string, unknown>);`,
+    `  const rawResult = ((row: Record<string, any>, input: Record<string, any>, context: Record<string, any>) => {`,
+    `    const payload = __dlPayload as Record<string, any>;`,
+    `    const extract = __dlInlineExtract;`,
+    `    const extractList = __dlInlineExtractList;`,
+    `    return (() => {`,
+    indent(renderJavascriptBody(code), 4),
+    `    })();`,
+    `  })(row as Record<string, any>, row as Record<string, any>, row as Record<string, any>);`,
+    `  const result = await Promise.resolve(rawResult);`,
+    `  return ${resultExpression};`,
+    `}`,
+  ].join('\n');
+}
+
+function renderJavascriptBody(source: string): string {
+  // Single chokepoint for all user-authored play code (extract_js, run_if_js,
+  // run_javascript). Reject non-deterministic / sandbox-escaping constructs.
+  assertUserCodeIsSafe(source, 'play step code');
+  const trimmed = source.trim();
+  if (/^(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(trimmed)) {
+    return `return (${trimmed});`;
+  }
+  if (
+    trimmed &&
+    !trimmed.includes('\n') &&
+    !trimmed.includes(';') &&
+    !/\breturn\b/.test(trimmed) &&
+    !/^(?:throw|if|for|while|switch|try|catch|const|let|var|class|function)\b/.test(
+      trimmed,
+    )
+  ) {
+    return `return (${trimmed});`;
+  }
+  return source;
+}
+
+function renderColumnStep(
+  alias: string,
+  resolverSource: string,
+  options: {
+    runIfSource?: string | null;
+  } = {},
+): string {
+  const resolver = indent(resolverSource, 8);
+  const optionFields = options.runIfSource
+    ? [`runIf: ${options.runIfSource}`]
+    : [];
+  const optionSource =
+    optionFields.length > 0 ? `{ ${optionFields.join(', ')} }` : null;
+  return [
+    `      .withColumn(${stringLiteral(alias)},`,
+    `${resolver}${optionSource ? ',' : ''}`,
+    ...(optionSource ? [`        ${optionSource},`] : []),
+    `      )`,
+  ].join('\n');
+}
+
+function metadataMode(command: EnrichStepCommand): 'list' | 'scalar' {
+  return /\bextractList\s*\(/.test(command.extract_js ?? '')
+    ? 'list'
+    : 'scalar';
+}
+
+function metadataEntryForCommand(
+  command: EnrichStepCommand,
+  waterfallGroupId?: string,
+): Record<string, unknown> {
+  const entry: Record<string, unknown> = {
+    tool_id: command.tool,
+  };
+  if (command.play?.ref) {
+    entry.play_ref = command.play.ref;
+    entry.kind = 'play_call';
+  }
+  if (command.operation) {
+    entry.operation = command.operation;
+  }
+  if (command.extract_js?.trim()) {
+    entry.extract_js = command.extract_js.trim();
+  }
+  if (waterfallGroupId) {
+    entry.waterfall = {
+      group_id: waterfallGroupId,
+      mode: metadataMode(command),
+    };
+  }
+  return entry;
+}
+
+function collectMetadataColumns(
+  commands: EnrichCommand[],
+  waterfallGroupId?: string,
+): Record<string, unknown> {
+  const columns: Record<string, unknown> = {};
+  for (const command of commands) {
+    if (isWaterfall(command)) {
+      Object.assign(
+        columns,
+        collectMetadataColumns(command.commands, command.with_waterfall),
+      );
+      continue;
+    }
+    if (command.disabled) {
+      continue;
+    }
+    columns[normalizeAlias(command.alias)] = metadataEntryForCommand(
+      command,
+      waterfallGroupId,
+    );
+  }
+  return columns;
+}
+
+function collectGeneratedAliases(commands: EnrichCommand[]): string[] {
+  const aliases: string[] = [];
+  const addAlias = (alias: string): void => {
+    if (alias && !aliases.includes(alias)) {
+      aliases.push(alias);
+    }
+  };
+  for (const command of commands) {
+    if (isWaterfall(command)) {
+      const before = aliases.length;
+      collectGeneratedAliases(command.commands).forEach(addAlias);
+      if (aliases.length > before) {
+        addAlias(command.with_waterfall);
+        addAlias(`${command.with_waterfall}_source`);
+      }
+      continue;
+    }
+    if (!command.disabled) {
+      addAlias(command.alias);
+    }
+  }
+  return aliases;
+}
+
+function renderMetadataColumnStep(config: EnrichCompiledConfig): string {
+  const columns = collectMetadataColumns(config.commands);
+  if (Object.keys(columns).length === 0) {
+    return '';
+  }
+  return [
+    `      .withColumn('_metadata',`,
+    `        (row) => __dlMergeMetadata(__dlMetadataFromRow(row), ${stableJson({ columns })}),`,
+    `      )`,
+  ].join('\n');
+}
+
+function renderWaterfallColumns(
+  command: EnrichWaterfallCommand,
+  forceAliases: Set<string>,
+  inlineRunJavascript: boolean,
+  idiomaticGetters: boolean,
+): string[] {
+  const activeChildren = command.commands.filter(
+    (nested): nested is EnrichStepCommand =>
+      !isWaterfall(nested) && !nested.disabled,
+  );
+  const minResults =
+    typeof command.min_results === 'number'
+      ? Math.max(1, Math.trunc(command.min_results))
+      : 1;
+  const columnSteps = activeChildren
+    .map((nested, stepIndex) => {
+      if (isWaterfall(nested)) {
+        throw new Error('Nested with_waterfall blocks are not supported.');
+      }
+      if (nested.disabled) {
+        return null;
+      }
+      const priorAliases = activeChildren
+        .slice(0, stepIndex)
+        .map((prior) => prior.alias);
+      const force = forceAliases.has(normalizeAlias(nested.alias));
+      const precheck =
+        priorAliases.length > 0
+          ? `__dlWaterfallSatisfied(row, ${stableJson(priorAliases)}, ${minResults})`
+          : undefined;
+      const runIfSource = renderCombinedRunIfFunction(
+        precheck,
+        renderColumnRunIfFunction(nested),
+      );
+      return renderColumnStep(
+        nested.alias,
+        renderExecuteStep(nested, {
+          force,
+          precheck,
+          legacyEnvelope: Boolean(nested.extract_js),
+          inlineRunJavascript,
+          idiomaticGetters,
+          nativeRunIf: Boolean(runIfSource),
+        }),
+        {
+          runIfSource,
+        },
+      );
+    })
+    .filter((line): line is string => line !== null);
+  const aliases = activeChildren.map((nested) => nested.alias);
+  const returnExpr =
+    typeof command.min_results === 'number'
+      ? `__dlFirstMinResults(row, ${stableJson(aliases)}, ${Math.max(
+          1,
+          Math.trunc(command.min_results),
+        )})`
+      : `__dlFirstMeaningful(row, ${stableJson(aliases)})`;
+  if (columnSteps.length === 0) {
+    return [];
+  }
+  return [
+    ...columnSteps,
+    renderColumnStep(command.with_waterfall, `(row) => ${returnExpr}`),
+    renderColumnStep(
+      `${command.with_waterfall}_source`,
+      typeof command.min_results === 'number'
+        ? `(row) => __dlContributingAliases(row, ${stableJson(aliases)})`
+        : `(row) => __dlFirstMeaningfulAlias(row, ${stableJson(aliases)})`,
+    ),
+  ];
+}
+
+export function compileEnrichConfigToPlaySource(
+  config: EnrichCompiledConfig,
+  options: EnrichPlaySourceOptions = {},
+): string {
+  if (
+    options.maxCreditsPerRun !== undefined &&
+    (!Number.isFinite(options.maxCreditsPerRun) ||
+      options.maxCreditsPerRun <= 0)
+  ) {
+    throw new Error('maxCreditsPerRun must be a number greater than 0.');
+  }
+  const compatibility = buildEnrichCompatibilityPlan(options);
+  const { playName, mapName } = compatibility;
+  const inlineRunJavascript = options.inlineRunJavascript ?? false;
+  const idiomaticGetters = options.idiomaticGetters ?? false;
+  const forceAliases = new Set(
+    [...(options.forceAliases ?? [])].map((alias) => normalizeAlias(alias)),
+  );
+  const columnSteps: string[] = [];
+  const inlineHandlers = collectInlinePlayHandlers(config.commands);
+  const inlineTypeImports = [
+    ...new Set(inlineHandlers.flatMap((inline) => inline.typeImports ?? [])),
+  ].sort();
+  const inlineRuntimeImports = [
+    ...new Set(inlineHandlers.flatMap((inline) => inline.runtimeImports ?? [])),
+  ].sort();
+
+  config.commands.forEach((command) => {
+    if (isWaterfall(command)) {
+      columnSteps.push(
+        ...renderWaterfallColumns(
+          command,
+          forceAliases,
+          inlineRunJavascript,
+          idiomaticGetters,
+        ),
+      );
+      return;
+    }
+    if (command.disabled) {
+      return;
+    }
+    const force = forceAliases.has(normalizeAlias(command.alias));
+    const runIfSource = renderColumnRunIfFunction(command);
+    columnSteps.push(
+      renderColumnStep(
+        command.alias,
+        renderExecuteStep(command, {
+          force,
+          inlineRunJavascript,
+          idiomaticGetters,
+          nativeRunIf: Boolean(runIfSource),
+        }),
+        {
+          runIfSource,
+        },
+      ),
+    );
+  });
+
+  const columnStepSource =
+    columnSteps.length > 0
+      ? columnSteps.join('\n')
+      : `      .withColumn('noop', () => null)`;
+  const metadataColumnSource = renderMetadataColumnStep(config);
+  const generatedAliases = collectGeneratedAliases(config.commands);
+  const runOptionsSource = options.failFast
+    ? `{ key: (row, index) => __dlEnrichRowKey(row, index + rowStart), onRowError: 'fail' as const }`
+    : `{ key: (row, index) => __dlEnrichRowKey(row, index + rowStart) }`;
+  const playOptionsSource = [
+    `description: ${stringLiteral(
+      'Read a CSV file, run the configured Deepline enrich commands, and return enriched rows.',
+    )}`,
+    ...(options.maxCreditsPerRun === undefined
+      ? []
+      : [`billing: { maxCreditsPerRun: ${String(options.maxCreditsPerRun)} }`]),
+  ].join(', ');
+
+  const body = [
+    `function __dlRunInlinePlay<TContext, TInput, TOutput>(handler: (ctx: TContext, input: TInput) => Promise<TOutput>, scope: TContext, payload: TInput, force: boolean): Promise<TOutput> {`,
+    `  if (!force) return handler(scope, payload);`,
+    `  const runtimeScope = scope as TContext & { __deeplineRunWithForcedTools?: <T>(run: () => Promise<T>) => Promise<T> };`,
+    `  if (typeof runtimeScope.__deeplineRunWithForcedTools !== 'function') {`,
+    `    throw new Error('This runtime does not support forced certified inline play execution.');`,
+    `  }`,
+    `  return runtimeScope.__deeplineRunWithForcedTools(() => handler(scope, payload));`,
+    `}`,
+    ``,
+    ...inlineHandlers.flatMap((inline) => [
+      `const __dlInlinePlay_${inline.sourceHash.slice(0, 16)} = ${inline.functionExpressionSource};`,
+      ``,
+    ]),
+    `export default definePlay(${stringLiteral(playName)}, async (ctx, input: EnrichInput) => {`,
+    `  const sourceRows = await ctx.csv<Record<string, unknown>>(input.file);`,
+    `  const rowStart = __dlNonNegativeInteger(input.rowStart, 0);`,
+    `  const rowEndExclusive = Number.isFinite(input.rowEnd) ? Math.max(rowStart, __dlWholeNumber(input.rowEnd, rowStart) + 1) : undefined;`,
+    `  const rows: Array<Record<string, unknown>> = [];`,
+    `  let sourceRowIndex = 0;`,
+    `  for await (const row of sourceRows) {`,
+    `    if (rowEndExclusive !== undefined && sourceRowIndex >= rowEndExclusive) break;`,
+    `    if (sourceRowIndex >= rowStart) {`,
+    `      rows.push(__dlPrepareEnrichRow(row, ${stableJson(generatedAliases)}, sourceRowIndex));`,
+    `    }`,
+    `    sourceRowIndex += 1;`,
+    `  }`,
+    `  const enriched = await ctx`,
+    `    .dataset(${stringLiteral(mapName)}, rows)`,
+    columnStepSource,
+    ...(metadataColumnSource ? [metadataColumnSource] : []),
+    `    .run(${runOptionsSource});`,
+    `  return { rows: enriched, count: await enriched.count() };`,
+    `}, { ${playOptionsSource} });`,
+  ];
+
+  // Idiomatic plays call `ctx.tools.execute` directly and read results via
+  // `extractedValues.<field>.get()`, so they reference almost none of the
+  // legacy extraction preamble. Tree-shake it to only the helpers the body
+  // actually uses (plus their transitive deps) so the emitted play is clean.
+  const helpers = idiomaticGetters
+    ? selectUsedHelpers(helperSource(), body.join('\n'))
+    : helperSource();
+  const typeImports = idiomaticGetters
+    ? inlineTypeImports
+    : [...new Set([...inlineTypeImports, 'DeeplinePlayRuntimeContext'])].sort();
+
+  return [
+    ...(inlineRunJavascript && configHasRunJavascript(config)
+      ? ['// @ts-nocheck', '/* eslint-disable */', '']
+      : []),
+    `import { ${['definePlay', 'steps', ...inlineRuntimeImports].join(', ')} } from 'deepline';`,
+    ...(typeImports.length > 0
+      ? [`import type { ${typeImports.join(', ')} } from 'deepline';`]
+      : []),
+    ``,
+    `type EnrichInput = { file: string; rowStart?: number | null; rowEnd?: number | null };`,
+    ``,
+    helpers,
+    ``,
+    ...body,
+    ``,
+  ].join('\n');
+}
+
+/**
+ * Tree-shakes the `__dl*` helper preamble down to only the helpers referenced
+ * by `referenceSource` (the generated play body) plus their transitive helper
+ * dependencies. Helpers are blank-line-separated function/type/const blocks in
+ * `helperSource()`; a block is kept if its name appears in the body or in any
+ * already-kept helper's source. Behavior-preserving: an unreferenced helper is
+ * dead code, and `bundlePlayFile` would flag any helper dropped while still in
+ * use.
+ */
+function selectUsedHelpers(
+  helperBlock: string,
+  referenceSource: string,
+): string {
+  const referencesSymbol = (source: string, symbol: string): boolean =>
+    new RegExp(`\\b${symbol}\\b`).test(source);
+
+  const blocks = helperBlock
+    .split('\n\n')
+    .map((source) => source.trim())
+    .filter(Boolean)
+    .map((source) => ({
+      name:
+        source.match(/(?:function|type|const)\s+(__[A-Za-z]\w*)/)?.[1] ?? '',
+      source,
+    }));
+
+  const used = new Set<string>();
+  for (const { name } of blocks) {
+    if (name && referencesSymbol(referenceSource, name)) used.add(name);
+  }
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const usedSource = blocks
+      .filter((block) => used.has(block.name))
+      .map((block) => block.source)
+      .join('\n');
+    for (const { name } of blocks) {
+      if (!name || used.has(name)) continue;
+      if (referencesSymbol(usedSource, name)) {
+        used.add(name);
+        changed = true;
+      }
+    }
+  }
+
+  return blocks
+    .filter((block) => used.has(block.name))
+    .map((block) => block.source)
+    .join('\n\n');
+}
+
+function helperSource(): string {
+  return [
+    `function __dlWholeNumber(value: unknown, fallback: number): number {`,
+    `  const numeric = Number(value);`,
+    `  if (!Number.isFinite(numeric)) return fallback;`,
+    `  return Math.floor(numeric);`,
+    `}`,
+    ``,
+    `function __dlNonNegativeInteger(value: unknown, fallback: number): number {`,
+    `  return Math.max(0, __dlWholeNumber(value, fallback));`,
+    `}`,
+    ``,
+    `function __dlAtLeastOneInteger(value: number): number {`,
+    `  return Math.max(1, Math.floor(Number(value)));`,
+    `}`,
+    ``,
+    `function __dlRecord(value: unknown): value is Record<string, unknown> {`,
+    `  return Boolean(value && typeof value === 'object' && !Array.isArray(value));`,
+    `}`,
+    ``,
+    `function __dlParseMetadata(value: unknown): Record<string, unknown> | null {`,
+    `  if (__dlRecord(value)) return value;`,
+    `  if (typeof value !== 'string') return null;`,
+    `  const trimmed = value.trim();`,
+    `  if (!trimmed) return null;`,
+    `  const candidates = [trimmed];`,
+    `  if (trimmed.includes('\\\\\"')) candidates.push(trimmed.replace(/\\\\\"/g, '"'));`,
+    `  for (const candidate of candidates) {`,
+    `    try {`,
+    `      const parsed = JSON.parse(candidate);`,
+    `      if (__dlRecord(parsed)) return parsed;`,
+    `      if (typeof parsed === 'string') {`,
+    `        const nested = JSON.parse(parsed);`,
+    `        if (__dlRecord(nested)) return nested;`,
+    `      }`,
+    `    } catch {}`,
+    `  }`,
+    `  return null;`,
+    `}`,
+    ``,
+    `function __dlMetadataFromRow(row: Record<string, unknown>): unknown {`,
+    `  const direct = __dlParseMetadata(row._metadata);`,
+    `  if (direct) return direct;`,
+    `  const relocated = __dlParseMetadata(row.metadata);`,
+    `  if (relocated) return relocated;`,
+    `  const dotted = __dlParseMetadata(row['metadata.columns']);`,
+    `  if (dotted) return { columns: dotted };`,
+    `  const underscored = __dlParseMetadata(row.metadata__columns);`,
+    `  if (underscored) return { columns: underscored };`,
+    `  return row._metadata;`,
+    `}`,
+    ``,
+    `function __dlMergeMetadata(existing: unknown, patch: Record<string, unknown>): Record<string, unknown> {`,
+    `  const base = __dlParseMetadata(existing) ?? {};`,
+    `  const baseColumns = __dlRecord(base.columns) ? base.columns : {};`,
+    `  const patchColumns = __dlRecord(patch.columns) ? patch.columns : {};`,
+    `  return {`,
+    `    ...base,`,
+    `    ...patch,`,
+    `    columns: {`,
+    `      ...baseColumns,`,
+    `      ...patchColumns,`,
+    `    },`,
+    `  };`,
+    `}`,
+    ``,
+    `function __dlPathParts(path: string): string[] {`,
+    `  const source = String(path || '');`,
+    `  const parts: string[] = [];`,
+    `  let current = '';`,
+    `  for (let index = 0; index < source.length; index += 1) {`,
+    `    const char = source.slice(index, index + 1);`,
+    `    if (char === '.' || char === '[' || char === ']') {`,
+    `      const trimmed = current.trim();`,
+    `      if (trimmed) parts.push(trimmed);`,
+    `      current = '';`,
+    `      continue;`,
+    `    }`,
+    `    current += char;`,
+    `  }`,
+    `  const trimmed = current.trim();`,
+    `  if (trimmed) parts.push(trimmed);`,
+    `  return parts;`,
+    `}`,
+    ``,
+    `function __dlNormalizeHeader(value: string): string {`,
+    `  return value.trim().replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');`,
+    `}`,
+    ``,
+    `function __dlOwnStringKeys(record: Record<string, unknown>): string[] {`,
+    `  return Object.keys(record);`,
+    `}`,
+    ``,
+    `function __dlReadOwnField(record: Record<string, unknown>, key: string): unknown {`,
+    `  return record[key];`,
+    `}`,
+    ``,
+    `function __dlGetNormalizedKey(record: Record<string, unknown>, part: string): string | null {`,
+    `  const normalized = __dlNormalizeHeader(part);`,
+    `  for (const key of __dlOwnStringKeys(record)) {`,
+    `    if (__dlNormalizeHeader(key) === normalized) return key;`,
+    `  }`,
+    `  return null;`,
+    `}`,
+    ``,
+    `function __dlGetRecordField(record: Record<string, unknown>, part: string): { found: boolean; value: unknown } {`,
+    `  if (part in record) return { found: true, value: record[part] };`,
+    `  const normalizedKey = __dlGetNormalizedKey(record, part);`,
+    `  if (normalizedKey) return { found: true, value: __dlReadOwnField(record, normalizedKey) };`,
+    `  const projectedValues = record.__deeplineCsvProjectedValues;`,
+    `  if (projectedValues && typeof projectedValues === 'object' && !Array.isArray(projectedValues)) {`,
+    `    const projectedRecord = projectedValues as Record<string, unknown>;`,
+    `    if (part in projectedRecord) return { found: true, value: projectedRecord[part] };`,
+    `    const projectedKey = __dlGetNormalizedKey(projectedRecord, part);`,
+    `    if (projectedKey) return { found: true, value: __dlReadOwnField(projectedRecord, projectedKey) };`,
+    `  }`,
+    `  const data = record.data;`,
+    `  if (data && typeof data === 'object' && !Array.isArray(data)) {`,
+    `    const dataRecord = data as Record<string, unknown>;`,
+    `    if (part in dataRecord) return { found: true, value: dataRecord[part] };`,
+    `    const dataKey = __dlGetNormalizedKey(dataRecord, part);`,
+    `    if (dataKey) return { found: true, value: __dlReadOwnField(dataRecord, dataKey) };`,
+    `  }`,
+    `  return { found: false, value: undefined };`,
+    `}`,
+    ``,
+    `function __dlGetByPath(root: unknown, path: string): unknown {`,
+    `  let cursor = root;`,
+    `  const parts = __dlPathParts(path);`,
+    `  for (let index = 0; index < parts.length; index += 1) {`,
+    `    const part = parts[index] || '';`,
+    `    cursor = __dlParseJsonContainer(cursor);`,
+    `    if (!cursor || typeof cursor !== 'object') return undefined;`,
+    `    const record = cursor as Record<string, unknown>;`,
+    `    let field = { found: false, value: undefined as unknown };`,
+    `    for (let end = parts.length; end > index + 1; end -= 1) {`,
+    `      const dottedPart = parts.slice(index, end).join('.');`,
+    `      field = __dlGetRecordField(record, dottedPart);`,
+    `      if (field.found) {`,
+    `        index = end - 1;`,
+    `        break;`,
+    `      }`,
+    `    }`,
+    `    if (!field.found) field = __dlGetRecordField(record, part);`,
+    `    if (!field.found) return undefined;`,
+    `    cursor = field.value;`,
+    `  }`,
+    `  return cursor;`,
+    `}`,
+    ``,
+    `function __dlParseJsonContainer(value: unknown): unknown {`,
+    `  if (typeof value !== 'string') return value;`,
+    `  const trimmed = value.trim();`,
+    `  if ((!trimmed.startsWith('{') || !trimmed.endsWith('}')) && (!trimmed.startsWith('[') || !trimmed.endsWith(']'))) return value;`,
+    `  try {`,
+    `    return JSON.parse(trimmed);`,
+    `  } catch {`,
+    `    return value;`,
+    `  }`,
+    `}`,
+    ``,
+    `function __dlMeaningful(value: unknown): boolean {`,
+    `  if (value && typeof value === 'object' && !Array.isArray(value)) {`,
+    `    const record = value as Record<string, unknown>;`,
+    `    const status = typeof record.status === 'string' ? record.status.toLowerCase() : '';`,
+    `    if (status === 'error' || status === 'failed') return false;`,
+    `    if (typeof record.error === 'string' && record.error.trim()) return false;`,
+    `    const result = record.result;`,
+    `    if (result && typeof result === 'object' && !Array.isArray(result)) {`,
+    `      const resultRecord = result as Record<string, unknown>;`,
+    `      if (typeof resultRecord.error === 'string' && resultRecord.error.trim()) return false;`,
+    `      if (typeof resultRecord.message === 'string' && resultRecord.message.trim()) return false;`,
+    `    }`,
+    `    if ('matched_result' in record) return __dlMeaningful(record.matched_result);`,
+    `  }`,
+    `  return value !== null && value !== undefined && !(typeof value === 'string' && value.trim() === '') && !(Array.isArray(value) && value.length === 0);`,
+    `}`,
+    ``,
+    `function __dlErrorPayload(value: unknown): boolean {`,
+    `  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;`,
+    `  const record = value as Record<string, unknown>;`,
+    `  const status = typeof record.status === 'string' ? record.status.toLowerCase() : '';`,
+    `  const result = record.result;`,
+    `  const resultError = result && typeof result === 'object' && !Array.isArray(result) ? (result as Record<string, unknown>).error : null;`,
+    `  return status === 'error' || status === 'failed' || (typeof record.error === 'string' && record.error.trim() !== '') || (typeof resultError === 'string' && resultError.trim() !== '');`,
+    `}`,
+    ``,
+    `function __dlAssertSuccessfulToolResult(value: unknown): void {`,
+    `  if (!__dlErrorPayload(value)) return;`,
+    `  const record = value as Record<string, unknown>;`,
+    `  const result = record.result && typeof record.result === 'object' && !Array.isArray(record.result) ? record.result as Record<string, unknown> : null;`,
+    `  const message = typeof record.error === 'string' ? record.error : typeof result?.error === 'string' ? result.error : typeof result?.message === 'string' ? result.message : 'Tool returned an error-shaped result.';`,
+    `  throw new Error(message);`,
+    `}`,
+    ``,
+    `function __dlGeneratedCellError(value: unknown): boolean {`,
+    `  if (typeof value === 'string') {`,
+    `    const lower = value.trim().toLowerCase();`,
+    `    if (!lower) return false;`,
+    `    if (/^column\\s+.+\\s+failed\\b/.test(lower)) return true;`,
+    `    if (lower.startsWith('error:') || lower.includes(': error:') || lower.includes('"error"')) return true;`,
+    `    try {`,
+    `      return __dlGeneratedCellError(JSON.parse(value));`,
+    `    } catch {`,
+    `      return false;`,
+    `    }`,
+    `  }`,
+    `  if (!__dlRecord(value)) return false;`,
+    `  const status = typeof value.status === 'string' ? value.status.toLowerCase() : '';`,
+    `  if (status === 'error' || status === 'failed') return true;`,
+    `  if (typeof value.error === 'string' && value.error.trim() !== '') return true;`,
+    `  const raw = __dlGetByPath(value, 'toolResponse.raw') ?? __dlGetByPath(value, 'toolOutput.raw');`,
+    `  if (raw !== undefined && raw !== value && __dlGeneratedCellError(raw)) return true;`,
+    `  const result = value.result;`,
+    `  return result !== undefined && result !== value && __dlGeneratedCellError(result);`,
+    `}`,
+    ``,
+    `function __dlStripErroredGeneratedColumns(row: Record<string, unknown>, aliases: string[]): Record<string, unknown> {`,
+    `  let next: Record<string, unknown> | null = null;`,
+    `  for (const alias of aliases) {`,
+    `    for (const key of __dlAliasCandidates(alias)) {`,
+    `      if (key in row && __dlGeneratedCellError(row[key])) {`,
+    `        if (next === null) next = { ...row };`,
+    `        delete next[key];`,
+    `      }`,
+    `    }`,
+    `  }`,
+    `  return next ?? row;`,
+    `}`,
+    ``,
+    `function __dlTemplateContext(row: Record<string, unknown>): Record<string, unknown> {`,
+    `  const context: Record<string, unknown> = {};`,
+    `  const projectedValues = row.__deeplineCsvProjectedValues;`,
+    `  if (__dlRecord(projectedValues)) {`,
+    `    for (const [key, value] of Object.entries(projectedValues)) context[key] = value;`,
+    `  }`,
+    `  for (const [key, value] of Object.entries(row)) {`,
+    `    if (key.startsWith('__deepline')) continue;`,
+    `    context[key] = value;`,
+    `  }`,
+    `  return context;`,
+    `}`,
+    ``,
+    `function __dlPrepareEnrichRow(row: Record<string, unknown>, aliases: string[], sourceRowIndex?: number): Record<string, unknown> {`,
+    `  const cleaned = __dlStripErroredGeneratedColumns(row, aliases);`,
+    `  const templateContext = __dlTemplateContext(cleaned);`,
+    `  return {`,
+    `    ...templateContext,`,
+    `    ...cleaned,`,
+    `    ...(typeof sourceRowIndex === 'number' && '__deeplineSourceRowIndex' in cleaned ? { __deeplineOriginalSourceRowIndex: cleaned.__deeplineSourceRowIndex } : {}),`,
+    `    ...(typeof sourceRowIndex === 'number' ? { __deeplineSourceRowIndex: sourceRowIndex } : {}),`,
+    `    __deeplineCsvProjectedFields: Object.keys(templateContext),`,
+    `    __deeplineCsvProjectedValues: templateContext,`,
+    `  };`,
+    `}`,
+    ``,
+    `function __dlRawToolOutput(result: unknown): unknown {`,
+    `  if (!result || typeof result !== 'object') return result;`,
+    `  const record = result as Record<string, unknown>;`,
+    `  return __dlGetByPath(record, 'toolOutput.raw') ?? __dlGetByPath(record, 'toolResponse.raw') ?? record.result ?? record.output ?? result;`,
+    `}`,
+    ``,
+    `function __dlPushCandidate(candidates: unknown[], value: unknown): void {`,
+    `  if (value === null || value === undefined) return;`,
+    `  if (!candidates.includes(value)) candidates.push(value);`,
+    `}`,
+    ``,
+    `function __dlRawToolCandidates(raw: unknown): unknown[] {`,
+    `  const candidates: unknown[] = [raw];`,
+    `  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return candidates;`,
+    `  const record = raw as Record<string, unknown>;`,
+    `  __dlPushCandidate(candidates, record.data);`,
+    `  __dlPushCandidate(candidates, record.result);`,
+    `  __dlPushCandidate(candidates, record.output);`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'data.data'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'result.data'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'result.data.data'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'output.data'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'output.data.data'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'output.body'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'output.body.data'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'toolResponse.raw'));`,
+    `  __dlPushCandidate(candidates, __dlGetByPath(record, 'toolOutput.raw'));`,
+    `  return candidates;`,
+    `}`,
+    ``,
+    `function __dlLegacyResultData(value: unknown): unknown {`,
+    `  if (!value || typeof value !== 'object' || Array.isArray(value)) return value;`,
+    `  const record = value as Record<string, unknown>;`,
+    `  return 'data' in record ? record.data : value;`,
+    `}`,
+    ``,
+    `function __dlLegacyOutputData(result: unknown, raw: unknown): unknown {`,
+    `  const rawRecord = raw && typeof raw === 'object' && !Array.isArray(raw) ? (raw as Record<string, unknown>) : null;`,
+    `  const data = rawRecord && 'data' in rawRecord ? rawRecord.data : raw;`,
+    `  const existingResult = rawRecord && rawRecord.result && typeof rawRecord.result === 'object' && !Array.isArray(rawRecord.result) ? (rawRecord.result as Record<string, unknown>) : null;`,
+    `  const resultData = existingResult && 'data' in existingResult ? __dlLegacyResultData(existingResult.data) : __dlLegacyResultData(data);`,
+    `  const resultObject = resultData && typeof resultData === 'object' && !Array.isArray(resultData) ? (resultData as Record<string, unknown>) : {};`,
+    `  return {`,
+    `    ...(rawRecord ?? {}),`,
+    `    data,`,
+    `    result: { ...resultObject, ...(existingResult ?? {}), data: resultData },`,
+    `    raw,`,
+    `    toolResponse: { raw },`,
+    `    originalResult: result,`,
+    `  };`,
+    `}`,
+    ``,
+    `function __dlTemplate(value: unknown, row: Record<string, unknown>): unknown {`,
+    `  if (Array.isArray(value)) return value.map((entry) => __dlTemplate(entry, row));`,
+    `  if (value && typeof value === 'object') {`,
+    `    return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([key, entry]) => [key, __dlTemplate(entry, row)]));`,
+    `  }`,
+    `  if (typeof value !== 'string') return value;`,
+    `  const exact = value.match(/^\\{\\{\\s*([^{}]+?)\\s*\\}\\}$/);`,
+    `  if (exact) return __dlGetByPath(row, exact[1] || '');`,
+    `  let rendered = '';`,
+    `  let cursor = 0;`,
+    `  while (cursor < value.length) {`,
+    `    const open = value.indexOf('{{', cursor);`,
+    `    if (open < 0) {`,
+    `      rendered += value.slice(cursor);`,
+    `      break;`,
+    `    }`,
+    `    const close = value.indexOf('}}', open + 2);`,
+    `    if (close < 0) {`,
+    `      rendered += value.slice(cursor);`,
+    `      break;`,
+    `    }`,
+    `    rendered += value.slice(cursor, open);`,
+    `    const path = value.slice(open + 2, close).trim();`,
+    `    const replacement = __dlGetByPath(row, path);`,
+    `    rendered += replacement === null || replacement === undefined ? '' : String(replacement);`,
+    `    cursor = close + 2;`,
+    `  }`,
+    `  return rendered;`,
+    `}`,
+    ``,
+    `function __dlStableRowKey(row: Record<string, unknown>, index: number): string {`,
+    `  for (const key of ['id', 'ID', 'row_key', 'ROW_KEY', 'email', 'Email', 'linkedin_url', 'LINKEDIN_URL', 'domain', 'DOMAIN', 'name', 'Name']) {`,
+    `    const value = row[key];`,
+    `    if (__dlMeaningful(value)) return String(value);`,
+    `  }`,
+    `  return String(index);`,
+    `}`,
+    ``,
+    `function __dlEnrichRowKey(row: Record<string, unknown>, index: number): string {`,
+    '  return `${__dlStableRowKey(row, index)}:${index}`;',
+    `}`,
+    ``,
+    `function __dlScalarValue(value: unknown): unknown {`,
+    `  if (value && typeof value === 'object' && !Array.isArray(value)) {`,
+    `    const record = value as Record<string, unknown>;`,
+    `    if ('matched_result' in record) return __dlScalarValue(record.matched_result);`,
+    `    for (const key of ['value', 'email', 'output', 'result', 'data']) {`,
+    `      const nested = record[key];`,
+    `      if (__dlMeaningful(nested)) return __dlScalarValue(nested);`,
+    `    }`,
+    `  }`,
+    `  return value;`,
+    `}`,
+    ``,
+    `function __dlFirstMeaningful(row: Record<string, unknown>, aliases: string[]): unknown {`,
+    `  for (const alias of aliases) {`,
+    `    const value = row[alias];`,
+    `    if (__dlMeaningful(value)) return __dlScalarValue(value);`,
+    `  }`,
+    `  return null;`,
+    `}`,
+    ``,
+    `function __dlFirstMeaningfulAlias(row: Record<string, unknown>, aliases: string[]): string | null {`,
+    `  for (const alias of aliases) {`,
+    `    if (__dlMeaningful(row[alias])) return alias;`,
+    `  }`,
+    `  return null;`,
+    `}`,
+    ``,
+    `function __dlListValue(value: unknown): unknown[] {`,
+    `  if (Array.isArray(value)) return value.filter(__dlMeaningful);`,
+    `  if (value && typeof value === 'object') {`,
+    `    const record = value as Record<string, unknown>;`,
+    `    if ('matched_result' in record) return __dlListValue(record.matched_result);`,
+    `    for (const key of ['result', 'value', 'data']) {`,
+    `      const nested = record[key];`,
+    `      const nestedList = __dlListValue(nested);`,
+    `      if (nestedList.length > 0) return nestedList;`,
+    `    }`,
+    `    return __dlMeaningful(value) ? [value] : [];`,
+    `  }`,
+    `  return __dlMeaningful(value) ? [value] : [];`,
+    `}`,
+    ``,
+    `function __dlFirstMinResults(row: Record<string, unknown>, aliases: string[], minResults: number): unknown {`,
+    `  const values: unknown[] = [];`,
+    `  for (const alias of aliases) {`,
+    `    values.push(...__dlListValue(row[alias]));`,
+    `    if (values.length >= minResults) return values;`,
+    `  }`,
+    `  return values.length > 0 ? values : null;`,
+    `}`,
+    ``,
+    `function __dlContributingAliases(row: Record<string, unknown>, aliases: string[]): string[] | null {`,
+    `  const sources: string[] = [];`,
+    `  for (const alias of aliases) {`,
+    `    if (__dlListValue(row[alias]).length > 0) sources.push(alias);`,
+    `  }`,
+    `  return sources.length > 0 ? sources : null;`,
+    `}`,
+    ``,
+    `function __dlWaterfallSatisfied(row: Record<string, unknown>, aliases: string[], minResults: number): boolean {`,
+    `  let count = 0;`,
+    `  for (const alias of aliases) {`,
+    `    count += __dlListValue(row[alias]).length;`,
+    `    if (count >= __dlAtLeastOneInteger(minResults)) return true;`,
+    `  }`,
+    `  return false;`,
+    `}`,
+    ``,
+    `function __dlKeyPaths(key: string): string[] {`,
+    `  const normalized = String(key || '').trim();`,
+    `  if (normalized === 'email') return ['email', 'email_address', 'person.email.email', 'data.person.email.email', 'result.person.email.email', 'result.data.person.email.email', 'person.email', 'contact.email', 'data.email', 'result.data.email'];`,
+    `  if (normalized === 'personal_email') return ['personal_email', 'email', 'email_address', 'data.personal_email', 'data.email'];`,
+    `  if (normalized === 'phone') return ['phone', 'phone_number', 'mobile_phone', 'mobile_phone_number', 'data.phone'];`,
+    `  if (normalized === 'linkedin') return ['linkedin', 'linkedin_url', 'linkedin_profile', 'profile_url', 'person.linkedin', 'person.linkedin_url'];`,
+    `  if (normalized === 'full_name') return ['full_name', 'name', 'person.full_name', 'person.name'];`,
+    `  if (normalized === 'first_name') return ['first_name', 'person.first_name'];`,
+    `  if (normalized === 'last_name') return ['last_name', 'person.last_name'];`,
+    `  if (normalized === 'title') return ['title', 'job_title', 'current_title', 'headline', 'person.title'];`,
+    `  if (normalized === 'company_name') return ['company_name', 'company.name', 'organization.name'];`,
+    `  if (normalized === 'company_domain') return ['company_domain', 'domain', 'company.domain', 'organization.domain'];`,
+    `  if (normalized === 'status') return ['status', 'verdict', 'state'];`,
+    `  if (normalized === 'email_status') return ['email_status', 'status', 'verdict', 'data.email_status'];`,
+    `  return [normalized];`,
+    `}`,
+    ``,
+    `function __dlSelectorKeys(selector: unknown): string[] | null {`,
+    `  if (!selector || typeof selector !== 'object' || Array.isArray(selector)) return null;`,
+    `  const keys = (selector as { keys?: unknown }).keys;`,
+    `  if (!Array.isArray(keys) || keys.length === 0) return null;`,
+    `  const out: string[] = [];`,
+    `  for (const key of keys) {`,
+    `    if (typeof key === 'string' && key.trim()) out.push(key.trim());`,
+    `  }`,
+    `  return out.length > 0 ? out : null;`,
+    `}`,
+    ``,
+    `function __dlFirstByPaths(payload: unknown, paths: string[] | string): unknown {`,
+    `  const candidates = Array.isArray(paths) ? paths : [paths];`,
+    `  for (const path of candidates) {`,
+    `    for (const candidate of __dlRawToolCandidates(payload)) {`,
+    `      const value = __dlGetByPath(candidate, String(path));`,
+    `      if (__dlMeaningful(value)) return value;`,
+    `    }`,
+    `  }`,
+    `  return null;`,
+    `}`,
+    ``,
+    `function __dlExtractTarget(payload: unknown, key: string): unknown {`,
+    `  return __dlFirstByPaths(payload, __dlKeyPaths(key));`,
+    `}`,
+    ``,
+    `function __dlExtractedValue(result: unknown, key: string): unknown {`,
+    `  if (!result || typeof result !== 'object' || Array.isArray(result)) return undefined;`,
+    `  const extractedValues = (result as Record<string, unknown>).extractedValues;`,
+    `  if (!extractedValues || typeof extractedValues !== 'object' || Array.isArray(extractedValues)) return undefined;`,
+    `  const accessor = (extractedValues as Record<string, unknown>)[key];`,
+    `  if (!accessor || typeof accessor !== 'object' || Array.isArray(accessor)) return undefined;`,
+    `  const record = accessor as Record<string, unknown>;`,
+    `  const get = record.get;`,
+    `  if (typeof get === 'function') {`,
+    `    try {`,
+    `      return (get as () => unknown)();`,
+    `    } catch {`,
+    `      return undefined;`,
+    `    }`,
+    `  }`,
+    `  return record.value;`,
+    `}`,
+    ``,
+    `function __dlLegacyExtractorPayload(payload: unknown, raw: unknown): unknown {`,
+    `  if (payload === undefined || payload === null) return raw;`,
+    `  if (payload && typeof payload === 'object' && !Array.isArray(payload) && Object.keys(payload as Record<string, unknown>).length === 0) return raw;`,
+    `  return payload;`,
+    `}`,
+    ``,
+    `function __dlLegacyMatchedEnvelope(value: unknown, raw: unknown): unknown {`,
+    `  if (value && typeof value === 'object' && !Array.isArray(value) && 'matched_result' in (value as Record<string, unknown>)) return value;`,
+    `  const legacyOutput = __dlLegacyOutputData(undefined, raw) as Record<string, unknown>;`,
+    `  const legacyResult = legacyOutput.result && typeof legacyOutput.result === 'object' && !Array.isArray(legacyOutput.result) ? legacyOutput.result : raw;`,
+    `  return { matched_result: value, result: legacyResult };`,
+    `}`,
+    ``,
+    `function __dlString(value: unknown): string | null {`,
+    `  return typeof value === 'string' && value.trim() ? value.trim() : null;`,
+    `}`,
+    ``,
+    `// NOTE: email_status is NOT normalized here. It is materialized once by the`,
+    `// provider's emailStatus({...}) contract via buildEmailStatus and read back`,
+    `// through __dlExtractedValue(result, 'email_status') below. There is no`,
+    `// legacy string coarsening — see CONTEXT.md "Provider Email Status Contract".`,
+    ``,
+    `function __dlListPathCandidates(selector: unknown): string[] {`,
+    `  const paths: string[] = [];`,
+    `  const push = (path: string) => { if (path && !paths.includes(path)) paths.push(path); };`,
+    `  if (Array.isArray(selector)) {`,
+    `    for (const path of selector) push(String(path));`,
+    `  } else if (typeof selector === 'string') {`,
+    `    push(selector);`,
+    `  }`,
+    `  for (const path of ['data', 'data.people', 'data.persons', 'data.contacts', 'data.results', 'data.leads', 'data.items', 'result.data', 'result.people', 'result.persons', 'result.contacts', 'result.results', 'result.leads', 'result.items', 'people', 'persons', 'contacts', 'results', 'leads', 'items', 'output.body', 'body']) push(path);`,
+    `  return paths;`,
+    `}`,
+    ``,
+    `function __dlFindList(payload: unknown, selector: unknown): unknown[] {`,
+    `  if (Array.isArray(payload)) return payload;`,
+    `  for (const path of __dlListPathCandidates(selector)) {`,
+    `    for (const candidate of __dlRawToolCandidates(payload)) {`,
+    `      const value = __dlGetByPath(candidate, path);`,
+    `      if (Array.isArray(value)) return value;`,
+    `    }`,
+    `  }`,
+    `  const queue = __dlRawToolCandidates(payload);`,
+    `  const seen: unknown[] = [];`,
+    `  for (let index = 0; index < queue.length; index += 1) {`,
+    `    const current = queue[index];`,
+    `    if (!current || typeof current !== 'object' || seen.includes(current)) continue;`,
+    `    seen.push(current);`,
+    `    for (const value of Object.values(current as Record<string, unknown>)) {`,
+    `      if (Array.isArray(value)) return value;`,
+    `      if (value && typeof value === 'object') queue.push(value);`,
+    `    }`,
+    `  }`,
+    `  return [];`,
+    `}`,
+    ``,
+    `function __dlDeriveFullName(row: Record<string, unknown>): string | null {`,
+    `  const existing = __dlFirstByPaths(row, ['full_name', 'name']);`,
+    `  if (typeof existing === 'string' && existing.trim()) return existing.trim();`,
+    `  const first = __dlFirstByPaths(row, ['first_name', 'firstName']);`,
+    `  const last = __dlFirstByPaths(row, ['last_name', 'lastName']);`,
+    `  const parts = [first, last].filter((part): part is string => typeof part === 'string').map((part) => part.trim()).filter(Boolean);`,
+    `  return parts.length > 0 ? parts.join(' ') : null;`,
+    `}`,
+    ``,
+    `function __dlProjectListRows(rows: unknown[], keys: string[], payload: unknown): Array<Record<string, unknown>> {`,
+    `  const projected: Array<Record<string, unknown>> = [];`,
+    `  for (const row of rows) {`,
+    `    const record = row && typeof row === 'object' && !Array.isArray(row) ? (row as Record<string, unknown>) : { value: row };`,
+    `    const out: Record<string, unknown> = {};`,
+    `    for (const key of keys) {`,
+    `      let value = __dlExtractTarget(record, key);`,
+    `      if (!__dlMeaningful(value) && key === 'full_name') value = __dlDeriveFullName(record);`,
+    `      if (!__dlMeaningful(value)) value = __dlExtractTarget(payload, key);`,
+    `      out[key] = value === undefined ? null : value;`,
+    `    }`,
+    `    if (Object.values(out).some(__dlMeaningful)) projected.push(out);`,
+    `  }`,
+    `  return projected;`,
+    `}`,
+    ``,
+    `type __DlExtractorHelpers = { row: Record<string, unknown>; result: unknown; data: unknown; raw: unknown; pick: (paths: string[] | string) => unknown; extract: (...args: unknown[]) => unknown; extractList: (...args: unknown[]) => unknown[]; target: (paths: string[] | string) => unknown; get: (path: string) => unknown };`,
+    ``,
+    `function __dlInlineExtractorArgs(args: unknown[]): { payload: unknown; selector: unknown } {`,
+    `  if (args.length >= 3) return { payload: args[1], selector: args[2] };`,
+    `  if (args.length >= 2) return { payload: args[0], selector: args[1] };`,
+    `  return { payload: args[0], selector: undefined };`,
+    `}`,
+    ``,
+    `function __dlInlineExtract(...args: unknown[]): unknown {`,
+    `  const { payload, selector } = __dlInlineExtractorArgs(args);`,
+    `  if (selector === undefined) return payload;`,
+    `  const keys = __dlSelectorKeys(selector);`,
+    `  if (keys) return Object.fromEntries(keys.map((key) => [key, __dlExtractTarget(payload, key) ?? null]));`,
+    `  if (Array.isArray(selector)) return __dlFirstByPaths(payload, selector.map(String));`,
+    `  if (typeof selector === 'string') return __dlExtractTarget(payload, selector) ?? __dlFirstByPaths(payload, selector);`,
+    `  return selector;`,
+    `}`,
+    ``,
+    `function __dlInlineExtractList(...args: unknown[]): unknown[] {`,
+    `  const { payload, selector } = __dlInlineExtractorArgs(args);`,
+    `  const rows = __dlFindList(payload, selector);`,
+    `  const keys = __dlSelectorKeys(selector);`,
+    `  return keys ? __dlProjectListRows(rows, keys, payload) : rows;`,
+    `}`,
+    ``,
+    `function __dlExtract(alias: string, result: unknown, row: Record<string, unknown>, extractor: ((args: __DlExtractorHelpers) => unknown) | null, legacyEnvelope = false): unknown {`,
+    `  const raw = __dlRawToolOutput(result);`,
+    `  if (!extractor) return raw;`,
+    `  const pick = (paths: string[] | string) => {`,
+    `    const requestedPaths = Array.isArray(paths) ? paths : [paths];`,
+    `    for (const requestedPath of requestedPaths) {`,
+    `      for (const path of __dlKeyPaths(String(requestedPath))) {`,
+    `        const extractedValue = __dlExtractedValue(result, path);`,
+    `        if (__dlMeaningful(extractedValue)) return extractedValue;`,
+    `        for (const candidate of __dlRawToolCandidates(raw)) {`,
+    `          const value = __dlGetByPath(candidate, path);`,
+    `          if (__dlMeaningful(value)) return value;`,
+    `        }`,
+    `      }`,
+    `    }`,
+    `    return null;`,
+    `  };`,
+    `  const extract = (...args: unknown[]): unknown => {`,
+    `    const payload = args.length >= 3 ? __dlLegacyExtractorPayload(args[1], raw) : raw;`,
+    `    const selector = args.length >= 3 ? args[2] : args[0];`,
+    `    if (selector === undefined) return payload;`,
+    `    const keys = __dlSelectorKeys(selector);`,
+    `    if (keys) return Object.fromEntries(keys.map((key) => [key, __dlExtractTarget(payload, key) ?? null]));`,
+    `    if (Array.isArray(selector)) return __dlFirstByPaths(payload, selector.map(String));`,
+    `    if (typeof selector === 'string') {`,
+    `      const extractedValue = __dlExtractedValue(result, selector);`,
+    `      if (__dlMeaningful(extractedValue)) return __dlLegacyMatchedEnvelope(extractedValue, payload);`,
+    `      return __dlExtractTarget(payload, selector) ?? __dlFirstByPaths(payload, selector);`,
+    `    }`,
+    `    return selector;`,
+    `  };`,
+    `  const extractList = (...args: unknown[]): unknown[] => {`,
+    `    const payload = args.length >= 3 ? __dlLegacyExtractorPayload(args[1], raw) : raw;`,
+    `    const selector = args.length >= 3 ? args[2] : args[0];`,
+    `    const rows = __dlFindList(payload, selector);`,
+    `    const keys = __dlSelectorKeys(selector);`,
+    `    return keys ? __dlProjectListRows(rows, keys, payload) : rows;`,
+    `  };`,
+    `  const get = (path: string): unknown => __dlExtractedValue(result, path) ?? __dlFirstByPaths(raw, path);`,
+    `  let resolved: unknown;`,
+    `  const extracted = extractor({ row, result, data: raw, raw, pick, extract, extractList, target: pick, get });`,
+    `  resolved = typeof extracted === 'function' ? (extracted as (outputData: unknown) => unknown)(__dlLegacyOutputData(result, raw)) : extracted;`,
+    `  if (resolved && typeof resolved === 'object' && !Array.isArray(resolved) && alias in (resolved as Record<string, unknown>)) {`,
+    `    const aliasValue = (resolved as Record<string, unknown>)[alias];`,
+    `    return legacyEnvelope && __dlMeaningful(aliasValue) ? __dlLegacyMatchedEnvelope(aliasValue, raw) : aliasValue;`,
+    `  }`,
+    `  if (Array.isArray(resolved)) return __dlLegacyMatchedEnvelope(resolved, raw);`,
+    `  if ((resolved === null || resolved === undefined) && __dlErrorPayload(raw)) return raw;`,
+    `  if (legacyEnvelope && __dlMeaningful(resolved)) return __dlLegacyMatchedEnvelope(resolved, raw);`,
+    `  return resolved === undefined ? raw : resolved;`,
+    `}`,
+    ``,
+    `function __dlMergeContextRecord(existing: unknown, defaults: Record<string, unknown>): Record<string, unknown> {`,
+    `  if (!existing || typeof existing !== 'object' || Array.isArray(existing)) return { ...defaults };`,
+    `  return { ...defaults, ...(existing as Record<string, unknown>) };`,
+    `}`,
+    ``,
+    `function __dlCompactJavascriptContext(value: unknown, depth = 0): unknown {`,
+    `  if (depth > 8) return '[Object]';`,
+    `  if (typeof value === 'string') return value.length > 20000 ? value.slice(0, 20000) + '...[truncated]' : value;`,
+    `  if (!value || typeof value !== 'object') return value;`,
+    `  if (Array.isArray(value)) {`,
+    `    const limit = depth <= 2 ? 25 : 10;`,
+    `    const items = value.slice(0, limit).map((entry) => __dlCompactJavascriptContext(entry, depth + 1));`,
+    `    if (value.length > limit) items.push({ __deepline_truncated_items: value.length - limit });`,
+    `    return items;`,
+    `  }`,
+    `  const out: Record<string, unknown> = {};`,
+    `  let count = 0;`,
+    `  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {`,
+    `    count += 1;`,
+    `    if (count > 80) {`,
+    `      out.__deepline_truncated_fields = count - 80;`,
+    `      break;`,
+    `    }`,
+    `    out[key] = __dlCompactJavascriptContext(entry, depth + 1);`,
+    `  }`,
+    `  return out;`,
+    `}`,
+    ``,
+    `function __dlRuntimePayload(tool: string, payload: Record<string, unknown>, row: Record<string, unknown>): Record<string, unknown> {`,
+    `  if (tool !== 'run_javascript') return payload;`,
+    `  const compactRow = __dlCompactJavascriptContext(row) as Record<string, unknown>;`,
+    `  return {`,
+    `    ...payload,`,
+    `    row: __dlMergeContextRecord(payload.row, compactRow),`,
+    `    input: __dlMergeContextRecord(payload.input, compactRow),`,
+    `    context: __dlMergeContextRecord(payload.context, compactRow),`,
+    `  };`,
+    `}`,
+    ``,
+    `function __dlBlankPayloadValue(value: unknown): boolean {`,
+    `  return value === null || value === undefined || (typeof value === 'string' && value.trim() === '');`,
+    `}`,
+    ``,
+    `function __dlShouldSkipEmptyPayload(tool: string, payload: Record<string, unknown>): boolean {`,
+    `  if (tool === 'leadmagic_email_validation') return __dlBlankPayloadValue(payload.email);`,
+    `  return false;`,
+    `}`,
+    ``,
+    `function __dlPayloadHasMeaningfulValue(value: unknown): boolean {`,
+    `  if (__dlBlankPayloadValue(value)) return false;`,
+    `  if (Array.isArray(value)) return value.some(__dlPayloadHasMeaningfulValue);`,
+    `  if (value && typeof value === 'object') return Object.values(value as Record<string, unknown>).some(__dlPayloadHasMeaningfulValue);`,
+    `  return true;`,
+    `}`,
+    ``,
+    `function __dlShouldSkipBlankPlayPayload(payload: Record<string, unknown>): boolean {`,
+    `  return Object.keys(payload).length > 0 && !__dlPayloadHasMeaningfulValue(payload);`,
+    `}`,
+    ``,
+    `function __dlAliasCandidates(alias: string): string[] {`,
+    `  const aliases: string[] = [];`,
+    `  for (const candidate of [alias, alias.replace(/-/g, '_'), alias.replace(/_/g, '-')]) {`,
+    `    if (candidate && !aliases.includes(candidate)) aliases.push(candidate);`,
+    `  }`,
+    `  return aliases;`,
+    `}`,
+    ``,
+    `function __dlPlayResultValue(alias: string, result: unknown): unknown {`,
+    `  if (!result || typeof result !== 'object' || Array.isArray(result)) return result;`,
+    `  const record = result as Record<string, unknown>;`,
+    `  const aliases = __dlAliasCandidates(alias);`,
+    `  for (const key of aliases) {`,
+    `    if (key in record && __dlMeaningful(record[key])) return __dlScalarValue(record[key]);`,
+    `  }`,
+    `  const values = Object.values(record).filter(__dlMeaningful);`,
+    `  if (values.length === 1) return __dlScalarValue(values[0]);`,
+    `  return result;`,
+    `}`,
+    ``,
+    `async function __dlRunCommand(input: { alias: string; callId: string; tool: string; payload: Record<string, unknown>; extract: ((args: __DlExtractorHelpers) => unknown) | null; runIf: ((row: Record<string, unknown>) => unknown) | null; row: Record<string, unknown>; stepCtx: DeeplinePlayRuntimeContext; description?: string; force?: boolean; legacyEnvelope?: boolean }): Promise<unknown> {`,
+    `  if (input.runIf) {`,
+    `    const shouldRun = input.runIf(input.row);`,
+    `    if (!shouldRun) return null;`,
+    `  }`,
+    `  const payload = __dlRuntimePayload(input.tool, __dlTemplate(input.payload, input.row) as Record<string, unknown>, input.row);`,
+    `  if (__dlShouldSkipEmptyPayload(input.tool, payload)) return null;`,
+    `  const result = await input.stepCtx.tools.execute({`,
+    `    id: input.callId,`,
+    `    tool: input.tool,`,
+    `    input: payload,`,
+    `    ...(input.description ? { description: input.description } : {}),`,
+    `    ...(input.force ? { force: true } : {}),`,
+    `  });`,
+    `  __dlAssertSuccessfulToolResult(result);`,
+    `  return __dlExtract(input.alias, result, input.row, input.extract, Boolean(input.legacyEnvelope));`,
+    `}`,
+  ].join('\n');
+}