deepline 0.1.178 → 0.1.180

package/dist/bundling-sources/shared_libs/play-runtime/run-ledger.ts

@@ -1,4 +1,7 @@
-import { normalizePlayRunFailure } from './run-failure';
+import {
+  normalizePlayRunFailure,
+  PLATFORM_DEPLOY_INTERRUPTED_MESSAGE,
+} from './run-failure';
 
 export type PlayRunLedgerStatus =
   | 'queued'
@@ -530,6 +533,25 @@ const TERMINAL_STATUS_BY_EVENT_TYPE = {
   'run.cancelled': 'cancelled',
 } as const satisfies Partial<Record<string, PlayRunLedgerStatus>>;
 
+function isRawPlatformDeployResetText(
+  error: string | null | undefined,
+): boolean {
+  return Boolean(
+    error &&
+    normalizePlayRunFailure(error).code === 'PLATFORM_DEPLOY_INTERRUPTED',
+  );
+}
+
+function isPlatformDeployFailureText(
+  error: string | null | undefined,
+): boolean {
+  return Boolean(
+    error &&
+    (isRawPlatformDeployResetText(error) ||
+      error.includes(PLATFORM_DEPLOY_INTERRUPTED_MESSAGE)),
+  );
+}
+
 /**
  * Append already-deduplicated log lines to the snapshot tail.
  *
@@ -566,31 +588,29 @@ function appendLogLines(
 }
 
 /**
- * Terminal-status precedence. Re-delivery of the same terminal status is a
- * benign no-op handled by the regular reduction. Conflicting terminal events
- * use newest-terminal-wins by event time: older events are ignored and logged,
- * newer events reconcile the snapshot. This is the idempotency model callers
- * expect when duplicate/retried work completes out of order. It also preserves
- * post-completion billing cap demotion because that denial arrives as a newer
- * run.failed event.
+ * Terminal-status precedence. Conflicting terminal events use
+ * newest-terminal-wins by event time: older events are ignored and logged,
+ * newer events reconcile the snapshot. Same-status terminal events continue to
+ * the reducer so recovery/transport paths can fill in canonical payloads after
+ * an earlier partial terminal snapshot. Retryable platform-deploy failures are
+ * the narrow exception: they are never allowed to replace a real terminal
+ * result from the runtime.
  */
 function conflictingTerminalSnapshot(
   base: PlayRunLedgerSnapshot,
   eventType: keyof typeof TERMINAL_STATUS_BY_EVENT_TYPE,
   occurredAt: number,
   eventError?: string | null,
+  options?: { allowStaleSameStatusPayloadMerge?: boolean },
 ): PlayRunLedgerSnapshot | null {
   if (!isTerminalPlayRunLedgerStatus(base.status)) {
     return null;
   }
-  if (TERMINAL_STATUS_BY_EVENT_TYPE[eventType] === base.status) {
-    return null;
-  }
+  const terminalAt = base.finishedAt ?? base.updatedAt ?? 0;
   if (
     base.status === 'completed' &&
     eventType === 'run.failed' &&
-    eventError &&
-    normalizePlayRunFailure(eventError).code === 'PLATFORM_DEPLOY_INTERRUPTED'
+    isPlatformDeployFailureText(eventError)
   ) {
     return withTiming(
       appendLogLines(base, [
@@ -598,7 +618,22 @@ function conflictingTerminalSnapshot(
       ]),
     );
   }
-  const terminalAt = base.finishedAt ?? base.updatedAt ?? 0;
+  if (
+    base.status === 'failed' &&
+    eventType === 'run.failed' &&
+    isPlatformDeployFailureText(eventError)
+  ) {
+    return withTiming(base);
+  }
+  if (TERMINAL_STATUS_BY_EVENT_TYPE[eventType] === base.status) {
+    if (
+      options?.allowStaleSameStatusPayloadMerge !== true ||
+      occurredAt < terminalAt
+    ) {
+      return withTiming(base);
+    }
+    return null;
+  }
   if (occurredAt > terminalAt) {
     // Newer terminal evidence reconciles the run. This covers replay/receipt
     // races where an earlier attempt failed but a later attempt recovered and
@@ -619,7 +654,7 @@ function retryablePlatformDeployFailureSnapshot(
   if (
     isTerminalPlayRunLedgerStatus(base.status) ||
     !eventError ||
-    normalizePlayRunFailure(eventError).code !== 'PLATFORM_DEPLOY_INTERRUPTED'
+    !isRawPlatformDeployResetText(eventError)
   ) {
     return null;
   }
@@ -717,7 +752,12 @@ export function reducePlayRunLedgerEvent(
       });
     case 'run.completed':
       return (
-        conflictingTerminalSnapshot(base, event.type, occurredAt) ??
+        conflictingTerminalSnapshot(base, event.type, occurredAt, null, {
+          allowStaleSameStatusPayloadMerge:
+            (base.result === undefined && event.result !== undefined) ||
+            (base.resultSummary === undefined &&
+              event.resultSummary !== undefined),
+        }) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'completed', occurredAt),
           status: 'completed',
@@ -733,16 +773,18 @@ export function reducePlayRunLedgerEvent(
     case 'run.failed':
       return (
         retryablePlatformDeployFailureSnapshot(base, event.error) ??
-        conflictingTerminalSnapshot(
-          base,
-          event.type,
-          occurredAt,
-          event.error,
-        ) ??
+        conflictingTerminalSnapshot(base, event.type, occurredAt, event.error, {
+          allowStaleSameStatusPayloadMerge:
+            (base.error == null && event.error != null) ||
+            (base.result === undefined && event.result !== undefined),
+        }) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'failed', occurredAt),
           status: 'failed',
-          error: event.error ?? base.error ?? null,
+          error:
+            base.status === 'failed'
+              ? (base.error ?? event.error ?? null)
+              : (event.error ?? base.error ?? null),
           startedAt: base.startedAt ?? occurredAt,
           finishedAt: terminalFinishedAt(base, event.type, occurredAt),
           activeStepId: null,
@@ -752,16 +794,18 @@ export function reducePlayRunLedgerEvent(
       );
     case 'run.cancelled':
       return (
-        conflictingTerminalSnapshot(
-          base,
-          event.type,
-          occurredAt,
-          event.error,
-        ) ??
+        conflictingTerminalSnapshot(base, event.type, occurredAt, event.error, {
+          allowStaleSameStatusPayloadMerge:
+            (base.error == null && event.error != null) ||
+            (base.result === undefined && event.result !== undefined),
+        }) ??
         withTiming({
           ...settleRunningStepsOnTerminal(base, 'failed', occurredAt),
           status: 'cancelled',
-          error: event.error ?? base.error ?? null,
+          error:
+            base.status === 'cancelled'
+              ? (base.error ?? event.error ?? null)
+              : (event.error ?? base.error ?? null),
           startedAt: base.startedAt ?? occurredAt,
           finishedAt: terminalFinishedAt(base, event.type, occurredAt),
           activeStepId: null,

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

@@ -112,6 +112,12 @@ const runtimeSheetEnsureCache = new Map<
 const DIRECT_POSTGRES_BATCH_SIZE = 10_000;
 const RUNTIME_DB_SESSION_ROW_LIMIT_FLOOR = DIRECT_POSTGRES_BATCH_SIZE;
 const APPEND_KEY_SUFFIX_LENGTH = 12;
+// On-demand (create_db_session) mint TTL. Deliberately NOT aligned with
+// DB_SESSION_DEFAULT_TTL_SECONDS (60 min): on-demand sessions are isolate-
+// cached and re-minted through sessionHasRenewalWindow, never stored in the
+// dedup DO, so they are not subject to the 410 expired-retention race the
+// 60-min alignment fixed. A shorter TTL only causes periodic re-mints (cheap;
+// the tenant runtime role is long-lived), not run failures.
 const RUNTIME_DB_SESSION_TTL_SECONDS = 10 * 60;
 const RUNTIME_SHEET_ENSURE_CACHE_TTL_MS = 10 * 60_000;
 const RUNTIME_SHEET_READY_AFTER_ENSURE_RETRY_DELAYS_MS = [

package/dist/cli/index.js

@@ -623,10 +623,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.178",
+  version: "0.1.180",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.178",
+    latest: "0.1.180",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -787,6 +787,58 @@ var SYNTHETIC_RUN_HEADER = "x-deepline-synthetic-run";
 // src/http.ts
 var MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
 var COWORK_NETWORK_HINT = "Claude Cowork appears to be running Deepline in a network-restricted sandbox. In Claude Desktop, open Settings > Capabilities, turn on Allow network egress, and set Domain allowlist to All domains for the Cowork session.";
+var REQUEST_TIMEOUT_MARKER = /* @__PURE__ */ Symbol("deeplineRequestTimeout");
+var REQUEST_ABORT_MARKER = /* @__PURE__ */ Symbol("deeplineRequestAbort");
+function normalizeRequestAbortError(error, input2) {
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  const tagged = normalized;
+  if (input2.timedOut) {
+    tagged[REQUEST_TIMEOUT_MARKER] = input2.timeoutMs;
+  } else if (isAbortLikeError(normalized)) {
+    tagged[REQUEST_ABORT_MARKER] = true;
+  }
+  return normalized;
+}
+function isAbortLikeError(error) {
+  const name = error.name.toLowerCase();
+  const message = error.message.toLowerCase();
+  return name === "aborterror" || message.includes("operation was aborted") || message === "aborted";
+}
+function mapNetworkError(baseUrl, error, targetLabel) {
+  const tagged = error;
+  const timeoutMs = tagged?.[REQUEST_TIMEOUT_MARKER];
+  if (typeof timeoutMs === "number") {
+    return {
+      message: `Request to ${targetLabel} timed out after ${timeoutMs}ms while waiting for a response.`,
+      code: "NETWORK_TIMEOUT",
+      details: { timeoutMs, target: targetLabel }
+    };
+  }
+  if (tagged?.[REQUEST_ABORT_MARKER]) {
+    return {
+      message: `Request to ${targetLabel} was aborted before it completed.`,
+      code: "NETWORK_ABORTED"
+    };
+  }
+  return {
+    message: error?.message ? `Unable to connect to ${baseUrl}. ${error.message}` : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`,
+    code: "NETWORK_ERROR"
+  };
+}
+function describeRequestTarget(path) {
+  const toolExecuteMatch = path.match(
+    /^\/api\/v2\/integrations\/([^/?#]+)\/execute(?:[/?#]|$)/
+  );
+  if (toolExecuteMatch) {
+    return providerLabelFromToolId(decodeURIComponent(toolExecuteMatch[1]));
+  }
+  return "Deepline";
+}
+function providerLabelFromToolId(toolId) {
+  const normalized = toolId.trim().toLowerCase();
+  const provider = normalized.split(/[_:./-]+/)[0];
+  return provider || normalized || "provider";
+}
 var HttpClient = class {
   constructor(config) {
     this.config = config;
@@ -899,10 +951,12 @@ var HttpClient = class {
       }
       for (const candidateUrl of candidateUrls) {
         const controller = new AbortController();
-        const timeoutId = setTimeout(
-          () => controller.abort(),
-          options?.timeout ?? this.config.timeout
-        );
+        const timeoutMs = options?.timeout ?? this.config.timeout;
+        let requestTimedOut = false;
+        const timeoutId = setTimeout(() => {
+          requestTimedOut = true;
+          controller.abort();
+        }, timeoutMs);
         try {
           const response = await fetch(candidateUrl, {
             method,
@@ -975,7 +1029,10 @@ var HttpClient = class {
             lastError = error;
             break;
           }
-          lastError = error instanceof Error ? error : new Error(String(error));
+          lastError = normalizeRequestAbortError(error, {
+            timeoutMs,
+            timedOut: requestTimedOut
+          });
         }
       }
       if (attempt < maxRetries) continue;
@@ -983,8 +1040,17 @@ var HttpClient = class {
     if (lastError instanceof DeeplineError) {
       throw lastError;
     }
-    const errorMessage4 = lastError?.message ? `Unable to connect to ${baseUrl}. ${lastError.message}` : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`;
-    throw new DeeplineError(withCoworkNetworkHint(errorMessage4));
+    const mappedNetworkError = mapNetworkError(
+      baseUrl,
+      lastError,
+      describeRequestTarget(path)
+    );
+    throw new DeeplineError(
+      withCoworkNetworkHint(mappedNetworkError.message),
+      void 0,
+      mappedNetworkError.code,
+      mappedNetworkError.details
+    );
   }
   /**
    * Send a GET request.
@@ -2255,6 +2321,57 @@ function decodeBase64Bytes(value) {
   }
   return bytes;
 }
+var STAGE_LEGACY_MULTIPART_MAX_BYTES = 4e6;
+var STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS = 3;
+function stagedUploadIdentity(logicalPath, contentHash) {
+  return `${contentHash}:${logicalPath}`;
+}
+function isStagedUploadMintUnsupported(error) {
+  return error instanceof DeeplineError && error.statusCode === 404;
+}
+function formatMegabytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function uploadStagedFileToPresignedUrl(input2) {
+  const arrayBuffer = input2.body.buffer.slice(
+    input2.body.byteOffset,
+    input2.body.byteOffset + input2.body.byteLength
+  );
+  let lastError;
+  for (let attempt = 1; attempt <= STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const response = await fetch(input2.url, {
+        method: "PUT",
+        headers: input2.headers,
+        body: new Blob([arrayBuffer])
+      });
+      if (response.ok) {
+        return;
+      }
+      const text = await response.text().catch(() => "");
+      lastError = new DeeplineError(
+        `Direct storage upload of ${input2.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
+        response.status,
+        "STAGED_FILE_UPLOAD_FAILED",
+        { logicalPath: input2.logicalPath }
+      );
+      if (response.status < 500 && response.status !== 429) {
+        break;
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt < STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS) {
+      await sleep2(250 * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new DeeplineError(
+    `Direct storage upload of ${input2.logicalPath} failed.`,
+    void 0,
+    "STAGED_FILE_UPLOAD_FAILED",
+    { logicalPath: input2.logicalPath }
+  );
+}
 function readStringArray(value) {
   return Array.isArray(value) ? value.filter((line) => typeof line === "string") : [];
 }
@@ -2660,6 +2777,21 @@ var DeeplineClient = class {
       ...input2.maxRows ? { max_rows: input2.maxRows } : {}
     });
   }
+  /**
+   * Re-establish this workspace's tenant storage contract: role/DB connect
+   * grants plus materialized table grants. Org-admin only. Use when a run fails
+   * with WORKSPACE_STORAGE_NOT_READY.
+   */
+  async repairIngestionStorage(input2) {
+    return this.http.post(
+      "/api/v2/ingestion/repair",
+      {
+        ...input2?.provider ? { provider: input2.provider } : {}
+      },
+      void 0,
+      { forbiddenAsApiError: true }
+    );
+  }
   // ——————————————————————————————————————————————————————————
   // Plays — submission and lifecycle
   // ——————————————————————————————————————————————————————————
@@ -3037,6 +3169,94 @@ var DeeplineClient = class {
    * ```
    */
   async stagePlayFiles(files) {
+    let uploads;
+    try {
+      uploads = await this.mintStagedPlayFileUploads(
+        files.map((file) => ({
+          logicalPath: file.logicalPath,
+          contentHash: file.contentHash,
+          contentType: file.contentType,
+          bytes: file.bytes
+        }))
+      );
+    } catch (error) {
+      if (isStagedUploadMintUnsupported(error)) {
+        return this.stagePlayFilesViaMultipart(files);
+      }
+      throw error;
+    }
+    const uploadByIdentity = /* @__PURE__ */ new Map();
+    for (const upload of uploads) {
+      uploadByIdentity.set(
+        stagedUploadIdentity(upload.logicalPath, upload.contentHash),
+        upload
+      );
+    }
+    await Promise.all(
+      files.map(async (file) => {
+        const upload = uploadByIdentity.get(
+          stagedUploadIdentity(file.logicalPath, file.contentHash)
+        );
+        if (!upload) {
+          throw new DeeplineError(
+            `The staging server did not return an upload target for ${file.logicalPath}.`,
+            void 0,
+            "STAGED_FILE_MINT_INCOMPLETE"
+          );
+        }
+        if (upload.alreadyStaged || !upload.uploadUrl) {
+          return;
+        }
+        await uploadStagedFileToPresignedUrl({
+          url: upload.uploadUrl,
+          headers: upload.uploadHeaders ?? {
+            "content-type": file.contentType
+          },
+          body: decodeBase64Bytes(file.contentBase64),
+          logicalPath: file.logicalPath
+        });
+      })
+    );
+    return files.map((file) => {
+      const upload = uploadByIdentity.get(
+        stagedUploadIdentity(file.logicalPath, file.contentHash)
+      );
+      if (!upload) {
+        throw new DeeplineError(
+          `The staging server did not return an upload target for ${file.logicalPath}.`,
+          void 0,
+          "STAGED_FILE_MINT_INCOMPLETE"
+        );
+      }
+      return upload.ref;
+    });
+  }
+  /**
+   * Mint short-lived presigned upload targets for staged play files.
+   *
+   * Internal primitive used by {@link stagePlayFiles}. The server returns an
+   * already-staged ref (no upload needed) for content-addressed files it
+   * already holds, or a presigned PUT URL the caller uploads the body to.
+   */
+  async mintStagedPlayFileUploads(files) {
+    const response = await this.http.post("/api/v2/plays/files/stage/mint", { files });
+    return response.uploads ?? [];
+  }
+  async stagePlayFilesViaMultipart(files) {
+    for (const file of files) {
+      if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
+        throw new DeeplineError(
+          `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): the connected Deepline server does not support direct-to-storage uploads, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to. Update the Deepline server (or target code.deepline.com) to stage files this large.`,
+          413,
+          "STAGED_FILE_TOO_LARGE_FOR_LEGACY_UPLOAD",
+          {
+            logicalPath: file.logicalPath,
+            bytes: file.bytes,
+            maxBytes: STAGE_LEGACY_MULTIPART_MAX_BYTES
+          }
+        );
+      }
+    }
     const buildFormData = () => {
       const formData = new FormData();
       formData.set(
@@ -7670,6 +7890,53 @@ async function handleDbQuery(args) {
   );
   return 0;
 }
+async function handleDbRepair(args) {
+  const providerIndex = args.indexOf("--provider");
+  const provider = providerIndex >= 0 ? args[providerIndex + 1]?.trim() : void 0;
+  const jsonOutput = argsWantJson(args);
+  const client2 = new DeeplineClient();
+  let result;
+  try {
+    result = await client2.repairIngestionStorage(
+      provider ? { provider } : void 0
+    );
+  } catch (error) {
+    if (error instanceof DeeplineError && error.statusCode === 403) {
+      console.error(
+        "deepline db repair requires org admin. Ask an organization admin to run it."
+      );
+      return 1;
+    }
+    console.error(errorMessage(error));
+    return 1;
+  }
+  printCommandEnvelope(
+    {
+      command: "db repair",
+      repaired: result.repaired,
+      count: result.count,
+      connection_grants: result.connection_grants,
+      render: {
+        sections: [
+          {
+            title: "storage contract repair",
+            lines: [
+              `Repaired ${result.count} table(s).`,
+              `Runtime role: ${result.connection_grants.runtime_role}`,
+              `Customer DB role: ${result.connection_grants.customer_db_role}`
+            ]
+          }
+        ]
+      }
+    },
+    {
+      json: jsonOutput,
+      text: `Repaired ${result.count} table(s). Storage grants re-established.
+`
+    }
+  );
+  return 0;
+}
 function registerDbCommands(program) {
   const db = program.command("db").description("Query the tenant customer database.").addHelpText(
     "after",
@@ -7725,6 +7992,26 @@ Examples:
       ...options.json ? ["--json"] : []
     ]);
   });
+  db.command("repair").description(
+    "Repair this workspace storage contract (role/DB grants). Org admin only."
+  ).addHelpText(
+    "after",
+    `
+Notes:
+  Re-establishes tenant runtime and customer-db role grants plus materialized
+  table grants for the active workspace. Run this after a play run fails with
+  WORKSPACE_STORAGE_NOT_READY, then re-run the play. Requires org admin.
+
+Examples:
+  deepline db repair
+  deepline db repair --json
+`
+  ).option("--provider <provider>", "Limit materialized-table repair to one provider").option("--json", "Emit raw JSON response. Also automatic when stdout is piped").action(async (options) => {
+    process.exitCode = await handleDbRepair([
+      ...options.provider ? ["--provider", options.provider] : [],
+      ...options.json ? ["--json"] : []
+    ]);
+  });
 }
 
 // src/cli/commands/enrich.ts
@@ -12531,6 +12818,26 @@ function resolveDatasetByName(available, datasetPath) {
   }
   return null;
 }
+function assertDatasetHasExportableRows(input2) {
+  if (input2.rowsInfo.rows.length > 0) {
+    return input2.rowsInfo;
+  }
+  const datasetLabel = input2.datasetPath ?? input2.rowsInfo.tableNamespace ?? input2.rowsInfo.source ?? "result.rows";
+  const available = input2.availableRows.map((info) => info.tableNamespace ?? info.source).filter((name) => typeof name === "string");
+  const runStatus = String(input2.status.status ?? "").toLowerCase();
+  const failedBeforePersisting = runStatus !== "completed";
+  throw new DeeplineError(
+    `Run ${input2.status.runId} has zero rows to export from dataset '${datasetLabel}'.` + (failedBeforePersisting ? ` The run status is '${runStatus || "unknown"}', so it likely failed before persisting rows to this dataset \u2014 provider calls may have been billed without a durable row. Fix the run's failure cause and re-run to resume.` : " The run completed but this dataset materialized no rows.") + (available.length > 0 ? ` Available datasets: ${available.join(", ")}.` : " No datasets were materialized for this run."),
+    void 0,
+    "RUN_EXPORT_EMPTY",
+    {
+      runId: input2.status.runId,
+      dataset: datasetLabel,
+      available,
+      runStatus: runStatus || null
+    }
+  );
+}
 async function exportPlayStatusRows(client2, status, outPath, options = {}) {
   if (!outPath) {
     return null;
@@ -12576,13 +12883,25 @@ async function exportPlayStatusRows(client2, status, outPath, options = {}) {
       }
     }
     if (fetchedRowsInfo?.complete) {
+      const guarded2 = assertDatasetHasExportableRows({
+        rowsInfo: fetchedRowsInfo,
+        status,
+        availableRows,
+        datasetPath: options.datasetPath
+      });
       return {
-        path: writeCanonicalRowsCsv(fetchedRowsInfo, outPath),
-        rowsInfo: fetchedRowsInfo
+        path: writeCanonicalRowsCsv(guarded2, outPath),
+        rowsInfo: guarded2
       };
     }
     if (rowsInfo.complete) {
-      return { path: writeCanonicalRowsCsv(rowsInfo, outPath), rowsInfo };
+      const guarded2 = assertDatasetHasExportableRows({
+        rowsInfo,
+        status,
+        availableRows,
+        datasetPath: options.datasetPath
+      });
+      return { path: writeCanonicalRowsCsv(guarded2, outPath), rowsInfo: guarded2 };
     }
     if (attempt < attempts && retryDelayMs > 0) {
       await sleep5(retryDelayMs);
@@ -12608,7 +12927,13 @@ async function exportPlayStatusRows(client2, status, outPath, options = {}) {
       }
     );
   }
-  return { path: writeCanonicalRowsCsv(rowsInfo, outPath), rowsInfo };
+  const guarded = assertDatasetHasExportableRows({
+    rowsInfo,
+    status,
+    availableRows,
+    datasetPath: options.datasetPath
+  });
+  return { path: writeCanonicalRowsCsv(guarded, outPath), rowsInfo: guarded };
 }
 function extractActiveRunsFromError(error) {
   if (!(error instanceof DeeplineError)) {