deepline 0.1.146 → 0.1.148

package/dist/index.js

@@ -418,10 +418,11 @@ var SDK_RELEASE = {
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
-  version: "0.1.146",
-  apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
+  // 0.1.111 ships dataset-native tool list getters and result row datasets.
+  version: "0.1.148",
+  apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.146",
+    latest: "0.1.148",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -432,52 +433,79 @@ var SDK_RELEASE = {
       },
       {
         command: "plays",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Play file commands now use dataset-native list getters and result row datasets."
       },
       {
         command: "plays run",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Play run results now promote row-shaped outputs into dataset handles for safe export."
       },
       {
         command: "run",
         displayCommand: "plays run",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Play run results now promote row-shaped outputs into dataset handles for safe export."
       },
       {
         command: "plays check",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Play file checks now validate dataset-native list getter authoring."
       },
       {
         command: "check",
         displayCommand: "plays check",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Play file checks now validate dataset-native list getter authoring."
       },
       {
         command: "plays publish",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Published play artifacts now target dataset-native list getters and result row datasets."
       },
       {
         command: "publish",
         displayCommand: "plays publish",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Published play artifacts now target dataset-native list getters and result row datasets."
       },
       {
         command: "plays set-live",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Published play artifacts now target dataset-native list getters and result row datasets."
       },
       {
         command: "set-live",
         displayCommand: "plays set-live",
-        minimumSupported: "0.1.110",
-        reason: "Play file commands now require top-level definePlay descriptions so agents and play surfaces can explain local plays."
+        minimumSupported: "0.1.111",
+        reason: "Published play artifacts now target dataset-native list getters and result row datasets."
+      },
+      {
+        command: "runs",
+        minimumSupported: "0.1.111",
+        reason: "Run result rows now render as dataset handles with explicit export commands."
+      },
+      {
+        command: "runs get",
+        minimumSupported: "0.1.111",
+        reason: "Run result rows now render as dataset handles with explicit export commands."
+      },
+      {
+        command: "get",
+        displayCommand: "runs get",
+        minimumSupported: "0.1.111",
+        reason: "Run result rows now render as dataset handles with explicit export commands."
+      },
+      {
+        command: "runs export",
+        minimumSupported: "0.1.111",
+        reason: "Run result row datasets now use the dataset-handle export contract."
+      },
+      {
+        command: "export",
+        displayCommand: "runs export",
+        minimumSupported: "0.1.111",
+        reason: "Run result row datasets now use the dataset-handle export contract."
       }
     ],
     autoUpdatePatchLag: 2
@@ -3973,6 +4001,420 @@ function isDeeplineExtractorTarget(value) {
   return value in DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS;
 }
 
