deepline 0.3.258 → 0.3.260

package/dist/index.js

@@ -102,6 +102,11 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// ../plays/trigger-config-route.ts
+function playTriggerConfigPath(playName) {
+  return `/api/v2/plays/${encodeURIComponent(playName)}/triggers`;
+}
+
 // src/pagination.ts
 async function* iterateCursorPages(fetchPage) {
   let cursor = null;
@@ -1320,7 +1325,7 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.258",
+  version: "0.3.260",
   updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
   packageCapabilities: {
     updatePreferences: 1
@@ -1456,6 +1461,30 @@ var SDK_VERSION = SDK_RELEASE.version;
 var SDK_API_MAJOR = SDK_RELEASE.contracts.api.currentMajor;
 var SDK_API_CONTRACT = SDK_RELEASE.contracts.api.legacyWireIds[0] ?? `api-v${SDK_API_MAJOR}`;
 
+// src/api-error.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function apiErrorCodeFromResponse(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(response?.error);
+  const code = error?.code ?? response?.code;
+  return typeof code === "string" ? code : "API_ERROR";
+}
+function apiErrorMessage(parsed, status) {
+  const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
+  if (typeof errorValue === "string") {
+    return errorValue;
+  }
+  if (errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string") {
+    return errorValue.message;
+  }
+  if (typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string") {
+    return parsed.message;
+  }
+  return `HTTP ${status}`;
+}
+
 // src/agent-runtime.ts
 var import_node_os2 = require("os");
 var EXPLICIT_AGENT_RUNTIMES = /* @__PURE__ */ new Set([
@@ -2475,24 +2504,18 @@ function parseResponseBody(body) {
   }
 }
 function isProviderOriginatedHttpError(parsed) {
-  const response = asRecord(parsed);
-  const error = asRecord(response?.error);
+  const response = asRecord2(parsed);
+  const error = asRecord2(response?.error);
   const failureOrigin = error?.failure_origin ?? response?.failure_origin;
   const code = error?.code ?? response?.code;
   return failureOrigin === "provider" || code === "UPSTREAM_BLOCKED";
 }
 function isMonitorRateLimitEnvelope(parsed) {
-  const response = asRecord(parsed);
-  const error = asRecord(response?.error);
+  const response = asRecord2(parsed);
+  const error = asRecord2(response?.error);
   return error?.code === "monitor_upstream_rate_limited" && typeof error.message === "string";
 }
-function apiErrorCodeFromResponse(parsed) {
-  const response = asRecord(parsed);
-  const error = asRecord(response?.error);
-  const code = error?.code ?? response?.code;
-  return typeof code === "string" ? code : "API_ERROR";
-}
-function asRecord(value) {
+function asRecord2(value) {
   return typeof value === "object" && value !== null ? value : null;
 }
 function isRetryableApiErrorResponse(status) {
@@ -2523,19 +2546,6 @@ function detectHtmlErrorBody(body, contentType) {
     }
   };
 }
-function apiErrorMessage(parsed, status) {
-  const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
-  if (typeof errorValue === "string") {
-    return errorValue;
-  }
-  if (errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string") {
-    return errorValue.message;
-  }
-  if (typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string") {
-    return parsed.message;
-  }
-  return `HTTP ${status}`;
-}
 function parseRetryAfter(response) {
   return parseOptionalRetryAfter(response) ?? 5e3;
 }
@@ -3422,6 +3432,278 @@ function isStopAllPlayRunsDryRunResult(result) {
   return "dryRun" in result && result.dryRun === true;
 }
 
+// src/plays/run-request.ts
+var PLAY_RUN_START_PATH = "/api/v2/plays/run";
+var PLAY_RUN_START_STREAM_PATH = `${PLAY_RUN_START_PATH}?stream=true`;
+var PLAY_FILES_STAGE_PATH = "/api/v2/plays/files/stage";
+var PLAY_FILES_STAGE_MINT_PATH = `${PLAY_FILES_STAGE_PATH}/mint`;
+function buildPlayRunStartBody(request) {
+  return {
+    ...request.name ? { name: request.name } : {},
+    ...request.revisionId ? { revisionId: request.revisionId } : {},
+    ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
+    ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
+    ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
+    ...request.description ? { description: request.description } : {},
+    ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
+    ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
+    ...request.graphHash ? { graphHash: request.graphHash } : {},
+    ...request.runtimeArtifact ? { runtimeArtifact: request.runtimeArtifact } : {},
+    ...request.compilerManifest ? { compilerManifest: request.compilerManifest } : {},
+    ...request.inputFileUpload ? { inputFileUpload: request.inputFileUpload } : {},
+    ...request.packagedFileUploads?.length ? { packagedFileUploads: request.packagedFileUploads } : {},
+    ...request.input ? { input: request.input } : {},
+    ...request.inputFile ? { inputFile: request.inputFile } : {},
+    ...request.packagedFiles?.length ? { packagedFiles: request.packagedFiles } : {},
+    ...request.force ? { force: true } : {},
+    ...request.forceToolRefresh === true ? { forceToolRefresh: true } : {},
+    ...typeof request.maxConcurrentExternalCalls === "number" ? { maxConcurrentExternalCalls: request.maxConcurrentExternalCalls } : {},
+    ...typeof request.maxConcurrentRows === "number" ? { maxConcurrentRows: request.maxConcurrentRows } : {},
+    ...typeof request.waitForCompletionMs === "number" ? { waitForCompletionMs: request.waitForCompletionMs } : {},
+    // Profile selection is the API's job, not the caller's. The server
+    // defaults to absurd; callers normally omit this field.
+    ...request.profile ? { profile: request.profile } : {},
+    ...request.integrationMode ? { integrationMode: request.integrationMode } : {},
+    ...request.fixtureBehavior ? { fixtureBehavior: request.fixtureBehavior } : {},
+    ...request.runtime ? { runtime: request.runtime } : {},
+    ...request.testPolicyOverrides ? { testPolicyOverrides: request.testPolicyOverrides } : {}
+  };
+}
+async function startPlayRun(http, request, headers) {
+  const response = await http.post(
+    PLAY_RUN_START_PATH,
+    buildPlayRunStartBody(request),
+    headers,
+    { maxRetries: 0, exactUrlOnly: true }
+  );
+  return normalizePlayRunStart(response);
+}
+function isPlayRunPackage(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && value.kind === "play_run" && value.run && typeof value.run?.id === "string"
+  );
+}
+function normalizePlayRunStart(raw) {
+  const runPackage = isPlayRunPackage(raw) ? raw : isPlayRunPackage(raw.package) ? raw.package : null;
+  if (!runPackage) {
+    const workflowId = typeof raw.workflowId === "string" && raw.workflowId ? raw.workflowId : typeof raw.runId === "string" ? raw.runId : "";
+    return {
+      ...raw,
+      workflowId
+    };
+  }
+  const status = typeof runPackage.run.status === "string" ? runPackage.run.status : "running";
+  return {
+    workflowId: runPackage.run.id,
+    name: runPackage.run.playName,
+    status,
+    ...runPackage.run.dashboardUrl ? { dashboardUrl: runPackage.run.dashboardUrl } : {},
+    ...isTerminalPlayRunLifecycleStatus(status) ? { finalStatus: runPackage } : {},
+    package: runPackage
+  };
+}
+var STAGE_LEGACY_MULTIPART_MAX_BYTES = 4e6;
+var STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS = 3;
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function stagedUploadIdentity(logicalPath, contentHash) {
+  return `${contentHash}:${logicalPath}`;
+}
+function isStagedUploadMintUnsupported(error) {
+  return error instanceof DeeplineError && error.statusCode === 404;
+}
+function isStagedUploadDirectEgressDenied(error) {
+  return error instanceof DeeplineError && error.code === "STAGED_FILE_UPLOAD_EGRESS_DENIED";
+}
+function formatMegabytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function decodeBase64Bytes(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+async function uploadStagedFileToPresignedUrl(input) {
+  const arrayBuffer = input.body.buffer.slice(
+    input.body.byteOffset,
+    input.body.byteOffset + input.body.byteLength
+  );
+  let lastError;
+  for (let attempt = 1; attempt <= STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const response = await fetch(input.url, {
+        method: "PUT",
+        headers: input.headers,
+        body: new Blob([arrayBuffer])
+      });
+      if (response.ok) {
+        return;
+      }
+      const text = await response.text().catch(() => "");
+      const egressDenied = response.status === 403 && response.headers.get("x-deny-reason")?.trim().toLowerCase() === "host_not_allowed";
+      lastError = new DeeplineError(
+        `Direct storage upload of ${input.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
+        response.status,
+        egressDenied ? "STAGED_FILE_UPLOAD_EGRESS_DENIED" : "STAGED_FILE_UPLOAD_FAILED",
+        { logicalPath: input.logicalPath }
+      );
+      if (response.status < 500 && response.status !== 429) {
+        break;
+      }
+    } catch (error) {
+      lastError = error instanceof TypeError ? new DeeplineError(
+        `Direct storage upload of ${input.logicalPath} could not reach the storage endpoint: ${error.message}`,
+        void 0,
+        "STAGED_FILE_UPLOAD_EGRESS_DENIED",
+        { logicalPath: input.logicalPath }
+      ) : error;
+    }
+    if (attempt < STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS) {
+      await sleep2(250 * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new DeeplineError(
+    `Direct storage upload of ${input.logicalPath} failed.`,
+    void 0,
+    "STAGED_FILE_UPLOAD_FAILED",
+    { logicalPath: input.logicalPath }
+  );
+}
+async function mintStagedPlayFileUploads(http, files) {
+  const response = await http.post(PLAY_FILES_STAGE_MINT_PATH, { files });
+  return response.uploads ?? [];
+}
+async function stagePlayFilesViaMultipart(http, files, reason = "mint-unsupported") {
+  for (const file of files) {
+    if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
+      const reasonMessage = reason === "direct-egress-denied" ? "direct storage is blocked by this environment's network egress policy" : "the connected Deepline server does not support direct-to-storage uploads";
+      throw new DeeplineError(
+        `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): ${reasonMessage}, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to.`,
+        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(
+      "metadata",
+      JSON.stringify({
+        files: files.map((file, index) => ({
+          index,
+          logicalPath: file.logicalPath,
+          contentHash: file.contentHash,
+          contentType: file.contentType,
+          bytes: file.bytes
+        }))
+      })
+    );
+    for (const [index, file] of files.entries()) {
+      const bytes = decodeBase64Bytes(file.contentBase64);
+      const body = bytes.buffer.slice(
+        bytes.byteOffset,
+        bytes.byteOffset + bytes.byteLength
+      );
+      formData.set(
+        `file:${index}`,
+        new Blob([body], { type: file.contentType }),
+        file.logicalPath
+      );
+    }
+    return formData;
+  };
+  const response = await http.postFormData(PLAY_FILES_STAGE_PATH, buildFormData);
+  return response.files;
+}
+async function stagePlayFiles(http, files) {
+  let uploads;
+  try {
+    uploads = await mintStagedPlayFileUploads(
+      http,
+      files.map((file) => ({
+        logicalPath: file.logicalPath,
+        contentHash: file.contentHash,
+        contentType: file.contentType,
+        bytes: file.bytes
+      }))
+    );
+  } catch (error) {
+    if (isStagedUploadMintUnsupported(error)) {
+      return stagePlayFilesViaMultipart(http, files);
+    }
+    throw error;
+  }
+  const uploadByIdentity = /* @__PURE__ */ new Map();
+  for (const upload of uploads) {
+    uploadByIdentity.set(
+      stagedUploadIdentity(upload.logicalPath, upload.contentHash),
+      upload
+    );
+  }
+  const directResults = 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 { ref: upload.ref };
+      }
+      try {
+        await uploadStagedFileToPresignedUrl({
+          url: upload.uploadUrl,
+          headers: upload.uploadHeaders ?? {
+            "content-type": file.contentType
+          },
+          body: decodeBase64Bytes(file.contentBase64),
+          logicalPath: file.logicalPath
+        });
+        return { ref: upload.ref };
+      } catch (error) {
+        if (isStagedUploadDirectEgressDenied(error)) {
+          return { fallbackFile: file };
+        }
+        throw error;
+      }
+    })
+  );
+  return await Promise.all(
+    directResults.map(async (result) => {
+      if ("fallbackFile" in result) {
+        const [ref] = await stagePlayFilesViaMultipart(
+          http,
+          [result.fallbackFile],
+          "direct-egress-denied"
+        );
+        if (!ref) {
+          throw new DeeplineError(
+            `The staging server did not return an upload target for ${result.fallbackFile.logicalPath}.`,
+            void 0,
+            "STAGED_FILE_MINT_INCOMPLETE"
+          );
+        }
+        return ref;
+      }
+      return result.ref;
+    })
+  );
+}
+
 // ../plays/artifact-types.ts
 var PLAY_ARTIFACT_KINDS = {
   cjsNode20: "cjs_node20"
@@ -3628,6 +3910,19 @@ function resolvePlayRunRuntimeSelection(request) {
     ...configuredPlacementPolicy ? { sandboxPlacementPolicy: configuredPlacementPolicy } : {}
   };
 }
+function resolveStartPlayRunRequest(request) {
+  const integrationMode = resolvePlayRunIntegrationMode(request);
+  const testPolicyOverrides = request.testPolicyOverrides ?? parseEnvTestPolicyOverrides();
+  const runtime = resolvePlayRunRuntimeSelection(request);
+  const resolved = { ...request };
+  delete resolved.integrationMode;
+  delete resolved.runtime;
+  delete resolved.testPolicyOverrides;
+  if (integrationMode) resolved.integrationMode = integrationMode;
+  if (runtime) resolved.runtime = runtime;
+  if (testPolicyOverrides) resolved.testPolicyOverrides = testPolicyOverrides;
+  return { request: resolved, runtime };
+}
 function runtimeSelectionHeaders(runtime) {
   if (!runtime) return void 0;
   const token = process.env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
@@ -3686,7 +3981,7 @@ function parseEnvTestPolicyOverrides() {
   }
   return normalizeTestPolicyOverrides(parsed, "DEEPLINE_TEST_POLICY_OVERRIDES");
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function isTransientCompileManifestError(error) {
@@ -3794,11 +4089,6 @@ function preferPrebuiltPlayDescriptions(plays) {
     (left, right) => Number(right.play.pinned) - Number(left.play.pinned) || Number(isPrebuiltPlayDescription(right.play)) - Number(isPrebuiltPlayDescription(left.play)) || left.index - right.index
   ).map(({ play }) => play);
 }
-function isPlayRunPackage(value) {
-  return Boolean(
-    value && typeof value === "object" && !Array.isArray(value) && value.kind === "play_run" && value.run && typeof value.run?.id === "string"
-  );
-}
 function normalizePlayStatus(raw) {
   const runPackage = isPlayRunPackage(raw) ? raw : isPlayRunPackage(raw.package) ? raw.package : null;
   const packageRun = runPackage?.run;
@@ -3826,93 +4116,6 @@ function normalizePlayStatus(raw) {
     status
   };
 }
-function normalizePlayRunStart(raw) {
-  const runPackage = isPlayRunPackage(raw) ? raw : isPlayRunPackage(raw.package) ? raw.package : null;
-  if (!runPackage) {
-    const workflowId = typeof raw.workflowId === "string" && raw.workflowId ? raw.workflowId : typeof raw.runId === "string" ? raw.runId : "";
-    return {
-      ...raw,
-      workflowId
-    };
-  }
-  const status = typeof runPackage.run.status === "string" ? runPackage.run.status : "running";
-  return {
-    workflowId: runPackage.run.id,
-    name: runPackage.run.playName,
-    status,
-    ...runPackage.run.dashboardUrl ? { dashboardUrl: runPackage.run.dashboardUrl } : {},
-    ...isTerminalPlayRunLifecycleStatus(status) ? { finalStatus: runPackage } : {},
-    package: runPackage
-  };
-}
-function decodeBase64Bytes(value) {
-  const binary = atob(value);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index += 1) {
-    bytes[index] = binary.charCodeAt(index);
-  }
-  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 isStagedUploadDirectEgressDenied(error) {
-  return error instanceof DeeplineError && error.code === "STAGED_FILE_UPLOAD_EGRESS_DENIED";
-}
-function formatMegabytes(bytes) {
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-async function uploadStagedFileToPresignedUrl(input) {
-  const arrayBuffer = input.body.buffer.slice(
-    input.body.byteOffset,
-    input.body.byteOffset + input.body.byteLength
-  );
-  let lastError;
-  for (let attempt = 1; attempt <= STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS; attempt += 1) {
-    try {
-      const response = await fetch(input.url, {
-        method: "PUT",
-        headers: input.headers,
-        body: new Blob([arrayBuffer])
-      });
-      if (response.ok) {
-        return;
-      }
-      const text = await response.text().catch(() => "");
-      const egressDenied = response.status === 403 && response.headers.get("x-deny-reason")?.trim().toLowerCase() === "host_not_allowed";
-      lastError = new DeeplineError(
-        `Direct storage upload of ${input.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
-        response.status,
-        egressDenied ? "STAGED_FILE_UPLOAD_EGRESS_DENIED" : "STAGED_FILE_UPLOAD_FAILED",
-        { logicalPath: input.logicalPath }
-      );
-      if (response.status < 500 && response.status !== 429) {
-        break;
-      }
-    } catch (error) {
-      lastError = error instanceof TypeError ? new DeeplineError(
-        `Direct storage upload of ${input.logicalPath} could not reach the storage endpoint: ${error.message}`,
-        void 0,
-        "STAGED_FILE_UPLOAD_EGRESS_DENIED",
-        { logicalPath: input.logicalPath }
-      ) : error;
-    }
-    if (attempt < STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS) {
-      await sleep2(250 * attempt);
-    }
-  }
-  throw lastError instanceof Error ? lastError : new DeeplineError(
-    `Direct storage upload of ${input.logicalPath} failed.`,
-    void 0,
-    "STAGED_FILE_UPLOAD_FAILED",
-    { logicalPath: input.logicalPath }
-  );
-}
 function readStringArray(value) {
   return Array.isArray(value) ? value.filter((line) => typeof line === "string") : [];
 }
@@ -4532,51 +4735,12 @@ var DeeplineClient = class _DeeplineClient {
    * ```
    */
   async startPlayRun(request) {
-    const integrationMode = resolvePlayRunIntegrationMode(request);
-    const testPolicyOverrides = request.testPolicyOverrides ?? parseEnvTestPolicyOverrides();
-    const forceToolRefresh = request.forceToolRefresh === true;
-    const runtime = resolvePlayRunRuntimeSelection(request);
-    const response = await this.http.post(
-      "/api/v2/plays/run",
-      {
-        ...request.name ? { name: request.name } : {},
-        ...request.revisionId ? { revisionId: request.revisionId } : {},
-        ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
-        ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
-        ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
-        ...request.description ? { description: request.description } : {},
-        ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
-        ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
-        ...request.graphHash ? { graphHash: request.graphHash } : {},
-        ...request.runtimeArtifact ? { runtimeArtifact: request.runtimeArtifact } : {},
-        ...request.compilerManifest ? { compilerManifest: request.compilerManifest } : {},
-        ...request.inputFileUpload ? { inputFileUpload: request.inputFileUpload } : {},
-        ...request.packagedFileUploads?.length ? { packagedFileUploads: request.packagedFileUploads } : {},
-        ...request.input ? { input: request.input } : {},
-        ...request.inputFile ? { inputFile: request.inputFile } : {},
-        ...request.packagedFiles?.length ? { packagedFiles: request.packagedFiles } : {},
-        ...request.force ? { force: true } : {},
-        ...forceToolRefresh ? { forceToolRefresh: true } : {},
-        ...typeof request.maxConcurrentExternalCalls === "number" ? {
-          maxConcurrentExternalCalls: request.maxConcurrentExternalCalls
-        } : {},
-        ...typeof request.maxConcurrentRows === "number" ? { maxConcurrentRows: request.maxConcurrentRows } : {},
-        ...typeof request.waitForCompletionMs === "number" ? { waitForCompletionMs: request.waitForCompletionMs } : {},
-        // Profile selection is the API's job, not the CLI's. The server
-        // defaults to absurd; callers normally omit this field.
-        ...request.profile ? { profile: request.profile } : {},
-        ...integrationMode ? { integrationMode } : {},
-        ...request.fixtureBehavior ? { fixtureBehavior: request.fixtureBehavior } : {},
-        ...runtime ? { runtime } : {},
-        ...testPolicyOverrides ? { testPolicyOverrides } : {}
-      },
-      runtimeSelectionHeaders(runtime),
-      // A start can reach the server even when its response is lost or times
-      // out. Retrying this mutation without an idempotency key can create a
-      // second root run, so callers must resolve ambiguous failures explicitly.
-      { maxRetries: 0, exactUrlOnly: true }
+    const resolved = resolveStartPlayRunRequest(request);
+    return startPlayRun(
+      this.http,
+      resolved.request,
+      runtimeSelectionHeaders(resolved.runtime)
     );
-    return normalizePlayRunStart(response);
   }
   /**
    * Submit a play run through the legacy event response.
@@ -4592,44 +4756,14 @@ var DeeplineClient = class _DeeplineClient {
    * @returns Async generator of play-scoped live events.
    */
   async *startPlayRunStream(request, options) {
-    const integrationMode = resolvePlayRunIntegrationMode(request);
-    const testPolicyOverrides = request.testPolicyOverrides ?? parseEnvTestPolicyOverrides();
-    const forceToolRefresh = request.forceToolRefresh === true;
-    const runtime = resolvePlayRunRuntimeSelection(request);
-    const body = {
-      ...request.name ? { name: request.name } : {},
-      ...request.revisionId ? { revisionId: request.revisionId } : {},
-      ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
-      ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
-      ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
-      ...request.description ? { description: request.description } : {},
-      ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
-      ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
-      ...request.graphHash ? { graphHash: request.graphHash } : {},
-      ...request.runtimeArtifact ? { runtimeArtifact: request.runtimeArtifact } : {},
-      ...request.compilerManifest ? { compilerManifest: request.compilerManifest } : {},
-      ...request.inputFileUpload ? { inputFileUpload: request.inputFileUpload } : {},
-      ...request.packagedFileUploads?.length ? { packagedFileUploads: request.packagedFileUploads } : {},
-      ...request.input ? { input: request.input } : {},
-      ...request.inputFile ? { inputFile: request.inputFile } : {},
-      ...request.packagedFiles?.length ? { packagedFiles: request.packagedFiles } : {},
-      ...request.force ? { force: true } : {},
-      ...forceToolRefresh ? { forceToolRefresh: true } : {},
-      ...typeof request.maxConcurrentExternalCalls === "number" ? { maxConcurrentExternalCalls: request.maxConcurrentExternalCalls } : {},
-      ...typeof request.maxConcurrentRows === "number" ? { maxConcurrentRows: request.maxConcurrentRows } : {},
-      ...typeof request.waitForCompletionMs === "number" ? { waitForCompletionMs: request.waitForCompletionMs } : {},
-      ...request.profile ? { profile: request.profile } : {},
-      ...integrationMode ? { integrationMode } : {},
-      ...request.fixtureBehavior ? { fixtureBehavior: request.fixtureBehavior } : {},
-      ...runtime ? { runtime } : {},
-      ...testPolicyOverrides ? { testPolicyOverrides } : {}
-    };
+    const resolved = resolveStartPlayRunRequest(request);
+    const body = buildPlayRunStartBody(resolved.request);
     for await (const event of this.http.streamSse(
-      "/api/v2/plays/run?stream=true",
+      PLAY_RUN_START_STREAM_PATH,
       {
         method: "POST",
         body,
-        headers: runtimeSelectionHeaders(runtime),
+        headers: runtimeSelectionHeaders(resolved.runtime),
         signal: options?.signal
       }
     )) {
@@ -4728,7 +4862,7 @@ var DeeplineClient = class _DeeplineClient {
         if (delayMs === void 0 || !isTransientCompileManifestError(error)) {
           throw error;
         }
-        await sleep2(delayMs);
+        await sleep3(delayMs);
       }
     }
   }
@@ -4895,81 +5029,7 @@ var DeeplineClient = class _DeeplineClient {
    * ```
    */
   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
-      );
-    }
-    const directResults = 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 { ref: upload.ref };
-        }
-        try {
-          await uploadStagedFileToPresignedUrl({
-            url: upload.uploadUrl,
-            headers: upload.uploadHeaders ?? {
-              "content-type": file.contentType
-            },
-            body: decodeBase64Bytes(file.contentBase64),
-            logicalPath: file.logicalPath
-          });
-          return { ref: upload.ref };
-        } catch (error) {
-          if (isStagedUploadDirectEgressDenied(error)) {
-            return { fallbackFile: file };
-          }
-          throw error;
-        }
-      })
-    );
-    return await Promise.all(
-      directResults.map(async (result) => {
-        if ("fallbackFile" in result) {
-          const [ref] = await this.stagePlayFilesViaMultipart(
-            [result.fallbackFile],
-            "direct-egress-denied"
-          );
-          if (!ref) {
-            throw new DeeplineError(
-              `The staging server did not return an upload target for ${result.fallbackFile.logicalPath}.`,
-              void 0,
-              "STAGED_FILE_MINT_INCOMPLETE"
-            );
-          }
-          return ref;
-        }
-        return result.ref;
-      })
-    );
+    return stagePlayFiles(this.http, files);
   }
   /**
    * Mint short-lived presigned upload targets for staged play files.
@@ -4979,55 +5039,7 @@ var DeeplineClient = class _DeeplineClient {
    * 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, reason = "mint-unsupported") {
-    for (const file of files) {
-      if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
-        const reasonMessage = reason === "direct-egress-denied" ? "direct storage is blocked by this environment's network egress policy" : "the connected Deepline server does not support direct-to-storage uploads";
-        throw new DeeplineError(
-          `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): ${reasonMessage}, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to.`,
-          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(
-        "metadata",
-        JSON.stringify({
-          files: files.map((file, index) => ({
-            index,
-            logicalPath: file.logicalPath,
-            contentHash: file.contentHash,
-            contentType: file.contentType,
-            bytes: file.bytes
-          }))
-        })
-      );
-      for (const [index, file] of files.entries()) {
-        const bytes = decodeBase64Bytes(file.contentBase64);
-        const body = bytes.buffer.slice(
-          bytes.byteOffset,
-          bytes.byteOffset + bytes.byteLength
-        );
-        formData.set(
-          `file:${index}`,
-          new Blob([body], { type: file.contentType }),
-          file.logicalPath
-        );
-      }
-      return formData;
-    };
-    const response = await this.http.postFormData("/api/v2/plays/files/stage", buildFormData);
-    return response.files;
+    return mintStagedPlayFileUploads(this.http, files);
   }
   /**
    * Resolve staged play files by content hash without uploading bytes.
@@ -5463,7 +5475,7 @@ var DeeplineClient = class _DeeplineClient {
     }
     return this.http.post(
       `/api/v2/runs/${encodeURIComponent(runId)}/rerun`,
-      {},
+      options?.inputOverrides ? { inputOverrides: options.inputOverrides } : {},
       { "Idempotency-Key": idempotencyKey || globalThis.crypto.randomUUID() }
     );
   }
@@ -5598,8 +5610,8 @@ var DeeplineClient = class _DeeplineClient {
     if (input.runId?.trim()) {
       params.set("runId", input.runId.trim());
     }
-    if (input.rowMode === "all") {
-      params.set("rowMode", "all");
+    if (input.rowMode === "all" || input.rowMode === "live") {
+      params.set("rowMode", input.rowMode);
     }
     const result = await this.http.get(
       `/api/v2/plays/${encodeURIComponent(input.playName)}/sheet?${params.toString()}`,
@@ -5763,6 +5775,18 @@ var DeeplineClient = class _DeeplineClient {
       patch
     );
   }
+  /** Read a Play's cron and webhook triggers and their scheduler state. */
+  async getPlayTriggerConfig(playName) {
+    return this.http.get(playTriggerConfigPath(playName));
+  }
+  /**
+   * Declare a Play's cron and/or webhook trigger (null removes it) and publish
+   * the rewritten source as a new live revision. Retry-safe: a request the
+   * live revision already satisfies returns `changed: false`.
+   */
+  async updatePlayTriggerConfig(playName, update) {
+    return this.http.put(playTriggerConfigPath(playName), update);
+  }
   /** List one bounded page of existing Play locations; continue with cursor. */
   async listPlaySettingsPaths(options = {}) {
     const query = new URLSearchParams();
@@ -6425,6 +6449,16 @@ var DeeplineClient = class _DeeplineClient {
     }
     return event;
   }
