deepline 0.3.294 → 0.3.296

package/dist/cli/chunk-JNNOCMQY.js

@@ -0,0 +1,47 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/cli/getting-started.ts
+var DEEPLINE_GTM_SKILL = "/deepline-gtm";
+var DEEPLINE_GTM_STARTER_PROMPTS = [
+  {
+    id: "competitor-tracking",
+    title: "Competitor tracking",
+    prompt: "/deepline-gtm Track competitors of my company. Use my business email domain when available; otherwise ask for my company name."
+  },
+  {
+    id: "contact-email-enrichment",
+    title: "Contact email enrichment",
+    prompt: "/deepline-gtm Find 10 CTOs at B2B SaaS companies and enrich them with email addresses."
+  },
+  {
+    // Historical ID retained for SDK payload compatibility; the current
+    // starter copy is the fintech hiring-and-growth workflow below.
+    id: "decision-maker-discovery",
+    title: "Fintech hiring and growth",
+    prompt: "/deepline-gtm Find five fintech companies with live SDR openings and six-month headcount growth. Show dated evidence for both."
+  }
+];
+var DEEPLINE_GTM_PRIMARY_STARTER_PROMPT = DEEPLINE_GTM_STARTER_PROMPTS[0].prompt;
+var DEEPLINE_GTM_HANDOFF_QUESTION = "What would you like to do with Deepline?";
+var DEEPLINE_GTM_CUSTOM_OPTION = "Tell me what you want to accomplish and I'll help you build it";
+var DEEPLINE_GTM_STARTER_OPTIONS = [
+  ...DEEPLINE_GTM_STARTER_PROMPTS.map(({ prompt }) => prompt),
+  DEEPLINE_GTM_CUSTOM_OPTION
+];
+function deeplineGtmGettingStartedPayload() {
+  return {
+    skill: DEEPLINE_GTM_SKILL,
+    examples: DEEPLINE_GTM_STARTER_PROMPTS,
+    question: DEEPLINE_GTM_HANDOFF_QUESTION,
+    customOption: DEEPLINE_GTM_CUSTOM_OPTION,
+    customProblemBehavior: "Turn the business problem into one exact /deepline-gtm prompt, show that reusable prompt, then execute it without asking the user to paste it again."
+  };
+}
+
+
+
+
+
+
+
+
+
+exports.DEEPLINE_GTM_SKILL = DEEPLINE_GTM_SKILL; exports.DEEPLINE_GTM_STARTER_PROMPTS = DEEPLINE_GTM_STARTER_PROMPTS; exports.DEEPLINE_GTM_PRIMARY_STARTER_PROMPT = DEEPLINE_GTM_PRIMARY_STARTER_PROMPT; exports.DEEPLINE_GTM_HANDOFF_QUESTION = DEEPLINE_GTM_HANDOFF_QUESTION; exports.DEEPLINE_GTM_CUSTOM_OPTION = DEEPLINE_GTM_CUSTOM_OPTION; exports.DEEPLINE_GTM_STARTER_OPTIONS = DEEPLINE_GTM_STARTER_OPTIONS; exports.deeplineGtmGettingStartedPayload = deeplineGtmGettingStartedPayload;

package/dist/cli/chunk-KRD6H754.mjs

@@ -0,0 +1,30 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};

