deepline 0.3.352 → 0.3.353

package/dist/cli/{chunk-YIO2PX4J.mjs → chunk-37F4EUJA.mjs}

@@ -11,21 +11,15 @@ import {
 } from "./chunk-EDWJY6T4.mjs";
 import {
   registerDeprecatedSearchCommand
-} from "./chunk-2ULH52Q7.mjs";
+} from "./chunk-LLI4RITH.mjs";
 import {
   handleDeploymentGet,
   handleDeploymentsList
-} from "./chunk-HD2RKIVK.mjs";
+} from "./chunk-DY253DRK.mjs";
 import {
-  PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY,
-  PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER,
-  PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY,
-  PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER,
-  formatPlayBootstrapTemplates,
-  isPlayBootstrapTemplate,
   pinLocalPlayImports,
   planLocalPlayExecution
-} from "./chunk-GVESPYSY.mjs";
+} from "./chunk-ERFN2QY4.mjs";
 import {
   CSV_HEADER_MATCHING_NOTE,
   DeeplineClient,
@@ -40,7 +34,7 @@ import {
   normalizeRunEventOperationRequest,
   parseLogLevel,
   playInputExampleArgs
-} from "./chunk-NNMGGD5Z.mjs";
+} from "./chunk-IVGFLYQ6.mjs";
 import {
   CSV_DATA_INPUT_KEY,
   buildNamedPlayRunRequest,
@@ -73,10 +67,10 @@ import {
   printJsonError,
   renderCommandEnvelopeText,
   shouldEmitJson
-} from "./chunk-ULX7APDZ.mjs";
+} from "./chunk-ZDEO3EGW.mjs";
 import {
   fetchWithDeploymentProtection
-} from "./chunk-3EIK6KTE.mjs";
+} from "./chunk-U3FUXTIB.mjs";
 import {
   PLAY_DEFAULT_EXPORT,
   extractDefinedPlayName,
@@ -3971,8 +3965,8 @@ import {
   readFileSync as readFileSync2,
   readdirSync,
   realpathSync,
-  statSync as statSync2,
-  writeFileSync as writeFileSync4
+  statSync,
+  writeFileSync as writeFileSync3
 } from "fs";
 import {
   lstat,
@@ -3985,1693 +3979,13 @@ import {
 import {
   basename,
   dirname as dirname2,
-  isAbsolute as isAbsolute3,
+  isAbsolute as isAbsolute2,
   join as join6,
-  relative as relative4,
-  resolve as resolve6
+  relative as relative3,
+  resolve as resolve5
 } from "path";
 import { Option as Option2 } from "commander";
 
-// src/cli/commands/plays/bootstrap.ts
-import {
-  closeSync,
-  openSync,
-  readSync,
-  statSync,
-  writeFileSync
-} from "fs";
-import { isAbsolute, relative, resolve } from "path";
-import { parse as parseCsvSync } from "csv-parse/sync";
-function parseReferencedPlayTarget(target) {
-  const trimmed = target.trim();
-  const slashIndex = trimmed.indexOf("/");
-  if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
-    return { ownerSlug: null, playName: trimmed, unqualifiedPlayName: trimmed };
-  }
-  return {
-    ownerSlug: trimmed.slice(0, slashIndex),
-    playName: trimmed,
-    unqualifiedPlayName: trimmed.slice(slashIndex + 1)
-  };
-}
-function parsePositiveInteger(value, flagName) {
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new PlayBootstrapUsageError(
-      `${flagName} must be a positive integer.`
-    );
-  }
-  return parsed;
-}
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function stringValue(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-function extractionEntries(value) {
-  if (Array.isArray(value)) return value.filter(isRecord);
-  if (!isRecord(value)) return [];
-  return Object.entries(value).map(
-    ([name, entry]) => isRecord(entry) ? { name, ...entry } : { name }
-  );
-}
-var PlayBootstrapError = class extends Error {
-  constructor(message, exitCode) {
-    super(message);
-    this.exitCode = exitCode;
-  }
-};
-var PlayBootstrapUsageError = class extends PlayBootstrapError {
-  constructor(message) {
-    super(message, 2);
-  }
-};
-var PlayBootstrapValidationError = class extends PlayBootstrapError {
-  constructor(message) {
-    super(message, 7);
-  }
-};
-var CSV_HEADER_SAMPLE_BYTES = 64 * 1024;
-function parseCsvList(value) {
-  return value.split(",").map((item) => item.trim()).filter(Boolean);
-}
-function parseProviderList(value, flag) {
-  const providers = parseCsvList(value);
-  if (providers.length === 0) {
-    throw new PlayBootstrapUsageError(`${flag} provider list cannot be empty.`);
-  }
-  return providers;
-}
-function parseBootstrapPrefixedRef(value, flag) {
-  const separatorIndex = value.indexOf(":");
-  if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
-    throw new PlayBootstrapUsageError(
-      `${flag} expects a typed resource reference like csv:data/leads.csv, play:prebuilt/name-and-domain-to-email-waterfall, provider:dropleads_search_people, or providers:hunter_email_finder,leadmagic_email_finder.`
-    );
-  }
-  return {
-    prefix: value.slice(0, separatorIndex).trim(),
-    body: value.slice(separatorIndex + 1).trim()
-  };
-}
-function parseBootstrapSourceRef(value, flag = "--from") {
-  const { prefix, body } = parseBootstrapPrefixedRef(value, flag);
-  switch (prefix) {
-    case "csv":
-      return { kind: "csv", value: body };
-    case "play":
-      return { kind: "play", value: parseReferencedPlayTarget(body).playName };
-    case "provider":
-    case "providers":
-      return { kind: "providers", values: parseProviderList(body, flag) };
-  }
-  throw new PlayBootstrapUsageError(
-    `${flag} does not support ${prefix}:. Use csv:, play:, provider:, or providers:.`
-  );
-}
-function parseBootstrapStageRef(value, flag) {
-  const { prefix, body } = parseBootstrapPrefixedRef(value, flag);
-  switch (prefix) {
-    case "play":
-      return { kind: "play", value: parseReferencedPlayTarget(body).playName };
-    case "provider":
-    case "providers":
-      return { kind: "providers", values: parseProviderList(body, flag) };
-  }
-  throw new PlayBootstrapUsageError(
-    `${flag} does not support ${prefix}:. Use play:, provider:, or providers:.`
-  );
-}
-function playBootstrapTemplateConfig(template) {
-  switch (template) {
-    case "company-list":
-      return { sourceEntity: "company", usingStage: null, requiredStages: [] };
-    case "people-list":
-      return { sourceEntity: "people", usingStage: null, requiredStages: [] };
-    case "people-email":
-      return {
-        sourceEntity: "people",
-        usingStage: "email",
-        requiredStages: []
-      };
-    case "people-phone":
-      return {
-        sourceEntity: "people",
-        usingStage: "phone",
-        requiredStages: []
-      };
-    case "company-people":
-      return {
-        sourceEntity: "company",
-        usingStage: "people",
-        requiredStages: []
-      };
-    case "company-people-email":
-      return {
-        sourceEntity: "company",
-        usingStage: null,
-        requiredStages: ["people", "email"]
-      };
-    case "company-people-phone":
-      return {
-        sourceEntity: "company",
-        usingStage: null,
-        requiredStages: ["people", "phone"]
-      };
-  }
-}
-function templateExample(template) {
-  switch (template) {
-    case "people-list":
-      return "deepline plays bootstrap people-list --from provider:dropleads_search_people --out people.play.ts";
-    case "company-list":
-      return "deepline plays bootstrap company-list --from provider:crustdata_companydb_search --out companies.play.ts";
-    case "people-email":
-      return "deepline plays bootstrap people-email --from csv:data/leads.csv --using play:prebuilt/name-and-domain-to-email-waterfall --out email-flow.play.ts";
-    case "people-phone":
-      return "deepline plays bootstrap people-phone --from csv:data/vp_contacts.csv --using play:prebuilt/person-to-phone --out phone-flow.play.ts";
-    case "company-people":
-      return "deepline plays bootstrap company-people --from provider:crustdata_companydb_search --using play:prebuilt/company-to-contact --out company-people.play.ts";
-    case "company-people-email":
-      return "deepline plays bootstrap company-people-email --from provider:crustdata_companydb_search --people play:prebuilt/company-to-contact --email providers:hunter_email_finder,leadmagic_email_finder --out account-emails.play.ts";
-    case "company-people-phone":
-      return "deepline plays bootstrap company-people-phone --from provider:crustdata_companydb_search --people play:prebuilt/company-to-contact --phone providers:ai_ark_mobile_phone_finder --out account-phones.play.ts";
-  }
-}
-var PLAY_BOOTSTRAP_STAGE_NAMES = [
-  "people",
-  "email",
-  "phone"
-];
-var MONITOR_BOOTSTRAP_TEMPLATE = "monitor-triggered";
-var MONITOR_BOOTSTRAP_DEFAULT_TOOL = "deepline_native.company_radar";
-var MONITOR_BOOTSTRAP_DEFAULT_STREAM = "company_job_openings";
-function isMonitorBootstrapTemplate(value) {
-  return value === MONITOR_BOOTSTRAP_TEMPLATE;
-}
-function hasMonitorBootstrapForbiddenChar(value) {
-  for (const char of value) {
-    const code = char.codePointAt(0) ?? 0;
-    if (code < 32 || code === 127) return true;
-    if (char === "'" || char === '"' || char === "`" || char === "\\") {
-      return true;
-    }
-  }
-  return false;
-}
-function validateMonitorBootstrapFlagValue(flag, value) {
-  if (hasMonitorBootstrapForbiddenChar(value)) {
-    throw new PlayBootstrapUsageError(
-      `${flag} may not contain line breaks, control characters, quotes, or backticks. It is interpolated into the generated play source (including comments); use a plain monitor tool id / stream key / name.`
-    );
-  }
-  return value;
-}
-function parseMonitorBootstrapOptions(args) {
-  const [, ...rest] = args;
-  const options = {
-    name: MONITOR_BOOTSTRAP_TEMPLATE,
-    tool: MONITOR_BOOTSTRAP_DEFAULT_TOOL,
-    stream: MONITOR_BOOTSTRAP_DEFAULT_STREAM,
-    out: null
-  };
-  for (let index = 0; index < rest.length; index += 1) {
-    const arg = rest[index];
-    const value = () => nextFlagValue(rest, index, arg);
-    switch (arg) {
-      case "--name":
-        options.name = validateMonitorBootstrapFlagValue("--name", value());
-        index += 1;
-        break;
-      case "--tool":
-        options.tool = validateMonitorBootstrapFlagValue("--tool", value());
-        index += 1;
-        break;
-      case "--stream":
-        options.stream = validateMonitorBootstrapFlagValue("--stream", value());
-        index += 1;
-        break;
-      case "--out":
-        options.out = value();
-        index += 1;
-        break;
-      default:
-        throw new PlayBootstrapUsageError(
-          `Unknown plays bootstrap option for ${MONITOR_BOOTSTRAP_TEMPLATE}: ${arg}
-Usage: deepline plays bootstrap ${MONITOR_BOOTSTRAP_TEMPLATE} [--tool <monitor-tool-id>] [--stream <stream-key>] [--name NAME] [--out monitor.play.ts]`
-        );
-    }
-  }
-  if (!options.tool) {
-    throw new PlayBootstrapUsageError(
-      `${MONITOR_BOOTSTRAP_TEMPLATE} needs a non-empty --tool.`
-    );
-  }
-  if (!options.stream) {
-    throw new PlayBootstrapUsageError(
-      `${MONITOR_BOOTSTRAP_TEMPLATE} needs a non-empty --stream.`
-    );
-  }
-  return options;
-}
-function generateMonitorTriggeredPlaySource(options) {
-  return `import { definePlay } from 'deepline';
-import type { SqlListenerEvent } from 'deepline';
-
-// Row shape delivered by ${options.tool} / ${options.stream}. This is a starting
-// point only: inspect the real columns with
-//   deepline monitors available ${options.tool}
-// and tighten this type to the fields you read below.
-//
-// Before deploying a NEW monitor, run \`deepline monitors list\` \u2014 if one
-// already feeds this stream for your scope, this play will already react to its
-// rows (a play binds to the shared stream), so you may not need to deploy at all.
-type MonitorRow = Record<string, unknown>;
-
-export default definePlay(
-  ${jsString(options.name)},
-  async (ctx, event: SqlListenerEvent<MonitorRow>) => {
-    // The monitor delivers the changed row as event.after. It is null for
-    // DELETE operations, so guard before reading fields.
-    const row = event.after;
-    if (!row) {
-      ctx.log(\`Monitor \${event.tool}/\${event.stream} \${event.operation} with no row; nothing to do.\`);
-      return { handled: false, operation: event.operation };
-    }
-
-    ctx.log(
-      \`Monitor \${event.tool}/\${event.stream} \${event.operation}: \${JSON.stringify(row).slice(0, 200)}\`,
-    );
-
-    // Capture the changed row into a durable dataset so the run has inspectable,
-    // exportable output. ctx.dataset is a CALLABLE: ctx.dataset(key, rows) where
-    // key is a compile-time string LITERAL and rows is an array of row objects.
-    // It returns a builder; add per-row columns with .withColumn(name, resolver)
-    // and finish with .run(). There is no .push/.add \u2014 pass all rows up front.
-    // TODO: replace this plain persist with your real per-row work \u2014 enrich each
-    // row via .withColumn('...', (row, rowCtx) => rowCtx.tools.execute(...)),
-    // notify, write to another table, or fan out with rowCtx.runPlay.
-    const captured = await ctx.dataset('monitor_events', [row]).run({
-      description: \`Captured \${event.tool}/\${event.stream} \${event.operation} rows.\`,
-    });
-
-    return {
-      handled: true,
-      tool: event.tool,
-      stream: event.stream,
-      operation: event.operation,
-      changedAt: event.changedAt,
-      capturedRows: await captured.count(),
-    };
-  },
-  {
-    description: ${jsString(`Run whenever ${options.tool} writes a new ${options.stream} row.`)},
-    // A monitor trigger: this play wakes on row changes written by the bound
-    // monitor tool + stream. Discover a tool's streams and columns with:
-    //   deepline monitors available ${options.tool}
-    // To bind a different monitor, swap tool/stream (and re-check operations)
-    // for one of its (tool, stream) pairs.
-    sqlListeners: [
-      {
-        id: 'events',
-        tool: ${jsString(options.tool)},
-        stream: ${jsString(options.stream)},
-        operations: ['INSERT'],
-        // Optional: only wake on some rows \u2014 add a where filter to the binding above:
-        //   where: { after: { <column>: { eq: 'value' } } }  // operators: eq, neq, in, notIn, isNull, isNotNull, ilike
-      },
-    ],
-  },
-);
-`;
-}
-function playBootstrapUsageLine() {
-  return `Usage: deepline plays bootstrap <${formatPlayBootstrapTemplates()}> --from <csv:PATH|play:REF|provider:ID|providers:ID,ID> [--using <play:REF|providers:ID,ID>] [--people play:REF] [--email <play:REF|providers:ID,ID>] [--phone <play:REF|providers:ID,ID>] [--limit 5] [--out flow.play.ts]`;
-}
-function requireBootstrapTemplate(rawTemplate) {
-  if (!rawTemplate) {
-    throw new PlayBootstrapUsageError(
-      `plays bootstrap needs a route template: ${formatPlayBootstrapTemplates()}|${MONITOR_BOOTSTRAP_TEMPLATE}.
-Example: deepline plays bootstrap people-email --from csv:data/leads.csv --using play:prebuilt/name-and-domain-to-email-waterfall --out email-flow.play.ts`
-    );
-  }
-  if (!isPlayBootstrapTemplate(rawTemplate)) {
-    const looksLikePlayReference = rawTemplate.includes("/") || rawTemplate.endsWith(".play.ts");
-    throw new PlayBootstrapUsageError(
-      `Unknown plays bootstrap template: ${rawTemplate}
-Supported templates: ${formatPlayBootstrapTemplates()}|${MONITOR_BOOTSTRAP_TEMPLATE}` + (looksLikePlayReference ? `
-
-"${rawTemplate}" looks like an existing play reference or file, not a bootstrap template. Do not run plays bootstrap on prebuilt/<play-name>. Use "deepline plays run ${rawTemplate} --input '{...}'" to run it directly, "deepline describe ${rawTemplate}" to inspect its contract, or "deepline plays get ${rawTemplate} --source --out scratchpad.play.ts" to clone/edit it.` : "")
-    );
-  }
-  return rawTemplate;
-}
-function nextFlagValue(args, index, flag) {
-  const value = args[index + 1];
-  if (!value || value.startsWith("--")) {
-    throw new PlayBootstrapUsageError(`${flag} needs a value.`);
-  }
-  return value;
-}
-function stageFlag(stage) {
-  return `--${stage}`;
-}
-function stageRefHelp(stage) {
-  switch (stage) {
-    case "people":
-      return "play:<people-play>";
-    case "email":
-    case "phone":
-      return "<play:REF|provider:ID|providers:ID,ID>";
-  }
-}
-function getStageRef(options, stage) {
-  switch (stage) {
-    case "people":
-      return options.people;
-    case "email":
-      return options.email;
-    case "phone":
-      return options.phone;
-  }
-}
-function setStageRef(options, stage, ref) {
-  switch (stage) {
-    case "people":
-      options.people = ref;
-      return;
-    case "email":
-      options.email = ref;
-      return;
-    case "phone":
-      options.phone = ref;
-      return;
-  }
-}
-function unsupportedStageMessage(template, stage) {
-  switch (stage) {
-    case "people":
-      return `${template} does not accept --people. Use company-people, company-people-email, or company-people-phone.`;
-    case "email":
-      return `${template} does not accept --email. Use people-email or company-people-email.`;
-    case "phone":
-      return `${template} does not accept --phone. Use people-phone or company-people-phone.`;
-  }
-}
-function requireSource(options) {
-  if (!options.from) {
-    throw new PlayBootstrapUsageError(
-      `${options.template} needs --from.
-Example: ${templateExample(options.template)}`
-    );
-  }
-  return options.from;
-}
-function assertAllowedStageFlags(options, allowedStages) {
-  const allowed = new Set(allowedStages);
-  for (const stage of PLAY_BOOTSTRAP_STAGE_NAMES) {
-    if (!allowed.has(stage) && getStageRef(options, stage)) {
-      throw new PlayBootstrapUsageError(
-        unsupportedStageMessage(options.template, stage)
-      );
-    }
-  }
-}
-function assertRequiredStages(options, stages) {
-  for (const stage of stages) {
-    if (!getStageRef(options, stage)) {
-      throw new PlayBootstrapUsageError(
-        `${options.template} needs ${stageFlag(stage)} ${stageRefHelp(stage)}.
-Example: ${templateExample(options.template)}`
-      );
-    }
-  }
-}
-function normalizeSingleStageRoute(options, stage) {
-  const explicitStage = getStageRef(options, stage);
-  if (options.using && explicitStage) {
-    throw new PlayBootstrapUsageError(
-      `${options.template} received both --using and ${stageFlag(stage)}. Choose one stage binding.`
-    );
-  }
-  const selectedStage = options.using ?? explicitStage;
-  if (!selectedStage) {
-    throw new PlayBootstrapUsageError(
-      `${options.template} needs --using ${stageRefHelp(stage)} or ${stageFlag(stage)} ${stageRefHelp(stage)}.
-Example: ${templateExample(options.template)}`
-    );
-  }
-  setStageRef(options, stage, selectedStage);
-  options.using = selectedStage;
-  assertAllowedStageFlags(options, [stage]);
-}
-function normalizeMultiStageRoute(options, stages) {
-  if (options.using) {
-    throw new PlayBootstrapUsageError(
-      `${options.template} does not accept --using. Use the explicit stage flags shown in: ${templateExample(options.template)}`
-    );
-  }
-  assertRequiredStages(options, stages);
-  assertAllowedStageFlags(options, stages);
-}
-function normalizeTemplateStages(options) {
-  const config = playBootstrapTemplateConfig(options.template);
-  const from = requireSource(options);
-  switch (config.usingStage) {
-    case "people":
-    case "email":
-    case "phone":
-      normalizeSingleStageRoute(options, config.usingStage);
-      break;
-    case null:
-      normalizeMultiStageRoute(options, config.requiredStages);
-      break;
-  }
-  return {
-    ...options,
-    from
-  };
-}
-function parsePlayBootstrapOptions(args) {
-  const [rawTemplate, ...rest] = args;
-  const template = requireBootstrapTemplate(rawTemplate);
-  const options = {
-    template,
-    name: `gtm-${template}`,
-    from: null,
-    using: null,
-    people: null,
-    email: null,
-    phone: null,
-    limit: 5,
-    out: null
-  };
-  for (let index = 0; index < rest.length; index += 1) {
-    const arg = rest[index];
-    const value = () => nextFlagValue(rest, index, arg);
-    switch (arg) {
-      case "--name":
-        options.name = value();
-        index += 1;
-        break;
-      case "--from":
-        options.from = parseBootstrapSourceRef(value(), "--from");
-        index += 1;
-        break;
-      case "--using":
-        options.using = parseBootstrapStageRef(value(), "--using");
-        index += 1;
-        break;
-      case "--people":
-        options.people = parseBootstrapStageRef(value(), "--people");
-        index += 1;
-        break;
-      case "--email":
-        options.email = parseBootstrapStageRef(value(), "--email");
-        index += 1;
-        break;
-      case "--phone":
-        options.phone = parseBootstrapStageRef(value(), "--phone");
-        index += 1;
-        break;
-      case "--limit":
-        options.limit = parsePositiveInteger(value(), "--limit");
-        index += 1;
-        break;
-      case "--out":
-        options.out = value();
-        index += 1;
-        break;
-      default:
-        throw new PlayBootstrapUsageError(
-          `Unknown plays bootstrap option: ${arg}
-${playBootstrapUsageLine()}`
-        );
-    }
-  }
-  return normalizeTemplateStages(options);
-}
-function jsString(value) {
-  return JSON.stringify(value);
-}
-function inferCsvCellTypeExpression(values) {
-  const nonEmptyValues = values.map((value) => value.trim()).filter((value) => value.length > 0);
-  const hasEmptyValue = values.some((value) => value.trim().length === 0);
-  if (nonEmptyValues.length === 0) return "string";
-  const numericPattern = /^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:[eE][+-]?\d+)?$/;
-  const booleanPattern = /^(?:true|false)$/i;
-  let inferred = "string";
-  if (nonEmptyValues.every((value) => numericPattern.test(value))) {
-    inferred = "`${number}`";
-  } else if (nonEmptyValues.every((value) => booleanPattern.test(value))) {
-    const canonicalBooleanValues = nonEmptyValues.every(
-      (value) => value === "true" || value === "false"
-    );
-    inferred = canonicalBooleanValues ? '"false" | "true"' : [...new Set(nonEmptyValues)].sort().map(jsString).join(" | ");
-  }
-  return hasEmptyValue && inferred !== "string" ? `${inferred} | ""` : inferred;
-}
-function inferCsvColumnSpecs(headers, rows) {
-  return headers.map((header) => ({
-    name: header,
-    typeExpression: inferCsvCellTypeExpression(
-      rows.map((row) => String(row[header] ?? ""))
-    )
-  }));
-}
-function readCsvSample(csvPath) {
-  const resolvedPath = resolve(csvPath);
-  const size = statSync(resolvedPath).size;
-  const fd = openSync(resolvedPath, "r");
-  const byteLength = Math.min(size, CSV_HEADER_SAMPLE_BYTES);
-  const buffer = Buffer.alloc(byteLength);
-  const bytesRead = readSync(fd, buffer, 0, byteLength, 0);
-  closeSync(fd);
-  if (bytesRead === 0) {
-    throw new PlayBootstrapUsageError(`--from csv:${csvPath} is empty.`);
-  }
-  return {
-    content: buffer.subarray(0, bytesRead).toString("utf8"),
-    truncated: size > bytesRead
-  };
-}
-function completeCsvSample(csvPath, sample) {
-  if (!sample.truncated) return sample.content;
-  const lastLineBreak = Math.max(
-    sample.content.lastIndexOf("\n"),
-    sample.content.lastIndexOf("\r")
-  );
-  if (lastLineBreak < 0) {
-    throw new PlayBootstrapUsageError(
-      `CSV header in ${csvPath} is longer than ${CSV_HEADER_SAMPLE_BYTES} bytes; shorten the header row before bootstrapping.`
-    );
-  }
-  return sample.content.slice(0, lastLineBreak + 1);
-}
-function readCsvHeaderFields(csvPath, sample) {
-  const records = parseCsvSync(sample, {
-    bom: true,
-    to_line: 1,
-    relax_column_count: true,
-    skip_empty_lines: false
-  });
-  const firstRecord = Array.isArray(records) ? records[0] : null;
-  const fields2 = Array.isArray(firstRecord) ? firstRecord.map((field) => String(field ?? "").trim()).filter(Boolean) : [];
-  const uniqueFields = [...new Set(fields2)];
-  if (uniqueFields.length === 0) {
-    throw new PlayBootstrapUsageError(
-      `Could not read a header row from --from csv:${csvPath}.`
-    );
-  }
-  return uniqueFields;
-}
-function readCsvSampleRows(sample) {
-  const parsedRows = parseCsvSync(sample, {
-    bom: true,
-    columns: true,
-    skip_empty_lines: true,
-    relax_column_count: true,
-    trim: true
-  });
-  return Array.isArray(parsedRows) ? parsedRows.filter(isRecord) : [];
-}
-function readSourceCsvColumnSpecs(csvPath) {
-  const sample = readCsvSample(csvPath);
-  const completeSample = completeCsvSample(csvPath, sample);
-  return inferCsvColumnSpecs(
-    readCsvHeaderFields(csvPath, sample.content),
-    readCsvSampleRows(completeSample)
-  );
-}
-function renderSourceCsvRowType(columns) {
-  if (columns.length === 0) return "";
-  const properties = columns.map((column) => `  ${jsString(column.name)}: ${column.typeExpression};`).join("\n");
-  return `// CSV cells are strings at runtime. \`${"${number}"}\` means a numeric-looking CSV string; cast before math.
-type SourceCsvRow = {
-${properties}
-};
-
-`;
-}
-function packagedCsvPathForPlay(csvPath) {
-  const playDir = process.cwd();
-  const absoluteCsvPath = resolve(csvPath);
-  const relativePath = relative(playDir, absoluteCsvPath);
-  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath)) {
-    throw new PlayBootstrapUsageError(
-      `--from csv:${csvPath} must point to a file inside the directory where you run plays bootstrap. Run bootstrap from the intended play directory and write the play with --out there.`
-    );
-  }
-  const portablePath = relativePath.split("\\").join("/");
-  return portablePath.startsWith(".") ? portablePath : `./${portablePath}`;
-}
-function getterNamesFromTool(tool, kind) {
-  const usageGuidance = isRecord(tool?.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
-  const key = kind === "list" ? "extractedLists" : "extractedValues";
-  const snakeKey = kind === "list" ? "extracted_lists" : "extracted_values";
-  return extractionEntries(resultGuidance[key] ?? resultGuidance[snakeKey]).map((entry) => stringValue(entry.name)).filter(Boolean);
-}
-function targetGettersFromTool(tool) {
-  const record3 = isRecord(tool) ? tool : {};
-  const raw = record3.targetGetters ?? record3.target_getters;
-  if (!isRecord(raw)) return {};
-  const entries = [];
-  for (const [target, value] of Object.entries(raw)) {
-    const paths = Array.isArray(value) ? value.map((path) => typeof path === "string" ? path.trim() : "").filter(Boolean) : [];
-    if (target.trim() && paths.length > 0) {
-      entries.push([target.trim(), paths]);
-    }
-  }
-  return Object.fromEntries(entries);
-}
-function listRowCandidateKeysFromTool(tool) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const paths of Object.values(targetGettersFromTool(tool))) {
-    for (const path of paths) {
-      const key = path.replace(/\[(?:\*|\d+)\]/g, "").split(/[.[\]]/, 1)[0]?.trim();
-      if (key) keys.add(key);
-    }
-  }
-  return [...keys].sort();
-}
-function inputPropertyNames(schema) {
-  if (!isRecord(schema)) return [];
-  if (isRecord(schema.properties)) return Object.keys(schema.properties);
-  if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord).map((field) => stringValue(field.name)).filter(Boolean);
-  }
-  return [];
-}
-function schemaFieldDetails(schema) {
-  const required = requiredPlayInputFields({
-    inputSchema: schema
-  });
-  const optional = inputPropertyNames(schema).filter(
-    (field) => !required.includes(field)
-  );
-  return { required, optional };
-}
-function jsonSchemaTypeExpression(schema) {
-  if (!isRecord(schema)) return "unknown";
-  const type = schema.type;
-  if (Array.isArray(type)) {
-    return type.map((entry) => jsonSchemaTypeExpression({ ...schema, type: entry })).join(" | ");
-  }
-  if (Array.isArray(schema.anyOf)) {
-    return schema.anyOf.map(jsonSchemaTypeExpression).join(" | ");
-  }
-  if (Array.isArray(schema.oneOf)) {
-    return schema.oneOf.map(jsonSchemaTypeExpression).join(" | ");
-  }
-  switch (type) {
-    case "string":
-      return "string";
-    case "number":
-    case "integer":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "null":
-      return "null";
-    case "array":
-      return `Array<${jsonSchemaTypeExpression(schema.items)}>`;
-    case "object":
-      return "Record<string, unknown>";
-    default:
-      return "unknown";
-  }
-}
-function objectPropertySchema(schema, property) {
-  return isRecord(schema) && isRecord(schema.properties) ? schema.properties[property] : null;
-}
-function playOutputHasField(schema, field) {
-  return objectPropertySchema(schema, field) != null;
-}
-function finderResultTypeName(finder) {
-  return finder === "email_finder" ? "EmailFinderPlayResult" : "PhoneFinderPlayResult";
-}
-function renderFinderPlayResultType(input) {
-  if (!input.play) return null;
-  const outputField = PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER[input.finder];
-  const fieldSchema = objectPropertySchema(
-    input.play.outputSchema,
-    outputField
-  );
-  if (fieldSchema) {
-    const fieldType = jsonSchemaTypeExpression(fieldSchema);
-    return `type ${finderResultTypeName(input.finder)} = {
-      ${outputField}?: ${fieldType};
-    };`;
-  }
-  return `type ${finderResultTypeName(input.finder)} = ${jsonSchemaTypeExpression(input.play.outputSchema)};`;
-}
-function generatedFinderPlayResultTypes(input) {
-  return ["email_finder", "phone_finder"].flatMap((finder) => {
-    const stage = finderStage(input.options, finder);
-    if (stage?.kind !== "play") return [];
-    const typeDefinition = renderFinderPlayResultType({
-      finder,
-      play: input.finderPlays[finder]
-    });
-    return typeDefinition ? [typeDefinition] : [];
-  }).join("\n\n");
-}
-function exampleValueComment(field) {
-  if (field === "limit" || field === "numResults" || field === "num_results" || field === "page_size") {
-    return "limit";
-  }
-  if (field === "roles" || field.endsWith("s")) return '["..."]';
-  return '"..."';
-}
-function rowFieldValueExpression(field) {
-  if (field === "limit" || field === "numResults" || field === "num_results" || field === "page_size" || field === "max_duration") {
-    return `Number(row[${jsString(field)}] ?? 0)`;
-  }
-  if (field === "roles" || field.endsWith("s")) {
-    return `String(row[${jsString(field)}] ?? '').split(',').map((item) => item.trim()).filter(Boolean)`;
-  }
-  return `String(row[${jsString(field)}] ?? '')`;
-}
-function generateContactInputObjectFromSchema(schema, indent, label, fallbackFields = ["first_name", "last_name", "domain"]) {
-  const details = schemaFieldDetails(schema);
-  const required = details.required.length ? details.required : fallbackFields;
-  const optional = details.optional;
-  const lines = [
-    `${indent}// TODO: map row fields into ${label}.`,
-    ...playInspectionComments(label, indent),
-    `${indent}// Required: ${required.join(", ") || "none declared"}.`
-  ];
-  for (const field of required) {
-    lines.push(
-      `${indent}${field}: ${rowFieldValueExpression(field)}, // TODO: confirm source field`
-    );
-  }
-  if (optional.length > 0) {
-    lines.push("");
-    lines.push(`${indent}// optional (delete unused):`);
-    for (const field of optional) {
-      lines.push(`${indent}// ${field}: row["TODO_SOURCE_FIELD"],`);
-    }
-  }
-  return `{
-${lines.join("\n")}
-${indent.slice(2)}}`;
-}
-function generateCompanyInputObjectFromSchema(schema, indent, label, fallbackFields = ["domain", "company_name"]) {
-  const details = schemaFieldDetails(schema);
-  const required = details.required.length ? details.required : fallbackFields;
-  const optional = details.optional;
-  const lines = [
-    `${indent}// TODO: map company fields into ${label}.`,
-    ...playInspectionComments(label, indent),
-    `${indent}// Required: ${required.join(", ") || "none declared"}.`
-  ];
-  for (const field of required) {
-    lines.push(`${indent}// ${field}: company["TODO_SOURCE_FIELD"],`);
-  }
-  if (optional.length > 0) {
-    lines.push("");
-    lines.push(`${indent}// optional (delete unused):`);
-    for (const field of optional) {
-      lines.push(`${indent}// ${field}: company["TODO_SOURCE_FIELD"],`);
-    }
-  }
-  return `{
-${lines.join("\n")}
-${indent.slice(2)}}`;
-}
-function generateSourceProviderInputObject(input) {
-  const { tool, indent, label, entity } = input;
-  const properties = inputPropertyNames(tool?.inputSchema);
-  const details = schemaFieldDetails(tool?.inputSchema);
-  const required = details.required;
-  const includeOptional = properties.length === 0 ? ["query", "title", "domain", "limit"] : properties.filter(
-    (field) => [
-      "query",
-      "q",
-      "search",
-      "title",
-      "role",
-      "persona",
-      "domain",
-      "company_domain",
-      "limit",
-      "numResults",
-      "num_results",
-      "page_size"
-    ].includes(field)
-  );
-  const lines = [
-    `${indent}// TODO: fill ${entity} source inputs for ${label}.`,
-    `${indent}// Inspect: deepline describe ${label}`
-  ];
-  for (const field of required) {
-    lines.push(`${indent}// ${field}: ${exampleValueComment(field)},`);
-  }
-  const activeTodoField = required.length === 0 ? ["query", "q", "search", "title", "role", "persona"].find(
-    (field) => includeOptional.includes(field)
-  ) ?? "query" : null;
-  if (activeTodoField) {
-    lines.push(
-      `${indent}// ${activeTodoField}: ${exampleValueComment(activeTodoField)},`
-    );
-  }
-  const optionalExamples = includeOptional.filter(
-    (field) => !required.includes(field) && field !== activeTodoField
-  );
-  if (optionalExamples.length > 0) {
-    lines.push("");
-    lines.push(`${indent}// optional - uncomment what this provider supports:`);
-    for (const field of optionalExamples) {
-      if (field === "limit" || field === "numResults" || field === "num_results" || field === "page_size") {
-        lines.push(`${indent}// ${field}: limit,`);
-      } else {
-        lines.push(`${indent}// ${field}: ${exampleValueComment(field)},`);
-      }
-    }
-  }
-  if (!required.some(
-    (field) => ["limit", "numResults", "num_results", "page_size"].includes(field)
-  )) {
-    lines.push(`${indent}limit,`);
-  }
-  return `{
-${lines.join("\n")}
-${indent.slice(2)}}`;
-}
-function generatePlayInputObject(input) {
-  const { schema, indent, label, entity } = input;
-  const details = schemaFieldDetails(schema);
-  const fallback = entity === "company" ? ["domain", "company_name"] : ["first_name", "last_name", "domain"];
-  const required = details.required.length ? details.required : fallback;
-  const lines = [
-    `${indent}// TODO: fill source play inputs for ${label}.`,
-    ...playInspectionComments(label, indent)
-  ];
-  for (const field of required) {
-    lines.push(`${indent}// ${field}: ${exampleValueComment(field)},`);
-  }
-  if (!required.includes("limit")) lines.push(`${indent}limit,`);
-  return `{
-${lines.join("\n")}
-${indent.slice(2)}}`;
-}
-function requiredPlayInputFields(play) {
-  const schema = play?.inputSchema;
-  if (!isRecord(schema)) return [];
-  if (Array.isArray(schema.required)) {
-    return schema.required.filter(
-      (value) => typeof value === "string"
-    );
-  }
-  if (Array.isArray(schema.fields)) {
-    return schema.fields.filter(isRecord).filter(
-      (field) => field.required === true && typeof field.name === "string"
-    ).map((field) => String(field.name));
-  }
-  return [];
-}
-function sourceProviders(options) {
-  return options.from.kind === "providers" ? options.from.values : [];
-}
-function sourcePlayRef(options) {
-  return options.from.kind === "play" ? options.from.value : null;
-}
-function stagePlayRef(stage) {
-  return stage?.kind === "play" ? stage.value : null;
-}
-function stageProviders(stage) {
-  return stage?.kind === "providers" ? stage.values : [];
-}
-function finderStage(options, finder) {
-  return finder === "email_finder" ? options.email : options.phone;
-}
-function stepFieldName(finder) {
-  return PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER[finder];
-}
-function finderProviderStepPrefix(finder) {
-  return finder === "email_finder" ? "emailFinder" : "phoneFinder";
-}
-function safeIdentifier(value) {
-  return value.replace(/[^A-Za-z0-9_]+/g, "_");
-}
-function playInspectionComments(playRef, indent) {
-  return [`${indent}// Inspect: deepline describe ${playRef}`];
-}
-function accessorExpression(base, field) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(field) ? `${base}.${field}` : `${base}[${jsString(field)}]`;
-}
-function sourceCollectionTypeName(entity) {
-  return entity === "company" ? "CompanySourceRow" : "ContactSourceRow";
-}
-function renderPartialRowType(input) {
-  if (input.fields.length === 0) {
-    return `type ${input.typeName} = Record<string, unknown>;`;
-  }
-  const properties = input.fields.map((field) => `  ${jsString(field)}?: unknown;`).join("\n");
-  return `type ${input.typeName} = Record<string, unknown> & Partial<{
-  // ${input.comment}
-${properties}
-}>;`;
-}
-function fieldsFromSchemaDetails(input) {
-  return [
-    ...input.details.required.length ? input.details.required : input.fallbackFields,
-    ...input.details.optional
-  ];
-}
-function schemaFieldsForStage(stage, input) {
-  switch (stage?.kind) {
-    case void 0:
-      return [];
-    case "play":
-      return fieldsFromSchemaDetails({
-        details: schemaFieldDetails(input.play?.inputSchema),
-        fallbackFields: input.fallbackFields
-      });
-    case "providers":
-      return input.tools.flatMap(
-        (tool) => fieldsFromSchemaDetails({
-          details: schemaFieldDetails(tool.inputSchema),
-          fallbackFields: input.fallbackFields
-        })
-      );
-  }
-}
-function sourceRowTypeDefinition(input) {
-  switch (input.options.from.kind) {
-    case "csv":
-      return `type ${input.sourceTypeName} = SourceCsvRow;`;
-    case "providers":
-      return renderPartialRowType({
-        typeName: input.sourceTypeName,
-        fields: [
-          ...new Set(input.sourceTools.flatMap(listRowCandidateKeysFromTool))
-        ].sort(),
-        comment: "Candidate source row keys from described list getters; confirm the actual provider keys with source_*.extractedLists.*.keys before mapping."
-      });
-    case "play": {
-      const details = schemaFieldDetails(input.sourcePlay?.outputSchema);
-      return renderPartialRowType({
-        typeName: input.sourceTypeName,
-        fields: [...details.required, ...details.optional].sort(),
-        comment: "Candidate source play output fields; confirm the selected rows field before mapping."
-      });
-    }
-  }
-}
-function contactBridgeRowTypeDefinition(input) {
-  const config = playBootstrapTemplateConfig(input.options.template);
-  if (config.sourceEntity !== "company" || !input.options.people) return null;
-  const emailFields = schemaFieldsForStage(input.options.email, {
-    tools: input.finderTools.email_finder ?? [],
-    play: input.finderPlays.email_finder,
-    fallbackFields: ["first_name", "last_name", "domain"]
-  });
-  const phoneFields = schemaFieldsForStage(input.options.phone, {
-    tools: input.finderTools.phone_finder ?? [],
-    play: input.finderPlays.phone_finder,
-    fallbackFields: ["first_name", "last_name", "domain"]
-  });
-  return renderPartialRowType({
-    typeName: "ContactSourceRow",
-    fields: [
-      .../* @__PURE__ */ new Set([
-        ...inputPropertyNames(input.peoplePlay?.outputSchema),
-        ...emailFields,
-        ...phoneFields
-      ])
-    ].sort(),
-    comment: "Fields the people play or later finder stages may need; the generated code still requires explicit mapping."
-  });
-}
-function generateRowTypeDefinitions(input) {
-  const config = playBootstrapTemplateConfig(input.options.template);
-  const sourceTypeName = sourceCollectionTypeName(config.sourceEntity);
-  const definitions = [
-    sourceRowTypeDefinition({
-      options: input.options,
-      sourceTypeName,
-      sourceTools: input.sourceTools,
-      sourcePlay: input.sourcePlay
-    }),
-    contactBridgeRowTypeDefinition(input)
-  ];
-  return definitions.filter(Boolean).join("\n\n");
-}
-function validateBootstrapRoutes(input) {
-  const config = playBootstrapTemplateConfig(input.options.template);
-  const sourceCategory = config.sourceEntity === "company" ? PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY : PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY;
-  for (const tool of input.sourceTools) {
-    if (!tool.categories.includes(sourceCategory)) {
-      throw new PlayBootstrapValidationError(
-        `Cannot use ${tool.toolId} as a ${config.sourceEntity} source for ${input.options.template}: expected category ${sourceCategory}, got ${tool.categories.join(", ") || "none"}. Run: deepline tools grep ${sourceCategory} --categories ${sourceCategory} --json`
-      );
-    }
-    if (getterNamesFromTool(tool, "list").length === 0) {
-      throw new PlayBootstrapValidationError(
-        `Cannot use ${tool.toolId} as a ${config.sourceEntity} source: it exposes no extracted list getters. Run: deepline describe ${tool.toolId}`
-      );
-    }
-  }
-  if (input.options.people?.kind === "providers") {
-    throw new PlayBootstrapValidationError(
-      "Company-to-people bootstrap only accepts --people play:<play-ref> for now. Providers are too task-specific; choose or create a people play so the generated file can show the mapping contract."
-    );
-  }
-  assertComposablePlayRoute({
-    stageLabel: "--people",
-    playRef: stagePlayRef(input.options.people),
-    play: input.peoplePlay
-  });
-  for (const finder of ["email_finder", "phone_finder"]) {
-    const requiredCategory = PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER[finder];
-    assertComposablePlayRoute({
-      stageLabel: finder === "email_finder" ? "--email/--using" : "--phone/--using",
-      playRef: stagePlayRef(finderStage(input.options, finder)),
-      play: input.finderPlays[finder] ?? null
-    });
-    for (const tool of input.finderTools[finder] ?? []) {
-      if (!tool.categories.includes(requiredCategory)) {
-        throw new PlayBootstrapValidationError(
-          `Cannot use ${tool.toolId} for ${finder}: expected category ${requiredCategory}, got ${tool.categories.join(", ") || "none"}. Run: deepline tools grep ${requiredCategory} --categories ${requiredCategory} --json`
-        );
-      }
-      if (getterNamesFromTool(tool, "value").length === 0) {
-        throw new PlayBootstrapValidationError(
-          `Cannot use ${tool.toolId} as a ${finder}: it exposes no extracted value getters. Run: deepline describe ${tool.toolId}`
-        );
-      }
-    }
-  }
-}
-function staticPipelineSubsteps(pipeline) {
-  if (!isRecord(pipeline)) return [];
-  return [
-    ...extractionEntries(pipeline.stages),
-    ...extractionEntries(pipeline.substeps)
-  ];
-}
-function playUsesMapBackedRuntime(play) {
-  const pipeline = play?.staticPipeline;
-  if (!isRecord(pipeline)) return false;
-  if (stringValue(pipeline.tableNamespace)) return true;
-  return staticPipelineSubsteps(pipeline).some((substep) => {
-    if (stringValue(substep.type) === "map") return true;
-    return playUsesMapBackedRuntime({
-      name: play?.name ?? "child",
-      aliases: [],
-      runCommand: "",
-      examples: [],
-      staticPipeline: isRecord(substep.pipeline) ? substep.pipeline : null
-    });
-  });
-}
-function assertComposablePlayRoute(input) {
-  if (!input.playRef || !playUsesMapBackedRuntime(input.play)) return;
-  const runCommand = input.play?.runCommand?.trim() || `deepline plays run ${input.playRef} --input '{...}'`;
-  throw new PlayBootstrapValidationError(
-    `Cannot use ${input.stageLabel} play:${input.playRef} in plays bootstrap composition: the selected play is dataset-backed/direct-run-only. Child plays that use ctx.dataset() own durable table state and must be run directly, exported, or validated as their own play instead of wrapped with ctx.runPlay. Run it directly first: ${runCommand}`
-  );
-}
-function sourcePlayNeedsExportFirst(input) {
-  return input.source.kind === "play" && playUsesMapBackedRuntime(input.sourcePlay);
-}
-function sourceCollectionName(entity) {
-  switch (entity) {
-    case "company":
-      return "companies";
-    case "people":
-      return "contacts";
-  }
-}
-function requiredGetterName(input) {
-  const getter = getterNamesFromTool(input.tool, input.kind)[0];
-  if (!getter) {
-    switch (input.kind) {
-      case "list":
-        throw new PlayBootstrapValidationError(
-          `Cannot use ${input.label} as a source: it exposes no extracted list getters.`
-        );
-      case "value":
-        throw new PlayBootstrapValidationError(
-          `Cannot use ${input.label} as a finder: it exposes no extracted value getters.`
-        );
-    }
-  }
-  return getter;
-}
-function generateCsvSourceRowsBlock(input) {
-  return `const sourceDataset = await ctx.csv<SourceCsvRow>(${jsString(input.packagedSourceCsvPath ?? input.source.value)});
-  const ${input.collection}: ${input.collectionType}[] = await sourceDataset.peek(limit);`;
-}
-function generatePlaySourceRowsBlock(input) {
-  if (sourcePlayNeedsExportFirst({
-    source: input.source,
-    sourcePlay: input.sourcePlay
-  })) {
-    const sourcePlay = input.sourcePlay;
-    const runCommand = sourcePlay?.runCommand?.trim() || `deepline plays run ${input.source.value} --input '{...}'`;
-    return `// Source play ${input.source.value} is dataset-backed/direct-run-only, so this generated play is stage 2.
-  // Stage 1:
-  //   ${runCommand}
-  // Stage 2:
-  //   deepline runs export <stage-1-run-id> --dataset 'result.rows' --out source-export.csv
-  // Stage 3:
-  //   deepline plays run <this-file.play.ts> --input '{"sourceCsv":"source-export.csv","limit":${input.sourcePlay ? "5" : "5"}}'
-  const sourceDataset = await ctx.csv<${input.collectionType}>(input.sourceCsv ?? './source-export.csv');
-  const ${input.collection}: ${input.collectionType}[] = await sourceDataset.peek(limit);`;
-  }
-  const playInput = generatePlayInputObject({
-    schema: input.sourcePlay?.inputSchema,
-    indent: "    ",
-    label: input.source.value,
-    entity: input.entity
-  });
-  return `const sourceInput = ${playInput};
-  throw new Error(${jsString(`TODO: map sourceInput for ${input.source.value}, choose the play output rows field, then delete this throw.`)});
-  const sourceResult = (await ctx.runPlay('source_play', ${jsString(input.source.value)}, sourceInput, {
-    description: ${jsString(`Seed ${input.entity} rows from the selected play.`)},
-  })) as { rows?: unknown[] };
-  // TODO: Replace sourceResult.rows with the selected play's actual row output field.
-  const ${input.collection}: ${input.collectionType}[] = (sourceResult.rows ?? []) as ${input.collectionType}[];`;
-}
-function generateProviderSourceBlock(input) {
-  const getter = requiredGetterName({
-    tool: input.tool,
-    kind: "list",
-    label: input.provider
-  });
-  const inputName = `${input.entity}Input_${input.index}`;
-  return `// ${input.entity === "company" ? "Company" : "People"} source provider: ${input.provider}
-  const ${inputName}: Record<string, unknown> = ${generateSourceProviderInputObject(
-    {
-      tool: input.tool,
-      indent: "    ",
-      label: input.provider,
-      entity: input.entity
-    }
-  )};
-  throw new Error(${jsString(`TODO: fill ${inputName} for ${input.provider}, then delete this throw.`)});
-  const source_${input.index} = await ctx.tools.execute({
-    staleAfterSeconds: 0,
-    id: ${jsString(`${input.entity}_source_${input.index}`)},
-    tool: ${jsString(input.provider)},
-    input: ${inputName},
-    description: ${jsString(`Seed ${input.entity} rows from ${input.provider}.`)},
-  });
-  // extractedLists.${getter}.get() returns provider-shaped rows. Do not assume canonical fields;
-  // inspect source_${input.index}.extractedLists.${getter}.keys or the provider output schema, then map explicitly below.
-  const sourceList_${input.index} = ${accessorExpression(`source_${input.index}.extractedLists`, getter)}.get();
-  // Legacy admitted Plays use a dataset getter; the new contract returns an ordinary array.
-  const sourceRows_${input.index} = (Array.isArray(sourceList_${input.index})
-    ? sourceList_${input.index}.slice(0, limit)
-    : await sourceList_${input.index}.peek(limit)) as ${input.collectionType}[];`;
-}
-function generateProviderSourceRowsBlock(input) {
-  const blocks = input.source.values.map(
-    (provider, index) => generateProviderSourceBlock({
-      provider,
-      index,
-      tool: input.sourceTools[index] ?? null,
-      entity: input.entity,
-      collectionType: input.collectionType
-    })
-  );
-  return `${blocks.join("\n\n  ")}
-  const ${input.collection}: ${input.collectionType}[] = [${input.source.values.map((_, index) => `...sourceRows_${index}`).join(", ")}];`;
-}
-function generateSourceRowsBlock(input) {
-  const config = playBootstrapTemplateConfig(input.options.template);
-  const entity = config.sourceEntity;
-  const collection = sourceCollectionName(entity);
-  const collectionType = sourceCollectionTypeName(entity);
-  switch (input.options.from.kind) {
-    case "csv":
-      return generateCsvSourceRowsBlock({
-        source: input.options.from,
-        collection,
-        collectionType,
-        packagedSourceCsvPath: input.packagedSourceCsvPath
-      });
-    case "play":
-      return generatePlaySourceRowsBlock({
-        source: input.options.from,
-        sourcePlay: input.sourcePlay,
-        entity,
-        collection,
-        collectionType
-      });
-    case "providers":
-      return generateProviderSourceRowsBlock({
-        source: input.options.from,
-        sourceTools: input.sourceTools,
-        entity,
-        collection,
-        collectionType
-      });
-  }
-}
-function generateSourceSeedBlock(input) {
-  const sourceRows = generateSourceRowsBlock(input);
-  const peoplePlayRef = stagePlayRef(input.options.people);
-  if (!peoplePlayRef) return sourceRows;
-  const peopleInput = generateCompanyInputObjectFromSchema(
-    input.peoplePlay?.inputSchema,
-    "      ",
-    peoplePlayRef,
-    ["domain", "company_name"]
-  );
-  return `${sourceRows}
-  const contacts: ContactSourceRow[] = [];
-  for (const [index, company] of companies.slice(0, limit).entries()) {
-    const peopleInput = ${peopleInput};
-    throw new Error(${jsString(`TODO: map company fields into peopleInput for ${peoplePlayRef}, choose the play output rows field, then delete this throw.`)});
-    const peopleResult = (await ctx.runPlay(
-      \`people_play_\${index}\`,
-      ${jsString(peoplePlayRef)},
-      peopleInput,
-      {
-        description: 'Map one company row into people/contact rows with the selected play.',
-      },
-    )) as { rows?: unknown[] };
-    // TODO: Replace peopleResult.rows with the selected play's actual contact rows field.
-    contacts.push(...((peopleResult.rows ?? []) as ContactSourceRow[]));
-  }`;
-}
-function finderProviderStepName(input) {
-  return `${input.aggregateStepName}${input.index}_${safeIdentifier(input.provider)}`;
-}
-function finderValueGetter(input) {
-  const getters = getterNamesFromTool(input.tool, "value");
-  const getter = getters.find((name) => name === input.outputField) ?? requiredGetterName({
-    tool: input.tool,
-    kind: "value",
-    label: input.provider
-  });
-  return getter;
-}
-function optionalFinderValueExpression(candidateExpression, outputField) {
-  const valueExpression = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(outputField) ? `${candidateExpression}?.${outputField}` : `${candidateExpression}?.[${jsString(outputField)}]`;
-  return `${valueExpression}?.trim()`;
-}
-function generateFinderPlayStep(input) {
-  const outputField = PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER[input.finder];
-  const resultTypeName = finderResultTypeName(input.finder);
-  const returnsObjectWithField = playOutputHasField(
-    input.play?.outputSchema,
-    outputField
-  );
-  const payload = generateContactInputObjectFromSchema(
-    input.play?.inputSchema,
-    "        ",
-    input.stage.value
-  );
-  return `.withColumn(${jsString(outputField)}, async (row, rowCtx) => {
-      const ${input.aggregateStepName}Input = ${payload};
-      throw new Error(${jsString(`TODO: map ${input.aggregateStepName}Input for ${input.stage.value}, then delete this throw.`)});
-      const ${input.aggregateStepName}Result = await rowCtx.runPlay<${resultTypeName}>(
-        ${jsString(`${input.aggregateStepName}Play`)},
-        ${jsString(input.stage.value)},
-        ${input.aggregateStepName}Input,
-        {
-          description: ${jsString(`Run ${input.finder} play.`)},
-        },
-      );
-      return ${returnsObjectWithField ? `${input.aggregateStepName}Result.${outputField} ?? null` : `${input.aggregateStepName}Result ?? null`};
-    })`;
-}
-function generateFinderProviderResolver(input) {
-  const payload = generateContactInputObjectFromSchema(
-    input.tool?.inputSchema,
-    "        ",
-    input.provider
-  );
-  const getter = finderValueGetter({
-    tool: input.tool,
-    provider: input.provider,
-    outputField: input.outputField
-  });
-  return `async (row, rowCtx) => {
-      const providerInput = ${payload};
-      throw new Error(${jsString(`TODO: map providerInput for ${input.provider}, then delete this throw.`)});
-      const result = await rowCtx.tools.execute({
-        staleAfterSeconds: 0,
-        id: ${jsString(`${input.aggregateStepName}_${input.providerIndex}`)},
-        tool: ${jsString(input.provider)},
-        input: providerInput,
-        description: ${jsString(`Try ${input.provider} as a ${input.finder}.`)},
-      });
-      return {
-        ${input.outputField}: (${accessorExpression("result.extractedValues", getter)}.get() as string | null) ?? null,
-        result,
-      };
-    }`;
-}
-function generateFinderProviderStep(input) {
-  const stepName = input.stepNames[input.index];
-  switch (input.index) {
-    case 0:
-      return `.withColumn(${jsString(stepName)}, ${input.resolver})`;
-    default: {
-      const priorCandidates = input.stepNames.slice(0, input.index).map((name) => `row.${name}`).join(", ");
-      return `.withColumn(
-      ${jsString(stepName)},
-      ${input.resolver},
-      {
-        runIf: (row) => ![${priorCandidates}].some((candidate) => ${optionalFinderValueExpression("candidate", input.outputField)}),
-      },
-    )`;
-    }
-  }
-}
-function generateFinderProviderWaterfall(input) {
-  const legPrefix = finderProviderStepPrefix(input.finder);
-  const stepNames = input.stage.values.map(
-    (provider, index) => finderProviderStepName({
-      aggregateStepName: legPrefix,
-      provider,
-      index
-    })
-  );
-  const providerSteps = input.stage.values.map(
-    (provider, index) => generateFinderProviderStep({
-      index,
-      stepNames,
-      outputField: input.outputField,
-      resolver: generateFinderProviderResolver({
-        finder: input.finder,
-        provider,
-        providerIndex: index,
-        tool: input.tools[index] ?? null,
-        aggregateStepName: input.aggregateStepName,
-        outputField: input.outputField
-      })
-    })
-  );
-  const candidateNames = stepNames.map((name) => `row.${name}`).join(", ");
-  return `// ${input.aggregateStepName} provider waterfall. Each provider leg is active once its TODO throw is removed;
-    // delete or comment out legs you do not want before running. Later legs are gated with { runIf }.
-    ${providerSteps.join("\n    ")}
-    .withColumn(${jsString(input.aggregateStepName)}, (row) => {
-      const candidates = [${candidateNames}];
-      const match = candidates.find((candidate) => ${optionalFinderValueExpression("candidate", input.outputField)});
-      return ${optionalFinderValueExpression("match", input.outputField)} ?? null;
-    })`;
-}
-function generateFinderStageSteps(input) {
-  const outputField = PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER[input.finder];
-  const aggregateStepName = stepFieldName(input.finder);
-  switch (input.stage.kind) {
-    case "play":
-      return generateFinderPlayStep({
-        finder: input.finder,
-        stage: input.stage,
-        play: input.finderPlays[input.finder],
-        aggregateStepName
-      });
-    case "providers":
-      return generateFinderProviderWaterfall({
-        finder: input.finder,
-        stage: input.stage,
-        tools: input.finderTools[input.finder] ?? [],
-        aggregateStepName,
-        outputField
-      });
-  }
-}
-function generateFinderSteps(input) {
-  return ["email_finder", "phone_finder"].flatMap((finder) => {
-    const stage = finderStage(input.options, finder);
-    return stage ? [
-      generateFinderStageSteps({
-        ...input,
-        finder,
-        stage
-      })
-    ] : [];
-  }).join("\n    ");
-}
-function generateBootstrapPlaySource(input) {
-  const config = playBootstrapTemplateConfig(input.options.template);
-  const sourceSeedBlock = generateSourceSeedBlock(input);
-  const finderSteps = generateFinderSteps(input);
-  const hasPeople = config.sourceEntity === "people" || Boolean(input.options.people);
-  const sourceCollection = hasPeople ? "contacts" : "companies";
-  const mapSteps = finderSteps ? `
-    ${finderSteps}` : "";
-  const sourceCsvRowType = input.options.from.kind === "csv" ? renderSourceCsvRowType(input.sourceCsvColumns) : "";
-  const rowTypeDefinitions = generateRowTypeDefinitions(input);
-  const finderPlayResultTypes = generatedFinderPlayResultTypes(input);
-  const typeDefinitions = [
-    sourceCsvRowType.trimEnd(),
-    rowTypeDefinitions,
-    finderPlayResultTypes
-  ].filter((definition) => definition.trim().length > 0).join("\n\n");
-  return `import { definePlay } from 'deepline';
-
-${typeDefinitions}
-
-type Input = {
-  limit?: number;
-  sourceCsv?: string;
-};
-
-export default definePlay(${jsString(input.options.name)}, async (ctx, input: Input = {}) => {
-  const limit = Math.max(1, Math.min(Number(input.limit ?? ${input.options.limit}), ${input.options.limit}));
-  ${sourceSeedBlock}
-
-  const rowsToProcess = ${sourceCollection}.slice(0, limit);
-  if (rowsToProcess.length === 0) {
-    throw new Error('plays bootstrap found 0 source rows. Check the source provider/play/CSV output.');
-  }
-
-  const rows = await ctx
-    .dataset('bootstrap_rows', rowsToProcess)${mapSteps}
-    .run({
-      key: (_row, index) => index,
-      description: ${jsString(`Bootstrap ${input.options.template}: seed source rows, run requested stages, then return the mapped rows.`)},
-    });
-
-  return {
-    count: await rows.count(),
-    rows,
-  };
-}, {
-  description: ${jsString(`Bootstrap ${input.options.template}: seed source rows, run requested stages, and return mapped rows.`)},
-});
-
-`;
-}
-async function describePlayMaybe(client, playRef) {
-  return playRef ? client.describePlay(playRef, { compact: true }) : null;
-}
-function loadTools(client, providers) {
-  return Promise.all(providers.map((provider) => client.getTool(provider)));
-}
-async function loadBootstrapContracts(client, options) {
-  const [
-    sourceTools,
-    sourcePlay,
-    peoplePlay,
-    emailPlay,
-    phonePlay,
-    emailTools,
-    phoneTools
-  ] = await Promise.all([
-    loadTools(client, sourceProviders(options)),
-    describePlayMaybe(client, sourcePlayRef(options)),
-    describePlayMaybe(client, stagePlayRef(options.people)),
-    describePlayMaybe(client, stagePlayRef(options.email)),
-    describePlayMaybe(client, stagePlayRef(options.phone)),
-    loadTools(client, stageProviders(options.email)),
-    loadTools(client, stageProviders(options.phone))
-  ]);
-  const contracts = {
-    sourceTools,
-    sourcePlay,
-    peoplePlay,
-    finderTools: {
-      email_finder: emailTools,
-      phone_finder: phoneTools
-    },
-    finderPlays: {
-      email_finder: emailPlay,
-      phone_finder: phonePlay
-    }
-  };
-  validateBootstrapRoutes({
-    options,
-    sourceTools: contracts.sourceTools,
-    sourcePlay: contracts.sourcePlay,
-    peoplePlay: contracts.peoplePlay,
-    finderTools: contracts.finderTools,
-    finderPlays: contracts.finderPlays
-  });
-  return contracts;
-}
-function loadCsvContext(source) {
-  switch (source.kind) {
-    case "csv":
-      return {
-        packagedSourceCsvPath: packagedCsvPathForPlay(source.value),
-        sourceCsvColumns: readSourceCsvColumnSpecs(source.value)
-      };
-    case "play":
-    case "providers":
-      return {
-        packagedSourceCsvPath: null,
-        sourceCsvColumns: []
-      };
-  }
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function renderPlayBootstrapError(error) {
-  console.error(errorMessage(error));
-  return error instanceof PlayBootstrapError ? error.exitCode : 1;
-}
-function writeBootstrapSource(source, out) {
-  if (out) {
-    writeFileSync(resolve(out), source, "utf-8");
-    process.stdout.write(`Wrote ${resolve(out)}
-`);
-    return 0;
-  }
-  process.stdout.write(source);
-  return 0;
-}
-function runMonitorBootstrap(args) {
-  const options = parseMonitorBootstrapOptions(args);
-  const source = generateMonitorTriggeredPlaySource(options);
-  return writeBootstrapSource(source, options.out);
-}
-async function runPlayBootstrap(args) {
-  if (isMonitorBootstrapTemplate(args[0])) {
-    return runMonitorBootstrap(args);
-  }
-  const options = parsePlayBootstrapOptions(args);
-  const client = new DeeplineClient();
-  const contracts = await loadBootstrapContracts(client, options);
-  const csvContext = loadCsvContext(options.from);
-  const source = generateBootstrapPlaySource({
-    options,
-    ...contracts,
-    ...csvContext
-  });
-  return writeBootstrapSource(source, options.out);
-}
-async function handlePlayBootstrap(args) {
-  return runPlayBootstrap(args).catch(renderPlayBootstrapError);
-}
-function registerPlayBootstrapCommand(play) {
-  play.command("bootstrap <template>").description(
-    "Print a scratchpad play for a GTM route or monitor-triggered template."
-  ).addHelpText(
-    "after",
-    `
-Notes:
-  Cloud-validated play generator for agents. Pick the JTBD as the positional
-  template, bind resources with typed refs, write the .play.ts file with --out,
-  then edit the generated TODO mapping comments. Multiple finder providers are
-  generated as a waterfall in the order you pass them.
-
-  This command requires auth because provider/play contracts are fetched from
-  Deepline. It prints TypeScript source only and does not run paid tools; the
-  generated play may spend credits later when you run it.
-
-  By default stdout is the generated .play.ts source. Use --out to write a file
-  directly. Errors and diagnostics go to stderr. There is no JSON mode.
-
-  Templates:
-    people-list             start from people/contact rows
-    company-list            start from company/account rows
-    people-email            people/contact rows -> email finder
-    people-phone            people/contact rows -> phone finder
-    company-people          company/account rows -> people play
-    company-people-email    company/account rows -> people play -> email finder
-    company-people-phone    company/account rows -> people play -> phone finder
-    monitor-triggered       run a play whenever a monitor writes a new row
-                            (definePlay with sqlListeners; no --from/stage flags)
-
-  Monitor-triggered options (only for the monitor-triggered template):
-    --tool <monitor-tool-id>   monitor tool to bind (default deepline_native.company_radar)
-    --stream <stream-key>      output stream to listen on (default company_job_openings)
-    Discover a tool's streams/columns with: deepline monitors available <id>
-
-  Resource refs:
-    csv:./contacts.csv
-    play:prebuilt/name-and-domain-to-email-waterfall
-    provider:dropleads_search_people
-    providers:hunter_email_finder,leadmagic_email_finder
-
-  Validation:
-    source providers must match the route entity: company_search or people_search
-    source providers must expose list getters
-    company -> people uses a play only; provider bridge is generated later when a play exists
-    email/phone finder providers must match their category and expose value getters
-    finder plays/providers must match the route; generated code leaves input mapping explicit
-    business-specific provider inputs and company -> people persona fields are TODOs in code
-    csv: paths are resolved from the directory where you run bootstrap; write the play file there too
-
-  Exit codes:
-    0 success
-    2 usage/local input error
-    7 route validation failed
-
-Examples:
-  deepline plays bootstrap people-email --from csv:data/leads.csv --using play:prebuilt/name-and-domain-to-email-waterfall --limit 5 --out email-flow.play.ts
-  deepline plays check email-flow.play.ts
-  deepline plays run email-flow.play.ts --input '{"limit":5}'
-
-  deepline plays bootstrap people-email --from provider:dropleads_search_people --using providers:hunter_email_finder,leadmagic_email_finder --limit 5 --out prospecting.play.ts
-  deepline plays bootstrap company-people-email --from provider:crustdata_companydb_search --people play:prebuilt/company-to-contact --email play:prebuilt/name-and-domain-to-email-waterfall --limit 5 --out account-contacts.play.ts
-  deepline plays bootstrap company-list --from provider:crustdata_companydb_search --limit 5 --out companies.play.ts
-
-  deepline plays bootstrap monitor-triggered --out on-new-row.play.ts
-  deepline plays bootstrap monitor-triggered --tool deepline_native.company_radar --stream company_job_openings --out on-new-job.play.ts
-`
-  ).option("--name <name>", "Generated play name").option(
-    "--from <ref>",
-    "Route source: csv:PATH, play:REF, provider:ID, or providers:ID,ID"
-  ).option(
-    "--using <ref>",
-    "Single-stage route shorthand for people-email, people-phone, or company-people"
-  ).option(
-    "--people <ref>",
-    "Company-to-people stage for company-people-email/phone; use play:REF"
-  ).option(
-    "--email <ref>",
-    "Email finder stage: play:REF, provider:ID, or providers:ID,ID"
-  ).option(
-    "--phone <ref>",
-    "Phone finder stage: play:REF, provider:ID, or providers:ID,ID"
-  ).option("--limit <n>", "Maximum rows to fan out in the generated play").option(
-    "--tool <id>",
-    "monitor-triggered only: monitor tool id to bind (e.g. deepline_native.company_radar)"
-  ).option(
-    "--stream <key>",
-    "monitor-triggered only: monitor output stream to listen on (e.g. company_job_openings)"
-  ).option("--out <path>", "Write generated play source to a file").action(async (template, options) => {
-    process.exitCode = await handlePlayBootstrap([
-      template,
-      ...options.name ? ["--name", options.name] : [],
-      ...options.from ? ["--from", options.from] : [],
-      ...options.using ? ["--using", options.using] : [],
-      ...options.people ? ["--people", options.people] : [],
-      ...options.email ? ["--email", options.email] : [],
-      ...options.phone ? ["--phone", options.phone] : [],
-      ...options.limit ? ["--limit", options.limit] : [],
-      ...options.tool ? ["--tool", options.tool] : [],
-      ...options.stream ? ["--stream", options.stream] : [],
-      ...options.out ? ["--out", options.out] : []
-    ]);
-  });
-}
-
 // src/cli/commands/run-receipt.ts
 import { readFile, writeFile } from "fs/promises";
 function registerRunReceiptCommand(runs) {
@@ -6028,8 +4342,8 @@ function formatRunHitCountLines(tables) {
 }
 
 // src/cli/run-dataset-csv.ts
-import { writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { writeFileSync } from "fs";
+import { resolve } from "path";
 
 // ../plays/table-csv.ts
 var TABLE_EXPORT_ERROR_COLUMN = "_error";
@@ -6135,9 +4449,9 @@ var RunDatasetCsv = class _RunDatasetCsv {
     return this.#projection;
   }
   write(outPath) {
-    const absolutePath = resolve2(outPath);
+    const absolutePath = resolve(outPath);
     const { rows, columns } = this.#projection;
-    writeFileSync2(
+    writeFileSync(
       absolutePath,
       tableCsvText(
         columns,
@@ -6376,24 +4690,24 @@ function sanitizeCsvProjectionInfo(input) {
   const rows = input.rows.map(stripCsvProjectionFields);
   return { rows, columns };
 }
-function isRecord2(value) {
+function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isSerializedDataset(value) {
-  return isRecord2(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
+  return isRecord(value) && value.kind === "dataset" && typeof value.count === "number" && (Array.isArray(value.preview) || typeof value.tableNamespace === "string");
 }
 function isPackagedDatasetOutput(value) {
-  return isRecord2(value) && value.kind === "dataset" && isRecord2(value.preview) && Array.isArray(value.preview.rows);
+  return isRecord(value) && value.kind === "dataset" && isRecord(value.preview) && Array.isArray(value.preview.rows);
 }
 function hasCurrentTableExport(value) {
-  if (!isRecord2(value) || !isRecord2(value.actions)) return false;
+  if (!isRecord(value) || !isRecord(value.actions)) return false;
   const exportCsv = value.actions.exportCsv;
-  return isRecord2(exportCsv) && isRecord2(exportCsv.scope) && exportCsv.scope.kind === "database" && exportCsv.scope.mutability === "current";
+  return isRecord(exportCsv) && isRecord(exportCsv.scope) && exportCsv.scope.kind === "database" && exportCsv.scope.mutability === "current";
 }
 function currentTableQueryCommand(value) {
-  if (!isRecord2(value) || !isRecord2(value.actions)) return void 0;
+  if (!isRecord(value) || !isRecord(value.actions)) return void 0;
   const query = value.actions.queryCurrentTable;
-  const command = isRecord2(query) ? query.command : void 0;
+  const command = isRecord(query) ? query.command : void 0;
   return typeof command === "string" && command.trim() ? command.trim() : void 0;
 }
 function recoveredReturnPaths(value) {
@@ -6425,7 +4739,7 @@ function pathParts(path) {
 function valueAtPath(root, path) {
   let cursor = root;
   for (const part of pathParts(path)) {
-    if (!isRecord2(cursor)) {
+    if (!isRecord(cursor)) {
       return void 0;
     }
     cursor = cursor[part];
@@ -6433,17 +4747,17 @@ function valueAtPath(root, path) {
   return cursor;
 }
 function totalRowsForDataset(result, datasetPath) {
-  const metadata = isRecord2(result._metadata) ? result._metadata : null;
+  const metadata = isRecord(result._metadata) ? result._metadata : null;
   const parentPath = datasetPath.split(".").slice(0, -1).join(".");
   const parent = parentPath ? valueAtPath({ result }, parentPath) : result;
-  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord2(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
+  return metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count ?? (isRecord(parent) ? parent.totalRows ?? parent.rowCount ?? parent.count : void 0) ?? result.totalRows ?? result.rowCount ?? result.count;
 }
 function rowArray(value) {
   if (!Array.isArray(value)) {
     return null;
   }
   const rows = value.filter(
-    (row) => isRecord2(row)
+    (row) => isRecord(row)
   );
   return rows.length === value.length ? rows : null;
 }
@@ -6467,7 +4781,7 @@ function inferColumns(rows) {
   return columns;
 }
 function columnsFromDatasetSummary(summary) {
-  if (!isRecord2(summary) || !isRecord2(summary.columnStats)) {
+  if (!isRecord(summary) || !isRecord(summary.columnStats)) {
     return [];
   }
   return Object.keys(summary.columnStats).filter((column) => column);
@@ -6529,7 +4843,7 @@ function canonicalRowsInfoFromCandidate(input) {
           candidate.value.recoveredReturnPaths
         )
       } : {},
-      ...isRecord2(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace" || candidate.value.exportUnavailable.reason === "ambiguous_selector" || candidate.value.exportUnavailable.reason === "returned_dataset_not_persisted") ? {
+      ...isRecord(candidate.value.exportUnavailable) && (candidate.value.exportUnavailable.reason === "empty_dataset" || candidate.value.exportUnavailable.reason === "shared_table_namespace" || candidate.value.exportUnavailable.reason === "ambiguous_selector" || candidate.value.exportUnavailable.reason === "returned_dataset_not_persisted") ? {
         exportUnavailableReason: candidate.value.exportUnavailable.reason,
         ...typeof candidate.value.exportUnavailable.message === "string" ? {
           exportUnavailableMessage: candidate.value.exportUnavailable.message
@@ -6577,7 +4891,7 @@ function collectDatasetCandidates(input) {
     });
     return;
   }
-  if (!isRecord2(input.value)) {
+  if (!isRecord(input.value)) {
     return;
   }
   for (const [key, child] of Object.entries(input.value)) {
@@ -6594,12 +4908,12 @@ function collectDatasetCandidates(input) {
   }
 }
 function collectCanonicalRowsInfos(statusOrResult) {
-  const root = isRecord2(statusOrResult) ? statusOrResult : null;
-  const result = isRecord2(root?.result) ? root.result : root;
+  const root = isRecord(statusOrResult) ? statusOrResult : null;
+  const result = isRecord(root?.result) ? root.result : root;
   if (!result) {
     return [];
   }
-  const metadata = isRecord2(result._metadata) ? result._metadata : null;
+  const metadata = isRecord(result._metadata) ? result._metadata : null;
   const totalFromMetadata = metadata?.totalRows ?? metadata?.rowCount ?? metadata?.count;
   const candidates = [
     {
@@ -6623,8 +4937,8 @@ function collectCanonicalRowsInfos(statusOrResult) {
       total: totalFromMetadata ?? result.totalRows ?? result.rowCount ?? result.count
     }
   ];
-  if (isRecord2(result.output)) {
-    const outputMetadata = isRecord2(result.output._metadata) ? result.output._metadata : null;
+  if (isRecord(result.output)) {
+    const outputMetadata = isRecord(result.output._metadata) ? result.output._metadata : null;
     const outputTotalFromMetadata = outputMetadata?.totalRows ?? outputMetadata?.rowCount ?? outputMetadata?.count;
     candidates.push(
       {
@@ -6651,14 +4965,14 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   if (Array.isArray(result.steps)) {
     result.steps.forEach((step, index) => {
-      if (!isRecord2(step) || !isRecord2(step.output)) {
+      if (!isRecord(step) || !isRecord(step.output)) {
         return;
       }
       const source = typeof step.output.path === "string" ? step.output.path : typeof step.id === "string" ? `steps.${step.id}.output` : `steps.${index}.output`;
       candidates.push({
         source,
         value: step.output,
-        total: step.output.rowCount ?? (isRecord2(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord2(step.progress) ? step.progress.total : void 0)
+        total: step.output.rowCount ?? (isRecord(step.output.preview) ? step.output.preview.totalRows : void 0) ?? (isRecord(step.progress) ? step.progress.total : void 0)
       });
     });
   }
@@ -6679,15 +4993,15 @@ function collectCanonicalRowsInfos(statusOrResult) {
   return distinctCanonicalRowsInfos(infos);
 }
 function collectPackagedDatasetCandidates(statusOrResult) {
-  const root = isRecord2(statusOrResult) ? statusOrResult : null;
+  const root = isRecord(statusOrResult) ? statusOrResult : null;
   if (!root) {
     return [];
   }
-  const pkg = isRecord2(root.package) ? root.package : root;
+  const pkg = isRecord(root.package) ? root.package : root;
   const datasets = Array.isArray(pkg.datasets) ? pkg.datasets : [];
   const candidates = [];
   for (const output of datasets) {
-    if (!isRecord2(output) || !isPackagedDatasetOutput(output)) {
+    if (!isRecord(output) || !isPackagedDatasetOutput(output)) {
       continue;
     }
     const source = typeof output.path === "string" && output.path.trim() ? output.path.trim() : null;
@@ -6697,18 +5011,18 @@ function collectPackagedDatasetCandidates(statusOrResult) {
     candidates.push({
       source,
       value: output,
-      total: output.rowCount ?? (isRecord2(output.preview) ? output.preview.totalRows : void 0)
+      total: output.rowCount ?? (isRecord(output.preview) ? output.preview.totalRows : void 0)
     });
   }
   return candidates;
 }
 function collectPackagedStepDatasetCandidates(statusOrResult) {
-  const root = isRecord2(statusOrResult) ? statusOrResult : null;
+  const root = isRecord(statusOrResult) ? statusOrResult : null;
   if (!root) return [];
-  const pkg = isRecord2(root.package) ? root.package : root;
+  const pkg = isRecord(root.package) ? root.package : root;
   const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
   return steps.flatMap((step) => {
-    if (!isRecord2(step) || !isPackagedDatasetOutput(step.output)) return [];
+    if (!isRecord(step) || !isPackagedDatasetOutput(step.output)) return [];
     const source = typeof step.output.path === "string" && step.output.path.trim() ? step.output.path.trim() : null;
     return source ? [
       {
@@ -6720,8 +5034,8 @@ function collectPackagedStepDatasetCandidates(statusOrResult) {
   });
 }
 function collectSerializedDatasetRowsInfos(statusOrResult) {
-  const root = isRecord2(statusOrResult) ? statusOrResult : null;
-  const result = root && "result" in root ? isRecord2(root.result) ? root.result : null : root?.kind === "play_run" || isRecord2(root?.package) ? null : root;
+  const root = isRecord(statusOrResult) ? statusOrResult : null;
+  const result = root && "result" in root ? isRecord(root.result) ? root.result : null : root?.kind === "play_run" || isRecord(root?.package) ? null : root;
   const candidates = [];
   if (result) {
     collectDatasetCandidates({
@@ -6729,7 +5043,7 @@ function collectSerializedDatasetRowsInfos(statusOrResult) {
       path: "result",
       output: candidates
     });
-    if (isRecord2(result.output)) {
+    if (isRecord(result.output)) {
       collectDatasetCandidates({
         value: result.output,
         path: "result",
@@ -6776,8 +5090,8 @@ function extractCanonicalRowsInfo(statusOrResult) {
 }
 
 // src/cli/run-dataset-selection.ts
-import { writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve3 } from "path";
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
 var Run = class _Run {
   #datasets;
   constructor(input) {
@@ -6903,8 +5217,8 @@ var RunDataset = class _RunDataset {
       );
     }
     if (options.format === "json") {
-      const absolutePath = resolve3(outPath);
-      writeFileSync3(
+      const absolutePath = resolve2(outPath);
+      writeFileSync2(
         absolutePath,
         `${JSON.stringify(orderRunExportJson(this.rows), null, 2)}
 `,
@@ -6958,7 +5272,7 @@ function withReturnedDatasetAliases(runPackage, available) {
   for (const outputValue of Object.values(outputs)) {
     const output = recordValue(outputValue);
     if (output.kind !== "dataset") continue;
-    const alias = stringValue2(output.path);
+    const alias = stringValue(output.path);
     if (!alias) continue;
     const canonical = resolveReturnedDataset(output, available);
     expanded.push(withDatasetAlias(canonical, alias));
@@ -6973,7 +5287,7 @@ function returnedRunDatasets(runPackage, available) {
     for (const outputValue of Object.values(outputs)) {
       const output = recordValue(outputValue);
       if (output.kind !== "dataset") continue;
-      const alias = stringValue2(output.path);
+      const alias = stringValue(output.path);
       const info = resolveReturnedDataset(output, available);
       selected.push(alias ? withDatasetAlias(info, alias) : info);
     }
@@ -7004,8 +5318,8 @@ function withDatasetAlias(info, alias) {
   };
 }
 function resolveReturnedDataset(output, available) {
-  const datasetId = stringValue2(output.datasetId);
-  const path = stringValue2(output.dataset) ?? stringValue2(output.path);
+  const datasetId = stringValue(output.datasetId);
+  const path = stringValue(output.dataset) ?? stringValue(output.path);
   if (datasetId) {
     const identified = uniqueDatasetMatch(
       available.filter((info) => info.datasetId === datasetId),
@@ -7032,7 +5346,7 @@ function resolveReturnedDataset(output, available) {
 function recordValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue2(value) {
+function stringValue(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
@@ -7288,7 +5602,7 @@ function isInternalGlueStepId(stepId) {
 import { randomUUID } from "crypto";
 import { mkdtemp as mkdtemp2, realpath, rm as rm2 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join4, resolve as resolve4 } from "path";
+import { join as join4, resolve as resolve3 } from "path";
 
 // ../plays/deploy/run-deployment.ts
 import { join as join3 } from "path";
@@ -7465,7 +5779,7 @@ var DeployApiClient = class {
 // ../plays/deploy/manifest.ts
 var import_picomatch = __toESM(require_picomatch2(), 1);
 import { readdir, readFile as readFile2, stat } from "fs/promises";
-import { join, relative as relative2 } from "path";
+import { join, relative } from "path";
 var DEFAULT_PLAY_GLOBS = ["**/*.play.ts"];
 var DEFAULT_MONITOR_GLOBS = ["**/*.monitor.json"];
 var MAX_DISCOVERED_FILES = 200;
@@ -7566,7 +5880,7 @@ async function discoverDeploymentFiles(input) {
         continue;
       }
       if (!entry.isFile()) continue;
-      const relativePath = relative2(input.projectRoot, absolute);
+      const relativePath = relative(input.projectRoot, absolute);
       if (matchers.some((match) => match(relativePath))) {
         found.push(relativePath);
         if (found.length > MAX_DISCOVERED_FILES) {
@@ -7906,7 +6220,7 @@ async function runDeployment(params, hooks) {
           throw lastError;
         }
         await new Promise(
-          (resolve7) => setTimeout(resolve7, hooks.checkRunRetryDelayMs ?? 1e3)
+          (resolve6) => setTimeout(resolve6, hooks.checkRunRetryDelayMs ?? 1e3)
         );
       }
     }
@@ -8389,7 +6703,7 @@ async function runDeployment(params, hooks) {
             "Monitor jobs are still reconciling. Retrying this deployment will resume the same jobs."
           );
         }
-        await new Promise((resolve7) => setTimeout(resolve7, 1e3));
+        await new Promise((resolve6) => setTimeout(resolve6, 1e3));
         for (let index = 0; index < monitorOutcomes.length; index += 1) {
           const outcome = monitorOutcomes[index];
           if (outcome.status !== "applying") continue;
@@ -8602,8 +6916,8 @@ function printResult2(input) {
   );
 }
 async function handlePlaysDeploy(directory, options) {
-  const root = await realpath(resolve4(directory ?? ".")).catch(() => {
-    throw new Error(`No such directory: ${resolve4(directory ?? ".")}`);
+  const root = await realpath(resolve3(directory ?? ".")).catch(() => {
+    throw new Error(`No such directory: ${resolve3(directory ?? ".")}`);
   });
   const { http, config } = getAuthedHttpClient();
   const deliveryId = `local:${randomUUID()}`;
@@ -8674,7 +6988,7 @@ async function handlePlaysDeploy(directory, options) {
 
 // src/cli/operations/play-run-options.ts
 import { existsSync, readFileSync } from "fs";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve4 } from "path";
 
 // ../play-runtime/fixture-behavior.ts
 var FIXTURE_BEHAVIOR_VERSION = 1;
@@ -9119,7 +7433,7 @@ function parsePlayRunHeaderFlag(raw) {
 function isBarePlayRunDebugFlag(args, index) {
   return args[index] === "--debug" && (args[index + 1] === void 0 || args[index + 1].startsWith("--"));
 }
-function parseReferencedPlayTarget2(target) {
+function parseReferencedPlayTarget(target) {
   const trimmed = target.trim();
   const slashIndex = trimmed.indexOf("/");
   if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
@@ -9132,7 +7446,7 @@ function parseReferencedPlayTarget2(target) {
   };
 }
 function isFileTarget(target) {
-  return existsSync(resolve5(target));
+  return existsSync(resolve4(target));
 }
 function looksLikeFilePath(target) {
   if (target.trim().toLowerCase().startsWith("prebuilt/")) {
@@ -9143,7 +7457,7 @@ function looksLikeFilePath(target) {
   }
   return target.includes("\\") || /\.(ts|js|mjs|play\.ts)$/.test(target);
 }
-function parsePositiveInteger2(value, flagName) {
+function parsePositiveInteger(value, flagName) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     throw new Error(`${flagName} must be a positive integer.`);
@@ -9151,7 +7465,7 @@ function parsePositiveInteger2(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw, flag = "--input") {
-  const source = raw.startsWith("@") ? readFileSync(resolve5(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? readFileSync(resolve4(raw.slice(1)), "utf-8") : raw;
   let parsed;
   try {
     parsed = JSON.parse(source);
@@ -9243,7 +7557,7 @@ function parsePlayRunOptions(args, initialInput = null) {
       continue;
     }
     if (arg === "--name" && args[index + 1]) {
-      playName = parseReferencedPlayTarget2(args[++index]).playName;
+      playName = parseReferencedPlayTarget(args[++index]).playName;
       continue;
     }
     if ((arg === "--input" || arg === "-i") && args[index + 1]) {
@@ -9310,7 +7624,7 @@ function parsePlayRunOptions(args, initialInput = null) {
           "--max-concurrent-external-calls requires a positive whole number."
         );
       }
-      maxConcurrentExternalCalls = parsePositiveInteger2(
+      maxConcurrentExternalCalls = parsePositiveInteger(
         value,
         "--max-concurrent-external-calls"
       );
@@ -9328,7 +7642,7 @@ function parsePlayRunOptions(args, initialInput = null) {
           "--max-concurrent-rows requires a positive whole number."
         );
       }
-      maxConcurrentRows = parsePositiveInteger2(value, "--max-concurrent-rows");
+      maxConcurrentRows = parsePositiveInteger(value, "--max-concurrent-rows");
       resolveMaxConcurrentRows(maxConcurrentRows);
       index += 1;
       continue;
@@ -9376,7 +7690,7 @@ function parsePlayRunOptions(args, initialInput = null) {
       );
     }
     if ((arg === "--tail-timeout-ms" || arg === "--timeout-ms") && args[index + 1]) {
-      waitTimeoutMs = parsePositiveInteger2(args[++index], arg);
+      waitTimeoutMs = parsePositiveInteger(args[++index], arg);
       continue;
     }
     if (arg === "--debug" && args[index + 1] && !args[index + 1].startsWith("--")) {
@@ -9424,7 +7738,7 @@ function parsePlayRunOptions(args, initialInput = null) {
       if (isFileTarget(arg) || looksLikeFilePath(arg)) {
         filePath = arg;
       } else {
-        playName = parseReferencedPlayTarget2(arg).playName;
+        playName = parseReferencedPlayTarget(arg).playName;
       }
       continue;
     }
@@ -9512,7 +7826,7 @@ function resolvePlayRunCliOptions(target, options, inputArgs = []) {
   );
   const resolvedTarget = file !== void 0 ? { kind: "file", path: file } : name !== void 0 ? {
     kind: "name",
-    name: parseReferencedPlayTarget2(name).playName
+    name: parseReferencedPlayTarget(name).playName
   } : base.target;
   const revisionId = stringOption(options.revisionId, "--revision-id") ?? base.revisionId;
   const selectors = [
@@ -9616,12 +7930,12 @@ function resolvePlayRunCliOptions(target, options, inputArgs = []) {
 }
 
 // src/plays/authoring-graph-path.ts
-import { dirname, isAbsolute as isAbsolute2, join as join5, relative as relative3 } from "path";
+import { dirname, isAbsolute, join as join5, relative as relative2 } from "path";
 function playAuthoringGraphPath(parent, filePath) {
-  if (isAbsolute2(parent.artifact.entryFile)) return filePath;
+  if (isAbsolute(parent.artifact.entryFile)) return filePath;
   return join5(
     dirname(parent.artifact.entryFile),
-    relative3(dirname(parent.filePath), filePath)
+    relative2(dirname(parent.filePath), filePath)
   ).replaceAll("\\", "/");
 }
 
@@ -9696,7 +8010,7 @@ async function removeRunIdTempFile(path) {
   }
 }
 async function preflightRunIdFile(path) {
-  const destination = resolve6(path);
+  const destination = resolve5(path);
   if (await pathExistsIncludingSymlink(destination)) {
     throw new Error(
       `--run-id-file destination already exists: ${destination}. Choose a new path so this run cannot overwrite another run identity.`
@@ -9811,9 +8125,9 @@ function traceCliSync(phase, fields2, run) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
-function parseReferencedPlayTarget3(target) {
+function parseReferencedPlayTarget2(target) {
   const trimmed = target.trim();
   const slashIndex = trimmed.indexOf("/");
   if (slashIndex <= 0 || slashIndex === trimmed.length - 1) {
@@ -9860,7 +8174,7 @@ function playSuggestionReference(play) {
   return ownerSlug ? `${ownerSlug}/${play.name}` : play.name;
 }
 function scorePlayReferenceSuggestion(requested, play) {
-  const parsed = parseReferencedPlayTarget3(requested);
+  const parsed = parseReferencedPlayTarget2(requested);
   const requestedTrimmed = requested.trim();
   const requestedRef = requestedTrimmed.toLowerCase();
   const requestedName = parsed.unqualifiedPlayName;
@@ -9938,7 +8252,7 @@ function rankPlayReferenceSuggestions(input) {
   }).slice(0, input.limit ?? 5);
 }
 function searchQueryForMissingPlayReference(target) {
-  return parseReferencedPlayTarget3(target).unqualifiedPlayName.replace(/[-_./]+/g, " ").replace(/\s+/g, " ").trim();
+  return parseReferencedPlayTarget2(target).unqualifiedPlayName.replace(/[-_./]+/g, " ").replace(/\s+/g, " ").trim();
 }
 function buildPlayReferenceNotFoundMessage(input) {
   const lines = [`Play not found: ${input.requested}`];
@@ -10015,7 +8329,7 @@ async function isMissingRunPlayReferenceError(input) {
   }
   try {
     await input.client.getPlay(
-      parseReferencedPlayTarget3(input.playName).playName
+      parseReferencedPlayTarget2(input.playName).playName
     );
     return false;
   } catch (lookupError) {
@@ -10023,7 +8337,7 @@ async function isMissingRunPlayReferenceError(input) {
   }
 }
 async function assertCanonicalNamedPlayReference(client, target, options = {}) {
-  const parsed = parseReferencedPlayTarget3(target);
+  const parsed = parseReferencedPlayTarget2(target);
   let detail;
   try {
     detail = await client.getPlay(
@@ -10060,10 +8374,10 @@ function formatPlayListReference(play) {
   return play.reference || play.name;
 }
 function defaultMaterializedPlayPath(reference) {
-  return resolve6(defaultStarterPlayPath(reference));
+  return resolve5(defaultStarterPlayPath(reference));
 }
 function defaultStarterPlayPath(reference) {
-  const playName = parseReferencedPlayTarget3(reference).unqualifiedPlayName;
+  const playName = parseReferencedPlayTarget2(reference).unqualifiedPlayName;
   const safeName = playName.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   return `./${safeName || "play"}.play.ts`;
 }
@@ -10093,23 +8407,23 @@ function materializeRemotePlaySource(input) {
         `Play ${input.playName} has ${files.length} source files. Use --out <directory> to write the complete bundle.`
       );
     }
-    const outputDirectory = resolve6(input.outPath);
+    const outputDirectory = resolve5(input.outPath);
     let created = 0;
     let updated = 0;
     for (const [logicalPath, sourceCode] of files) {
-      const outputPath2 = resolve6(outputDirectory, logicalPath);
-      const outputRelativePath = relative4(outputDirectory, outputPath2);
-      if (!outputRelativePath || outputRelativePath.startsWith("..") || isAbsolute3(outputRelativePath)) {
+      const outputPath2 = resolve5(outputDirectory, logicalPath);
+      const outputRelativePath = relative3(outputDirectory, outputPath2);
+      if (!outputRelativePath || outputRelativePath.startsWith("..") || isAbsolute2(outputRelativePath)) {
         throw new Error(
           `Refusing to materialize unsafe Play source path ${JSON.stringify(logicalPath)}.`
         );
       }
       mkdirSync(dirname2(outputPath2), { recursive: true });
       if (!existsSync2(outputPath2)) {
-        writeFileSync4(outputPath2, sourceCode, "utf-8");
+        writeFileSync3(outputPath2, sourceCode, "utf-8");
         created += 1;
       } else if (readFileSync2(outputPath2, "utf-8") !== sourceCode) {
-        writeFileSync4(outputPath2, sourceCode, "utf-8");
+        writeFileSync3(outputPath2, sourceCode, "utf-8");
         updated += 1;
       }
     }
@@ -10126,10 +8440,10 @@ function materializeRemotePlaySource(input) {
     if (existingSource === entrySource) {
       return { path: outputPath, status: "unchanged", created: false };
     }
-    writeFileSync4(outputPath, entrySource, "utf-8");
+    writeFileSync3(outputPath, entrySource, "utf-8");
     return { path: outputPath, status: "updated", created: false };
   }
-  writeFileSync4(outputPath, entrySource, "utf-8");
+  writeFileSync3(outputPath, entrySource, "utf-8");
   return { path: outputPath, status: "created", created: true };
 }
 function formatLoadedPlayMessage(materializedFile) {
@@ -10154,7 +8468,7 @@ To make your own version:
   );
 }
 async function ensureEditableRemotePlay(client, target) {
-  const parsed = parseReferencedPlayTarget3(target);
+  const parsed = parseReferencedPlayTarget2(target);
   const detail = await client.getPlay(parsed.playName);
   if (detail.play.ownerType === "deepline") {
     throw buildReadonlyPrebuiltPlayError(formatPlayReference(detail.play));
@@ -10174,7 +8488,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget2(target) {
-  return existsSync2(resolve6(target));
+  return existsSync2(resolve5(target));
 }
 function looksLikeRunId(target) {
   return /^play\/[^/]+\/run\/[^/]+/.test(target.trim());
@@ -10195,7 +8509,7 @@ function looksLikeFilePath2(target) {
   }
   return target.includes("\\") || /\.(ts|js|mjs|play\.ts)$/.test(target);
 }
-function parsePositiveInteger3(value, flagName) {
+function parsePositiveInteger2(value, flagName) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     throw new Error(`${flagName} must be a positive integer.`);
@@ -10205,7 +8519,7 @@ function parsePositiveInteger3(value, flagName) {
 function isLocalFilePathValue(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
-  return existsSync2(resolve6(value));
+  return existsSync2(resolve5(value));
 }
 function inputContainsLocalFilePath(value) {
   if (isLocalFilePathValue(value)) {
@@ -10251,7 +8565,7 @@ function collectLocalFileInputRefs(value, inputPath, key, out) {
     const looksLikeFile = /\.[a-z0-9]{1,8}$/i.test(trimmed);
     if (keyIsCsvData) {
       out.push({ inputPath, value: trimmed, isCsvData: true });
-    } else if (endsWithCsv || looksLikeFile && existsSync2(resolve6(trimmed))) {
+    } else if (endsWithCsv || looksLikeFile && existsSync2(resolve5(trimmed))) {
       out.push({ inputPath, value: trimmed, isCsvData: false });
     }
     return;
@@ -10293,7 +8607,7 @@ function preflightLocalFileInputs(runtimeInput) {
     collectLocalFileInputRefs(value, key, key, refs);
   }
   for (const ref of refs) {
-    const absolutePath = resolve6(ref.value);
+    const absolutePath = resolve5(ref.value);
     if (!existsSync2(absolutePath)) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that does not exist: ${ref.value} (resolved to ${absolutePath}). No run was created.`,
@@ -10304,7 +8618,7 @@ function preflightLocalFileInputs(runtimeInput) {
     }
     let stat2;
     try {
-      stat2 = statSync2(absolutePath);
+      stat2 = statSync(absolutePath);
     } catch (error) {
       throw new DeeplineError(
         `Input ${ref.inputPath} references a local file that is not readable: ${ref.value} (${error instanceof Error ? error.message : String(error)}). No run was created.`,
@@ -10358,7 +8672,7 @@ async function stageFileInputArgs(input) {
     codec: NODE_STAGED_FILE_CODEC,
     resolveLocalFile: (value) => {
       if (!isLocalFilePathValue(value)) return null;
-      const absolutePath = resolve6(value);
+      const absolutePath = resolve5(value);
       return {
         logicalPath: basename(absolutePath),
         read: async () => readFileSync2(absolutePath)
@@ -10381,9 +8695,9 @@ function stageFile(logicalPath, absolutePath) {
 }
 function normalizePlayPath(filePath) {
   try {
-    return realpathSync.native(resolve6(filePath));
+    return realpathSync.native(resolve5(filePath));
   } catch {
-    return resolve6(filePath);
+    return resolve5(filePath);
   }
 }
 var PlayBundleGraphError = class extends Error {
@@ -13473,7 +11787,7 @@ async function resolvePlayRunOutputStatus(input) {
 }
 var RUN_EXPORT_PAGE_SIZE = 5e3;
 function runExportRetryCommand(runId, outPath, datasetPath, options = {}) {
-  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellQuote(datasetPath)}` : ""} --out ${shellQuote(resolve6(outPath))}${options.format === "json" ? " --format json" : ""}`;
+  return `deepline runs export ${runId}${datasetPath ? ` --dataset ${shellQuote(datasetPath)}` : ""} --out ${shellQuote(resolve5(outPath))}${options.format === "json" ? " --format json" : ""}`;
 }
 function extractRunPlayName(status) {
   const run = status.run;
@@ -13999,7 +12313,7 @@ function extractPlayValidationErrors(value) {
   if (value instanceof DeeplineError) {
     return extractPlayValidationErrors(value.details);
   }
-  if (!isRecord3(value)) {
+  if (!isRecord2(value)) {
     return [];
   }
   const directErrors = stringArrayField(value, "errors");
@@ -14390,34 +12704,34 @@ function formatPlayRuntimeLimit(runtimeLimit) {
   if (seconds % 60 === 0) return `${seconds / 60} min`;
   return `${seconds} sec`;
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function stringValue3(value) {
+function stringValue2(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function asArray(value) {
   return Array.isArray(value) ? value : [];
 }
-function extractionEntries2(value) {
-  if (Array.isArray(value)) return value.filter(isRecord3);
-  if (!isRecord3(value)) return [];
+function extractionEntries(value) {
+  if (Array.isArray(value)) return value.filter(isRecord2);
+  if (!isRecord2(value)) return [];
   return Object.entries(value).map(
-    ([name, entry]) => isRecord3(entry) ? { name, ...entry } : { name }
+    ([name, entry]) => isRecord2(entry) ? { name, ...entry } : { name }
   );
 }
 function firstRawPath(entry) {
-  const details = isRecord3(entry.details) ? entry.details : {};
+  const details = isRecord2(entry.details) ? entry.details : {};
   const paths = [
     ...asArray(details.rawToolOutputPaths),
     ...asArray(details.raw_tool_output_paths),
     ...asArray(details.candidatePaths),
     ...asArray(details.candidate_paths)
-  ].map(stringValue3).filter(Boolean);
+  ].map(stringValue2).filter(Boolean);
   return paths[0];
 }
 function checkHintExpression(value) {
-  return stringValue3(value).replace(/^toolExecutionResult\./, "result.");
+  return stringValue2(value).replace(/^toolExecutionResult\./, "result.");
 }
 function checkHintRawPath(value) {
   return value?.startsWith("toolResponse.rawV2") ? value.replace(/^toolResponse\./, "result.toolResponse.") : void 0;
@@ -14425,14 +12739,14 @@ function checkHintRawPath(value) {
 function collectStaticPipelineToolIds(staticPipeline) {
   const seen = /* @__PURE__ */ new Set();
   const visitPipeline = (pipeline) => {
-    if (!isRecord3(pipeline)) return;
+    if (!isRecord2(pipeline)) return;
     for (const step of [
       ...asArray(pipeline.stages),
       ...asArray(pipeline.substeps)
     ]) {
-      if (!isRecord3(step)) continue;
+      if (!isRecord2(step)) continue;
       if (step.type === "tool") {
-        const toolId = stringValue3(step.toolId) || stringValue3(step.tool);
+        const toolId = stringValue2(step.toolId) || stringValue2(step.tool);
         if (toolId) seen.add(toolId);
       }
       if (step.type === "play_call") {
@@ -14444,20 +12758,20 @@ function collectStaticPipelineToolIds(staticPipeline) {
   return [...seen].sort();
 }
 function toolGetterHintFromMetadata(toolId, tool) {
-  const usageGuidance = isRecord3(tool.usageGuidance) ? tool.usageGuidance : {};
-  const resultGuidance = isRecord3(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord3(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
-  const toolResponse = isRecord3(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord3(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
-  const lists = extractionEntries2(
+  const usageGuidance = isRecord2(tool.usageGuidance) ? tool.usageGuidance : {};
+  const resultGuidance = isRecord2(usageGuidance.toolExecutionResult) ? usageGuidance.toolExecutionResult : isRecord2(usageGuidance.tool_execution_result) ? usageGuidance.tool_execution_result : {};
+  const toolResponse = isRecord2(resultGuidance.toolResponse) ? resultGuidance.toolResponse : isRecord2(resultGuidance.tool_response) ? resultGuidance.tool_response : {};
+  const lists = extractionEntries(
     resultGuidance.extractedLists ?? resultGuidance.extracted_lists
   ).map((entry) => ({
-    name: stringValue3(entry.name),
+    name: stringValue2(entry.name),
     expression: checkHintExpression(entry.expression),
     raw: checkHintRawPath(firstRawPath(entry))
   })).filter((entry) => entry.name && entry.expression);
-  const values = extractionEntries2(
+  const values = extractionEntries(
     resultGuidance.extractedValues ?? resultGuidance.extracted_values
   ).map((entry) => ({
-    name: stringValue3(entry.name),
+    name: stringValue2(entry.name),
     expression: checkHintExpression(entry.expression),
     raw: checkHintRawPath(firstRawPath(entry))
   })).filter((entry) => entry.name && entry.expression);
@@ -14584,7 +12898,7 @@ async function handlePlayCheck(args) {
         command: "check"
       });
       const play = await client.describePlay(
-        parseReferencedPlayTarget3(options.target).playName,
+        parseReferencedPlayTarget2(options.target).playName,
         { compact: true }
       );
       const result = {
@@ -14614,7 +12928,7 @@ async function handlePlayCheck(args) {
       });
       return 0;
     } catch (error) {
-      const resolved = resolve6(options.target);
+      const resolved = resolve5(options.target);
       const message = error instanceof Error && error.message ? error.message : `File not found: ${resolved}`;
       if (options.jsonOutput) {
         printCommandEnvelope(
@@ -14635,7 +12949,7 @@ async function handlePlayCheck(args) {
       return 1;
     }
   }
-  const absolutePlayPath = resolve6(options.target);
+  const absolutePlayPath = resolve5(options.target);
   const sourceCode = readFileSync2(absolutePlayPath, "utf-8");
   const exportNames = resolvePlayCheckExportNames(sourceCode);
   const outcomes = [];
@@ -14685,7 +12999,7 @@ function artifactForProductionCompatibilityCheck(artifact) {
       "DEEPLINE_PROD_CHECK_AUTHORING_CONTRACT_EDITION must be a positive integer."
     );
   }
-  const compatibility = isRecord3(artifact.compatibility) ? artifact.compatibility : {};
+  const compatibility = isRecord2(artifact.compatibility) ? artifact.compatibility : {};
   return {
     ...artifact,
     compatibility: {
@@ -14755,7 +13069,7 @@ async function handleFileBackedRun(options, hooks) {
   }
   let client;
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  const absolutePlayPath = resolve6(options.target.path);
+  const absolutePlayPath = resolve5(options.target.path);
   progress.phase("compiling play");
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
@@ -15164,7 +13478,7 @@ async function handlePlayRun(args, hooks) {
   const parsedOptions = Array.isArray(args) ? parsePlayRunOptions(args) : args;
   const options = parsedOptions.runIdFile ? {
     ...parsedOptions,
-    runIdFile: parsedOptions.dryRun ? resolve6(parsedOptions.runIdFile) : await preflightRunIdFile(parsedOptions.runIdFile)
+    runIdFile: parsedOptions.dryRun ? resolve5(parsedOptions.runIdFile) : await preflightRunIdFile(parsedOptions.runIdFile)
   } : parsedOptions;
   const runHooks = options.runIdFile ? {
     ...hooks,
@@ -15197,7 +13511,7 @@ async function handlePlayRun(args, hooks) {
     if (isFileTarget2(options.target.path)) {
       return handleFileBackedRun(options, runHooks);
     }
-    const resolved = resolve6(options.target.path);
+    const resolved = resolve5(options.target.path);
     console.error(`File not found: ${resolved}`);
     const dir = dirname2(resolved);
     if (existsSync2(dir)) {
@@ -15958,11 +14272,11 @@ async function handleRunLogs(args) {
       continue;
     }
     if (arg === "--limit" && args[index + 1]) {
-      limit = parsePositiveInteger3(args[++index], "--limit");
+      limit = parsePositiveInteger2(args[++index], "--limit");
       continue;
     }
     if (arg === "--out" && args[index + 1]) {
-      outPath = resolve6(args[++index]);
+      outPath = resolve5(args[++index]);
       continue;
     }
     if (arg === "--cursor" && args[index + 1]) {
@@ -15997,7 +14311,7 @@ async function handleRunLogs(args) {
   if (outPath) {
     const result2 = await client.runs.logs(runId, { all: true });
     const logs = result2.entries.filter((line) => logLevelReaches(classifyLogLine(line).level, logLevel)).map((line) => classifyLogLine(line).line);
-    writeFileSync4(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
+    writeFileSync3(outPath, `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}`);
     printCommandEnvelope(
       {
         runId: result2.runId,
@@ -16483,7 +14797,7 @@ async function handleRunExport(args) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = resolve6(args[++index]);
+      outPath = resolve5(args[++index]);
       continue;
     }
     if (arg === "--dataset" && args[index + 1]) {
@@ -16491,11 +14805,11 @@ async function handleRunExport(args) {
       continue;
     }
     if (arg === "--metadata-out" && args[index + 1]) {
-      metadataOutPath = resolve6(args[++index]);
+      metadataOutPath = resolve5(args[++index]);
     }
     if (arg === "--format") format = args[++index] ?? "";
     if (arg === "--timeout-ms") {
-      waitTimeoutMs = parsePositiveInteger3(args[++index] ?? "", arg);
+      waitTimeoutMs = parsePositiveInteger2(args[++index] ?? "", arg);
       if (!wait) {
         throw new DeeplineError(
           "--timeout-ms requires --wait.",
@@ -16625,7 +14939,7 @@ async function handleRunExport(args) {
     payload.actions
   );
   if (metadataOutPath) {
-    writeFileSync4(
+    writeFileSync3(
       metadataOutPath,
       `${JSON.stringify(payload, null, 2)}
 `,
@@ -16676,7 +14990,7 @@ async function handlePlayGet(args) {
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--out" && args[index + 1]) {
-      outPath = resolve6(args[++index]);
+      outPath = resolve5(args[++index]);
     }
     if (arg === "--revision") {
       const rawVersion = args[++index];
@@ -16697,7 +15011,7 @@ async function handlePlayGet(args) {
     );
     return 2;
   }
-  const playName = isFileTarget2(target) ? extractPlayName(readFileSync2(resolve6(target), "utf-8"), resolve6(target)) : parseReferencedPlayTarget3(target).playName;
+  const playName = isFileTarget2(target) ? extractPlayName(readFileSync2(resolve5(target), "utf-8"), resolve5(target)) : parseReferencedPlayTarget2(target).playName;
   const includeSource = sourceOutput || outPath !== null;
   const detail = isFileTarget2(target) ? await client.getPlay(
     playName,
@@ -16810,7 +15124,7 @@ async function handlePlayVersions(args) {
     command: "versions"
   });
   const versions = await client.listPlayVersions(
-    parseReferencedPlayTarget3(playName).playName
+    parseReferencedPlayTarget2(playName).playName
   );
   if (jsonOutput) {
     printCompactJson({ versions });
@@ -16970,7 +15284,7 @@ async function handlePlayPin(args, pinned) {
     );
     return 2;
   }
-  const parsedTarget = parseReferencedPlayTarget3(target);
+  const parsedTarget = parseReferencedPlayTarget2(target);
   if (parsedTarget.ownerSlug) {
     console.error(
       `deepline plays ${pinned ? "pin" : "unpin"} accepts an org-owned Play identifier without a namespace. Use "${parsedTarget.unqualifiedPlayName}" instead of "${target}".`
@@ -16989,12 +15303,12 @@ async function handlePlayPin(args, pinned) {
   return 0;
 }
 function csvColumnLines(csvInput) {
-  const rowSchema = isRecord3(csvInput.rowInputSchema) ? csvInput.rowInputSchema : {};
-  const columns = isRecord3(rowSchema.properties) ? Object.keys(rowSchema.properties) : [];
+  const rowSchema = isRecord2(csvInput.rowInputSchema) ? csvInput.rowInputSchema : {};
+  const columns = isRecord2(rowSchema.properties) ? Object.keys(rowSchema.properties) : [];
   const required = new Set(
     Array.isArray(rowSchema.required) ? rowSchema.required.map(String) : []
   );
-  const defaults = isRecord3(csvInput.defaultColumns) ? csvInput.defaultColumns : {};
+  const defaults = isRecord2(csvInput.defaultColumns) ? csvInput.defaultColumns : {};
   return [
     ...columns.map((column) => {
       const headers = [defaults[column]].flat().filter((header) => header && header !== column);
@@ -17007,7 +15321,7 @@ function describedPlay(play) {
   const reference = formatPlayListReference(play);
   const starter = play.cloneEditStarter ?? buildCloneEditStarter(play);
   const csv = play.csvInput ?? {};
-  const headers = isRecord3(csv.defaultColumns) ? csv.defaultColumns : {};
+  const headers = isRecord2(csv.defaultColumns) ? csv.defaultColumns : {};
   const rowInputs = schemaFields(csv.rowInputSchema).map((field) => {
     const header = [headers[field.name]].flat().filter((name) => name && name !== field.name).join(" or ");
     return header ? {
@@ -17016,7 +15330,7 @@ function describedPlay(play) {
     } : field;
   });
   const rowOutput = play.rowOutputSchema ?? {};
-  const added = isRecord3(rowOutput.addedColumns) ? rowOutput.addedColumns : {};
+  const added = isRecord2(rowOutput.addedColumns) ? rowOutput.addedColumns : {};
   const rowOutputs = schemaFields(
     Object.keys(added).length ? { properties: added } : rowOutput
   ).map((field) => ({ ...field, required: true }));
@@ -17195,7 +15509,7 @@ async function handlePlayDescribe(args) {
     const definedName = isFileTarget2(playName) ? (() => {
       try {
         return extractPlayName(
-          readFileSync2(resolve6(playName), "utf-8"),
+          readFileSync2(resolve5(playName), "utf-8"),
           playName
         );
       } catch {
@@ -17226,7 +15540,7 @@ async function handlePlayDescribe(args) {
     command: "describe"
   });
   const play = await client.describePlay(
-    parseReferencedPlayTarget3(playName).playName,
+    parseReferencedPlayTarget2(playName).playName,
     {
       compact: args.includes("--compact")
     }
@@ -17258,7 +15572,7 @@ async function handlePlaySave(args) {
     graph = await traceCliSpan(
       "cli.play_save_bundle_graph",
       { targetKind: "file" },
-      () => collectBundledPlayGraph(resolve6(options.target))
+      () => collectBundledPlayGraph(resolve5(options.target))
     );
     assertPlayGraphAuthoring(graph);
   } catch (error) {
@@ -17383,7 +15697,7 @@ async function handlePlayPublish(args) {
       graph = await traceCliSpan(
         "cli.play_publish_bundle_graph",
         { targetKind: "file" },
-        () => collectBundledPlayGraph(resolve6(playName))
+        () => collectBundledPlayGraph(resolve5(playName))
       );
       assertPlayGraphAuthoring(graph);
     } catch (error) {
@@ -17527,7 +15841,7 @@ async function handlePlayPublish(args) {
     printCompactJson(result2);
     return 0;
   }
-  const resolvedName = parseReferencedPlayTarget3(playName).playName;
+  const resolvedName = parseReferencedPlayTarget2(playName).playName;
   if (useLatest) {
     const versions = await client.listPlayVersions(resolvedName);
     const latest = versions[0];
@@ -17591,7 +15905,7 @@ async function handlePlayDelete(args) {
   const client = new DeeplineClient();
   let detail;
   try {
-    detail = await client.getPlay(parseReferencedPlayTarget3(playName).playName);
+    detail = await client.getPlay(parseReferencedPlayTarget2(playName).playName);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     return 5;
@@ -17602,7 +15916,7 @@ async function handlePlayDelete(args) {
     );
     return 2;
   }
-  const resolvedName = parseReferencedPlayTarget3(
+  const resolvedName = parseReferencedPlayTarget2(
     formatPlayReference(detail.play)
   ).playName;
   if (args.includes("--dry-run")) {
@@ -17666,7 +15980,7 @@ async function handlePlayRestore(args) {
   const client = new DeeplineClient();
   try {
     const result = await client.restorePlay(
-      parseReferencedPlayTarget3(playName).playName
+      parseReferencedPlayTarget2(playName).playName
     );
     if (argsWantJson(args)) {
       printCompactJson(result);
@@ -17960,7 +16274,6 @@ JSON field selection:
       process.exitCode = exitCode;
     }
   );
-  registerPlayBootstrapCommand(play);
   registerPlaySettingsCommands(play);
   registerPlayTriggerConfigCommands(play);
   play.command("get <target>").description(
@@ -18160,7 +16473,7 @@ Examples:
         process.exitCode = await ownView();
         return;
       }
-      const { describeAnything } = await import("./describe-JTEJNG67.mjs");
+      const { describeAnything } = await import("./describe-QUOLGZKH.mjs");
       process.exitCode = await describeAnything(
         name,
         {
@@ -18898,7 +17211,7 @@ async function handlePlayShareStatus(args) {
     console.error("Usage: deepline plays share status <play> [--json]");
     return 2;
   }
-  const name = parseReferencedPlayTarget3(target).playName;
+  const name = parseReferencedPlayTarget2(target).playName;
   const status = await new DeeplineClient().getSharePage(name);
   const outputStatus = shareStatusForOutput(status);
   if (argsWantJson(args)) {
@@ -18940,7 +17253,7 @@ async function handlePlaySharePublish(args) {
     );
     return 2;
   }
-  const name = parseReferencedPlayTarget3(target).playName;
+  const name = parseReferencedPlayTarget2(target).playName;
   const client = new DeeplineClient();
   let revisionId = shareFlagValue(args, "--revision-id");
   let resolvedVersion;
@@ -19032,7 +17345,7 @@ async function handlePlayShareUpdate(args) {
     );
     return 2;
   }
-  const name = parseReferencedPlayTarget3(target).playName;
+  const name = parseReferencedPlayTarget2(target).playName;
   const seo = shareFlagValue(args, "--seo");
   const seoIndexing = seo === "index" ? "index" : seo === "noindex" ? "noindex" : void 0;
   const request = {
@@ -19056,7 +17369,7 @@ async function handlePlayShareRegenerate(args) {
     );
     return 2;
   }
-  const name = parseReferencedPlayTarget3(target).playName;
+  const name = parseReferencedPlayTarget2(target).playName;
   const client = new DeeplineClient();
   let revisionId = shareFlagValue(args, "--revision-id");
   const versionFlag = shareFlagValue(args, "--version");
@@ -19099,7 +17412,7 @@ async function handlePlayShareUnpublish(args) {
     );
     return 2;
   }
-  const name = parseReferencedPlayTarget3(target).playName;
+  const name = parseReferencedPlayTarget2(target).playName;
   const status = await new DeeplineClient().unpublishSharePage(name);
   if (argsWantJson(args)) {
     printCompactJson(status);