+  /**
+   * What Deepline has billed each run so far (customer-visible credits, never
+   * provider spend) and whether any of its charges is still settling — the
+   * same read the dashboard's runs grid shows. `GET /api/v2/runs/billing`.
+   */
+  async getRunBilling(runIds) {
+    const params = new URLSearchParams();
+    for (const runId of runIds) params.append("runId", runId);
+    return this.http.get(`/api/v2/runs/billing?${params}`);
+  }
   /**
    * Read workspace usage and recent customer-facing Deepline charges. Pass
    * the `job_id` from `executeTool` as `requestId` to retrieve one exact call,
@@ -7140,7 +7174,7 @@ var DeeplineClient = class _DeeplineClient {
       const state = typeof job?.state === "string" ? job.state : void 0;
       if (state && terminal.has(state)) return latest;
       if (Date.now() - startedAt >= timeoutMs) return latest;
-      await sleep2(pollIntervalMs);
+      await sleep3(pollIntervalMs);
       latest = await this.getMonitorJob(jobId);
     }
   }
@@ -7253,7 +7287,7 @@ var DeeplineClient = class _DeeplineClient {
       const status = typeof latest.status === "string" ? latest.status : void 0;
       if (status && terminal.has(status)) return latest;
       if (Date.now() - startedAt >= timeoutMs) return latest;
-      await sleep2(pollIntervalMs);
+      await sleep3(pollIntervalMs);
       latest = await this.getMonitorFleet(fleetId);
     }
   }