deepline 0.1.101 → 0.1.102

package/dist/cli/index.js

@@ -233,10 +233,14 @@ var SDK_RELEASE = {
   // 0.1.98 ships the duplicate-browser-tab fix (default-browser detection).
   // 0.1.99 ships prebuilt job-change source-column preservation and validation fixes.
   // 0.1.101 ships retryable play artifact publish failures and CI retry hardening.
-  version: "0.1.101",
+  // 0.1.102 ships the job-change ledger fixes: recovered-dataset export on
+  // failed runs, persisted/succeeded/failed row counts, strict local CSV
+  // preflight (existence, data rows, quotes, duplicate headers), HTML error
+  // scrubbing, and word-boundary watch truncation.
+  version: "0.1.102",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.101",
+    latest: "0.1.102",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53"
   }
@@ -387,6 +391,22 @@ var HttpClient = class {
             parsed = body;
           }
           if (!response.ok) {
+            const htmlError = detectHtmlErrorBody(
+              body,
+              response.headers.get("content-type")
+            );
+            if (htmlError) {
+              throw new DeeplineError(
+                htmlError.message(response.status),
+                response.status,
+                "API_ERROR",
+                {
+                  htmlErrorPage: true,
+                  ...htmlError.title ? { title: htmlError.title } : {},
+                  ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+                }
+              );
+            }
             const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
             const msg = typeof errorValue === "string" ? errorValue : errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string" ? errorValue.message : typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string" ? parsed.message : `HTTP ${response.status}`;
             throw new DeeplineError(msg, response.status, "API_ERROR", {
@@ -447,6 +467,22 @@ var HttpClient = class {
         }
         if (!response.ok) {
           const body = await response.text();
+          const htmlError = detectHtmlErrorBody(
+            body,
+            response.headers.get("content-type")
+          );
+          if (htmlError) {
+            throw new DeeplineError(
+              htmlError.message(response.status),
+              response.status,
+              "API_ERROR",
+              {
+                htmlErrorPage: true,
+                ...htmlError.title ? { title: htmlError.title } : {},
+                ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+              }
+            );
+          }
           const parsed = parseResponseBody(body);
           throw new DeeplineError(
             apiErrorMessage(parsed, response.status),
@@ -512,6 +548,31 @@ function parseResponseBody(body) {
     return body;
   }
 }
+function detectHtmlErrorBody(body, contentType) {
+  const trimmed = body.trim();
+  const lower = trimmed.toLowerCase();
+  const isHtml = (contentType ?? "").toLowerCase().includes("text/html") || lower.startsWith("<!doctype") || lower.startsWith("<html");
+  if (!isHtml) {
+    return null;
+  }
+  const titleMatch = trimmed.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch?.[1]?.replace(/\s+/g, " ").trim() || void 0;
+  const workerThrewException = /worker threw exception/i.test(trimmed);
+  return {
+    title,
+    workerThrewException,
+    message: (status) => {
+      const segments = [`HTTP ${status}`];
+      if (workerThrewException) {
+        segments.push("Worker threw exception");
+      }
+      if (title) {
+        segments.push(title);
+      }
+      return `${segments.join(": ")} (Cloudflare HTML error page suppressed)`;
+    }
+  };
+}
 function apiErrorMessage(parsed, status) {
   const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
   if (typeof errorValue === "string") {
@@ -607,7 +668,7 @@ function isTransientPlayStreamError(error) {
     return error.statusCode >= 500 && error.statusCode < 600;
   }
   const text = error instanceof Error ? error.message : String(error);
-  return /auth validation backend timed out|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
+  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
     text
   );
 }
@@ -839,6 +900,10 @@ function buildSnapshotFromLedger(snapshot) {
   return {
     runId: snapshot.runId,
     status: normalizePlayRunLiveStatus(snapshot.status),
+    createdAt: snapshot.createdAt ?? null,
+    startedAt: snapshot.startedAt ?? null,
+    finishedAt: snapshot.finishedAt ?? null,
+    durationMs: snapshot.durationMs ?? null,
     updatedAt: snapshot.updatedAt ?? snapshot.finishedAt ?? snapshot.startedAt ?? null,
     logs: snapshot.logTail,
     totalLogCount: snapshot.totalLogCount,
@@ -4549,14 +4614,25 @@ var import_node_fs5 = require("fs");
 var import_node_path6 = require("path");
 
 // ../shared_libs/plays/dataset-summary.ts
+function formatDatasetRowCountsLine(counts) {
+  const { persisted, succeeded, failed } = counts;
+  if (succeeded === persisted && failed === 0) {
+    return `${persisted} persisted`;
+  }
+  return `${persisted} persisted (${succeeded} succeeded, ${failed} failed)`;
+}
 function datasetSummaryPercentText(numerator, denominator) {
   return denominator > 0 ? `${numerator}/${denominator} (${Math.round(100 * numerator / denominator)}%)` : "0/0 (0%)";
 }
 function readCount(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
 }
-function formatDatasetExecutionStats(raw, denominator) {
-  return {
+function executionAttemptTotal(raw) {
+  return readCount(raw.queued) + readCount(raw.running) + readCount(raw.completed) + readCount(raw.cached) + readCount(raw.skipped) + readCount(raw.missed) + readCount(raw.failed);
+}
+function formatDatasetExecutionStats(raw, _persistedRowTotal) {
+  const denominator = executionAttemptTotal(raw);
+  const stats = {
     queued: datasetSummaryPercentText(readCount(raw.queued), denominator),
     running: datasetSummaryPercentText(readCount(raw.running), denominator),
     "completed:executed": datasetSummaryPercentText(
@@ -4577,6 +4653,17 @@ function formatDatasetExecutionStats(raw, denominator) {
     ),
     failed: datasetSummaryPercentText(readCount(raw.failed), denominator)
   };
+  if (Object.values(stats).some((text) => {
+    const match = /\((\d+)%\)/.exec(text);
+    return match ? Number(match[1]) > 100 : false;
+  })) {
+    throw new Error(
+      `formatDatasetExecutionStats produced a >100% execution stat; column counts are corrupt: ${JSON.stringify(
+        raw
+      )}`
+    );
+  }
+  return stats;
 }
 
 // src/cli/dataset-stats.ts
@@ -4726,7 +4813,8 @@ function canonicalRowsInfoFromCandidate(input2) {
       complete: rows2.length === totalRows2,
       source: candidate.source,
       datasetId: typeof candidate.value.datasetId === "string" ? candidate.value.datasetId : null,
-      tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null
+      tableNamespace: typeof candidate.value.tableNamespace === "string" ? candidate.value.tableNamespace : null,
+      ...candidate.value.recovered === true ? { recovered: true } : {}
     };
   }
   if (candidate.serializedOnly) {
@@ -4876,18 +4964,46 @@ function collectCanonicalRowsInfos(statusOrResult) {
   }
   return infos;
 }
-function collectSerializedDatasetRowsInfos(statusOrResult) {
+function collectPackagedStepDatasetCandidates(statusOrResult) {
   const root = isRecord3(statusOrResult) ? statusOrResult : null;
-  const result = isRecord3(root?.result) ? root.result : root;
-  if (!result) {
+  if (!root) {
     return [];
   }
+  const pkg = isRecord3(root.package) ? root.package : root;
+  const steps = Array.isArray(pkg.steps) ? pkg.steps : [];
   const candidates = [];
-  collectDatasetCandidates({
-    value: result,
-    path: "result",
-    output: candidates
-  });
+  for (const step of steps) {
+    if (!isRecord3(step) || !isRecord3(step.output)) {
+      continue;
+    }
+    const output2 = step.output;
+    if (!isPackagedDatasetOutput(output2)) {
+      continue;
+    }
+    const source = typeof output2.path === "string" && output2.path.trim() ? output2.path.trim() : typeof step.id === "string" ? step.id : null;
+    if (!source) {
+      continue;
+    }
+    candidates.push({
+      source,
+      value: output2,
+      total: output2.rowCount ?? (isRecord3(output2.preview) ? output2.preview.totalRows : void 0) ?? (isRecord3(step.progress) ? step.progress.total : void 0)
+    });
+  }
+  return candidates;
+}
+function collectSerializedDatasetRowsInfos(statusOrResult) {
+  const root = isRecord3(statusOrResult) ? statusOrResult : null;
+  const result = isRecord3(root?.result) ? root.result : root;
+  const candidates = [];
+  if (result) {
+    collectDatasetCandidates({
+      value: result,
+      path: "result",
+      output: candidates
+    });
+  }
+  candidates.push(...collectPackagedStepDatasetCandidates(statusOrResult));
   const seen = /* @__PURE__ */ new Set();
   const infos = [];
   for (const candidate of candidates) {
@@ -5576,6 +5692,7 @@ var import_node_path13 = require("path");
 var import_node_crypto3 = require("crypto");
 var import_node_fs10 = require("fs");
 var import_node_path12 = require("path");
+var import_sync5 = require("csv-parse/sync");
 
 // src/plays/bundle-play-file.ts
 var import_node_os6 = require("os");
@@ -9374,6 +9491,177 @@ function inputContainsLocalFilePath(value) {
   }
   return false;
 }
+function isUrlValue(value) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim());
+}
+function looksLikeStagedFileRef(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  return typeof record.contentHash === "string" || typeof record.contentBase64 === "string" || typeof record.logicalPath === "string" && typeof record.bytes === "number";
+}
+var CSV_DATA_INPUT_KEY = "csv";
+function collectLocalFileInputRefs(value, inputPath, key, out) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed || isUrlValue(trimmed)) {
+      return;
+    }
+    const keyIsCsvData = key === CSV_DATA_INPUT_KEY;
+    const endsWithCsv = /\.csv$/i.test(trimmed);
+    const looksLikeFile = /\.[a-z0-9]{1,8}$/i.test(trimmed);
+    if (keyIsCsvData) {
+      out.push({ inputPath, value: trimmed, isCsvData: true });
+    } else if (endsWithCsv || looksLikeFile && (0, import_node_fs10.existsSync)((0, import_node_path12.resolve)(trimmed))) {
+      out.push({ inputPath, value: trimmed, isCsvData: false });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach(
+      (entry, index) => collectLocalFileInputRefs(entry, `${inputPath}[${index}]`, key, out)
+    );
+    return;
+  }
+  if (looksLikeStagedFileRef(value)) {
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [childKey, child] of Object.entries(value)) {
+      collectLocalFileInputRefs(
+        child,
+        inputPath ? `${inputPath}.${childKey}` : childKey,
+        childKey,
+        out
+      );
+    }
+  }
+}
+function preflightLocalFileInputs(runtimeInput) {
+  if (CSV_DATA_INPUT_KEY in runtimeInput) {
+    const csvValue = runtimeInput[CSV_DATA_INPUT_KEY];
+    if (typeof csvValue === "string" && csvValue.trim().length === 0) {
+      throw new DeeplineError(
+        `Input ${CSV_DATA_INPUT_KEY} is an empty string. Provide a path to a CSV file (or a CSV URL). No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        { inputPath: CSV_DATA_INPUT_KEY, reason: "csv_empty_string" }
+      );
+    }
+  }
+  const refs = [];
+  for (const [key, value] of Object.entries(runtimeInput)) {
+    collectLocalFileInputRefs(value, key, key, refs);
+  }
+  for (const ref of refs) {
+    const absolutePath = (0, import_node_path12.resolve)(ref.value);
+    if (!(0, import_node_fs10.existsSync)(absolutePath)) {
+      throw new DeeplineError(
+        `Input ${ref.inputPath} references a local file that does not exist: ${ref.value} (resolved to ${absolutePath}). No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        { inputPath: ref.inputPath, path: ref.value, resolved: absolutePath }
+      );
+    }
+    let stat4;
+    try {
+      stat4 = (0, import_node_fs10.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.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        { inputPath: ref.inputPath, path: ref.value }
+      );
+    }
+    if (!stat4.isFile()) {
+      throw new DeeplineError(
+        `Input ${ref.inputPath} references ${ref.value}, which is not a file. No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        { inputPath: ref.inputPath, path: ref.value }
+      );
+    }
+    if (!ref.isCsvData) {
+      continue;
+    }
+    preflightCsvDataInput(ref, absolutePath);
+  }
+}
+function preflightCsvDataInput(ref, absolutePath) {
+  let content;
+  try {
+    content = (0, import_node_fs10.readFileSync)(absolutePath, "utf-8");
+  } catch (error) {
+    throw new DeeplineError(
+      `Input ${ref.inputPath} CSV ${ref.value} is not readable: ${error instanceof Error ? error.message : String(error)}. No run was created.`,
+      void 0,
+      "PLAY_INPUT_FILE_PREFLIGHT",
+      { inputPath: ref.inputPath, path: ref.value }
+    );
+  }
+  let records;
+  try {
+    records = (0, import_sync5.parse)(content, {
+      bom: true,
+      columns: false,
+      skip_empty_lines: true,
+      relax_column_count: true,
+      // STRICT RFC quoting: an unclosed quote or ragged quoting is a hard
+      // error rather than being swallowed into one giant field.
+      relax_quotes: false,
+      trim: true
+    });
+  } catch (error) {
+    throw new DeeplineError(
+      `Input ${ref.inputPath} could not be parsed as CSV (${ref.value}): ${error instanceof Error ? error.message : String(error)}. This usually means an unclosed quote or ragged quoting. No run was created.`,
+      void 0,
+      "PLAY_INPUT_FILE_PREFLIGHT",
+      { inputPath: ref.inputPath, path: ref.value }
+    );
+  }
+  if (records.length === 0) {
+    throw new DeeplineError(
+      `${ref.value} has a header row but no data rows. No run was created.`,
+      void 0,
+      "PLAY_INPUT_FILE_PREFLIGHT",
+      { inputPath: ref.inputPath, path: ref.value }
+    );
+  }
+  const header = records[0];
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < header.length; i++) {
+    const raw = header[i] ?? "";
+    const name = raw.trim();
+    if (name.length === 0) continue;
+    const prior = seen.get(name);
+    if (prior) {
+      throw new DeeplineError(
+        `Input ${ref.inputPath} (${ref.value}) has a duplicate CSV header "${name}" (columns ${prior.index + 1} and ${i + 1}). The second column would silently overwrite the first. Rename one of them. No run was created.`,
+        void 0,
+        "PLAY_INPUT_FILE_PREFLIGHT",
+        {
+          inputPath: ref.inputPath,
+          path: ref.value,
+          duplicateHeader: name,
+          columns: [prior.index + 1, i + 1],
+          rawSpellings: [prior.raw, raw]
+        }
+      );
+    }
+    seen.set(name, { index: i, raw });
+  }
+  const dataRowCount = records.length - 1;
+  if (dataRowCount < 1) {
+    throw new DeeplineError(
+      `${ref.value} has a header row but no data rows. No run was created.`,
+      void 0,
+      "PLAY_INPUT_FILE_PREFLIGHT",
+      { inputPath: ref.inputPath, path: ref.value }
+    );
+  }
+}
 function namedRunNeedsPlayDefinition(input2) {
   return input2.revisionSelector === "latest" || inputContainsLocalFilePath(input2.runtimeInput);
 }
@@ -9608,6 +9896,21 @@ function isRetryablePendingStartFailure(status) {
   if (status.runId && status.runId !== "pending") return false;
   return isTransientPlayStreamError(new Error(playStatusErrorText(status)));
 }
+function pendingStartFailureStatus(input2) {
+  const message = input2.error instanceof Error ? input2.error.message : String(input2.error);
+  return {
+    runId: "pending",
+    name: input2.playName,
+    playName: input2.playName,
+    dashboardUrl: input2.dashboardUrl,
+    status: "failed",
+    progress: {
+      status: "failed",
+      logs: [],
+      error: message
+    }
+  };
+}
 var TERMINAL_PLAY_STATUSES2 = /* @__PURE__ */ new Set([
   "completed",
   "failed",
@@ -10387,6 +10690,23 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
         progress: input2.progress
       });
     }
+    if (!lastKnownWorkflowId && isTransientPlayStreamError(error)) {
+      recordCliTrace({
+        phase: "cli.play_start_stream_transient_failure",
+        ms: Date.now() - startedAt,
+        ok: false,
+        playName: input2.playName,
+        eventCount,
+        firstRunIdMs,
+        lastPhase,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      return pendingStartFailureStatus({
+        playName: input2.playName,
+        dashboardUrl,
+        error
+      });
+    }
     throw error;
   } finally {
     if (timeout) {
@@ -10438,6 +10758,28 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
 function formatInteger(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toLocaleString("en-US") : String(value ?? "-");
 }
+var RUN_ERROR_DISPLAY_MAX_CHARS = 2e3;
+function truncateErrorForDisplay(message, runId, maxChars = RUN_ERROR_DISPLAY_MAX_CHARS) {
+  const compact = message.replace(/\s+/g, " ").trim();
+  if (compact.length <= maxChars) {
+    return compact;
+  }
+  const slice = compact.slice(0, maxChars);
+  const lastSpace = slice.lastIndexOf(" ");
+  const wordBoundary = lastSpace > 0 ? slice.slice(0, lastSpace) : slice;
+  const fullErrorHint = runId ? ` (full error: deepline runs get ${runId} --full)` : " (full error: deepline runs get <runId> --full)";
+  return `${wordBoundary}\u2026${fullErrorHint}`;
+}
+function clampJsonPreviewText(json, maxChars) {
+  if (json.length <= maxChars) {
+    return json;
+  }
+  const slice = json.slice(0, maxChars);
+  const lastNewline = slice.lastIndexOf("\n");
+  const head = lastNewline > 0 ? slice.slice(0, lastNewline) : slice;
+  return `${head}
+... truncated; use --json for full output`;
+}
 var BULKY_RETURN_KEYS = /* @__PURE__ */ new Set([
   "contract",
   "staticPipeline",
@@ -10522,8 +10864,7 @@ function formatJsonPreview(value) {
     return [];
   }
   const MAX_CHARS = 4e3;
-  const truncated = json.length > MAX_CHARS ? `${json.slice(0, MAX_CHARS)}
-... truncated; use --json for full output` : json;
+  const truncated = clampJsonPreviewText(json, MAX_CHARS);
   return truncated.split("\n").map((line) => `    ${line}`);
 }
 function formatReturnValue(result) {
@@ -11054,6 +11395,9 @@ function readRecordArray(value) {
 function readRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+function readNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : null;
+}
 function formatSummaryScalar(value) {
   if (typeof value === "number") {
     return Number.isFinite(value) ? formatInteger(Math.trunc(value)) : null;
@@ -11086,7 +11430,25 @@ function formatPackageDatasetSummaryLines(summary, indent2 = "    ") {
     return [];
   }
   const lines = [];
-  const parts = formatSummaryScalarParts(record, /* @__PURE__ */ new Set(["columnStats"]));
+  const rowCounts = readRecord(record.rowCounts);
+  if (rowCounts) {
+    const persisted = readNonNegativeInteger(rowCounts.persisted);
+    const succeeded = readNonNegativeInteger(rowCounts.succeeded);
+    const failed = readNonNegativeInteger(rowCounts.failed);
+    if (persisted !== null) {
+      lines.push(
+        `${indent2}rows: ${formatDatasetRowCountsLine({
+          persisted,
+          succeeded: succeeded ?? persisted,
+          failed: failed ?? 0
+        })}`
+      );
+    }
+  }
+  const parts = formatSummaryScalarParts(
+    record,
+    /* @__PURE__ */ new Set(["columnStats", "rowCounts"])
+  );
   if (parts.length > 0) {
     lines.push(`${indent2}summary: ${parts.join(" ")}`);
   }
@@ -11147,7 +11509,7 @@ function buildRunPackageTextLines(packaged) {
   ];
   const runError = typeof run.error === "string" && run.error.trim() ? run.error.trim() : null;
   if (runError && (status === "failed" || status === "cancelled")) {
-    lines.push(`  error: ${runError.slice(0, 200)}`);
+    lines.push(`  error: ${truncateErrorForDisplay(runError, runId)}`);
   }
   for (const step of readRecordArray(packaged.steps)) {
     const output2 = step.output && typeof step.output === "object" && !Array.isArray(step.output) ? step.output : null;
@@ -11232,7 +11594,7 @@ function writePlayResult(status, jsonOutput, options) {
       lines.push(...buildInsufficientCreditsSummaryLines({ status, billing }));
     }
     const displayError = formatPlayErrorForDisplay(status, progressError) ?? progressError;
-    lines.push(`  error: ${displayError.slice(0, 200)}`);
+    lines.push(`  error: ${truncateErrorForDisplay(displayError, runId)}`);
   }
   const renderedServerView = renderServerResultView(status.resultView);
   if (result) {
@@ -11403,12 +11765,51 @@ async function fetchBackingDatasetRows(input2) {
     source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
   };
 }
+function resolveDatasetByName(available, datasetPath) {
+  const target = datasetPath.trim();
+  const exact = available.find((info) => info.source === target);
+  if (exact) {
+    return exact;
+  }
+  const byNamespace = available.find(
+    (info) => info.tableNamespace && info.tableNamespace === target
+  );
+  if (byNamespace) {
+    return byNamespace;
+  }
+  const trailing = target.split(".").filter(Boolean).at(-1);
+  if (!trailing) {
+    return null;
+  }
+  const byTrailing = available.find(
+    (info) => info.tableNamespace === trailing || typeof info.source === "string" && info.source.split(".").filter(Boolean).at(-1) === trailing
+  );
+  if (byTrailing) {
+    return byTrailing;
+  }
+  if (target.split(".").filter(Boolean)[0] === "result") {
+    const recovered = available.filter((info) => info.recovered);
+    if (recovered.length === 1) {
+      return recovered[0];
+    }
+    if (recovered.length > 1) {
+      const names = recovered.map((info) => info.tableNamespace ?? info.source).filter((name) => typeof name === "string");
+      throw new DeeplineError(
+        `Run returned multiple recovered datasets; '${target}' is ambiguous. Choose one with --dataset <path>: ${names.join(", ")}.`,
+        void 0,
+        "RUN_EXPORT_DATASET_AMBIGUOUS",
+        { dataset: target, available: names }
+      );
+    }
+  }
+  return null;
+}
 async function exportPlayStatusRows(client2, status, outPath, options = {}) {
   if (!outPath) {
     return null;
   }
   const availableRows = collectSerializedDatasetRowsInfos(status);
-  const rowsInfo = options.datasetPath ? availableRows.find((info) => info.source === options.datasetPath) ?? null : availableRows.length === 1 ? availableRows[0] : null;
+  const rowsInfo = options.datasetPath ? resolveDatasetByName(availableRows, options.datasetPath) ?? null : availableRows.length === 1 ? availableRows[0] : null;
   if (!rowsInfo && options.datasetPath) {
     const available = availableRows.map((info) => info.source).filter((source) => typeof source === "string");
     throw new DeeplineError(
@@ -12154,6 +12555,12 @@ async function handleFileBackedRun(options) {
     () => (0, import_node_fs10.readFileSync)(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
+  try {
+    preflightLocalFileInputs(runtimeInput);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
   let graph;
   try {
     graph = await traceCliSpan(
@@ -12311,6 +12718,12 @@ async function handleNamedRun(options) {
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const playName = options.target.name;
   const runtimeInput = options.input ? { ...options.input } : {};
+  try {
+    preflightLocalFileInputs(runtimeInput);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
   const needsPlayDefinition = namedRunNeedsPlayDefinition({
     runtimeInput,
     revisionSelector: options.revisionSelector