deepline 0.3.294 → 0.3.296

package/dist/cli/workflow-IVLCPFTG.js

@@ -0,0 +1,1936 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunk3XX5TEA4js = require('./chunk-3XX5TEA4.js');
+
+
+var _chunk2C3AVPTYjs = require('./chunk-2C3AVPTY.js');
+require('./chunk-LA46MMTL.js');
+
+
+
+
+
+var _chunk7D6QG5KFjs = require('./chunk-7D6QG5KF.js');
+require('./chunk-6HPEDBSJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-LIKFCE7Z.js');
+
+
+var _chunk3KC45UVFjs = require('./chunk-3KC45UVF.js');
+require('./chunk-6A3TJUWC.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+// src/cli/commands/workflow.ts
+var _promises = require('fs/promises');
+var _path = require('path');
+
+// src/cli/workflow-to-play.ts
+var _crypto = require('crypto');
+
+// ../plays/tool-codegen.ts
+var KNOWN_GETTER_NAMES = /* @__PURE__ */ new Set([
+  "company_domain",
+  "company_linkedin_url",
+  "company_name",
+  "domain",
+  "email",
+  "email_status",
+  "first_name",
+  "full_name",
+  "job_change",
+  "job_change_status",
+  "job_changed",
+  "last_name",
+  "linkedin",
+  "personal_email",
+  "phone",
+  "phone_status",
+  "status",
+  "title"
+]);
+function renderToolCodegenString(value) {
+  return JSON.stringify(value);
+}
+function renderToolRowPathExpression(path, rowName = "row") {
+  const parts = String(path || "").replace(/\[(\d+)\]/g, ".$1").split(".").map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) return rowName;
+  return parts.reduce((expr, part, index) => {
+    if (index === 0) return `${rowName}[${renderToolCodegenString(part)}]`;
+    return `(${expr} as Record<string, unknown> | null | undefined)?.[${renderToolCodegenString(part)}]`;
+  }, rowName);
+}
+function renderToolPayloadExpression(value, rowName = "row") {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => renderToolPayloadExpression(entry, rowName)).join(", ")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([left], [right]) => left.localeCompare(right)
+    );
+    return `{ ${entries.map(
+      ([key, entry]) => `${renderToolCodegenString(key)}: ${renderToolPayloadExpression(entry, rowName)}`
+    ).join(", ")} }`;
+  }
+  if (typeof value !== "string") return JSON.stringify(value);
+  const exact = value.match(/^\{\{\s*([^{}]+?)\s*\}\}$/);
+  if (exact) return renderToolRowPathExpression(_nullishCoalesce(exact[1], () => ( "")), rowName);
+  const pieces = [];
+  let cursor = 0;
+  for (const match of value.matchAll(/\{\{\s*([^{}]+?)\s*\}\}/g)) {
+    const index = _nullishCoalesce(match.index, () => ( 0));
+    if (index > cursor) {
+      pieces.push(renderToolCodegenString(value.slice(cursor, index)));
+    }
+    pieces.push(
+      `String(${renderToolRowPathExpression(_nullishCoalesce(match[1], () => ( "")), rowName)} ?? '')`
+    );
+    cursor = index + match[0].length;
+  }
+  if (pieces.length === 0) return renderToolCodegenString(value);
+  if (cursor < value.length) {
+    pieces.push(renderToolCodegenString(value.slice(cursor)));
+  }
+  return pieces.join(" + ");
+}
+function renderExtractedValueGetterExpression(toolResultVar, targetKey) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(targetKey) ? `${toolResultVar}.extractedValues.${targetKey}?.get()` : `${toolResultVar}.extractedValues[${renderToolCodegenString(targetKey)}]?.get()`;
+}
+function getterFromLegacyPath(path) {
+  const last = String(path || "").replace(/\[(\d+)\]/g, ".$1").split(".").map((part) => part.trim()).filter(Boolean).at(-1);
+  if (!last) return null;
+  const normalized = last.replace(/[^A-Za-z0-9_]/g, "_");
+  return KNOWN_GETTER_NAMES.has(normalized) ? normalized : null;
+}
+function getterFromLegacyExtractJs(extractJs, fallbackAlias) {
+  const source = _optionalChain([extractJs, 'optionalAccess', _ => _.trim, 'call', _2 => _2()]);
+  if (!source) {
+    const aliasGetter = _optionalChain([fallbackAlias, 'optionalAccess', _3 => _3.replace, 'call', _4 => _4(/[^A-Za-z0-9_]/g, "_")]);
+    return aliasGetter && KNOWN_GETTER_NAMES.has(aliasGetter) ? aliasGetter : null;
+  }
+  const directExtract = source.match(
+    /\bextract\(\s*["'][^"']+["']\s*,\s*output_data\s*,\s*["']([^"']+)["']\s*\)/
+  );
+  if (_optionalChain([directExtract, 'optionalAccess', _5 => _5[1]])) {
+    return getterFromLegacyPath(
+      directExtract[1] === "linkedin_url" ? "linkedin" : directExtract[1]
+    );
+  }
+  const pick = source.match(
+    /\b(?:pick|extract|target)\(\s*(\[[\s\S]*?\]|["'][^"']+["'])\s*\)/
+  );
+  if (!_optionalChain([pick, 'optionalAccess', _6 => _6[1]])) return null;
+  try {
+    const parsed = JSON.parse(pick[1].replace(/'/g, '"'));
+    const paths = Array.isArray(parsed) ? parsed : [parsed];
+    for (const path of paths) {
+      if (typeof path !== "string") continue;
+      const getter = getterFromLegacyPath(path);
+      if (getter) return getter;
+    }
+  } catch (e) {
+    return null;
+  }
+  return null;
+}
+
+// ../plays/user-code-safety.ts
+var FORBIDDEN = [
+  // Non-deterministic — breaks replay.
+  { pattern: /\bMath\s*\.\s*random\b/, reason: "Math.random()" },
+  { pattern: /\bDate\s*\.\s*now\b/, reason: "Date.now()" },
+  { pattern: /\bnew\s+Date\s*\(\s*\)/, reason: "new Date() with no argument" },
+  { pattern: /\bperformance\s*\.\s*now\b/, reason: "performance.now()" },
+  {
+    pattern: /\bcrypto\s*\.\s*(?:randomUUID|getRandomValues)\b/,
+    reason: "crypto random"
+  },
+  // Sandbox escape / I/O.
+  { pattern: /(?<!\.)\bfetch\s*\(/, reason: "fetch()" },
+  { pattern: /(?<!\.)\bimport\s*\(/, reason: "dynamic import()" },
+  { pattern: /(?<!\.)\brequire\s*\(/, reason: "require()" },
+  { pattern: /(?<!\.)\beval\s*\(/, reason: "eval()" },
+  {
+    pattern: /(?<!\.)\bnew\s+Function\b|(?<!\.)\bFunction\s*\(/,
+    reason: "the Function constructor"
+  },
+  { pattern: /(?<!\.)\bprocess\b/, reason: "process" },
+  { pattern: /(?<!\.)\bglobalThis\b/, reason: "globalThis" },
+  { pattern: /(?<!\.)\b(?:window|self)\b/, reason: "window/self" },
+  { pattern: /(?<!\.)\bXMLHttpRequest\b/, reason: "XMLHttpRequest" },
+  { pattern: /(?<!\.)\bWebAssembly\b/, reason: "WebAssembly" }
+];
+function assertUserCodeIsSafe(code, label) {
+  if (typeof code !== "string" || !code.trim()) return;
+  for (const { pattern, reason } of FORBIDDEN) {
+    if (pattern.test(code)) {
+      throw new Error(
+        `${label} uses ${reason}, which is not allowed in play code: it breaks deterministic replay or escapes the sandbox. Remove it and compute the value from the row/result instead.`
+      );
+    }
+  }
+}
+
+// ../plays/enrich-play-compiler.ts
+function isWaterfall(command) {
+  return "with_waterfall" in command;
+}
+function configHasRunJavascript(config) {
+  const walk = (commands) => commands.some(
+    (command) => isWaterfall(command) ? walk(command.commands) : command.tool === "run_javascript"
+  );
+  return walk(_nullishCoalesce(config.commands, () => ( [])));
+}
+function stringLiteral(value) {
+  return JSON.stringify(value);
+}
+function stableJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableJson).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([left], [right]) => left.localeCompare(right)
+    );
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function indent(source, spaces) {
+  const pad = " ".repeat(spaces);
+  return source.split("\n").map((line) => line ? `${pad}${line}` : line).join("\n");
+}
+function commandCallId(command) {
+  return `${command.alias}__${command.tool}`;
+}
+function normalizeAlias(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function renderExecuteStep(command, options = {
+  force: false
+}) {
+  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(_nullishCoalesce(command.payload, () => ( {})));
+  const extractJs = renderExtractFunction(command, 6);
+  const runIfJs = options.nativeRunIf ? "null" : _nullishCoalesce(renderRunIfFunction(command), () => ( "null"));
+  const description = command.description ? `,
+      description: ${stringLiteral(command.description)}` : "";
+  const force = options.force ? `,
+    force: true` : "";
+  const legacyEnvelope = options.legacyEnvelope ? `,
+    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) {
+  const code = typeof _optionalChain([command, 'access', _7 => _7.payload, 'optionalAccess', _8 => _8.code]) === "string" ? command.payload.code : "";
+  if (/\btriggerWorkflow\b/.test(code)) {
+    return false;
+  }
+  try {
+    assertUserCodeIsSafe(code, `run_javascript step "${command.alias}"`);
+  } catch (e2) {
+    return false;
+  }
+  return true;
+}
+function renderExtractFunction(command, indentSpaces) {
+  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);
+${indent(renderJavascriptBody(command.extract_js), indentSpaces)}
+    }` : "null";
+}
+function renderRunIfFunction(command) {
+  return command.run_if_js ? `(row) => { const input = row; const context = row;
+${indent(renderJavascriptBody(command.run_if_js), 6)}
+    }` : null;
+}
+function renderColumnRunIfFunction(command) {
+  if (!command.run_if_js) {
+    return null;
+  }
+  return `(__dlRawRow) => { const row = __dlPrepareEnrichRow(__dlRawRow, [${stringLiteral(command.alias)}]); const input = row; const context = row;
+${indent(renderJavascriptBody(command.run_if_js), 6)}
+    }`;
+}
+function renderCombinedRunIfFunction(precheck, runIfSource) {
+  if (!runIfSource) {
+    return null;
+  }
+  return precheck ? `(row) => { if (${precheck}) return false; return (${runIfSource})(row); }` : runIfSource;
+}
+function renderIdiomaticExecuteStep(command, options) {
+  const callId = stringLiteral(commandCallId(command));
+  const tool = stringLiteral(command.tool);
+  const input = renderToolPayloadExpression(_nullishCoalesce(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((_nullishCoalesce(command.description, () => ( ""))).trim() || `Run ${command.alias} via ${command.tool}.`)},`,
+    ...options.force ? [`      force: true,`] : [],
+    `  });`,
+    `  __dlAssertSuccessfulToolResult(result);`,
+    `  return ${extraction};`,
+    `}`
+  ].join("\n");
+}
+function renderPlayStep(command, options) {
+  const alias = stringLiteral(command.alias);
+  const callId = stringLiteral(commandCallId(command));
+  const playRef = stringLiteral(_nullishCoalesce(_optionalChain([command, 'access', _9 => _9.play, 'optionalAccess', _10 => _10.ref]), () => ( command.tool)));
+  const payload = stableJson(_nullishCoalesce(command.payload, () => ( {})));
+  const runIfJs = _nullishCoalesce(renderRunIfFunction(command), () => ( "null"));
+  const runIfLines = command.run_if_js && !options.nativeRunIf ? [
+    `  const __dlRunIf = ${runIfJs};`,
+    `  if (!__dlRunIf(templateRow)) return null;`
+  ] : [];
+  const inline = _optionalChain([command, 'access', _11 => _11.play, 'optionalAccess', _12 => _12.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(_nullishCoalesce(command.description, () => ( command.alias)))}`,
+      `    });`
+    ],
+    ``,
+    `  __dlAssertSuccessfulToolResult(result);`,
+    `  return __dlPlayResultValue(${alias}, result);`,
+    `}`
+  ].join("\n");
+}
+function collectInlinePlayHandlers(commands) {
+  const handlers = /* @__PURE__ */ new Map();
+  const visit = (command) => {
+    if (isWaterfall(command)) {
+      command.commands.forEach(visit);
+      return;
+    }
+    const inline = _optionalChain([command, 'access', _13 => _13.play, 'optionalAccess', _14 => _14.inline]);
+    if (inline) handlers.set(inline.sourceHash, inline);
+  };
+  commands.forEach(visit);
+  return [...handlers.values()];
+}
+function renderInlineJavascriptStep(command, options) {
+  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(_nullishCoalesce(command.payload, () => ( {})));
+  const code = typeof _optionalChain([command, 'access', _15 => _15.payload, 'optionalAccess', _16 => _16.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) {
+  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, resolverSource, options = {}) {
+  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) {
+  return /\bextractList\s*\(/.test(_nullishCoalesce(command.extract_js, () => ( ""))) ? "list" : "scalar";
+}
+function metadataEntryForCommand(command, waterfallGroupId) {
+  const entry = {
+    tool_id: command.tool
+  };
+  if (_optionalChain([command, 'access', _17 => _17.play, 'optionalAccess', _18 => _18.ref])) {
+    entry.play_ref = command.play.ref;
+    entry.kind = "play_call";
+  }
+  if (command.operation) {
+    entry.operation = command.operation;
+  }
+  if (_optionalChain([command, 'access', _19 => _19.extract_js, 'optionalAccess', _20 => _20.trim, 'call', _21 => _21()])) {
+    entry.extract_js = command.extract_js.trim();
+  }
+  if (waterfallGroupId) {
+    entry.waterfall = {
+      group_id: waterfallGroupId,
+      mode: metadataMode(command)
+    };
+  }
+  return entry;
+}
+function collectMetadataColumns(commands, waterfallGroupId) {
+  const columns = {};
+  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) {
+  const aliases = [];
+  const addAlias = (alias) => {
+    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) {
+  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, forceAliases, inlineRunJavascript, idiomaticGetters) {
+  const activeChildren = command.commands.filter(
+    (nested) => !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})` : void 0;
+    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 !== 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)})`
+    )
+  ];
+}
+function compileEnrichConfigToPlaySource(config, options = {}) {
+  if (options.maxCreditsPerRun !== void 0 && (!Number.isFinite(options.maxCreditsPerRun) || options.maxCreditsPerRun <= 0)) {
+    throw new Error("maxCreditsPerRun must be a number greater than 0.");
+  }
+  const compatibility = _chunk3XX5TEA4js.buildEnrichCompatibilityPlan.call(void 0, options);
+  const { playName, mapName } = compatibility;
+  const inlineRunJavascript = _nullishCoalesce(options.inlineRunJavascript, () => ( false));
+  const idiomaticGetters = _nullishCoalesce(options.idiomaticGetters, () => ( false));
+  const forceAliases = new Set(
+    [..._nullishCoalesce(options.forceAliases, () => ( []))].map((alias) => normalizeAlias(alias))
+  );
+  const columnSteps = [];
+  const inlineHandlers = collectInlinePlayHandlers(config.commands);
+  const inlineTypeImports = [
+    ...new Set(inlineHandlers.flatMap((inline) => _nullishCoalesce(inline.typeImports, () => ( []))))
+  ].sort();
+  const inlineRuntimeImports = [
+    ...new Set(inlineHandlers.flatMap((inline) => _nullishCoalesce(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 === void 0 ? [] : [`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} });`
+  ];
+  const helpers = idiomaticGetters ? selectUsedHelpers(helperSource(), body.join("\n")) : helperSource();
+  const typeImports = idiomaticGetters ? inlineTypeImports : [.../* @__PURE__ */ 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");
+}
+function selectUsedHelpers(helperBlock, referenceSource) {
+  const referencesSymbol = (source, symbol) => new RegExp(`\\b${symbol}\\b`).test(source);
+  const blocks = helperBlock.split("\n\n").map((source) => source.trim()).filter(Boolean).map((source) => ({
+    name: _nullishCoalesce(_optionalChain([source, 'access', _22 => _22.match, 'call', _23 => _23(/(?:function|type|const)\s+(__[A-Za-z]\w*)/), 'optionalAccess', _24 => _24[1]]), () => ( "")),
+    source
+  }));
+  const used = /* @__PURE__ */ new Set();
+  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() {
+  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 \u2014 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");
+}
+
+// src/cli/workflow-to-play.ts
+var HITL_WAIT_FOR_SIGNAL_TOOL = "deepline_workflow_wait_for_signal";
+var HITL_SLACK_TOOL = "slack_message_with_hitl";
+var SUB_WORKFLOW_TOOL_PREFIX = "deepline_workflow_";
+var UNSUPPORTED_REASON_HINT = {
+  unsafe_user_code: "a step's JavaScript (extract_js / run_if_js / run_javascript) uses non-deterministic or sandbox-escaping code (e.g. new Date(), Date.now(), Math.random(), fetch, require). Plays replay deterministically inside a sandbox, so the compiler rejects it \u2014 rewrite it to compute from the row/result before migrating.",
+  hitl: "human-in-the-loop / wait-for-signal steps have no play-runtime equivalent yet.",
+  sub_workflow: "sub-workflow calls have no play-runtime equivalent yet (a future ctx.runPlay bridge).",
+  nested_waterfall: "nested with_waterfall blocks are not supported by the play compiler.",
+  inline_secret: 'a step inlines a hardcoded secret (API key / token / private key). Plays forbid inline secrets \u2014 move it to a dashboard secret and read it with ctx.secrets.get("NAME") before migrating.'
+};
+var UnsupportedWorkflowCommandError = (_class = class extends Error {
+  __init() {this.status = 400}
+  
+  constructor(unsupported) {
+    super(
+      `Workflow uses ${unsupported.length} command${unsupported.length === 1 ? "" : "s"} that cannot run as a play yet: ${unsupported.map((entry) => `${entry.alias} (${entry.reason})`).join(", ")}.`
+    );_class.prototype.__init.call(this);;
+    this.name = "UnsupportedWorkflowCommandError";
+    this.unsupported = unsupported;
+  }
+}, _class);
+function isWaterfall2(command) {
+  return "with_waterfall" in command;
+}
+function stepInlinedText(command) {
+  return [
+    JSON.stringify(_nullishCoalesce(command.payload, () => ( {}))),
+    _nullishCoalesce(command.extract_js, () => ( "")),
+    _nullishCoalesce(command.run_if_js, () => ( ""))
+  ].join("\n");
+}
+function stepUserCode(command) {
+  const code = [];
+  if (command.extract_js) code.push(command.extract_js);
+  if (command.run_if_js) code.push(command.run_if_js);
+  if (command.tool === "run_javascript" && typeof _optionalChain([command, 'access', _25 => _25.payload, 'optionalAccess', _26 => _26.code]) === "string") {
+    code.push(command.payload.code);
+  }
+  return code;
+}
+function hasUnsafeUserCode(command) {
+  return stepUserCode(command).some((code) => {
+    try {
+      assertUserCodeIsSafe(code, "play step code");
+      return false;
+    } catch (e3) {
+      return true;
+    }
+  });
+}
+function classifyUnsupportedCommand(command) {
+  const { tool } = command;
+  if (tool === HITL_SLACK_TOOL || tool === HITL_WAIT_FOR_SIGNAL_TOOL) {
+    return "hitl";
+  }
+  if (tool.startsWith(SUB_WORKFLOW_TOOL_PREFIX)) return "sub_workflow";
+  if (_chunk3KC45UVFjs.collectInlineSecretFindings.call(void 0, stepInlinedText(command)).length > 0) {
+    return "inline_secret";
+  }
+  if (hasUnsafeUserCode(command)) return "unsafe_user_code";
+  return null;
+}
+function collectStepOffenders(command, offenders) {
+  if (command.disabled) return;
+  const reason = classifyUnsupportedCommand(command);
+  if (reason) {
+    offenders.push({ alias: command.alias, tool: command.tool, reason });
+  }
+}
+function findUnsupportedWorkflowCommands(config) {
+  const offenders = [];
+  for (const command of _nullishCoalesce(config.commands, () => ( []))) {
+    if (!isWaterfall2(command)) {
+      collectStepOffenders(command, offenders);
+      continue;
+    }
+    for (const child of _nullishCoalesce(command.commands, () => ( []))) {
+      if (isWaterfall2(child)) {
+        offenders.push({
+          alias: command.with_waterfall,
+          tool: "with_waterfall",
+          reason: "nested_waterfall"
+        });
+        continue;
+      }
+      collectStepOffenders(child, offenders);
+    }
+  }
+  return offenders;
+}
+function validateWorkflowConfigForPlay(config) {
+  const offenders = findUnsupportedWorkflowCommands(config);
+  if (offenders.length > 0) {
+    throw new UnsupportedWorkflowCommandError(offenders);
+  }
+}
+function describeUnsupportedReason(reason) {
+  return UNSUPPORTED_REASON_HINT[reason];
+}
+var MAX_PLAY_NAME_LENGTH = 39;
+function sanitizePlayNameSegment(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function deriveWorkflowPlayName(workflowName) {
+  const base = sanitizePlayNameSegment(workflowName) || "workflow";
+  const suffix = _crypto.createHash.call(void 0, "sha256").update(workflowName).digest("hex").slice(0, 8);
+  const reserved = suffix.length + 1;
+  const allowedBase = Math.max(1, MAX_PLAY_NAME_LENGTH - reserved);
+  let name = `${base.slice(0, allowedBase)}_${suffix}`;
+  if (name.startsWith("prebuilt")) {
+    name = `wf_${name}`.slice(0, MAX_PLAY_NAME_LENGTH);
+  }
+  return name;
+}
+function compileWorkflowConfigToPlay(config, options) {
+  validateWorkflowConfigForPlay(config);
+  const playName = deriveWorkflowPlayName(options.workflowName);
+  const sourceCode = compileEnrichConfigToPlaySource(config, {
+    playName,
+    inlineRunJavascript: true,
+    idiomaticGetters: true
+  });
+  const warnings = [];
+  if (typeof config.cost_cap_usd_per_run === "number") {
+    warnings.push(
+      `cost_cap_usd_per_run ($${config.cost_cap_usd_per_run}) was not carried into the play \u2014 credits are not USD. Set billing.maxCreditsPerRun manually after checking your credit conversion.`
+    );
+  }
+  return { playName, sourceCode, warnings };
+}
+
+// src/cli/commands/workflow.ts
+var PLAY_EQUIVALENT = {
+  list: "deepline plays list",
+  get: "deepline plays get <name>",
+  call: "deepline plays run <name>",
+  apply: "deepline plays publish <file>",
+  lint: "deepline plays check <file>",
+  schema: "deepline plays describe <name>",
+  runs: "deepline runs list --play <name>",
+  run: "deepline runs get <run-id>",
+  tail: "deepline runs watch <run-id>",
+  cancel: "deepline runs stop <run-id>",
+  delete: "deepline plays delete <name>"
+};
+var MIGRATE_HINT = "deepline workflows transform <id>";
+var TRIGGER_REDIRECT = "Looking to trigger a play automatically? Use a trigger binding in definePlay \u2014 `cron`/`webhook`, or `sqlListeners` to run on a monitor\u2019s output (see `deepline monitors available <id>` for a monitor\u2019s streams and the deepline-monitors skill). `workflows` only manages prebuilt plays and is deprecated in favor of `plays`.";
+var JSON_OPTION_DESCRIPTION = "Emit JSON output. Also automatic when stdout is piped";
+function withJsonOption(command) {
+  return command.option("--json", JSON_OPTION_DESCRIPTION);
+}
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "succeeded",
+  "success",
+  "failed",
+  "error",
+  "errored",
+  "cancelled",
+  "canceled",
+  "done"
+]);
+function migrationDeprecation(command) {
+  const use = PLAY_EQUIVALENT[command];
+  if (!use) return null;
+  return { use, migrate: MIGRATE_HINT };
+}
+function noticeToStderr(command) {
+  const deprecation = migrationDeprecation(command);
+  if (!deprecation) return;
+  process.stderr.write(
+    `note: \`deepline workflows ${command}\` is a legacy surface \u2014 workflows are becoming plays.
+      equivalent: \`${deprecation.use}\`
+      migrate this workflow: \`${MIGRATE_HINT}\`
+      ${TRIGGER_REDIRECT}
+`
+  );
+}
+function emitPassThrough(command, payload, options) {
+  const json = _chunk7D6QG5KFjs.shouldEmitJson.call(void 0, options.json);
+  const deprecation = migrationDeprecation(command);
+  if (json) {
+    const enriched = payload && typeof payload === "object" && !Array.isArray(payload) ? { ...payload, deprecation } : { result: payload, deprecation };
+    _chunk7D6QG5KFjs.printJson.call(void 0, enriched);
+    return;
+  }
+  _chunk7D6QG5KFjs.printJson.call(void 0, payload);
+  noticeToStderr(command);
+}
+function client() {
+  return new (0, _chunk2C3AVPTYjs.DeeplineClient)();
+}
+function clientWithTimeout(timeoutSeconds) {
+  if (!timeoutSeconds) return client();
+  const seconds = Number(timeoutSeconds);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new Error("--timeout must be a positive number of seconds.");
+  }
+  return new (0, _chunk2C3AVPTYjs.DeeplineClient)({ timeout: seconds * 1e3 });
+}
+function readStatus(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const record = payload;
+  if (typeof record.status === "string") return record.status;
+  const run = record.run;
+  if (run && typeof run === "object") {
+    const status = run.status;
+    if (typeof status === "string") return status;
+  }
+  return null;
+}
+async function readJsonOption(payload, file) {
+  if (file) {
+    const raw = await _promises.readFile.call(void 0, _path.resolve.call(void 0, file), "utf8");
+    return JSON.parse(raw);
+  }
+  if (payload) {
+    return JSON.parse(payload);
+  }
+  throw new Error("Provide --payload <json> or --file <path>.");
+}
+async function transformOne(api, workflowId, outDir, publish) {
+  const { workflow } = await api.getWorkflow(workflowId);
+  if (!workflow) {
+    return {
+      ok: false,
+      workflowId,
+      workflowName: workflowId,
+      reason: "Workflow not found."
+    };
+  }
+  const revision = workflow.current_published_revision;
+  if (!revision) {
+    return {
+      ok: false,
+      workflowId,
+      workflowName: workflow.name,
+      reason: "Workflow has no published revision to transform."
+    };
+  }
+  try {
+    const compiled = compileWorkflowConfigToPlay(
+      // The API returns the config as `unknown`; it is structurally the
+      // EnrichCompiledConfig the compiler expects. Cast at this single boundary.
+      revision.config,
+      { workflowName: workflow.name, version: revision.version }
+    );
+    const file = _path.join.call(void 0, _path.resolve.call(void 0, outDir), `${compiled.playName}.play.ts`);
+    await _promises.mkdir.call(void 0, _path.dirname.call(void 0, file), { recursive: true });
+    await _promises.writeFile.call(void 0, file, compiled.sourceCode, "utf8");
+    let published = false;
+    if (publish) {
+      const { handlePlayPublish } = await Promise.resolve().then(() => _interopRequireWildcard(require("./play-46ZJ4FMI.js")));
+      const code = await handlePlayPublish([file]);
+      if (code !== 0) {
+        return {
+          ok: false,
+          workflowId,
+          workflowName: workflow.name,
+          reason: `Wrote ${file} but publish failed (exit ${code}).`
+        };
+      }
+      published = true;
+    }
+    return {
+      ok: true,
+      workflowId,
+      workflowName: workflow.name,
+      playName: compiled.playName,
+      file,
+      warnings: compiled.warnings,
+      published
+    };
+  } catch (error) {
+    if (error instanceof UnsupportedWorkflowCommandError) {
+      return {
+        ok: false,
+        workflowId,
+        workflowName: workflow.name,
+        reason: error.unsupported.map((u) => `${u.alias} (${describeUnsupportedReason(u.reason)})`).join("; "),
+        unsupported: error.unsupported
+      };
+    }
+    throw error;
+  }
+}
+function renderTransformReport(outcomes) {
+  const lines = [];
+  for (const outcome of outcomes) {
+    if (outcome.ok) {
+      lines.push(
+        `\u2705 ${outcome.workflowName} \u2192 ${outcome.file}` + (outcome.published ? "  (published)" : `  (next: deepline plays publish ${outcome.file})`)
+      );
+      for (const warning of outcome.warnings) {
+        lines.push(`   \u26A0\uFE0F  ${warning}`);
+      }
+    } else {
+      lines.push(`\u26A0\uFE0F  ${outcome.workflowName} \u2014 skipped: ${outcome.reason}`);
+    }
+  }
+  const ok = outcomes.filter((o) => o.ok).length;
+  const total = outcomes.length;
+  const manual = total - ok;
+  lines.push("");
+  lines.push(
+    `${ok}/${total} transformed` + (manual > 0 ? `, ${manual} need manual attention` : "")
+  );
+  return `${lines.join("\n")}
+`;
+}
+async function handleTransform(id, options) {
+  const api = client();
+  const outDir = _nullishCoalesce(options.out, () => ( "./plays"));
+  const publish = options.publish === true;
+  let ids;
+  if (options.all) {
+    const { workflows } = await api.listWorkflows();
+    ids = workflows.map((w) => w.id);
+  } else if (id) {
+    ids = [id];
+  } else {
+    throw new Error("Provide a workflow <id> or --all.");
+  }
+  const outcomes = [];
+  for (const workflowId of ids) {
+    outcomes.push(await transformOne(api, workflowId, outDir, publish));
+  }
+  _chunk7D6QG5KFjs.printCommandEnvelope.call(void 0, 
+    { outcomes, deprecation: null },
+    {
+      json: _chunk7D6QG5KFjs.shouldEmitJson.call(void 0, options.json),
+      text: renderTransformReport(outcomes)
+    }
+  );
+  return outcomes.every((o) => o.ok) ? 0 : 1;
+}
+async function handleList(options) {
+  const limit = options.limit ? Number(options.limit) : void 0;
+  const result = await client().listWorkflows({
+    limit: Number.isFinite(limit) ? limit : void 0
+  });
+  emitPassThrough("list", result, options);
+}
+async function handleGet(id, options) {
+  emitPassThrough("get", await client().getWorkflow(id), options);
+}
+async function handleDelete(id, options) {
+  emitPassThrough("delete", await client().deleteWorkflow(id), options);
+}
+async function handleDisable(id, options) {
+  const result = await client().disableWorkflow(id);
+  _chunk7D6QG5KFjs.printJson.call(void 0, result);
+}
+async function handleEnable(id, options) {
+  const result = await client().enableWorkflow(id);
+  _chunk7D6QG5KFjs.printJson.call(void 0, result);
+}
+async function handleApply(options) {
+  const body = await readJsonOption(options.payload, options.file);
+  emitPassThrough(
+    "apply",
+    await clientWithTimeout(options.timeout).applyWorkflow(body),
+    options
+  );
+}
+async function handleLint(options) {
+  const body = await readJsonOption(options.payload, options.file);
+  emitPassThrough("lint", await client().lintWorkflow(body), options);
+}
+async function handleSchema(options) {
+  emitPassThrough(
+    "schema",
+    await client().getWorkflowSchema(options.subject),
+    options
+  );
+}
+async function handleCall(options) {
+  const body = {};
+  if (options.workflowId) body.workflow_id = options.workflowId;
+  if (options.workflowName) body.workflow_name = options.workflowName;
+  const input = options.payload ? JSON.parse(options.payload) : {};
+  if (options.mode) input.__execution_mode = options.mode;
+  body.input = input;
+  emitPassThrough(
+    "call",
+    await clientWithTimeout(options.timeout).callWorkflow(body),
+    options
+  );
+}
+async function handleRuns(id, options) {
+  const limit = options.limit ? Number(options.limit) : void 0;
+  emitPassThrough(
+    "runs",
+    await client().listWorkflowRuns(id, {
+      limit: Number.isFinite(limit) ? limit : void 0
+    }),
+    options
+  );
+}
+async function handleRun(id, runId, options) {
+  emitPassThrough("run", await client().getWorkflowRun(id, runId), options);
+}
+async function handleCancel(id, runId, options) {
+  emitPassThrough(
+    "cancel",
+    await client().cancelWorkflowRun(id, runId),
+    options
+  );
+}
+async function handleTail(id, runId, options) {
+  const api = client();
+  const intervalMs = Math.max(500, Number(_nullishCoalesce(options.intervalMs, () => ( 2e3))) || 2e3);
+  const deadline = Date.now() + 10 * 6e4;
+  for (; ; ) {
+    const run = await api.getWorkflowRun(id, runId);
+    emitPassThrough("tail", run, options);
+    const status = readStatus(run);
+    if (status && TERMINAL_RUN_STATUSES.has(status) || Date.now() > deadline) {
+      return;
+    }
+    await _chunk7D6QG5KFjs.sleep.call(void 0, intervalMs);
+  }
+}
+function registerWorkflowCommands(program) {
+  const workflows = program.command("workflows", { hidden: true }).description(
+    "Legacy cloud workflows (now becoming plays). Commands still work; use `workflows transform` to migrate one to a play. " + TRIGGER_REDIRECT
+  ).addHelpText(
+    "after",
+    `
+Workflows are a legacy surface. They still run in the cloud and these commands
+keep working, but new work belongs in plays. Migrate a workflow with:
+
+  deepline workflows transform <id>            # write a reviewable .play.ts
+  deepline workflows transform --all --publish # migrate + publish them all
+
+Equivalents: list\u2192plays list \xB7 call\u2192plays run \xB7 apply\u2192plays publish \xB7
+lint\u2192plays check \xB7 runs\u2192runs list.
+
+${TRIGGER_REDIRECT}
+Add the binding as the third arg to definePlay in your .play.ts; the
+deepline-monitors skill has a monitor-triggered example.
+`
+  );
+  withJsonOption(
+    workflows.command("transform [id]").description("Compile a workflow into a reviewable V2 play (.play.ts).").option("--all", "Transform every workflow in the workspace").option("--out <dir>", "Output directory for generated plays", "./plays").option("--publish", "Publish each clean play immediately")
+  ).addHelpText(
+    "after",
+    `
+Examples:
+  deepline workflows transform wf_123 --out ./plays
+  deepline workflows transform --all
+  deepline workflows transform --all --publish --json
+
+Notes:
+  HITL, run_javascript steps, and sub-workflow calls cannot run as a play yet;
+  those workflows are reported as needing manual attention and skipped.
+`
+  ).action(async (id, options) => {
+    process.exitCode = await handleTransform(id, options);
+  });
+  withJsonOption(
+    workflows.command("list").description("List workspace workflows.").option("--limit <n>", "Max workflows to return")
+  ).action(handleList);
+  withJsonOption(
+    workflows.command("get <id>").description(
+      "Fetch a workflow, including its published-revision config."
+    )
+  ).action(handleGet);
+  withJsonOption(
+    workflows.command("disable <id>").description("Turn a workflow off.")
+  ).action(handleDisable);
+  withJsonOption(
+    workflows.command("enable <id>").description("Turn a workflow back on.")
+  ).action(handleEnable);
+  withJsonOption(
+    workflows.command("delete <id>").description("Delete a workflow and its revisions/runs.")
+  ).action(handleDelete);
+  withJsonOption(
+    workflows.command("apply").description("Create or update a workflow from config.").option("--payload <json>", "Inline config JSON").option("--file <path>", "Path to a config JSON file").option("--timeout <seconds>", "API read timeout in seconds.")
+  ).action(handleApply);
+  withJsonOption(
+    workflows.command("lint").description("Validate a workflow config without saving.").option("--payload <json>", "Inline config JSON").option("--file <path>", "Path to a config JSON file")
+  ).action(handleLint);
+  withJsonOption(
+    workflows.command("schema").description("Fetch live workflow request schemas.").option(
+      "--subject <subject>",
+      "Schema subject (apply|call|trigger|all|\u2026)"
+    )
+  ).action(handleSchema);
+  withJsonOption(
+    workflows.command("call").description("Queue a workflow run.").option("--workflow-id <id>", "Workflow id").option("--workflow-name <name>", "Workflow name").option("--payload <json>", "Run input JSON").option("--mode <mode>", "live | dry_run | smoke_test").option("--timeout <seconds>", "API read timeout in seconds.")
+  ).action(handleCall);
+  withJsonOption(
+    workflows.command("runs <id>").description("List a workflow\u2019s runs.").option("--limit <n>", "Max runs to return")
+  ).action(handleRuns);
+  withJsonOption(
+    workflows.command("run <id> <runId>").description("Fetch a single workflow run.")
+  ).action(handleRun);
+  withJsonOption(
+    workflows.command("tail <id> <runId>").description("Poll a workflow run until it reaches a terminal status.").option("--interval-ms <n>", "Poll interval in ms (default 2000)")
+  ).action(handleTail);
+  withJsonOption(
+    workflows.command("cancel <id> <runId>").description("Cancel a running workflow run.")
+  ).action(handleCancel);
+}
+
+
+
+
+
+
+
+exports.emitPassThrough = emitPassThrough; exports.migrationDeprecation = migrationDeprecation; exports.noticeToStderr = noticeToStderr; exports.registerWorkflowCommands = registerWorkflowCommands; exports.renderTransformReport = renderTransformReport; exports.transformOne = transformOne;