+// ../shared_libs/plays/dataset.ts
+var PLAY_DATASET_BRAND = /* @__PURE__ */ Symbol.for("deepline.play.dataset");
+var NODE_INSPECT_CUSTOM = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var DEFAULT_MATERIALIZE_LIMIT = 1e4;
+function resolveMaterializeLimitCap() {
+  const raw = process.env.DEEPLINE_PLAY_DATASET_MATERIALIZE_LIMIT;
+  const parsed = raw ? Number(raw) : NaN;
+  if (Number.isFinite(parsed) && parsed > 0) {
+    return Math.floor(parsed);
+  }
+  return DEFAULT_MATERIALIZE_LIMIT;
+}
+function inferPreviewColumns(rows) {
+  const columns = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+      continue;
+    }
+    for (const key of Object.keys(row)) {
+      columns.add(key);
+    }
+  }
+  return columns.size > 0 ? [...columns] : void 0;
+}
+var DeferredPlayDataset = class {
+  [PLAY_DATASET_BRAND] = true;
+  datasetKind;
+  datasetId;
+  backing;
+  sourceLabel;
+  tableNamespace;
+  previewRows;
+  previewColumns;
+  workProgress;
+  cachedCount;
+  resolvers;
+  constructor(input) {
+    this.datasetKind = input.datasetKind;
+    this.datasetId = input.datasetId;
+    this.cachedCount = input.count;
+    this.backing = input.backing;
+    this.previewRows = input.previewRows;
+    this.previewColumns = inferPreviewColumns(this.previewRows);
+    this.sourceLabel = input.sourceLabel ?? null;
+    this.tableNamespace = input.tableNamespace ?? null;
+    this.workProgress = input.workProgress;
+    this.resolvers = input.resolvers;
+  }
+  async count() {
+    this.cachedCount = await this.resolvers.count();
+    return this.cachedCount;
+  }
+  async peek(limit = 10) {
+    if (limit <= this.previewRows.length) {
+      return this.previewRows.slice(0, Math.max(0, limit));
+    }
+    return await this.resolvers.peek(limit);
+  }
+  map(mapper, options) {
+    return createTransformedPlayDataset(this, { kind: "map", mapper }, options);
+  }
+  filter(predicate, options) {
+    return createTransformedPlayDataset(
+      this,
+      { kind: "filter", predicate },
+      options
+    );
+  }
+  slice(start, end, options) {
+    return createTransformedPlayDataset(
+      this,
+      { kind: "slice", start, end },
+      options
+    );
+  }
+  take(limit, options) {
+    return this.slice(0, limit, options);
+  }
+  async materialize(limit) {
+    const requestedLimit = limit !== void 0 ? Math.max(0, Math.floor(limit)) : void 0;
+    const cap = resolveMaterializeLimitCap();
+    if (requestedLimit !== void 0) {
+      if (requestedLimit > cap) {
+        throw new Error(
+          `PlayDataset.materialize(${requestedLimit}) exceeds the hard limit of ${cap} rows. Return the dataset handle instead, or request a smaller bounded slice.`
+        );
+      }
+      return await this.resolvers.materialize(requestedLimit);
+    }
+    const count = await this.count();
+    if (count > cap) {
+      throw new Error(
+        `PlayDataset.materialize() refuses to load ${count} rows into memory. The hard limit is ${cap}. Return the dataset handle instead or call materialize(limit).`
+      );
+    }
+    return await this.resolvers.materialize();
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const row of this.resolvers.iterate()) {
+      yield row;
+    }
+  }
+  toJSON() {
+    return {
+      kind: "dataset",
+      datasetKind: this.datasetKind,
+      datasetId: this.datasetId,
+      count: this.cachedCount,
+      ...this.backing ? { backing: this.backing } : {},
+      ...this.sourceLabel ? { sourceLabel: this.sourceLabel } : {},
+      ...this.tableNamespace ? { tableNamespace: this.tableNamespace } : {},
+      ...this.previewColumns ? { columns: this.previewColumns } : {},
+      ...this.workProgress ? { _metadata: { workProgress: this.workProgress } } : {},
+      preview: [...this.previewRows]
+    };
+  }
+  [NODE_INSPECT_CUSTOM]() {
+    return this.toJSON();
+  }
+};
+function normalizeSliceBounds(input) {
+  const count = Math.max(0, Math.floor(input.count));
+  const rawStart = input.start ?? 0;
+  const rawEnd = input.end ?? count;
+  const startInteger = Number.isFinite(rawStart) ? Math.trunc(rawStart) : 0;
+  const endInteger = Number.isFinite(rawEnd) ? Math.trunc(rawEnd) : count;
+  const start = startInteger < 0 ? Math.max(count + startInteger, 0) : Math.min(startInteger, count);
+  const end = endInteger < 0 ? Math.max(count + endInteger, 0) : Math.min(endInteger, count);
+  return { start, end: Math.max(start, end) };
+}
+function transformDatasetId(input) {
+  const key = input.key?.trim();
+  return key ? `${input.source.datasetId}:${input.kind}:${key}` : `${input.source.datasetId}:${input.kind}`;
+}
+function createTransformedPlayDataset(source, transform, options) {
+  const sourceLabel = options?.sourceLabel ?? `${source.sourceLabel ?? source.tableNamespace ?? source.datasetId}.${transform.kind}`;
+  const iterate = async function* () {
+    if (transform.kind === "slice") {
+      const bounds = normalizeSliceBounds({
+        start: transform.start,
+        end: transform.end,
+        count: await source.count()
+      });
+      let index = 0;
+      for await (const row of source) {
+        if (index >= bounds.end) break;
+        if (index >= bounds.start) {
+          yield row;
+        }
+        index += 1;
+      }
+      return;
+    }
+    let inputIndex = 0;
+    let outputIndex = 0;
+    for await (const row of source) {
+      if (transform.kind === "filter") {
+        if (await transform.predicate(row, inputIndex)) {
+          yield row;
+          outputIndex += 1;
+        }
+      } else {
+        yield await transform.mapper(row, outputIndex);
+        outputIndex += 1;
+      }
+      inputIndex += 1;
+    }
+  };
+  const collect = async (limit) => {
+    const rows = [];
+    const boundedLimit = limit === void 0 ? void 0 : Math.max(0, Math.floor(limit));
+    if (boundedLimit === 0) return rows;
+    for await (const row of iterate()) {
+      rows.push(row);
+      if (boundedLimit !== void 0 && rows.length >= boundedLimit) break;
+    }
+    return rows;
+  };
+  const count = async () => {
+    if (transform.kind === "map") return await source.count();
+    if (transform.kind === "slice") {
+      const bounds = normalizeSliceBounds({
+        start: transform.start,
+        end: transform.end,
+        count: await source.count()
+      });
+      return Math.max(0, bounds.end - bounds.start);
+    }
+    let total = 0;
+    for await (const _row of iterate()) {
+      void _row;
+      total += 1;
+    }
+    return total;
+  };
+  return createDeferredPlayDataset({
+    datasetKind: source.datasetKind,
+    datasetId: transformDatasetId({
+      source,
+      kind: transform.kind,
+      key: options?.key
+    }),
+    count: 0,
+    backing: source.backing,
+    sourceLabel,
+    tableNamespace: options?.key ?? null,
+    resolvers: {
+      count,
+      peek: async (limit) => collect(limit),
+      materialize: async (limit) => collect(limit),
+      iterate: () => ({
+        async *[Symbol.asyncIterator]() {
+          yield* iterate();
+        }
+      })
+    }
+  });
+}
+function createDeferredPlayDataset(input) {
+  return new DeferredPlayDataset({
+    ...input,
+    previewRows: input.previewRows ?? []
+  });
+}
+function createPlayDataset(rows, metadata) {
+  const materializedRows = [...rows];
+  return createDeferredPlayDataset({
+    datasetKind: metadata?.kind ?? "map",
+    datasetId: metadata?.datasetId ?? `${metadata?.kind ?? "map"}:${metadata?.tableNamespace ?? metadata?.sourceLabel ?? "inline"}`,
+    count: materializedRows.length,
+    previewRows: materializedRows.slice(0, 5),
+    sourceLabel: metadata?.sourceLabel ?? null,
+    tableNamespace: metadata?.tableNamespace ?? null,
+    resolvers: {
+      count: async () => materializedRows.length,
+      peek: async (limit) => materializedRows.slice(0, Math.max(0, limit)),
+      materialize: async (limit) => limit === void 0 ? [...materializedRows] : materializedRows.slice(0, Math.max(0, limit)),
+      iterate: () => ({
+        async *[Symbol.asyncIterator]() {
+          for (const row of materializedRows) {
+            yield row;
+          }
+        }
+      })
+    }
+  });
+}
+
+// ../shared_libs/plays/row-identity.ts
+var POSTGRES_IDENTIFIER_MAX_LENGTH = 63;
+var MAP_KEY_NAMESPACE_MAX_LENGTH = POSTGRES_IDENTIFIER_MAX_LENGTH;
+var SHA256_INITIAL_HASH = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+var SHA256_ROUND_CONSTANTS = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function rightRotate32(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function sha256Hex(input) {
+  const bytes = Array.from(new TextEncoder().encode(input));
+  const bitLength = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+  const highBits = Math.floor(bitLength / 4294967296);
+  const lowBits = bitLength >>> 0;
+  bytes.push(
+    highBits >>> 24 & 255,
+    highBits >>> 16 & 255,
+    highBits >>> 8 & 255,
+    highBits & 255,
+    lowBits >>> 24 & 255,
+    lowBits >>> 16 & 255,
+    lowBits >>> 8 & 255,
+    lowBits & 255
+  );
+  const hash = [...SHA256_INITIAL_HASH];
+  const words = new Array(64).fill(0);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const wordOffset = offset + index * 4;
+      words[index] = (bytes[wordOffset] ?? 0) << 24 | (bytes[wordOffset + 1] ?? 0) << 16 | (bytes[wordOffset + 2] ?? 0) << 8 | (bytes[wordOffset + 3] ?? 0);
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rightRotate32(words[index - 15], 7) ^ rightRotate32(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rightRotate32(words[index - 2], 17) ^ rightRotate32(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rightRotate32(e, 6) ^ rightRotate32(e, 11) ^ rightRotate32(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + SHA256_ROUND_CONSTANTS[index] + words[index] >>> 0;
+      const s0 = rightRotate32(a, 2) ^ rightRotate32(a, 13) ^ rightRotate32(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    hash[0] = hash[0] + a >>> 0;
+    hash[1] = hash[1] + b >>> 0;
+    hash[2] = hash[2] + c >>> 0;
+    hash[3] = hash[3] + d >>> 0;
+    hash[4] = hash[4] + e >>> 0;
+    hash[5] = hash[5] + f >>> 0;
+    hash[6] = hash[6] + g >>> 0;
+    hash[7] = hash[7] + h >>> 0;
+  }
+  return hash.map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function sanitizeIdentifierPart(value) {
+  return value.trim().replace(/[^a-z0-9]+/gi, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function validateIdentifierPart(rawValue, label, maxLength) {
+  const sanitized = sanitizeIdentifierPart(rawValue);
+  if (!sanitized) {
+    throw new Error(
+      `${label} must contain at least one letter or number after normalization. Use only letters, numbers, underscores, or hyphens.`
+    );
+  }
+  if (sanitized.length > maxLength) {
+    throw new Error(
+      `${label} is too long after normalization (${sanitized.length}/${maxLength}). Shorten it to ${maxLength} characters or fewer. Normalized value: "${sanitized}".`
+    );
+  }
+  return sanitized;
+}
+function normalizeTableNamespace(value) {
+  return validateIdentifierPart(
+    value,
+    "ctx.dataset() key",
+    MAP_KEY_NAMESPACE_MAX_LENGTH
+  );
+}
+
 // ../shared_libs/play-runtime/tool-result.ts
 var TARGET_FALLBACK_KEYS = {
   email: [/^email$/i, /^address$/i, /email/i],
@@ -4320,17 +4762,31 @@ function resolveListRows(result, listExtractorPaths) {
     );
     let resolvedPath = null;
     let rows = null;
+    let emptyMatch = null;
     for (const candidate of candidates) {
       rows = normalizeRows(getAtPath(result, candidate));
-      if (rows) {
+      if (!rows) {
+        continue;
+      }
+      if (rows.length > 0) {
         resolvedPath = candidate;
         break;
       }
+      emptyMatch ??= { path: candidate, rows };
+    }
+    if (!rows && emptyMatch) {
+      resolvedPath = emptyMatch.path;
+      rows = emptyMatch.rows;
     }
     if (!rows) continue;
     const storedPath = resolvedPath ?? path;
     const name = storedPath.split(".").filter(Boolean).at(-1)?.replace(/\[\d+\]$/, "");
-    lists[name || storedPath] = { path: storedPath, rows };
+    const listName = name || storedPath;
+    const existing = lists[listName];
+    if (existing?.rows.length && rows.length === 0) {
+      continue;
+    }
+    lists[listName] = { path: storedPath, rows };
   }
   return lists;
 }
@@ -4478,10 +4934,24 @@ function buildExtractedAccessors(targets) {
     })
   );
 }
-function buildListAccessors(resolved, lists) {
+function buildListAccessors(resolved, lists, toolId, executionDiscriminator) {
   return Object.fromEntries(
     Object.entries(lists).map(([name, metadata]) => {
       const rows = resolved[name]?.rows ?? [];
+      const datasetDiscriminator = `${executionDiscriminator}:${listRowsFingerprint(rows)}`;
+      const dataset = createPlayDataset(rows, {
+        kind: "csv",
+        sourceLabel: metadata.path,
+        tableNamespace: listTableNamespace(
+          toolId,
+          name,
+          metadata.path,
+          datasetDiscriminator
+        ),
+        datasetId: `tool-list:${sha256Hex(
+          `${toolId}:${metadata.path}:${datasetDiscriminator}`
+        )}`
+      });
       const accessor = {
         path: metadata.path,
         count: metadata.count,
@@ -4489,7 +4959,7 @@ function buildListAccessors(resolved, lists) {
       };
       Object.defineProperty(accessor, "get", {
         value() {
-          return rows;
+          return dataset;
         },
         enumerable: false
       });
@@ -4497,6 +4967,37 @@ function buildListAccessors(resolved, lists) {
     })
   );
 }
+function listRowsFingerprint(rows) {
+  try {
+    return sha256Hex(
+      JSON.stringify(
+        {
+          count: rows.length,
+          rows
+        },
+        (_key, value) => typeof value === "bigint" ? value.toString() : value
+      )
+    ).slice(0, 12);
+  } catch {
+    return sha256Hex(String(rows.length)).slice(0, 12);
+  }
+}
+function listTableNamespace(toolId, name, path, discriminator) {
+  const raw = `${toolId}_${name || path || "rows"}_${sha256Hex(discriminator).slice(0, 10)}`;
+  try {
+    return normalizeTableNamespace(raw);
+  } catch {
+    const hash = sha256Hex(raw).slice(0, 10);
+    const leaf = name || path.split(".").filter(Boolean).at(-1) || "rows";
+    let prefix = "rows";
+    try {
+      prefix = normalizeTableNamespace(leaf).slice(0, 52) || "rows";
+    } catch {
+      prefix = "rows";
+    }
+    return normalizeTableNamespace(`${prefix}_${hash}`);
+  }
+}
 function createToolExecuteResult(input) {
   const result = toResultEnvelope(input.result);
   const resultRoot = {
@@ -4527,7 +5028,12 @@ function createToolExecuteResult(input) {
     ...result.meta ? { meta: result.meta } : {}
   };
   const extractedValues = buildExtractedAccessors(targets);
-  const extractedLists = buildListAccessors(resolvedLists, lists);
+  const extractedLists = buildListAccessors(
+    resolvedLists,
+    lists,
+    input.metadata.toolId,
+    input.jobId ?? input.execution.cacheKey ?? "inline"
+  );
   const wrapper = {
     status: input.status,
     ...input.jobId ? { job_id: input.jobId } : {},
@@ -5138,16 +5644,24 @@ function tryConvertToList(payload, options) {
     (entry) => typeof entry === "string" && entry.trim().length > 0
   ) : [];
   if (listExtractorPaths.length > 0) {
+    let emptyMatch = null;
     for (const root of candidateRoots(payload)) {
       for (const extractorPath of listExtractorPaths) {
         const resolved = getByDottedPath(root.value, extractorPath);
         const rows = normalizeRows2(resolved);
-        if (rows && rows.length > 0) {
-          const sourcePath = root.path ? `${root.path}.${extractorPath}` : extractorPath;
+        if (!rows) {
+          continue;
+        }
+        const sourcePath = root.path ? `${root.path}.${extractorPath}` : extractorPath;
+        if (rows.length > 0) {
           return { rows, strategy: "configured_paths", sourcePath };
         }
+        emptyMatch ??= { rows, strategy: "configured_paths", sourcePath };
       }
     }
+    if (emptyMatch) {
+      return emptyMatch;
+    }
   }
   for (const root of candidateRoots(payload)) {
     const candidate = findBestArrayCandidate(root.value, root.path ?? "");
@@ -5171,9 +5685,9 @@ function writeJsonOutputFile(payload, stem) {
   (0, import_node_fs3.writeFileSync)(outputPath, JSON.stringify(payload, null, 2), "utf-8");
   return outputPath;
 }
-function writeCsvOutputFile(rows, stem) {
-  const outputDir = ensureOutputDir();
-  const outputPath = (0, import_node_path3.join)(outputDir, `${stem}_${Date.now()}.csv`);
+function writeCsvOutputFile(rows, stem, options) {
+  const outputPath = options?.outPath ? options.outPath : (0, import_node_path3.join)(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(outputPath), { recursive: true });
   const seen = /* @__PURE__ */ new Set();
   const columns = [];
   for (const row of rows) {