package/dist/cli/chunk-L4HBNHFW.js

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk4Y6CG4GEjs = require('./chunk-4Y6CG4GE.js');
+
+// src/cli/npm-script-policy.ts
+var _child_process = require('child_process');
+function npmSupportsAllowScripts(version) {
+  const match = /^(\d+)\.(\d+)(?:\.|$)/.exec(_nullishCoalesce(_optionalChain([version, 'optionalAccess', _ => _.trim, 'call', _2 => _2()]), () => ( "")));
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > 11 || major === 11 && minor >= 16;
+}
+function readNpmVersion(env) {
+  try {
+    const plan = _chunk4Y6CG4GEjs.resolveShellSpawn.call(void 0, "npm", ["--version"]);
+    const result = _child_process.spawnSync.call(void 0, plan.command, plan.args, {
+      encoding: "utf8",
+      env,
+      shell: plan.shell,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    });
+    if (result.status !== 0) return null;
+    return String(_nullishCoalesce(result.stdout, () => ( ""))).trim() || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+
+
+
+exports.npmSupportsAllowScripts = npmSupportsAllowScripts; exports.readNpmVersion = readNpmVersion;

package/dist/cli/chunk-LA46MMTL.js

@@ -0,0 +1,560 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkXNYIZMNQjs = require('./chunk-XNYIZMNQ.js');
+
+
+var _chunk7P5AA3SNjs = require('./chunk-7P5AA3SN.js');
+
+// ../play-runtime/run-lifecycle-policy.ts
+var TERMINAL_PLAY_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled",
+  "terminated",
+  "timed_out"
+]);
+function normalizePlayRunLifecycleStatus(value) {
+  const normalized = String(_nullishCoalesce(value, () => ( ""))).trim().toLowerCase();
+  switch (normalized) {
+    case "queued":
+    case "pending":
+      return "queued";
+    case "running":
+    case "started":
+      return "running";
+    case "waiting":
+      return "waiting";
+    case "completed":
+    case "complete":
+    case "succeeded":
+      return "completed";
+    case "failed":
+    case "error":
+      return "failed";
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    case "terminated":
+      return "terminated";
+    case "timed_out":
+    case "timeout":
+      return "timed_out";
+    default:
+      return "unknown";
+  }
+}
+function isTerminalPlayRunLifecycleStatus(status) {
+  return TERMINAL_PLAY_RUN_STATUSES.has(
+    normalizePlayRunLifecycleStatus(status)
+  );
+}
+function decodePlayRunPublicStatus(value) {
+  const status = normalizePlayRunLifecycleStatus(value);
+  switch (status) {
+    case "queued":
+    case "running":
+    case "waiting":
+    case "completed":
+    case "failed":
+    case "cancelled":
+      return status;
+    case "terminated":
+    case "timed_out":
+      return "cancelled";
+    case "unknown":
+      return null;
+  }
+}
+
+// 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 } : {},
+    ..._optionalChain([request, 'access', _ => _.packagedFileUploads, 'optionalAccess', _2 => _2.length]) ? { packagedFileUploads: request.packagedFileUploads } : {},
+    ...request.input ? { input: request.input } : {},
+    ...request.inputFile ? { inputFile: request.inputFile } : {},
+    ..._optionalChain([request, 'access', _3 => _3.packagedFiles, 'optionalAccess', _4 => _4.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 _optionalChain([value, 'access', _5 => _5.run, 'optionalAccess', _6 => _6.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
+  };
+}
+function buildNamedPlayRunRequest(input) {
+  return {
+    name: input.name,
+    ...input.revisionId ? { revisionId: input.revisionId } : {},
+    ...Object.keys(input.runtimeInput).length > 0 ? { input: input.runtimeInput } : {},
+    ...input.stagedFileInputs.inputFile ? { inputFile: input.stagedFileInputs.inputFile } : {},
+    ...input.stagedFileInputs.packagedFiles.length ? { packagedFiles: input.stagedFileInputs.packagedFiles } : {},
+    ...input.extra
+  };
+}
+var CSV_DATA_INPUT_KEY = "csv";
+function schemaMetadata(schema, key) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return null;
+  const value = schema[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringMetadata(metadata, key) {
+  const value = _optionalChain([metadata, 'optionalAccess', _7 => _7[key]]);
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function inputFieldFromCsvArg(csvArg) {
+  if (typeof csvArg !== "string") return null;
+  const match = /^\(?\s*input\.([A-Za-z_$][\w$]*)\s*\)?(?:\s*\?\?[\s\S]+)?$/.exec(
+    csvArg.trim()
+  );
+  return _nullishCoalesce(_optionalChain([match, 'optionalAccess', _8 => _8[1]]), () => ( null));
+}
+function fileInputBindingsFromPlaySchema(inputSchema) {
+  const csvInput = schemaMetadata(inputSchema, "csvInput");
+  if (!csvInput) return [];
+  return [
+    {
+      inputPath: _nullishCoalesce(stringMetadata(csvInput, "inputField"), () => ( CSV_DATA_INPUT_KEY))
+    }
+  ];
+}
+function fileInputBindingsFromStaticPipeline(staticPipeline) {
+  if (!staticPipeline || typeof staticPipeline !== "object" || Array.isArray(staticPipeline)) {
+    return [];
+  }
+  const inputField = inputFieldFromCsvArg(
+    staticPipeline.csvArg
+  );
+  return inputField ? [{ inputPath: inputField }] : [];
+}
+function playRunFileInputBindings(play) {
+  return [
+    ...fileInputBindingsFromPlaySchema(play.inputSchema),
+    ...fileInputBindingsFromStaticPipeline(play.staticPipeline)
+  ];
+}
+function getDottedInputValue(input, path) {
+  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
+  let cursor = input;
+  for (const part of parts) {
+    if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
+      return void 0;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function setDottedInputValue(input, path, value) {
+  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) {
+    throw new Error(`Invalid play input flag path: ${path}`);
+  }
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const existing = cursor[part];
+    if (existing !== void 0 && (!existing || typeof existing !== "object" || Array.isArray(existing))) {
+      throw new Error(
+        `Cannot set --${path}; input.${part} is already a non-object value.`
+      );
+    }
+    if (!existing) {
+      cursor[part] = {};
+    }
+    cursor = cursor[part];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+var webStagedFileCodec = {
+  async sha256Hex(bytes) {
+    const digest = await globalThis.crypto.subtle.digest(
+      "SHA-256",
+      bytes
+    );
+    return Array.from(
+      new Uint8Array(digest),
+      (byte) => byte.toString(16).padStart(2, "0")
+    ).join("");
+  },
+  base64(bytes) {
+    let binary = "";
+    for (let offset = 0; offset < bytes.length; offset += 32768) {
+      binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+    }
+    return btoa(binary);
+  }
+};
+function stagedFileContentType(logicalPath) {
+  const lower = logicalPath.toLowerCase();
+  return lower.endsWith(".csv") ? "text/csv" : lower.endsWith(".json") ? "application/json" : "application/octet-stream";
+}
+async function createStagedFileUpload(logicalPath, bytes, codec = webStagedFileCodec) {
+  return {
+    logicalPath,
+    contentBase64: codec.base64(bytes),
+    contentHash: await codec.sha256Hex(bytes),
+    contentType: stagedFileContentType(logicalPath),
+    bytes: bytes.byteLength
+  };
+}
+var STAGE_LEGACY_MULTIPART_MAX_BYTES = 4e6;
+var STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS = 3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stagedUploadIdentity(logicalPath, contentHash) {
+  return `${contentHash}:${logicalPath}`;
+}
+function isStagedUploadMintUnsupported(error) {
+  return error instanceof _chunk7P5AA3SNjs.DeeplineError && error.statusCode === 404;
+}
+function isStagedUploadDirectEgressDenied(error) {
+  return error instanceof _chunk7P5AA3SNjs.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 && _optionalChain([response, 'access', _9 => _9.headers, 'access', _10 => _10.get, 'call', _11 => _11("x-deny-reason"), 'optionalAccess', _12 => _12.trim, 'call', _13 => _13(), 'access', _14 => _14.toLowerCase, 'call', _15 => _15()]) === "host_not_allowed";
+      lastError = new (0, _chunk7P5AA3SNjs.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 (0, _chunk7P5AA3SNjs.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 sleep(250 * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new (0, _chunk7P5AA3SNjs.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 _nullishCoalesce(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 (0, _chunk7P5AA3SNjs.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 (0, _chunk7P5AA3SNjs.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: _nullishCoalesce(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 (0, _chunk7P5AA3SNjs.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;
+    })
+  );
+}
+async function stageFileInputs(input) {
+  const uniqueBindings = [
+    ...new Map(
+      input.bindings.map((binding) => [binding.inputPath, binding])
+    ).values()
+  ];
+  const localFiles = uniqueBindings.flatMap((binding) => {
+    const file = input.resolveLocalFile(
+      getDottedInputValue(input.runtimeInput, binding.inputPath),
+      binding
+    );
+    return file ? [{ binding, file }] : [];
+  });
+  if (localFiles.length === 0) {
+    return { inputFile: null, packagedFiles: [] };
+  }
+  _optionalChain([input, 'access', _16 => _16.onStaging, 'optionalCall', _17 => _17(localFiles.length)]);
+  const uploads = await Promise.all(
+    localFiles.map(
+      async ({ file }) => createStagedFileUpload(file.logicalPath, await file.read(), input.codec)
+    )
+  );
+  const staged = await input.stage(uploads);
+  for (const [index, { binding, file }] of localFiles.entries()) {
+    setDottedInputValue(
+      input.runtimeInput,
+      binding.inputPath,
+      file.logicalPath
+    );
+    const stagedFile = staged[index];
+    if (stagedFile && stagedFile.logicalPath !== file.logicalPath) {
+      setDottedInputValue(
+        input.runtimeInput,
+        binding.inputPath,
+        stagedFile.logicalPath
+      );
+    }
+  }
+  return {
+    inputFile: _nullishCoalesce(staged[0], () => ( null)),
+    packagedFiles: staged.slice(1)
+  };
+}
+function createSessionPlayRunHttp(fetchImpl = (...args) => fetch(...args)) {
+  const send = async (path, init) => {
+    const response = await fetchImpl(path, {
+      ...init,
+      credentials: "include"
+    });
+    const text = await response.text();
+    let parsed = text;
+    try {
+      parsed = text ? JSON.parse(text) : null;
+    } catch (e) {
+    }
+    if (!response.ok) {
+      throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+        _chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status),
+        response.status,
+        _chunkXNYIZMNQjs.apiErrorCodeFromResponse.call(void 0, parsed),
+        { response: parsed }
+      );
+    }
+    return parsed;
+  };
+  return {
+    post: (path, body, headers) => send(path, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...headers },
+      body: JSON.stringify(body)
+    }),
+    postFormData: (path, formData) => send(path, {
+      method: "POST",
+      body: typeof formData === "function" ? formData() : formData
+    })
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.isTerminalPlayRunLifecycleStatus = isTerminalPlayRunLifecycleStatus; exports.decodePlayRunPublicStatus = decodePlayRunPublicStatus; exports.PLAY_RUN_START_PATH = PLAY_RUN_START_PATH; exports.PLAY_RUN_START_STREAM_PATH = PLAY_RUN_START_STREAM_PATH; exports.PLAY_FILES_STAGE_PATH = PLAY_FILES_STAGE_PATH; exports.PLAY_FILES_STAGE_MINT_PATH = PLAY_FILES_STAGE_MINT_PATH; exports.buildPlayRunStartBody = buildPlayRunStartBody; exports.startPlayRun = startPlayRun; exports.isPlayRunPackage = isPlayRunPackage; exports.normalizePlayRunStart = normalizePlayRunStart; exports.buildNamedPlayRunRequest = buildNamedPlayRunRequest; exports.CSV_DATA_INPUT_KEY = CSV_DATA_INPUT_KEY; exports.fileInputBindingsFromPlaySchema = fileInputBindingsFromPlaySchema; exports.fileInputBindingsFromStaticPipeline = fileInputBindingsFromStaticPipeline; exports.playRunFileInputBindings = playRunFileInputBindings; exports.getDottedInputValue = getDottedInputValue; exports.setDottedInputValue = setDottedInputValue; exports.webStagedFileCodec = webStagedFileCodec; exports.stagedFileContentType = stagedFileContentType; exports.createStagedFileUpload = createStagedFileUpload; exports.STAGE_LEGACY_MULTIPART_MAX_BYTES = STAGE_LEGACY_MULTIPART_MAX_BYTES; exports.mintStagedPlayFileUploads = mintStagedPlayFileUploads; exports.stagePlayFiles = stagePlayFiles; exports.stageFileInputs = stageFileInputs; exports.createSessionPlayRunHttp = createSessionPlayRunHttp;