deepline 0.1.161 → 0.1.163

package/dist/bundling-sources/shared_libs/play-runtime/runtime-api.ts

@@ -64,11 +64,13 @@ import {
 import { RECEIPT_STATUS_CODE, receiptStatusFromCode } from './receipt-status';
 import type { MapRowOutcome } from './durability-store';
 import {
+  normalizeRuntimeMapInputIndex,
   prepareRuntimeSheetRowTransitions,
   type RuntimePreparedCompletedRow,
   type RuntimePreparedFailedRow,
 } from './runtime-sheet-row-transition';
 import {
+  MAP_ROW_OUTCOME_RUNTIME_FIELDS,
   mapRowOutcomeRuntimeFields,
   resolveMapRowOutcomeKey,
 } from './map-row-outcome';
@@ -2251,6 +2253,21 @@ async function prepareRuntimeSheetDatasetRows(
             AND (${targetMissingOutputSql})
           RETURNING target._key
         ),
+        claimed_existing_rows AS (
+          UPDATE ${sheetTable(session)} AS target
+          SET _run_id = $4::text,
+              _input_index = input_rows._input_index,
+              _updated_at = now(),
+              _version = ${nextRuntimeSheetVersionExpression(session)}
+          FROM input_rows
+          WHERE target._key = input_rows._key
+            AND target._status IN ('pending', 'running', 'failed')
+            AND (
+              target._run_id IS DISTINCT FROM $4::text
+              OR target._input_index IS DISTINCT FROM input_rows._input_index
+            )
+          RETURNING target._key
+        ),
         pending_rows AS (
           SELECT _key
           FROM inserted_rows
@@ -2258,6 +2275,9 @@ async function prepareRuntimeSheetDatasetRows(
           SELECT _key
           FROM missing_output_rows
           UNION
+          SELECT _key
+          FROM claimed_existing_rows
+          UNION
           SELECT existing._key
           FROM ${sheetTable(session)} AS existing
           JOIN input_rows ON input_rows._key = existing._key
@@ -3206,7 +3226,10 @@ export async function startRuntimeSheetDataset(
     rows: input.rows.length,
   });
   const normalizeStartedAt = Date.now();
-  const uniqueRows = new Map<string, Record<string, unknown>>();
+  const uniqueRows = new Map<
+    string,
+    { row: Record<string, unknown>; inputIndex: number | null }
+  >();
   for (const row of input.rows) {
     // Materializes projected CSV aliases as visible cells and drops internal
     // __deepline* keys — a plain spread would silently lose the
@@ -3216,15 +3239,20 @@ export async function startRuntimeSheetDataset(
       resolveMapRowOutcomeKey(row) ??
       derivePlayRowIdentity(cleanedRow, input.tableNamespace);
     if (key && !uniqueRows.has(key)) {
-      uniqueRows.set(key, cleanedRow);
+      uniqueRows.set(key, {
+        row: cleanedRow,
+        inputIndex: normalizeRuntimeMapInputIndex(
+          row[MAP_ROW_OUTCOME_RUNTIME_FIELDS.inputIndex],
+        ),
+      });
     }
   }
   const inputOffset = Math.max(0, Math.floor(input.inputOffset ?? 0));
   const rowEntries = [...uniqueRows.entries()].map(
-    ([key, row], inputIndex) => ({
+    ([key, entry], inputIndex) => ({
       key,
-      row,
-      inputIndex: inputOffset + inputIndex,
+      row: entry.row,
+      inputIndex: entry.inputIndex ?? inputOffset + inputIndex,
     }),
   );
   timings.push({
@@ -3409,6 +3437,7 @@ async function completeRuntimeMapRowChunks(
            AND (target._run_id IS NULL OR target._run_id <= $5::text)
            AND (
              target._status <> 'enriched'
+             OR target._run_id IS DISTINCT FROM $5::text
              OR (${targetChangedPatchedCellSql})
              OR EXISTS (
                SELECT 1
@@ -3608,6 +3637,7 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
            AND (target._run_id IS NULL OR target._run_id <= $5::text)
            AND (
              target._status <> 'enriched'
+             OR target._run_id IS DISTINCT FROM $5::text
              OR (${targetChangedPatchedCellSql})
              OR EXISTS (
                SELECT 1
@@ -3722,6 +3752,148 @@ async function completeRuntimeMapRowChunksWithInputIndexRepair(
   return { updated };
 }
 
+async function insertMissingCompletedMapRowChunks(
+  client: RuntimeQueryClient,
+  session: RuntimePostgresSession,
+  input: CompleteRuntimeMapRowChunksInput,
+): Promise<{ inserted: number }> {
+  let inserted = 0;
+  const physicalInsertColumnsSql =
+    input.physicalColumnProjections.length > 0
+      ? `, ${input.physicalColumnProjections
+          .map((column) => quoteIdentifier(column.sqlName))
+          .join(', ')}`
+      : '';
+  const physicalInsertValuesSql =
+    input.physicalColumnProjections.length > 0
+      ? `, ${input.physicalColumnProjections
+          .map(
+            (column) =>
+              `missing_rows.data_patch -> ${quoteLiteral(column.fieldName)}`,
+          )
+          .join(', ')}`
+      : '';
+
+  for (const chunk of input.chunks) {
+    const chunkKeys = chunk.map((row) => row.key);
+    const chunkInputIndexes = chunk.map((row) => row.input_index);
+    const chunkDataPatches = chunk.map((row) =>
+      stringifyPostgresJson(row.data_patch),
+    );
+    const chunkCellMetaPatches = chunk.map((row) =>
+      stringifyPostgresJson(row.cell_meta_patch),
+    );
+    const { rows } = await client.query<{ inserted: number }>(
+      `WITH input_rows AS (
+         SELECT key_values._key,
+                input_index_values.input_index,
+                data_values.data_patch,
+                cell_meta_values.cell_meta_patch
+         FROM unnest($1::text[]) WITH ORDINALITY AS key_values(_key, ord)
+         JOIN unnest($2::bigint[]) WITH ORDINALITY AS input_index_values(input_index, ord)
+           ON input_index_values.ord = key_values.ord
+         JOIN unnest($3::jsonb[]) WITH ORDINALITY AS data_values(data_patch, ord)
+           ON data_values.ord = key_values.ord
+         JOIN unnest($4::jsonb[]) WITH ORDINALITY AS cell_meta_values(cell_meta_patch, ord)
+           ON cell_meta_values.ord = key_values.ord
+       ),
+       missing_rows AS (
+         SELECT input_rows.*
+           FROM input_rows
+          WHERE NOT EXISTS (
+            SELECT 1
+              FROM ${sheetTable(session)} AS target
+             WHERE target._key = input_rows._key
+                OR (
+                  input_rows.input_index IS NOT NULL
+                  AND target._run_id = $5::text
+                  AND target._input_index = input_rows.input_index
+                )
+          )
+       ),
+       inserted_rows AS (
+         INSERT INTO ${sheetTable(session)} (_key, _status, _run_id, _input_index, _cell_meta${physicalInsertColumnsSql})
+         SELECT _key, 'enriched', $5::text, input_index, cell_meta_patch${physicalInsertValuesSql}
+           FROM missing_rows
+         ON CONFLICT (_key) DO NOTHING
+         RETURNING _key
+       ),
+       inserted_count AS (
+         SELECT count(*)::bigint AS c FROM inserted_rows
+       ),
+       summary_delta AS (
+         INSERT INTO ${summaryTable(session)} AS target (
+           play_name,
+           table_namespace,
+           total,
+           queued,
+           running,
+           completed,
+           failed
+         )
+         SELECT $6::text,
+                $7::text,
+                c::int,
+                0,
+                0,
+                c::int,
+                0
+           FROM inserted_count
+          WHERE c > 0
+         ON CONFLICT (play_name, table_namespace) DO UPDATE SET
+           total = ${runtimeSummaryTotalSql({
+             currentTotal: 'target.total',
+             totalDelta: 'EXCLUDED.total',
+             queued: 'target.queued',
+             running: 'target.running',
+             completed: 'target.completed + EXCLUDED.completed',
+             failed: 'target.failed',
+           })},
+           completed = target.completed + EXCLUDED.completed,
+           _updated_at = now()
+         RETURNING 1
+       ),
+       completed_cell_delta AS (
+         SELECT field_values.field, (SELECT c FROM inserted_count) AS c
+           FROM unnest($8::text[]) AS field_values(field)
+          WHERE (SELECT c FROM inserted_count) > 0
+       ),
+       column_delta AS (
+         INSERT INTO ${columnSummaryTable(session)} AS target (
+           play_name,
+           table_namespace,
+           field,
+           completed,
+           failed
+         )
+         SELECT $6::text,
+                $7::text,
+                field,
+                c::int,
+                0
+           FROM completed_cell_delta
+         ON CONFLICT (play_name, table_namespace, field) DO UPDATE SET
+           completed = target.completed + EXCLUDED.completed,
+           _updated_at = now()
+         RETURNING 1
+       )
+       SELECT c::int AS inserted FROM inserted_count`,
+      [
+        chunkKeys,
+        chunkInputIndexes,
+        chunkDataPatches,
+        chunkCellMetaPatches,
+        input.runId,
+        input.normalizedPlayName,
+        input.normalizedTableNamespace,
+        [...new Set(input.outputFields)],
+      ],
+    );
+    inserted += Number(rows[0]?.inserted ?? 0);
+  }
+  return { inserted };
+}
+
 /**
  * Mark map rows FAILED in the per-run scoped Postgres sheet table by key.
  *
@@ -4003,17 +4175,30 @@ export async function completeRuntimeMapRows(
     async (client) => {
       const completed =
         completedRows.length > 0
-          ? await completeRuntimeMapRowChunks(client, session, {
-              chunks,
-              physicalUpdateSetSql,
-              physicalColumnProjections: projections,
-              runId: input.runId,
-              normalizedPlayName: normalizePlayNameForSheet(session.playName),
-              normalizedTableNamespace: normalizeTableNamespace(
-                input.tableNamespace,
-              ),
-              outputFields,
-            })
+          ? await (async () => {
+              const chunkInput = {
+                chunks,
+                physicalUpdateSetSql,
+                physicalColumnProjections: projections,
+                runId: input.runId,
+                normalizedPlayName: normalizePlayNameForSheet(session.playName),
+                normalizedTableNamespace: normalizeTableNamespace(
+                  input.tableNamespace,
+                ),
+                outputFields,
+              };
+              const updated = await completeRuntimeMapRowChunks(
+                client,
+                session,
+                chunkInput,
+              );
+              const inserted = await insertMissingCompletedMapRowChunks(
+                client,
+                session,
+                chunkInput,
+              );
+              return { updated: updated.updated + inserted.inserted };
+            })()
           : { updated: 0 };
       const failed =
         failedRows.length > 0
@@ -4075,6 +4260,65 @@ export async function readRuntimeSheetDatasetRows(
   };
 }
 
+export async function readRuntimeSheetDatasetRowKeys(
+  context: RuntimeApiContext & { playName: string },
+  input: {
+    tableNamespace: string;
+    runId: string;
+    keys: string[];
+    rowMode?: 'output' | 'all';
+  },
+): Promise<{ keys: string[] }> {
+  const keys = [
+    ...new Set(
+      input.keys
+        .map((key) => key.trim())
+        .filter((key) => key.length > 0),
+    ),
+  ];
+  if (keys.length === 0) {
+    return { keys: [] };
+  }
+  const session = requireRuntimePostgresSession(
+    await getRuntimeDbSession(
+      {
+        ...context,
+        playName: context.playName,
+        runId: context.runId ?? input.runId,
+      },
+      {
+        tableNamespace: input.tableNamespace,
+        logicalTable: 'sheet_rows',
+        operations: ['rows.read'],
+        limits: { maxRows: runtimeDbSessionRowLimit(keys.length) },
+      },
+    ),
+  );
+  const rows = await withRuntimePostgres(session, async (client) => {
+    if (input.rowMode === 'all') {
+      const { rows: matchedRows } = await client.query<{ _key: string }>(
+        `SELECT _key
+           FROM ${sheetTable(session)}
+          WHERE _run_id = $1::text
+            AND _key = ANY($2::text[])
+            AND _status IN ('enriched', 'failed')`,
+        [input.runId, keys],
+      );
+      return matchedRows;
+    }
+    const { rows: matchedRows } = await client.query<{ _key: string }>(
+      `SELECT _key
+         FROM ${sheetTable(session)}
+        WHERE _run_id = $1::text
+          AND _key = ANY($2::text[])
+          AND _status = 'enriched'`,
+      [input.runId, keys],
+    );
+    return matchedRows;
+  });
+  return { keys: rows.map((row) => row._key) };
+}
+
 export async function persistRuntimeCsvDataset(
   context: RuntimeApiContext & { playName: string },
   input: {

package/dist/bundling-sources/shared_libs/plays/static-pipeline.ts

@@ -12,6 +12,14 @@ export { sqlSafePlayColumnName };
 export interface PlayStaticReturnField {
   name: string;
   isDataset: boolean;
+  /**
+   * For a dataset-valued field, the `ctx.dataset(KEY, ...)` key backing it
+   * (e.g. `job_change_checks`) — so the UI can label the return by the dataset
+   * it actually produces instead of the bland object key (`rows`). Undefined
+   * for non-dataset fields, `ctx.csv(...)` (no durable name), or when the key
+   * isn't a static string literal.
+   */
+  datasetName?: string;
 }
 
 export interface PlayStaticPipeline {
@@ -333,6 +341,19 @@ type PlayStaticSubstepMetadata = {
   dependsOnFields?: string[];
 };
 
+/**
+ * One arm of a conditional `control_flow` substep — an `if`/`else if`/`else`
+ * leg, a `switch` case, or a ternary branch. Carries its own steps so the graph
+ * can render the conditional as a real fork instead of a flat strip.
+ */
+export type PlayStaticControlFlowBranch = {
+  /** Short arm label, e.g. `if`, `else if`, `else`, `case 'x'`, `default`. */
+  label: string;
+  /** The arm's condition source text, when it has one (omitted for `else`). */
+  condition?: string;
+  steps: PlayStaticSubstep[];
+};
+
 export type PlayStaticSubstep = PlayStaticSubstepMetadata &
   (
     | {
@@ -421,7 +442,12 @@ export type PlayStaticSubstep = PlayStaticSubstepMetadata &
         type: 'control_flow';
         kind: 'conditional' | 'loop';
         field: string;
+        /** Flattened steps across every arm, in source order (back-compat). */
         steps: PlayStaticSubstep[];
+        /** Discriminant source text (the `if`/ternary test, `switch` subject). */
+        condition?: string;
+        /** Per-arm breakdown for conditionals; omitted for loops. */
+        branches?: PlayStaticControlFlowBranch[];
         description?: string;
         sourceRange?: PlayStaticSourceRange;
         callDepth?: number;

package/dist/cli/index.js

@@ -622,10 +622,10 @@ var SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: "0.1.161",
+  version: "0.1.163",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.161",
+    latest: "0.1.163",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -17742,7 +17742,7 @@ function fallbackRowsInfoForGeneratedEnrichExport(status, options) {
     columns: [],
     columnsExplicit: false,
     complete: false,
-    source: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE,
+    source: null,
     tableNamespace: GENERATED_ENRICH_ROWS_TABLE_NAMESPACE
   };
 }
@@ -17763,10 +17763,45 @@ function hasLossyPreviewPlaceholder(value, depth = 0) {
   }
   return false;
 }
+function statusReferencesGeneratedEnrichRows(value, depth = 0) {
+  if (depth > 12 || value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.trim() === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  }
+  if (Array.isArray(value)) {
+    return value.some(
+      (item) => statusReferencesGeneratedEnrichRows(item, depth + 1)
+    );
+  }
+  if (typeof value === "object") {
+    return Object.values(value).some(
+      (item) => statusReferencesGeneratedEnrichRows(item, depth + 1)
+    );
+  }
+  return false;
+}
+function generatedEnrichRowsTableNamespaceForExport(rowsInfo, status) {
+  const tableNamespace = rowsInfo.tableNamespace?.trim() || null;
+  if (tableNamespace === "result.rows") {
+    return GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  }
+  if (!tableNamespace && statusReferencesGeneratedEnrichRows(status)) {
+    return GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  }
+  return tableNamespace;
+}
 function shouldFetchBackingRowsForEnrichExport(rowsInfo, status, options = {}) {
   const terminalStatus = readEnrichRunStatus(status);
-  const tableNamespace = rowsInfo.tableNamespace?.trim();
+  const tableNamespace = generatedEnrichRowsTableNamespaceForExport(
+    rowsInfo,
+    status
+  );
   if (terminalStatus === "failed" || terminalStatus === "cancelled") {
+    if (tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && rowsInfo.source !== null && typeof options.selectedSourceRows === "number" && rowsInfo.rows.length < options.selectedSourceRows) {
+      return true;
+    }
     return tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && (rowsInfo.recovered === true || hasPartialRunOutputWarning(status));
   }
   if (tableNamespace === GENERATED_ENRICH_ROWS_TABLE_NAMESPACE && typeof options.selectedSourceRows === "number" && rowsInfo.rows.length < options.selectedSourceRows) {
@@ -17894,6 +17929,45 @@ function exportableSheetRow2(row, sourceRowStart = 0) {
   }
   return fallback;
 }
+function mergeExportedSheetRow(target, next) {
+  const baseMetadata = target._metadata;
+  const nextMetadata = next._metadata;
+  for (const [key, value] of Object.entries(next)) {
+    const existing = target[key];
+    if (isNonEmptyCsvCell(existing) && !isNonEmptyCsvCell(value)) {
+      continue;
+    }
+    target[key] = value;
+  }
+  const metadata = mergeLegacyMetadataCell(baseMetadata, nextMetadata);
+  if (metadata !== void 0) {
+    target._metadata = metadata;
+  }
+}
+function coalesceExportableSheetRows(rows, sourceRowStart = 0) {
+  const mergedRows = [];
+  const bySourceRowIndex = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const rowIndex = sourceRowIndexFromEnrichRow(
+      row,
+      sourceRowStart,
+      Number.MAX_SAFE_INTEGER
+    );
+    if (rowIndex === null) {
+      mergedRows.push(row);
+      continue;
+    }
+    const existing = bySourceRowIndex.get(rowIndex);
+    if (existing) {
+      mergeExportedSheetRow(existing, row);
+      continue;
+    }
+    const next = { ...row };
+    bySourceRowIndex.set(rowIndex, next);
+    mergedRows.push(next);
+  }
+  return mergedRows;
+}
 function sourceRowIndexFromEnrichRow(row, start, end) {
   const value = row[ENRICH_SOURCE_ROW_INDEX_COLUMN];
   const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
@@ -17998,7 +18072,11 @@ function aliasFailureCellCandidates(row, alias) {
     if (key.startsWith(dottedPrefix)) {
       assignFlattenedFailurePath(nested, key.slice(dottedPrefix.length), value);
     } else if (key.startsWith(underscorePrefix)) {
-      assignFlattenedFailurePath(nested, key.slice(underscorePrefix.length), value);
+      assignFlattenedFailurePath(
+        nested,
+        key.slice(underscorePrefix.length),
+        value
+      );
     }
   }
   if (Object.keys(nested).length > 0) {
@@ -18376,13 +18454,14 @@ function mergePreferredColumns(preferredColumns, rows) {
 async function fetchBackingRowsForCsvExport(input2) {
   const runId = extractRunId(input2.status);
   const playName = extractPlayName2(input2.status);
-  const tableNamespace = input2.rowsInfo.tableNamespace?.trim() || GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
+  const tableNamespace = generatedEnrichRowsTableNamespaceForExport(input2.rowsInfo, input2.status) || GENERATED_ENRICH_ROWS_TABLE_NAMESPACE;
   if (!runId || !playName || !tableNamespace) {
     return null;
   }
   const deadline = Date.now() + enrichExportBackingRowsWaitMs();
   let lastRows = [];
-  const minimumExpectedRows = typeof input2.expectedRows === "number" && input2.expectedRows > 0 ? Math.trunc(input2.expectedRows) : input2.rowsInfo.totalRows;
+  const hasExplicitExpectedRows = typeof input2.expectedRows === "number" && input2.expectedRows > 0;
+  const minimumExpectedRows = hasExplicitExpectedRows ? Math.trunc(Number(input2.expectedRows)) : input2.rowsInfo.totalRows;
   let lastExpectedTotal = minimumExpectedRows;
   for (; ; ) {
     const sheetRows = [];
@@ -18407,10 +18486,15 @@ async function fetchBackingRowsForCsvExport(input2) {
       }
       offset += page.rows.length;
     }
-    const rows = sheetRows.map((row) => exportableSheetRow2(row, input2.sourceRowStart ?? 0)).filter((row) => Boolean(row));
+    const rawRows = sheetRows.map((row) => exportableSheetRow2(row, input2.sourceRowStart ?? 0)).filter((row) => Boolean(row));
+    const rows = coalesceExportableSheetRows(
+      rawRows,
+      input2.sourceRowStart ?? 0
+    );
     lastRows = rows;
     lastExpectedTotal = expectedTotal;
-    if (expectedTotal > 0 && rows.length >= expectedTotal || expectedTotal === 0 && rows.length > 0) {
+    const requiredExportRows = hasExplicitExpectedRows ? minimumExpectedRows : expectedTotal;
+    if (requiredExportRows > 0 && rows.length >= requiredExportRows || requiredExportRows === 0 && rows.length > 0) {
       return {
         ...input2.rowsInfo,
         rows,
@@ -18418,7 +18502,7 @@ async function fetchBackingRowsForCsvExport(input2) {
           input2.rowsInfo.columnsExplicit ? input2.rowsInfo.columns : [],
           rows
         ),
-        totalRows: Math.max(rows.length, expectedTotal),
+        totalRows: hasExplicitExpectedRows ? Math.max(rows.length, minimumExpectedRows) : Math.max(rows.length, expectedTotal),
         complete: true,
         source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
       };
@@ -18438,7 +18522,7 @@ async function fetchBackingRowsForCsvExport(input2) {
       input2.rowsInfo.columnsExplicit ? input2.rowsInfo.columns : [],
       lastRows
     ),
-    totalRows: Math.max(lastExpectedTotal, input2.rowsInfo.totalRows),
+    totalRows: hasExplicitExpectedRows ? Math.max(lastRows.length, minimumExpectedRows) : Math.max(lastExpectedTotal, input2.rowsInfo.totalRows),
     complete: false,
     source: `${input2.rowsInfo.source ?? "result.rows"} -> /api/v2/plays/${playName}/sheet?tableNamespace=${tableNamespace}`
   };
@@ -18626,8 +18710,13 @@ function materializeAliasSuccessCell(row, alias) {
         directCells.push({ field, value });
       }
     }
-    for (const preferredField of [alias, ...ENRICH_FLATTENED_SUCCESS_FIELD_PRIORITY]) {
-      const preferred = directCells.find(({ field }) => field === preferredField);
+    for (const preferredField of [
+      alias,
+      ...ENRICH_FLATTENED_SUCCESS_FIELD_PRIORITY
+    ]) {
+      const preferred = directCells.find(
+        ({ field }) => field === preferredField
+      );
       if (preferred) {
         return materializeCsvCellValue(preferred.value);
       }
@@ -18829,7 +18918,7 @@ function assertCompleteRowsForCsvExport(rowsInfo, status, outputPath, options =
     return;
   }
   const runId = status && typeof status === "object" && !Array.isArray(status) && typeof status.runId === "string" ? status.runId : null;
-  const dataset = rowsInfo.source ?? "result.rows";
+  const dataset = rowsInfo.source ?? rowsInfo.tableNamespace ?? "result.rows";
   const retry = runId ? ` Retry after the run finalizes its backing dataset with: deepline runs export ${runId} --dataset ${dataset} --out ${outputPath}` : "";
   throw new Error(
     `Refusing to write a partial CSV export: the run returned ${rowsInfo.rows.length} preview row(s) out of ${rowsInfo.totalRows}.${retry}`