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 describedColumns = config.commands
    .filter((command) => isWaterfall(command) || !command.disabled)
    .map((command) =>
      (isWaterfall(command) ? command.with_waterfall : command.alias)
        .replace(/[_-]+/g, ' ')
        .trim(),
    )
    .filter(Boolean)
    .slice(0, 3);
  const generatedDescription = describedColumns.length
    ? `Enrich CSV rows with ${describedColumns.join(', ')}.`
    : 'Prepare CSV rows for enrichment.';
  const playOptionsSource = [
    `description: ${stringLiteral(generatedDescription)}`,
    ...(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');
}