deepline 0.3.461 → 0.3.463

package/dist/cli/chunk-LYFKBLJI.mjs

@@ -0,0 +1,1039 @@
+import {
+  SCHEMA_LINE_LIMIT,
+  fieldBlockLines,
+  schemaFields
+} from "./chunk-JVHOS3K3.mjs";
+import {
+  csvSafeJsonString,
+  csvStringFromRows
+} from "./chunk-WUMIYOXQ.mjs";
+
+// src/cli/describe-options.ts
+function addDescribeOptions(command, options = {}) {
+  command.option(
+    "--prebuilt",
+    "Show the Deepline tool or play, not a play your workspace created under the same name"
+  ).option("--tool", "Same as --prebuilt").option(
+    "--verbose",
+    "Show secondary fields, and fill in every input and read every output in the examples"
+  ).option(
+    "--cli-example",
+    "Show only the CLI example, and explain how it takes inputs and returns outputs"
+  ).option(
+    "--play-example",
+    "Show only the in-play example, and explain how it takes inputs and returns outputs"
+  ).option("--no-example", "Hide the run examples").option(
+    "--full-schema",
+    `Print every field: a long schema unfolded (over ${SCHEMA_LINE_LIMIT} lines), list rows, and a tool's raw response`
+  ).option(
+    "--fields <names>",
+    "Show only these fields, comma-separated, plus every required input"
+  ).option(
+    "--feature <name[=value]>",
+    "Describe one feature of a tool, such as a model: --feature model=openai/gpt-5.6-luna. A tool lists its features."
+  ).option(
+    "-o, --out <path>",
+    "Save the output to this file instead of printing it"
+  );
+  if (options.schemaOnly !== false) {
+    command.option(
+      "--schema-only",
+      "Print only the schema, with every field, and nothing else"
+    );
+  }
+  if (options.json !== false) {
+    command.option(
+      "--json",
+      "Print JSON instead of text; with --schema-only, only the input and output JSON Schemas"
+    );
+  }
+  return command;
+}
+
+// src/cli/execution-observation.ts
+import { writeFileSync, renameSync } from "fs";
+function writeObservation(observation) {
+  const path = process.env.DEEPLINE_EXECUTION_OBSERVATION_PATH;
+  const invocationId = process.env.DEEPLINE_EXECUTION_OBSERVATION_ID;
+  if (!path || !invocationId) return;
+  const pending = `${path}.pending`;
+  try {
+    writeFileSync(
+      pending,
+      JSON.stringify({
+        schema_version: 1,
+        invocation_id: invocationId,
+        ...observation
+      }),
+      { mode: 384 }
+    );
+    renameSync(pending, path);
+  } catch {
+    console.error(
+      "[execution-observation] could not write the configured diagnostic sink",
+      { kind: observation.kind }
+    );
+  }
+}
+function recordApiResponse(observation) {
+  writeObservation({
+    kind: "api_response",
+    received_at_ms: observation.receivedAtMs,
+    state: observation.state,
+    http_status: observation.httpStatus
+  });
+}
+function recordPlayTermination(run) {
+  if (typeof run.id !== "string" || !["completed", "failed", "cancelled", "canceled"].includes(
+    String(run.status)
+  ) || typeof run.finishedAt !== "number" || !Number.isSafeInteger(run.finishedAt) || run.finishedAt <= 0)
+    return;
+  writeObservation({
+    kind: "play_terminal",
+    run: { id: run.id, status: run.status, finishedAt: run.finishedAt }
+  });
+}
+
+// ../plays/table-csv.ts
+var TABLE_EXPORT_ERROR_COLUMN = "_error";
+var UNRECORDED_FAILURE_REASON = "Row failed without a recorded reason.";
+function tableCellText(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean")
+    return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "symbol" || typeof value === "function") return "";
+  try {
+    return JSON.stringify(
+      value,
+      (_key, nested) => typeof nested === "bigint" ? nested.toString() : nested
+    ) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+function csvField(value) {
+  const text = tableCellText(value);
+  return /[",\r\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function csvRecord(values) {
+  return `${values.map(csvField).join(",")}
+`;
+}
+function isFailedRow(row) {
+  return row.status === "failed";
+}
+function tableExportHasFailedRows(rows) {
+  for (const row of rows) if (isFailedRow(row)) return true;
+  return false;
+}
+function tableExportErrorCell(row) {
+  if (!isFailedRow(row)) return "";
+  const reason = typeof row.error === "string" ? row.error.trim() : "";
+  return reason || UNRECORDED_FAILURE_REASON;
+}
+function tableExportColumns(columns, withError) {
+  if (!withError) return [...columns];
+  return [
+    ...columns.filter((column) => column !== TABLE_EXPORT_ERROR_COLUMN),
+    TABLE_EXPORT_ERROR_COLUMN
+  ];
+}
+function tableExportCells(row, columns, withError) {
+  return tableExportColumns(columns, withError).map(
+    (column) => column === TABLE_EXPORT_ERROR_COLUMN && withError ? tableExportErrorCell(row) : Object.hasOwn(row.data, column) ? row.data[column] : void 0
+  );
+}
+function tableCsvText(header, records) {
+  let text = csvRecord(header);
+  for (const record2 of records) text += csvRecord(record2);
+  return text;
+}
+
+// src/cli/run-dataset-order.ts
+function underscoreKeysLast(keys) {
+  return [...keys].sort(
+    (left, right) => Number(left.startsWith("_")) - Number(right.startsWith("_"))
+  );
+}
+function orderRunExportJson(value) {
+  const copies = /* @__PURE__ */ new WeakMap();
+  function visit(item) {
+    if (item === null || typeof item !== "object") return item;
+    if (copies.has(item)) return copies.get(item);
+    if (Array.isArray(item)) {
+      const copy2 = [];
+      copies.set(item, copy2);
+      for (const element of item) copy2.push(visit(element));
+      return copy2;
+    }
+    const prototype = Object.getPrototypeOf(item);
+    if (prototype !== Object.prototype && prototype !== null) return item;
+    const record2 = item;
+    const copy = /* @__PURE__ */ Object.create(null);
+    copies.set(item, copy);
+    for (const key of underscoreKeysLast(Object.keys(record2))) {
+      copy[key] = visit(record2[key]);
+    }
+    return copy;
+  }
+  return visit(value);
+}
+
+// src/cli/execution-output.ts
+import {
+  accessSync,
+  appendFileSync,
+  constants,
+  existsSync,
+  linkSync,
+  mkdtempSync,
+  realpathSync,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { tmpdir } from "os";
+import { dirname, join, resolve as resolve2 } from "path";
+import { randomUUID } from "crypto";
+
+// src/cli/run-dataset-csv.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+var RunDatasetCsv = class _RunDatasetCsv {
+  #projection;
+  constructor(input) {
+    const rows = input.rows.map(projectRunDatasetRow);
+    this.#projection = {
+      rows,
+      columns: runDatasetCsvColumns(rows, input.columns)
+    };
+  }
+  static from(input) {
+    return new _RunDatasetCsv(input);
+  }
+  projection() {
+    return this.#projection;
+  }
+  write(outPath) {
+    const absolutePath = resolve(outPath);
+    const { rows, columns } = this.#projection;
+    writeFileSync2(
+      absolutePath,
+      tableCsvText(
+        columns,
+        rows.map((data) => tableExportCells({ data }, columns, false))
+      ),
+      "utf-8"
+    );
+    return absolutePath;
+  }
+};
+function projectRunDatasetCsv(input) {
+  return RunDatasetCsv.from(input).projection();
+}
+function writeRunDatasetCsv(input) {
+  return RunDatasetCsv.from(input).write(input.outPath);
+}
+function projectRunDatasetRow(row) {
+  return Object.fromEntries(
+    Object.entries(row).map(([column, value]) => [
+      column,
+      projectRunDatasetCell(value)
+    ])
+  );
+}
+function projectRunDatasetCell(value) {
+  const logicalValue = parseSerializedDatasetValue(value);
+  if (logicalValue === null || logicalValue === void 0) return logicalValue;
+  if (typeof logicalValue === "object") {
+    return csvSafeJsonString(canonicalDatasetJson(logicalValue));
+  }
+  return logicalValue;
+}
+function canonicalDatasetJson(value) {
+  return canonicalDatasetJsonValue(value, /* @__PURE__ */ new WeakSet());
+}
+function canonicalDatasetJsonValue(value, ancestors) {
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) return value;
+    ancestors.add(value);
+    const normalized2 = value.map(
+      (item) => canonicalDatasetJsonValue(item, ancestors)
+    );
+    ancestors.delete(value);
+    return normalized2;
+  }
+  if (!value || typeof value !== "object" || value instanceof Date) {
+    return value;
+  }
+  if (ancestors.has(value)) return value;
+  ancestors.add(value);
+  const record2 = value;
+  const normalized = Object.fromEntries(
+    underscoreKeysLast(
+      Object.keys(record2).sort((left, right) => left.localeCompare(right))
+    ).map((key) => [key, canonicalDatasetJsonValue(record2[key], ancestors)])
+  );
+  ancestors.delete(value);
+  return normalized;
+}
+function parseSerializedDatasetValue(value) {
+  if (typeof value !== "string") return value;
+  const text = value.trim();
+  if (!text || !["{", "["].includes(text[0] ?? "")) return value;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return value;
+  }
+}
+function runDatasetCsvColumns(rows, declaredColumns) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (column) => {
+    if (!column || seen.has(column)) return;
+    seen.add(column);
+    columns.push(column);
+  };
+  for (const column of declaredColumns) add(column);
+  for (const row of rows) {
+    for (const column of Object.keys(row)) add(column);
+  }
+  return underscoreKeysLast(columns);
+}
+
+// src/cli/value-outline.ts
+var OUTLINE_LINES = 32;
+var ITEMS_SHOWN = 3;
+var VALUE_CHARACTERS = 60;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isContainer(value) {
+  return Array.isArray(value) && value.length > 0 || isRecord(value) && Object.keys(value).length > 0;
+}
+function node(label, value) {
+  const children = !isContainer(value) ? null : Array.isArray(value) ? value.some(isContainer) ? value.map((item) => node(null, item)) : null : Object.entries(value).filter(([, child]) => child !== void 0).map(([key, child]) => node(key, child));
+  return { label, value, children, shown: 0 };
+}
+function wanted(parent, left) {
+  const count = parent.children?.length ?? 0;
+  if (!Array.isArray(parent.value)) return count;
+  const first = parent.value[0];
+  const perItem = isRecord(first) ? Math.max(1, Object.keys(first).length) : 1;
+  return Math.min(count, Math.max(ITEMS_SHOWN, Math.floor(left / perItem)));
+}
+function shareLines(wants, total) {
+  const grants = wants.map(() => 0);
+  let left = total;
+  let open = wants.flatMap((want, index) => want > 0 ? [index] : []);
+  while (left > 0 && open.length) {
+    const each = Math.floor(left / open.length);
+    if (each === 0) {
+      for (const index of open.slice(0, left)) grants[index] += 1;
+      break;
+    }
+    for (const index of open) {
+      const grant = Math.min(each, wants[index] - grants[index]);
+      grants[index] += grant;
+      left -= grant;
+    }
+    open = open.filter((index) => grants[index] < wants[index]);
+  }
+  return grants;
+}
+function cut(text) {
+  return text.length > VALUE_CHARACTERS ? `${text.slice(0, VALUE_CHARACTERS)}\u2026` : text;
+}
+function valueText(value) {
+  if (Array.isArray(value)) {
+    if (!value.length) return "[]";
+    const items = value.map((item) => cut(JSON.stringify(item) ?? "null"));
+    const text = `[${items.join(", ")}]`;
+    return text.length <= VALUE_CHARACTERS ? text : `[${items[0]}, \u2026 ${value.length} items]`;
+  }
+  if (isRecord(value)) return "{}";
+  return typeof value === "string" ? JSON.stringify(cut(value)) : String(JSON.stringify(value) ?? "null");
+}
+function foldedText(value) {
+  if (Array.isArray(value)) return `[${value.length} items]`;
+  return `{ ${cut(Object.keys(value).join(", "))} }`;
+}
+function countNote(item) {
+  const total = item.children?.length ?? 0;
+  if (Array.isArray(item.value)) {
+    return item.shown < total ? `(${item.shown} of ${total} items)` : `(${total} ${total === 1 ? "item" : "items"})`;
+  }
+  return item.shown < total ? `(${item.shown} of ${total} fields)` : "";
+}
+function renderChildren(parent, indent) {
+  return (parent.children ?? []).slice(0, parent.shown).flatMap((child) => renderNode(child, indent));
+}
+function renderNode(item, indent) {
+  const prefix = item.label === null ? "- " : `${item.label}: `;
+  if (!item.children) return [`${indent}${prefix}${valueText(item.value)}`];
+  if (!item.shown) return [`${indent}${prefix}${foldedText(item.value)}`];
+  const note = countNote(item);
+  const children = renderChildren(item, `${indent}  `);
+  if (mergesWithFirstField(item)) {
+    const [first, ...rest] = children;
+    const head = `${indent}- ${first.slice(indent.length + 2)}`;
+    return [note ? `${head}  ${note}` : head, ...rest];
+  }
+  return [`${indent}${prefix.trimEnd()}${note ? ` ${note}` : ""}`, ...children];
+}
+function mergesWithFirstField(item) {
+  return item.label === null && isRecord(item.value) && item.shown > 0;
+}
+function anythingHidden(item) {
+  if (!item.children) return false;
+  if (item.shown < item.children.length) return true;
+  return item.children.some(anythingHidden);
+}
+function outlineLines(value, budget = OUTLINE_LINES) {
+  const root = node("", value);
+  if (!root.children)
+    return { lines: [valueText(value)], note: "", cut: false };
+  let left = budget;
+  let level = [root];
+  while (level.length) {
+    const wants = level.map((parent) => wanted(parent, left));
+    const items = level.map(
+      (parent, index) => parent.label === null && isRecord(parent.value) && wants[index] > 0
+    );
+    let returned = items.filter(Boolean).length;
+    if (left + returned <= 0) break;
+    let grants = shareLines(wants, left + returned);
+    for (; ; ) {
+      const merged = grants.filter((grant, index) => items[index] && grant > 0);
+      if (merged.length === returned) break;
+      returned = merged.length;
+      grants = shareLines(wants, left + returned);
+    }
+    left += returned;
+    const next = [];
+    level.forEach((parent, index) => {
+      parent.shown = grants[index];
+      left -= parent.shown;
+      next.push(
+        ...parent.children.slice(0, parent.shown).filter((child) => child.children)
+      );
+    });
+    level = next;
+  }
+  return {
+    lines: renderChildren(root, ""),
+    note: countNote(root),
+    cut: anythingHidden(root)
+  };
+}
+function merge(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.map((item, index) => merge(item, b[index]));
+  }
+  if (isRecord(a) && isRecord(b)) {
+    const merged = { ...a };
+    for (const [key, value] of Object.entries(b)) {
+      merged[key] = key in merged ? merge(merged[key], value) : value;
+    }
+    return merged;
+  }
+  return b === void 0 ? a : b;
+}
+function pick(value, path) {
+  if (!path.length) return value;
+  if (Array.isArray(value)) return value.map((item) => pick(item, path));
+  if (!isRecord(value) || !(path[0] in value)) return void 0;
+  const child = pick(value[path[0]], path.slice(1));
+  return child === void 0 ? void 0 : { [path[0]]: child };
+}
+function pickFields(value, paths) {
+  const missing = [];
+  let picked;
+  for (const path of paths) {
+    const one = pick(value, path.split("."));
+    const found = Array.isArray(one) ? one.some((item) => item !== void 0) : one !== void 0;
+    if (found) picked = picked === void 0 ? one : merge(picked, one);
+    else missing.push(path);
+  }
+  return { value: picked, missing };
+}
+
+// src/cli/execution-output.ts
+var ExecutionOutputError = class extends Error {
+};
+var JSON_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+function dataOnStdout(options) {
+  return options.jsonOut === "-" || (options.csvOut ?? []).some((target) => target.path === "-");
+}
+function listPath(source) {
+  return source.replace(/^\//, "").replace(/\//g, ".").replace(/^result(\.|$)/, "");
+}
+function valueAt(value, path) {
+  return path.split(".").reduce((at, key) => record(at) ? at[key] : void 0, value);
+}
+function validateExecutionOutput(options) {
+  const toStdout = [
+    ["--json-out", options.jsonOut],
+    ...(options.csvOut ?? []).map((target) => ["--csv-out", target.path]),
+    ["--logs-out", options.logsOut]
+  ].filter(([, path]) => path === "-");
+  if ((options.csvOut ?? []).filter((target) => !target.list).length > 1) {
+    throw new Error(
+      "Only one --csv-out may leave out the list name; name the others as list=path."
+    );
+  }
+  if (toStdout.length > 1) {
+    throw new Error(
+      `Only one of ${toStdout.map(([flag]) => flag).join(" and ")} may write to stdout.`
+    );
+  }
+  if (options.receiptOut === "-") {
+    throw new Error(
+      "--receipt-out takes a file. Use --json to print the receipt as JSON."
+    );
+  }
+  const paths = [
+    options.jsonOut,
+    ...(options.csvOut ?? []).map((target) => target.path),
+    options.receiptOut,
+    options.logsOut
+  ].filter((p) => p !== void 0 && p !== "-");
+  const resolved = paths.map((p) => {
+    if (!p.trim()) throw new Error("Output filenames must not be empty.");
+    const absolute = resolve2(p);
+    if (existsSync(absolute))
+      throw new Error(
+        `Output file already exists: ${absolute}. Choose a new filename.`
+      );
+    accessSync(dirname(absolute), constants.W_OK);
+    return join(
+      realpathSync(dirname(absolute)),
+      absolute.slice(dirname(absolute).length + 1)
+    );
+  });
+  if (new Set(resolved).size !== resolved.length) {
+    throw new Error(
+      "--json-out, --csv-out, --receipt-out and --logs-out must use different files."
+    );
+  }
+}
+function preflightExecutionOutput(options) {
+  try {
+    validateExecutionOutput(options);
+    return true;
+  } catch (error) {
+    writeExecutionOutput(
+      {
+        id: null,
+        status: "failed",
+        error: {
+          message: error instanceof Error ? error.message : String(error)
+        },
+        ran: false
+      },
+      // A rejected destination must not be opened, nor may errors pollute data stdout.
+      {
+        receiptJson: options.receiptJson,
+        ...dataOnStdout(options) ? { jsonOut: "-" } : {}
+      }
+    );
+    return false;
+  }
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function pointerPart(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function outputCollections(data, source = "") {
+  if (Array.isArray(data)) return [{ source, rows: data, complete: null }];
+  if (!record(data)) return [];
+  return Object.entries(data).flatMap(
+    ([key, value]) => outputCollections(value, `${source}/${pointerPart(key)}`)
+  );
+}
+function mergeSchema(a, b) {
+  if (!Object.keys(a).length) return b;
+  if (!Object.keys(b).length) return a;
+  if (a.type !== b.type || a.anyOf || b.anyOf) {
+    const variants = [
+      ...Array.isArray(a.anyOf) ? a.anyOf : [a],
+      ...Array.isArray(b.anyOf) ? b.anyOf : [b]
+    ];
+    const byType = /* @__PURE__ */ new Map();
+    for (const variant of variants) {
+      const previous = byType.get(variant.type);
+      byType.set(
+        variant.type,
+        previous ? mergeSchema(previous, variant) : variant
+      );
+    }
+    return { anyOf: [...byType.values()] };
+  }
+  if (a.type === "array")
+    return {
+      type: "array",
+      items: mergeSchema(a.items, b.items)
+    };
+  if (a.type !== "object") return a;
+  const properties = { ...a.properties };
+  for (const [key, value] of Object.entries(
+    b.properties
+  )) {
+    Object.defineProperty(properties, key, {
+      value: properties[key] && Object.hasOwn(properties, key) ? mergeSchema(properties[key], value) : value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return {
+    type: "object",
+    properties,
+    required: a.required.filter(
+      (key) => b.required.includes(key)
+    )
+  };
+}
+function observedSchema(value) {
+  if (value === null) return { type: "null" };
+  if (Array.isArray(value))
+    return {
+      type: "array",
+      items: value.reduce(
+        (schema, item) => mergeSchema(schema, observedSchema(item ?? null)),
+        {}
+      )
+    };
+  if (record(value)) {
+    const entries = Object.entries(value).filter(
+      ([, item]) => item !== void 0
+    );
+    return {
+      type: "object",
+      properties: Object.fromEntries(
+        entries.map(([key, item]) => [key, observedSchema(item)])
+      ),
+      required: entries.map(([key]) => key)
+    };
+  }
+  return { type: typeof value === "number" ? "number" : typeof value };
+}
+function csvColumns(collection, fields) {
+  const prefix = listPath(collection.source);
+  const columns = (fields ?? []).flatMap(
+    (field) => !prefix ? [field] : field.startsWith(`${prefix}.`) ? [field.slice(prefix.length + 1)] : []
+  );
+  if (!columns.length) return csvText(collection.rows, collection.columns);
+  return csvText(
+    collection.rows.map(
+      (row) => Object.fromEntries(
+        columns.map((column) => [column, valueAt(row, column)])
+      )
+    ),
+    columns
+  );
+}
+function csvText(rows, columns = []) {
+  const projection = projectRunDatasetCsv({
+    rows: rows.map((row) => record(row) ? row : { value: row }),
+    columns
+  });
+  return csvStringFromRows(projection.rows, projection.columns);
+}
+function writeExecutionOutput(result, options) {
+  let temp;
+  const temporary = (name) => join(temp ??= mkdtempSync(join(tmpdir(), "deepline-output-")), name);
+  const jsonText = (value) => `${JSON.stringify(value, null, 2)}
+`;
+  const persist = (path, content) => {
+    const absolute = resolve2(path);
+    const staging = join(dirname(absolute), `.deepline-${randomUUID()}.tmp`);
+    try {
+      writeFileSync3(staging, content, { flag: "wx", mode: 384 });
+      linkSync(staging, absolute);
+    } finally {
+      if (existsSync(staging)) unlinkSync(staging);
+    }
+    return absolute;
+  };
+  let stdoutData;
+  const artifact = (destination, content, format, source, rowCount, complete) => {
+    const stdout = destination === "-";
+    if (stdout) stdoutData = content;
+    return {
+      path: stdout ? null : persist(destination, content),
+      destination: stdout ? "stdout" : "file",
+      format,
+      source,
+      rowCount,
+      complete
+    };
+  };
+  let savedJson;
+  const ensureJson = () => savedJson ??= persist(temporary("result.json"), jsonText(result.data));
+  try {
+    const hasData = result.data !== void 0;
+    const collections = result.collections ?? (hasData ? outputCollections(result.data).map((collection) => ({
+      ...collection,
+      complete: result.complete ?? null
+    })) : []);
+    const ordered = collections.map((c, index) => ({ ...c, index })).sort((a, b) => b.rows.length - a.rows.length || a.index - b.index);
+    const csvTargets = hasData ? options.csvOut ?? [] : [];
+    if (csvTargets.length && !ordered.length)
+      throw new Error(
+        "This result has no row list to write as CSV. Use --json-out."
+      );
+    const underFields = ordered.find((collection) => {
+      const prefix = listPath(collection.source);
+      return prefix && options.fields?.some((field) => field.startsWith(`${prefix}.`));
+    });
+    const declaredList = ordered.find(
+      (collection) => result.declared?.some(
+        ({ path }) => path !== null && path === listPath(collection.source)
+      )
+    );
+    const defaultList = underFields ?? declaredList ?? ordered[0];
+    const csvFor = /* @__PURE__ */ new Map();
+    for (const target of csvTargets) {
+      const chosen = target.list ? ordered.find(
+        (collection) => collection.name === target.list || listPath(collection.source) === target.list || listPath(collection.source).endsWith(`.${target.list}`)
+      ) : defaultList;
+      if (!chosen) {
+        throw new Error(
+          `No row list named "${target.list}". The lists are: ${ordered.map((collection) => collection.name ?? (listPath(collection.source) || "(top level)")).join(", ")}`
+        );
+      }
+      csvFor.set(chosen, target);
+    }
+    const outputs = { json: null, csv: [] };
+    if (hasData && (options.jsonOut || !csvTargets.length)) {
+      outputs.json = artifact(
+        options.jsonOut ?? temporary("result.json"),
+        jsonText(result.data),
+        "json",
+        "",
+        Array.isArray(result.data) ? result.data.length : null,
+        result.complete ?? null
+      );
+      savedJson = outputs.json.path ?? void 0;
+    }
+    const summaries = ordered.map((collection) => {
+      const target = csvFor.get(collection);
+      const csv = target ? artifact(
+        target.path,
+        csvColumns(collection, options.fields),
+        "csv",
+        collection.source,
+        collection.rows.length,
+        collection.complete
+      ) : null;
+      if (csv) outputs.csv.push(csv);
+      return {
+        source: collection.source,
+        rowCount: collection.rows.length,
+        complete: collection.complete,
+        outcomes: collection.outcomes ?? null,
+        columns: collection.columns?.length ? collection.columns : columnsOf(collection.rows),
+        csv: csv ? csv.path ?? "stdout" : null
+      };
+    });
+    const schemaFile = hasData ? persist(
+      temporary("result.schema.json"),
+      jsonText({
+        $schema: JSON_SCHEMA_DIALECT,
+        ...observedSchema(result.data)
+      })
+    ) : null;
+    const receipt = {
+      status: result.status,
+      id: result.id,
+      name: options.label ?? null,
+      credits: result.credits ?? null,
+      outputs,
+      page: result.page ?? null,
+      price: result.price ?? null,
+      declaredOutputs: (result.declared ?? []).map(({ name, path }) => ({
+        name,
+        path
+      })),
+      schemaFile,
+      logsFile: options.logsFile ?? null,
+      collections: summaries,
+      warnings: result.warnings ?? [],
+      error: result.error ?? null,
+      next: result.next ?? {}
+    };
+    const receiptFile = options.receiptOut ? persist(options.receiptOut, jsonText(receipt)) : null;
+    printReceipt(receipt, options, {
+      receiptFile,
+      data: hasData ? result.data : void 0,
+      ran: result.ran,
+      declared: result.declared
+    });
+    if (stdoutData !== void 0) process.stdout.write(stdoutData);
+  } catch (error) {
+    let recoveryFile = null;
+    try {
+      if (result.data !== void 0) recoveryFile = ensureJson();
+    } catch {
+    }
+    const failure = {
+      status: "output_failed",
+      id: result.id,
+      name: options.label ?? null,
+      credits: result.credits ?? null,
+      outputs: { json: null, csv: [] },
+      page: result.page ?? null,
+      price: result.price ?? null,
+      declaredOutputs: [],
+      schemaFile: null,
+      logsFile: options.logsFile ?? null,
+      collections: [],
+      warnings: [],
+      error: {
+        message: error instanceof Error ? error.message : String(error),
+        recoveryFile
+      },
+      next: result.next ?? {}
+    };
+    printReceipt(failure, options, { receiptFile: null, ran: result.ran });
+    throw new ExecutionOutputError(
+      `Output failed${result.id ? ` for ${result.id}` : ""}: ${error instanceof Error ? error.message : String(error)}. Do not re-execute paid work.`,
+      { cause: error }
+    );
+  }
+}
+var EXAMPLE_CHARACTERS = 40;
+var HEADLINES = {
+  completed: "Completed",
+  failed: "Failed",
+  cancelled: "Cancelled",
+  running: "Still running",
+  queued: "Started",
+  pending: "Started",
+  output_failed: "Ran, but the output could not be written",
+  dry_run: "Dry run, nothing sent"
+};
+var NEXT_NOTES = {
+  billing: "what this call cost",
+  status: "check on the run",
+  export: "save its rows once it finishes",
+  getActorRun: "check the Apify run",
+  getDatasetItems: "read the Apify run\u2019s items"
+};
+function exampleOf(value) {
+  return typeof value === "string" && value.length > EXAMPLE_CHARACTERS ? `${value.slice(0, EXAMPLE_CHARACTERS)}\u2026` : value;
+}
+function annotated(schema, values) {
+  const present = values.filter((value) => value !== void 0);
+  const first = present.find(
+    (value) => value !== null && typeof value !== "object"
+  );
+  const node2 = { ...schema };
+  if (first !== void 0) node2.example = exampleOf(first);
+  if (Array.isArray(schema.anyOf)) {
+    node2.anyOf = schema.anyOf.map(
+      (variant) => annotated(variant, present)
+    );
+  }
+  if (record(schema.properties)) {
+    const rows = present.filter(record);
+    node2.properties = Object.fromEntries(
+      Object.entries(schema.properties).map(([key, child]) => [
+        key,
+        annotated(
+          child,
+          rows.map((row) => row[key])
+        )
+      ])
+    );
+  }
+  if (schema.type === "array" && record(schema.items)) {
+    const lists = present.filter(Array.isArray);
+    node2.items = annotated(schema.items, lists.flat());
+    const lengths = lists.map((list) => list.length);
+    const [low, high] = [Math.min(...lengths), Math.max(...lengths)];
+    const items = high === 1 ? "item" : "items";
+    if (lengths.length === 1) node2.description = `${low} ${items}`;
+    else if (lengths.length > 1) {
+      node2.description = low === high ? `${low} ${items} each` : `${low}-${high} items each`;
+    }
+  }
+  return node2;
+}
+function shapeLines(title, data) {
+  const schema = annotated(observedSchema(data), [data]);
+  const block = (heading, fieldSchema) => {
+    const { lines, folded } = fieldBlockLines(
+      heading,
+      schemaFields(fieldSchema)
+    );
+    return [
+      ...lines,
+      ...folded ? ["Long result: deeper objects show only their field names."] : [],
+      "Types are what this result contained; a field that was only ever null shows as null."
+    ];
+  };
+  if (record(schema.properties)) return block(title, schema);
+  if (schema.type === "array" && record(schema.items) && record(schema.items.properties)) {
+    const count = Array.isArray(data) ? data.length : 0;
+    return block(`${title}
+A list of ${count} items, each:`, schema.items);
+  }
+  const value = Array.isArray(data) ? `a list of ${data.length} values` : data === null ? "null" : `${typeof data}, ${JSON.stringify(exampleOf(data))}`;
+  return [`${title} ${value}`];
+}
+function receiptText(receipt, options, extra) {
+  const headline = HEADLINES[receipt.status] ?? receipt.status;
+  const sections = [
+    [
+      options.label ? `${headline}: ${options.label}` : headline,
+      ...receipt.id ? [`Id: ${receipt.id}`] : [],
+      ...receipt.credits !== null ? [
+        `Cost: ${receipt.credits} ${receipt.credits === 1 ? "credit" : "credits"}`
+      ] : [],
+      ...receipt.price ? [`Price: ${receipt.price}`] : []
+    ]
+  ];
+  const { csv, json } = receipt.outputs;
+  const data = [];
+  for (const artifact of csv) {
+    data.push(
+      `Rows: ${artifact.path ?? "stdout"} (${artifact.rowCount} rows from ${listPath(artifact.source ?? "") || "the result"})`
+    );
+  }
+  if (extra.data !== void 0) {
+    const title = json ? `Result: ${json.path ?? "stdout"}` : "Result (not saved; --json-out saves all of it):";
+    data.push(...resultLines(title, extra.data, extra.declared, options));
+    if (receipt.schemaFile) {
+      data.push(`Full JSON Schema: ${receipt.schemaFile}`);
+    }
+  }
+  if (receipt.logsFile) data.push(`Logs: ${receipt.logsFile}`);
+  if (receipt.page) data.push(`Page: ${receipt.page}`);
+  if (data.length) sections.push(data);
+  const problems = [];
+  if (receipt.warnings.length) {
+    problems.push(
+      "Warnings:",
+      ...receipt.warnings.map((warning) => `  - ${warning}`)
+    );
+  }
+  if (receipt.error) {
+    const error = receipt.error;
+    problems.push(
+      `Error: ${record(error) && typeof error.message === "string" ? error.message : JSON.stringify(error)}`
+    );
+    if (record(error) && typeof error.recoveryFile === "string") {
+      problems.push(
+        `The data was saved to ${error.recoveryFile}; do not run again.`
+      );
+    }
+  }
+  if (extra.ran === false) problems.push("Nothing ran.");
+  if (problems.length) sections.push(problems);
+  const next = Object.entries(receipt.next);
+  if (next.length) {
+    const width = Math.max(...next.map(([, command]) => command.length));
+    sections.push([
+      "Next:",
+      ...next.map(
+        ([key, command]) => NEXT_NOTES[key] ? `  ${command.padEnd(width)}   # ${NEXT_NOTES[key]}` : `  ${command}`
+      )
+    ]);
+  }
+  if (extra.receiptFile) {
+    sections.push([`JSON receipt: ${extra.receiptFile}`]);
+  }
+  return `${sections.map((lines) => lines.join("\n")).join("\n\n")}
+`;
+}
+function columnsOf(rows) {
+  const columns = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (record(row)) for (const key of Object.keys(row)) columns.add(key);
+  }
+  return [...columns];
+}
+function resultLines(title, data, declared, options) {
+  if (options.full) {
+    const sources = (declared ?? []).flatMap(
+      ({ name, path }) => path ? [`${name} at ${path}`] : []
+    );
+    return [
+      ...shapeLines(title, data),
+      ...sources.length ? [`Declared outputs: ${sources.join(", ")}`] : []
+    ];
+  }
+  const budget = options.lines ?? OUTLINE_LINES;
+  const indented = (lines) => lines.map((line) => `  ${line}`);
+  const more = "Not everything is shown: --lines <n> shows more, --fields <paths> picks fields, --full shows every field's type.";
+  if (options.fields?.length) {
+    const { value, missing } = pickFields(data, options.fields);
+    const outline2 = value === void 0 ? null : outlineLines(value, budget);
+    return [
+      `${title}${outline2?.note ? ` ${outline2.note}` : ""}`,
+      ...indented(outline2?.lines ?? []),
+      ...missing.map((path) => `No field at ${path}.`),
+      ...outline2?.cut ? [more] : []
+    ];
+  }
+  if (declared?.length) {
+    const outline2 = outlineLines(
+      Object.fromEntries(declared.map(({ name, value }) => [name, value])),
+      budget
+    );
+    return [
+      title,
+      "Outputs, as the tool declares them:",
+      ...indented(outline2.lines),
+      outline2.cut ? more : "--full shows every field of the result; --fields <paths> picks fields."
+    ];
+  }
+  const outline = outlineLines(data, budget);
+  return [
+    `${title}${outline.note ? ` ${outline.note}` : ""}`,
+    ...indented(outline.lines),
+    ...outline.cut ? [more] : []
+  ];
+}
+function printReceipt(receipt, options, extra) {
+  const text = options.receiptJson ? `${JSON.stringify(receipt, null, 2)}
+` : receiptText(receipt, options, extra);
+  (dataOnStdout(options) ? process.stderr : process.stdout).write(text);
+}
+function openLogDestination(output) {
+  if (output.logsOut === "-") {
+    return (line) => process.stdout.write(`${line}
+`);
+  }
+  const path = resolve2(
+    output.logsOut ?? join(mkdtempSync(join(tmpdir(), "deepline-logs-")), "logs.txt")
+  );
+  writeFileSync3(path, "", { flag: "wx", mode: 384 });
+  output.logsFile = path;
+  process.stderr.write(`Live logs: ${path}
+`);
+  return (line) => appendFileSync(path, `${line}
+`);
+}
+
+export {
+  addDescribeOptions,
+  recordApiResponse,
+  recordPlayTermination,
+  TABLE_EXPORT_ERROR_COLUMN,
+  tableExportHasFailedRows,
+  tableExportErrorCell,
+  underscoreKeysLast,
+  orderRunExportJson,
+  writeRunDatasetCsv,
+  preflightExecutionOutput,
+  outputCollections,
+  writeExecutionOutput,
+  openLogDestination
+};