tensorlake 0.4.39

package/dist/index.cjs

@@ -0,0 +1,1462 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIClient: () => APIClient,
+  CloudClient: () => CloudClient,
+  ContainerState: () => ContainerState,
+  OutputMode: () => OutputMode,
+  PoolInUseError: () => PoolInUseError,
+  PoolNotFoundError: () => PoolNotFoundError,
+  ProcessStatus: () => ProcessStatus,
+  RemoteAPIError: () => RemoteAPIError,
+  RequestExecutionError: () => RequestExecutionError,
+  RequestFailedError: () => RequestFailedError,
+  RequestNotFinishedError: () => RequestNotFinishedError,
+  Sandbox: () => Sandbox,
+  SandboxClient: () => SandboxClient,
+  SandboxConnectionError: () => SandboxConnectionError,
+  SandboxError: () => SandboxError,
+  SandboxException: () => SandboxException,
+  SandboxNotFoundError: () => SandboxNotFoundError,
+  SandboxStatus: () => SandboxStatus,
+  SnapshotStatus: () => SnapshotStatus,
+  StdinMode: () => StdinMode
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/defaults.ts
+var API_URL = process.env.TENSORLAKE_API_URL ?? "https://api.tensorlake.ai";
+var API_KEY = process.env.TENSORLAKE_API_KEY ?? void 0;
+var NAMESPACE = process.env.INDEXIFY_NAMESPACE ?? "default";
+var SANDBOX_PROXY_URL = process.env.TENSORLAKE_SANDBOX_PROXY_URL ?? "https://sandbox.tensorlake.ai";
+var DEFAULT_HTTP_TIMEOUT_MS = 3e4;
+var MAX_RETRIES = 3;
+var RETRY_BACKOFF_MS = 500;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+
+// src/errors.ts
+var SandboxException = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxException";
+  }
+};
+var SandboxError = class extends SandboxException {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxError";
+  }
+};
+var SandboxConnectionError = class extends SandboxError {
+  constructor(message) {
+    super(`Connection error: ${message}`);
+    this.name = "SandboxConnectionError";
+  }
+};
+var SandboxNotFoundError = class extends SandboxError {
+  sandboxId;
+  constructor(sandboxId) {
+    super(`Sandbox not found: ${sandboxId}`);
+    this.name = "SandboxNotFoundError";
+    this.sandboxId = sandboxId;
+  }
+};
+var PoolNotFoundError = class extends SandboxError {
+  poolId;
+  constructor(poolId) {
+    super(`Sandbox pool not found: ${poolId}`);
+    this.name = "PoolNotFoundError";
+    this.poolId = poolId;
+  }
+};
+var PoolInUseError = class extends SandboxError {
+  poolId;
+  constructor(poolId, message) {
+    const base = `Cannot delete pool ${poolId}: pool is in use`;
+    super(message ? `${base} - ${message}` : base);
+    this.name = "PoolInUseError";
+    this.poolId = poolId;
+  }
+};
+var RemoteAPIError = class extends SandboxError {
+  statusCode;
+  responseMessage;
+  constructor(statusCode, message) {
+    super(`API error (status ${statusCode}): ${message}`);
+    this.name = "RemoteAPIError";
+    this.statusCode = statusCode;
+    this.responseMessage = message;
+  }
+};
+var RequestNotFinishedError = class extends Error {
+  constructor() {
+    super("Request has not finished yet");
+    this.name = "RequestNotFinishedError";
+  }
+};
+var RequestFailedError = class extends Error {
+  failure;
+  constructor(failure) {
+    super(`Request failed: ${failure}`);
+    this.name = "RequestFailedError";
+    this.failure = failure;
+  }
+};
+var RequestExecutionError = class extends Error {
+  functionName;
+  constructor(message, functionName) {
+    super(
+      functionName ? `Request error in ${functionName}: ${message}` : message
+    );
+    this.name = "RequestExecutionError";
+    this.functionName = functionName;
+  }
+};
+
+// src/http.ts
+var HttpClient = class {
+  baseUrl;
+  headers;
+  maxRetries;
+  retryBackoffMs;
+  timeoutMs;
+  abortController = null;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.maxRetries = options.maxRetries ?? MAX_RETRIES;
+    this.retryBackoffMs = options.retryBackoffMs ?? RETRY_BACKOFF_MS;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
+    this.headers = {};
+    if (options.apiKey) {
+      this.headers["Authorization"] = `Bearer ${options.apiKey}`;
+    }
+    if (options.organizationId) {
+      this.headers["X-Forwarded-Organization-Id"] = options.organizationId;
+    }
+    if (options.projectId) {
+      this.headers["X-Forwarded-Project-Id"] = options.projectId;
+    }
+    if (options.hostHeader) {
+      this.headers["Host"] = options.hostHeader;
+    }
+  }
+  close() {
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+  /** Make a JSON request, returning the parsed response body. */
+  async requestJson(method, path, options) {
+    const response = await this.requestResponse(method, path, {
+      json: options?.body,
+      headers: options?.headers,
+      signal: options?.signal
+    });
+    const text = await response.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  /** Make a request returning raw bytes. */
+  async requestBytes(method, path, options) {
+    const headers = { ...options?.headers ?? {} };
+    if (options?.contentType) {
+      headers["Content-Type"] = options.contentType;
+    }
+    const response = await this.requestResponse(
+      method,
+      path,
+      {
+        body: options?.body,
+        headers,
+        signal: options?.signal
+      }
+    );
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  /** Make a request and return the raw Response (for SSE streaming). */
+  async requestStream(method, path, options) {
+    const response = await this.requestResponse(
+      method,
+      path,
+      {
+        headers: { Accept: "text/event-stream" },
+        signal: options?.signal
+      }
+    );
+    if (!response.body) {
+      throw new RemoteAPIError(response.status, "No response body for SSE stream");
+    }
+    return response.body;
+  }
+  /** Make a request and return the raw Response. */
+  async requestResponse(method, path, options) {
+    const headers = {
+      ...this.headers,
+      ...options?.headers ?? {}
+    };
+    const hasJsonBody = options?.json !== void 0;
+    if (hasJsonBody && !hasHeader(headers, "Content-Type")) {
+      headers["Content-Type"] = "application/json";
+    }
+    const body = hasJsonBody ? JSON.stringify(options?.json) : normalizeRequestBody(options?.body);
+    return this.doFetch(
+      method,
+      path,
+      body,
+      headers,
+      options?.signal,
+      options?.allowHttpErrors ?? false
+    );
+  }
+  async doFetch(method, path, body, headers, signal, allowHttpErrors = false) {
+    const url = `${this.baseUrl}${path}`;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = this.retryBackoffMs * Math.pow(2, attempt - 1);
+        await sleep(delay);
+      }
+      this.abortController = new AbortController();
+      const timeoutId = setTimeout(
+        () => this.abortController?.abort(),
+        this.timeoutMs
+      );
+      const combinedSignal = signal ? anySignal([signal, this.abortController.signal]) : this.abortController.signal;
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body,
+          signal: combinedSignal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) return response;
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+          lastError = new RemoteAPIError(
+            response.status,
+            await response.text().catch(() => "")
+          );
+          continue;
+        }
+        if (allowHttpErrors) {
+          return response;
+        }
+        const errorBody = await response.text().catch(() => "");
+        throwMappedError(response.status, errorBody, path);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof RemoteAPIError || err instanceof SandboxNotFoundError || err instanceof PoolNotFoundError || err instanceof PoolInUseError) {
+          throw err;
+        }
+        if (signal?.aborted) {
+          throw new SandboxConnectionError("Request aborted");
+        }
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt >= this.maxRetries) {
+          throw new SandboxConnectionError(lastError.message);
+        }
+      }
+    }
+    throw new SandboxConnectionError(lastError?.message ?? "Request failed");
+  }
+};
+function hasHeader(headers, name) {
+  const lowered = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === lowered);
+}
+function normalizeRequestBody(body) {
+  if (body == null) {
+    return void 0;
+  }
+  if (body instanceof Uint8Array) {
+    return Uint8Array.from(body).buffer;
+  }
+  return body;
+}
+function throwMappedError(status, body, path) {
+  let message = body;
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.message) message = parsed.message;
+    else if (parsed.error) message = parsed.error;
+  } catch {
+  }
+  if (status === 404) {
+    if (path.includes("sandbox-pools") || path.includes("pools")) {
+      const match = path.match(/sandbox-pools\/([^/]+)/);
+      if (match) throw new PoolNotFoundError(match[1]);
+    }
+    if (path.includes("sandboxes")) {
+      const match = path.match(/sandboxes\/([^/]+)/);
+      if (match) throw new SandboxNotFoundError(match[1]);
+    }
+    throw new RemoteAPIError(404, message);
+  }
+  if (status === 409) {
+    if (path.includes("sandbox-pools") || path.includes("pools")) {
+      const match = path.match(/sandbox-pools\/([^/]+)/);
+      if (match) throw new PoolInUseError(match[1], message);
+    }
+  }
+  throw new RemoteAPIError(status, message);
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), {
+      once: true
+    });
+  }
+  return controller.signal;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/models.ts
+var SandboxStatus = /* @__PURE__ */ ((SandboxStatus2) => {
+  SandboxStatus2["PENDING"] = "pending";
+  SandboxStatus2["RUNNING"] = "running";
+  SandboxStatus2["SNAPSHOTTING"] = "snapshotting";
+  SandboxStatus2["SUSPENDED"] = "suspended";
+  SandboxStatus2["TERMINATED"] = "terminated";
+  return SandboxStatus2;
+})(SandboxStatus || {});
+var SnapshotStatus = /* @__PURE__ */ ((SnapshotStatus2) => {
+  SnapshotStatus2["IN_PROGRESS"] = "in_progress";
+  SnapshotStatus2["COMPLETED"] = "completed";
+  SnapshotStatus2["FAILED"] = "failed";
+  return SnapshotStatus2;
+})(SnapshotStatus || {});
+var ProcessStatus = /* @__PURE__ */ ((ProcessStatus2) => {
+  ProcessStatus2["RUNNING"] = "running";
+  ProcessStatus2["EXITED"] = "exited";
+  ProcessStatus2["SIGNALED"] = "signaled";
+  return ProcessStatus2;
+})(ProcessStatus || {});
+var StdinMode = /* @__PURE__ */ ((StdinMode2) => {
+  StdinMode2["CLOSED"] = "closed";
+  StdinMode2["PIPE"] = "pipe";
+  return StdinMode2;
+})(StdinMode || {});
+var OutputMode = /* @__PURE__ */ ((OutputMode2) => {
+  OutputMode2["CAPTURE"] = "capture";
+  OutputMode2["DISCARD"] = "discard";
+  return OutputMode2;
+})(OutputMode || {});
+var ContainerState = /* @__PURE__ */ ((ContainerState2) => {
+  ContainerState2["IDLE"] = "Idle";
+  ContainerState2["RUNNING"] = "Running";
+  return ContainerState2;
+})(ContainerState || {});
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase());
+}
+function parseTimestamp(v) {
+  if (v == null) return void 0;
+  if (v instanceof Date) return v;
+  if (typeof v === "string") {
+    const parsed = Date.parse(v);
+    return Number.isNaN(parsed) ? void 0 : new Date(parsed);
+  }
+  const ts = Number(v);
+  if (isNaN(ts)) return void 0;
+  if (ts > 1e15) return new Date(ts / 1e3);
+  if (ts > 1e12) return new Date(ts);
+  return new Date(ts * 1e3);
+}
+function fromSnakeKeys(obj, idField) {
+  if (Array.isArray(obj)) return obj.map((item) => fromSnakeKeys(item, idField));
+  if (obj !== null && typeof obj === "object" && !(obj instanceof Date)) {
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+      let key;
+      if (k === "id" && idField) {
+        key = idField;
+      } else {
+        key = snakeToCamel(k);
+      }
+      if (key.endsWith("At") || key === "timestamp" || key === "startedAt" || key === "endedAt") {
+        result[key] = parseTimestamp(v);
+      } else if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+        result[key] = fromSnakeKeys(v);
+      } else if (Array.isArray(v)) {
+        result[key] = v.map((item) => fromSnakeKeys(item));
+      } else {
+        result[key] = v === null ? void 0 : v;
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/sse.ts
+async function* parseSSEMessages(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) break;
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split(/\r?\n\r?\n/);
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        const lines = part.split(/\r?\n/);
+        const dataLines = [];
+        let event;
+        let id;
+        for (const line of lines) {
+          if (!line || line.startsWith(":")) continue;
+          const separator = line.indexOf(":");
+          const field = separator === -1 ? line : line.slice(0, separator);
+          let value2 = separator === -1 ? "" : line.slice(separator + 1);
+          if (value2.startsWith(" ")) {
+            value2 = value2.slice(1);
+          }
+          if (field === "data") {
+            dataLines.push(value2);
+          } else if (field === "event") {
+            event = value2;
+          } else if (field === "id") {
+            id = value2;
+          }
+        }
+        if (dataLines.length > 0 || event || id) {
+          yield { data: dataLines.join("\n"), event, id };
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* parseSSEStream(stream, signal) {
+  for await (const message of parseSSEMessages(stream, signal)) {
+    if (!message.data) continue;
+    try {
+      yield JSON.parse(message.data);
+    } catch {
+    }
+  }
+}
+
+// src/url.ts
+function isLocalhost(apiUrl) {
+  try {
+    const parsed = new URL(apiUrl);
+    return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
+function resolveProxyUrl(apiUrl) {
+  const explicit = process.env.TENSORLAKE_SANDBOX_PROXY_URL;
+  if (explicit) return explicit;
+  if (isLocalhost(apiUrl)) return "http://localhost:9443";
+  try {
+    const parsed = new URL(apiUrl);
+    const host = parsed.hostname;
+    if (host.startsWith("api.")) {
+      const proxyHost = "sandbox." + host.slice(4);
+      return `${parsed.protocol}//${proxyHost}`;
+    }
+  } catch {
+  }
+  return SANDBOX_PROXY_URL;
+}
+function resolveProxyTarget(proxyUrl, sandboxId) {
+  try {
+    const parsed = new URL(proxyUrl);
+    const host = parsed.hostname;
+    if (host === "localhost" || host === "127.0.0.1") {
+      return {
+        baseUrl: proxyUrl.replace(/\/+$/, ""),
+        hostHeader: `${sandboxId}.local`
+      };
+    }
+    const port = parsed.port ? `:${parsed.port}` : "";
+    return {
+      baseUrl: `${parsed.protocol}//${sandboxId}.${host}${port}`,
+      hostHeader: void 0
+    };
+  } catch {
+    return {
+      baseUrl: `${proxyUrl.replace(/\/+$/, "")}/${sandboxId}`,
+      hostHeader: void 0
+    };
+  }
+}
+function lifecyclePath(path, isLocal, namespace) {
+  if (isLocal) {
+    return `/v1/namespaces/${namespace}/${path}`;
+  }
+  return `/${path}`;
+}
+
+// src/sandbox.ts
+var Sandbox = class {
+  sandboxId;
+  http;
+  baseUrl;
+  ownsSandbox = false;
+  lifecycleClient = null;
+  constructor(options) {
+    this.sandboxId = options.sandboxId;
+    const proxyUrl = options.proxyUrl ?? SANDBOX_PROXY_URL;
+    const { baseUrl, hostHeader } = resolveProxyTarget(proxyUrl, options.sandboxId);
+    this.baseUrl = baseUrl;
+    this.http = new HttpClient({
+      baseUrl,
+      apiKey: options.apiKey,
+      organizationId: options.organizationId,
+      projectId: options.projectId,
+      hostHeader
+    });
+  }
+  /** @internal Used by SandboxClient.createAndConnect to set ownership. */
+  _setOwner(client) {
+    this.ownsSandbox = true;
+    this.lifecycleClient = client;
+  }
+  close() {
+    this.http.close();
+  }
+  async terminate() {
+    const client = this.lifecycleClient;
+    this.ownsSandbox = false;
+    this.lifecycleClient = null;
+    this.close();
+    if (client) {
+      await client.delete(this.sandboxId);
+    }
+  }
+  // --- High-level convenience ---
+  async run(command, options) {
+    const proc = await this.startProcess(command, {
+      args: options?.args,
+      env: options?.env,
+      workingDir: options?.workingDir
+    });
+    const deadline = options?.timeout ? Date.now() + options.timeout * 1e3 : null;
+    let info;
+    while (true) {
+      info = await this.getProcess(proc.pid);
+      if (info.status !== "running" /* RUNNING */) break;
+      if (deadline && Date.now() > deadline) {
+        await this.killProcess(proc.pid);
+        throw new SandboxError(`Command timed out after ${options.timeout}s`);
+      }
+      await sleep2(100);
+    }
+    const stdoutResp = await this.getStdout(proc.pid);
+    const stderrResp = await this.getStderr(proc.pid);
+    let exitCode;
+    if (info.exitCode != null) {
+      exitCode = info.exitCode;
+    } else if (info.signal != null) {
+      exitCode = -info.signal;
+    } else {
+      exitCode = -1;
+    }
+    return {
+      exitCode,
+      stdout: stdoutResp.lines.join("\n"),
+      stderr: stderrResp.lines.join("\n")
+    };
+  }
+  // --- Process management ---
+  async startProcess(command, options) {
+    const payload = { command };
+    if (options?.args != null) payload.args = options.args;
+    if (options?.env != null) payload.env = options.env;
+    if (options?.workingDir != null) payload.working_dir = options.workingDir;
+    if (options?.stdinMode != null && options.stdinMode !== "closed" /* CLOSED */) {
+      payload.stdin_mode = options.stdinMode;
+    }
+    if (options?.stdoutMode != null && options.stdoutMode !== "capture" /* CAPTURE */) {
+      payload.stdout_mode = options.stdoutMode;
+    }
+    if (options?.stderrMode != null && options.stderrMode !== "capture" /* CAPTURE */) {
+      payload.stderr_mode = options.stderrMode;
+    }
+    const raw = await this.http.requestJson(
+      "POST",
+      "/api/v1/processes",
+      { body: payload }
+    );
+    return fromSnakeKeys(raw);
+  }
+  async listProcesses() {
+    const raw = await this.http.requestJson(
+      "GET",
+      "/api/v1/processes"
+    );
+    return (raw.processes ?? []).map((p) => fromSnakeKeys(p));
+  }
+  async getProcess(pid) {
+    const raw = await this.http.requestJson(
+      "GET",
+      `/api/v1/processes/${pid}`
+    );
+    return fromSnakeKeys(raw);
+  }
+  async killProcess(pid) {
+    await this.http.requestJson("DELETE", `/api/v1/processes/${pid}`);
+  }
+  async sendSignal(pid, signal) {
+    const raw = await this.http.requestJson(
+      "POST",
+      `/api/v1/processes/${pid}/signal`,
+      { body: { signal } }
+    );
+    return fromSnakeKeys(raw);
+  }
+  // --- Process I/O ---
+  async writeStdin(pid, data) {
+    await this.http.requestBytes("POST", `/api/v1/processes/${pid}/stdin`, {
+      body: data,
+      contentType: "application/octet-stream"
+    });
+  }
+  async closeStdin(pid) {
+    await this.http.requestJson("POST", `/api/v1/processes/${pid}/stdin/close`);
+  }
+  async getStdout(pid) {
+    const raw = await this.http.requestJson(
+      "GET",
+      `/api/v1/processes/${pid}/stdout`
+    );
+    return fromSnakeKeys(raw);
+  }
+  async getStderr(pid) {
+    const raw = await this.http.requestJson(
+      "GET",
+      `/api/v1/processes/${pid}/stderr`
+    );
+    return fromSnakeKeys(raw);
+  }
+  async getOutput(pid) {
+    const raw = await this.http.requestJson(
+      "GET",
+      `/api/v1/processes/${pid}/output`
+    );
+    return fromSnakeKeys(raw);
+  }
+  // --- Streaming (SSE) ---
+  async *followStdout(pid, options) {
+    const stream = await this.http.requestStream(
+      "GET",
+      `/api/v1/processes/${pid}/stdout/follow`,
+      options
+    );
+    for await (const raw of parseSSEStream(
+      stream,
+      options?.signal
+    )) {
+      yield fromSnakeKeys(raw);
+    }
+  }
+  async *followStderr(pid, options) {
+    const stream = await this.http.requestStream(
+      "GET",
+      `/api/v1/processes/${pid}/stderr/follow`,
+      options
+    );
+    for await (const raw of parseSSEStream(
+      stream,
+      options?.signal
+    )) {
+      yield fromSnakeKeys(raw);
+    }
+  }
+  async *followOutput(pid, options) {
+    const stream = await this.http.requestStream(
+      "GET",
+      `/api/v1/processes/${pid}/output/follow`,
+      options
+    );
+    for await (const raw of parseSSEStream(
+      stream,
+      options?.signal
+    )) {
+      yield fromSnakeKeys(raw);
+    }
+  }
+  // --- File operations ---
+  async readFile(path) {
+    return this.http.requestBytes(
+      "GET",
+      `/api/v1/files?path=${encodeURIComponent(path)}`
+    );
+  }
+  async writeFile(path, content) {
+    await this.http.requestBytes(
+      "PUT",
+      `/api/v1/files?path=${encodeURIComponent(path)}`,
+      { body: content, contentType: "application/octet-stream" }
+    );
+  }
+  async deleteFile(path) {
+    await this.http.requestJson(
+      "DELETE",
+      `/api/v1/files?path=${encodeURIComponent(path)}`
+    );
+  }
+  async listDirectory(path) {
+    const raw = await this.http.requestJson(
+      "GET",
+      `/api/v1/files/list?path=${encodeURIComponent(path)}`
+    );
+    return fromSnakeKeys(raw);
+  }
+  // --- PTY ---
+  async createPtySession(options) {
+    const payload = {
+      command: options.command,
+      rows: options.rows ?? 24,
+      cols: options.cols ?? 80
+    };
+    if (options.args != null) payload.args = options.args;
+    if (options.env != null) payload.env = options.env;
+    if (options.workingDir != null) payload.working_dir = options.workingDir;
+    const raw = await this.http.requestJson(
+      "POST",
+      "/api/v1/pty",
+      { body: payload }
+    );
+    return fromSnakeKeys(raw);
+  }
+  ptyWsUrl(sessionId, token) {
+    let wsBase;
+    if (this.baseUrl.startsWith("https://")) {
+      wsBase = "wss://" + this.baseUrl.slice(8);
+    } else if (this.baseUrl.startsWith("http://")) {
+      wsBase = "ws://" + this.baseUrl.slice(7);
+    } else {
+      wsBase = this.baseUrl;
+    }
+    return `${wsBase}/api/v1/pty/${sessionId}/ws?token=${token}`;
+  }
+  // --- Health ---
+  async health() {
+    const raw = await this.http.requestJson(
+      "GET",
+      "/api/v1/health"
+    );
+    return fromSnakeKeys(raw);
+  }
+  async info() {
+    const raw = await this.http.requestJson(
+      "GET",
+      "/api/v1/info"
+    );
+    return fromSnakeKeys(raw);
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/client.ts
+var SandboxClient = class _SandboxClient {
+  http;
+  apiUrl;
+  apiKey;
+  organizationId;
+  projectId;
+  namespace;
+  local;
+  constructor(options) {
+    this.apiUrl = options?.apiUrl ?? API_URL;
+    this.apiKey = options?.apiKey ?? API_KEY;
+    this.organizationId = options?.organizationId;
+    this.projectId = options?.projectId;
+    this.namespace = options?.namespace ?? NAMESPACE;
+    this.local = isLocalhost(this.apiUrl);
+    this.http = new HttpClient({
+      baseUrl: this.apiUrl,
+      apiKey: this.apiKey,
+      organizationId: this.organizationId,
+      projectId: this.projectId,
+      maxRetries: options?.maxRetries ?? MAX_RETRIES,
+      retryBackoffMs: options?.retryBackoffMs ?? RETRY_BACKOFF_MS
+    });
+  }
+  /** Create a client for the TensorLake cloud platform. */
+  static forCloud(options) {
+    return new _SandboxClient({
+      apiUrl: options?.apiUrl ?? "https://api.tensorlake.ai",
+      apiKey: options?.apiKey,
+      organizationId: options?.organizationId,
+      projectId: options?.projectId
+    });
+  }
+  /** Create a client for a local Indexify server. */
+  static forLocalhost(options) {
+    return new _SandboxClient({
+      apiUrl: options?.apiUrl ?? "http://localhost:8900",
+      namespace: options?.namespace ?? "default"
+    });
+  }
+  close() {
+    this.http.close();
+  }
+  // --- Path helper ---
+  path(subpath) {
+    return lifecyclePath(subpath, this.local, this.namespace);
+  }
+  // --- Sandbox CRUD ---
+  async create(options) {
+    const body = {
+      resources: {
+        cpus: options?.cpus ?? 1,
+        memory_mb: options?.memoryMb ?? 1024,
+        ephemeral_disk_mb: options?.ephemeralDiskMb ?? 1024
+      }
+    };
+    if (options?.image != null) body.image = options.image;
+    if (options?.secretNames != null) body.secret_names = options.secretNames;
+    if (options?.timeoutSecs != null) body.timeout_secs = options.timeoutSecs;
+    if (options?.entrypoint != null) body.entrypoint = options.entrypoint;
+    if (options?.snapshotId != null) body.snapshot_id = options.snapshotId;
+    if (options?.name != null) body.name = options.name;
+    if (options?.allowInternetAccess === false || options?.allowOut != null || options?.denyOut != null) {
+      body.network = {
+        allow_internet_access: options?.allowInternetAccess ?? true,
+        allow_out: options?.allowOut ?? [],
+        deny_out: options?.denyOut ?? []
+      };
+    }
+    const raw = await this.http.requestJson(
+      "POST",
+      this.path("sandboxes"),
+      { body }
+    );
+    return fromSnakeKeys(raw, "sandboxId");
+  }
+  async get(sandboxId) {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.path(`sandboxes/${sandboxId}`)
+    );
+    return fromSnakeKeys(raw, "sandboxId");
+  }
+  async list() {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.path("sandboxes")
+    );
+    return (raw.sandboxes ?? []).map(
+      (s) => fromSnakeKeys(s, "sandboxId")
+    );
+  }
+  async update(sandboxId, options) {
+    const body = {};
+    if (options.name != null) body.name = options.name;
+    const raw = await this.http.requestJson(
+      "PATCH",
+      this.path(`sandboxes/${sandboxId}`),
+      { body }
+    );
+    return fromSnakeKeys(raw, "sandboxId");
+  }
+  async delete(sandboxId) {
+    await this.http.requestJson(
+      "DELETE",
+      this.path(`sandboxes/${sandboxId}`)
+    );
+  }
+  async claim(poolId) {
+    const raw = await this.http.requestJson(
+      "POST",
+      this.path(`sandbox-pools/${poolId}/sandboxes`)
+    );
+    return fromSnakeKeys(raw, "sandboxId");
+  }
+  // --- Snapshots ---
+  async snapshot(sandboxId) {
+    const raw = await this.http.requestJson(
+      "POST",
+      this.path(`sandboxes/${sandboxId}/snapshot`)
+    );
+    return fromSnakeKeys(raw, "snapshotId");
+  }
+  async getSnapshot(snapshotId) {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.path(`snapshots/${snapshotId}`)
+    );
+    return fromSnakeKeys(raw, "snapshotId");
+  }
+  async listSnapshots() {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.path("snapshots")
+    );
+    return (raw.snapshots ?? []).map(
+      (s) => fromSnakeKeys(s, "snapshotId")
+    );
+  }
+  async deleteSnapshot(snapshotId) {
+    await this.http.requestJson(
+      "DELETE",
+      this.path(`snapshots/${snapshotId}`)
+    );
+  }
+  async snapshotAndWait(sandboxId, options) {
+    const timeout = options?.timeout ?? 300;
+    const pollInterval = options?.pollInterval ?? 1;
+    const result = await this.snapshot(sandboxId);
+    const deadline = Date.now() + timeout * 1e3;
+    while (Date.now() < deadline) {
+      const info = await this.getSnapshot(result.snapshotId);
+      if (info.status === "completed" /* COMPLETED */) return info;
+      if (info.status === "failed" /* FAILED */) {
+        throw new SandboxError(
+          `Snapshot ${result.snapshotId} failed: ${info.error}`
+        );
+      }
+      await sleep3(pollInterval * 1e3);
+    }
+    throw new SandboxError(
+      `Snapshot ${result.snapshotId} did not complete within ${timeout}s`
+    );
+  }
+  // --- Pools ---
+  async createPool(options) {
+    const body = {
+      image: options.image,
+      resources: {
+        cpus: options.cpus ?? 1,
+        memory_mb: options.memoryMb ?? 1024,
+        ephemeral_disk_mb: options.ephemeralDiskMb ?? 1024
+      },
+      timeout_secs: options.timeoutSecs ?? 0
+    };
+    if (options.secretNames != null) body.secret_names = options.secretNames;
+    if (options.entrypoint != null) body.entrypoint = options.entrypoint;
+    if (options.maxContainers != null) body.max_containers = options.maxContainers;
+    if (options.warmContainers != null) body.warm_containers = options.warmContainers;
+    const raw = await this.http.requestJson(
+      "POST",
+      this.path("sandbox-pools"),
+      { body }
+    );
+    return fromSnakeKeys(raw, "poolId");
+  }
+  async getPool(poolId) {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.path(`sandbox-pools/${poolId}`)
+    );
+    return fromSnakeKeys(raw, "poolId");
+  }
+  async listPools() {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.path("sandbox-pools")
+    );
+    return (raw.pools ?? []).map(
+      (p) => fromSnakeKeys(p, "poolId")
+    );
+  }
+  async updatePool(poolId, options) {
+    const body = {
+      image: options.image,
+      resources: {
+        cpus: options.cpus ?? 1,
+        memory_mb: options.memoryMb ?? 1024,
+        ephemeral_disk_mb: options.ephemeralDiskMb ?? 1024
+      },
+      timeout_secs: options.timeoutSecs ?? 0
+    };
+    if (options.secretNames != null) body.secret_names = options.secretNames;
+    if (options.entrypoint != null) body.entrypoint = options.entrypoint;
+    if (options.maxContainers != null) body.max_containers = options.maxContainers;
+    if (options.warmContainers != null) body.warm_containers = options.warmContainers;
+    const raw = await this.http.requestJson(
+      "PUT",
+      this.path(`sandbox-pools/${poolId}`),
+      { body }
+    );
+    return fromSnakeKeys(raw, "poolId");
+  }
+  async deletePool(poolId) {
+    await this.http.requestJson(
+      "DELETE",
+      this.path(`sandbox-pools/${poolId}`)
+    );
+  }
+  // --- Connect ---
+  connect(sandboxId, proxyUrl) {
+    const resolvedProxy = proxyUrl ?? resolveProxyUrl(this.apiUrl);
+    return new Sandbox({
+      sandboxId,
+      proxyUrl: resolvedProxy,
+      apiKey: this.apiKey,
+      organizationId: this.organizationId,
+      projectId: this.projectId
+    });
+  }
+  async createAndConnect(options) {
+    const startupTimeout = options?.startupTimeout ?? 60;
+    let result;
+    if (options?.poolId != null) {
+      result = await this.claim(options.poolId);
+    } else {
+      result = await this.create(options);
+    }
+    const deadline = Date.now() + startupTimeout * 1e3;
+    while (Date.now() < deadline) {
+      const info = await this.get(result.sandboxId);
+      if (info.status === "running" /* RUNNING */) {
+        const sandbox = this.connect(result.sandboxId, options?.proxyUrl);
+        sandbox._setOwner(this);
+        return sandbox;
+      }
+      if (info.status === "terminated" /* TERMINATED */) {
+        throw new SandboxError(
+          `Sandbox ${result.sandboxId} terminated during startup`
+        );
+      }
+      await sleep3(500);
+    }
+    try {
+      await this.delete(result.sandboxId);
+    } catch {
+    }
+    throw new SandboxError(
+      `Sandbox ${result.sandboxId} did not start within ${startupTimeout}s`
+    );
+  }
+};
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/cloud-client.ts
+var CloudClient = class _CloudClient {
+  http;
+  organizationId;
+  projectId;
+  namespace;
+  constructor(options) {
+    this.organizationId = options?.organizationId;
+    this.projectId = options?.projectId;
+    this.namespace = options?.namespace ?? NAMESPACE;
+    this.http = new HttpClient({
+      baseUrl: options?.apiUrl ?? API_URL,
+      apiKey: options?.apiKey ?? API_KEY,
+      organizationId: this.organizationId,
+      projectId: this.projectId,
+      maxRetries: options?.maxRetries ?? MAX_RETRIES,
+      retryBackoffMs: options?.retryBackoffMs ?? RETRY_BACKOFF_MS
+    });
+  }
+  static forCloud(options) {
+    return new _CloudClient(options);
+  }
+  close() {
+    this.http.close();
+  }
+  async upsertApplication(manifest, codeZip, upgradeRunningRequests = false) {
+    const form = new FormData();
+    form.append(
+      "code",
+      new Blob([toBlobPart(codeZip)], { type: "application/zip" }),
+      "code.zip"
+    );
+    form.append("code_content_type", "application/zip");
+    form.append("application", JSON.stringify(manifest));
+    form.append(
+      "upgrade_requests_to_latest_code",
+      String(upgradeRunningRequests)
+    );
+    await this.http.requestResponse("POST", this.namespacePath("applications"), {
+      body: form
+    });
+  }
+  async deleteApplication(applicationName) {
+    await this.http.requestResponse(
+      "DELETE",
+      this.namespacePath(`applications/${encodeURIComponent(applicationName)}`)
+    );
+  }
+  async applications() {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.namespacePath("applications")
+    );
+    return (raw.applications ?? []).map(
+      (application) => fromSnakeKeys(application)
+    );
+  }
+  async applicationManifest(applicationName) {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.namespacePath(`applications/${encodeURIComponent(applicationName)}`)
+    );
+    return fromSnakeKeys(raw);
+  }
+  async runRequest(applicationName, inputs = []) {
+    const path = this.namespacePath(
+      `applications/${encodeURIComponent(applicationName)}`
+    );
+    const response = inputs.length === 0 ? await this.http.requestResponse("POST", path, {
+      body: new Uint8Array(),
+      headers: { Accept: "application/json" }
+    }) : inputs.length === 1 && inputs[0].name === "0" ? await this.http.requestResponse("POST", path, {
+      body: toRequestBody(inputs[0].data),
+      headers: {
+        Accept: "application/json",
+        "Content-Type": inputs[0].contentType
+      }
+    }) : await this.runMultipartRequest(path, inputs);
+    const body = await parseJsonResponse(response);
+    const requestId = body?.request_id;
+    if (!requestId) {
+      throw new Error("missing request_id in run request response body");
+    }
+    return requestId;
+  }
+  async waitOnRequestCompletion(applicationName, requestId) {
+    const stream = await this.http.requestStream(
+      "GET",
+      this.namespacePath(
+        `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}/progress`
+      )
+    );
+    for await (const event of parseSSEStream(stream)) {
+      if (Object.prototype.hasOwnProperty.call(event, "RequestFinished")) {
+        return;
+      }
+    }
+    throw new Error("progress stream ended before request completion");
+  }
+  async requestMetadata(applicationName, requestId) {
+    const raw = await this.http.requestJson(
+      "GET",
+      this.namespacePath(
+        `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}`
+      )
+    );
+    return fromSnakeKeys(raw);
+  }
+  async requestOutput(applicationName, requestId) {
+    const response = await this.http.requestResponse(
+      "GET",
+      this.namespacePath(
+        `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}/output`
+      )
+    );
+    const serializedValue = new Uint8Array(await response.arrayBuffer());
+    const contentType = response.headers.get("content-type") ?? "";
+    return {
+      serializedValue,
+      contentType
+    };
+  }
+  async introspectApiKey() {
+    const raw = await this.http.requestJson(
+      "POST",
+      "/platform/v1/keys/introspect"
+    );
+    return fromSnakeKeys(raw);
+  }
+  async listSecrets(options) {
+    const scope = this.resolveScope(options?.organizationId, options?.projectId);
+    const raw = await this.http.requestJson(
+      "GET",
+      `/platform/v1/organizations/${encodeURIComponent(scope.organizationId)}/projects/${encodeURIComponent(scope.projectId)}/secrets?pageSize=${options?.pageSize ?? 100}`
+    );
+    return fromSnakeKeys(raw);
+  }
+  async getSecret(secretId, options) {
+    const scope = this.resolveScope(options?.organizationId, options?.projectId);
+    const raw = await this.http.requestJson(
+      "GET",
+      `/platform/v1/organizations/${encodeURIComponent(scope.organizationId)}/projects/${encodeURIComponent(scope.projectId)}/secrets/${encodeURIComponent(secretId)}`
+    );
+    return fromSnakeKeys(raw);
+  }
+  async upsertSecrets(secrets, options) {
+    const scope = this.resolveScope(options?.organizationId, options?.projectId);
+    const raw = await this.http.requestJson(
+      "PUT",
+      `/platform/v1/organizations/${encodeURIComponent(scope.organizationId)}/projects/${encodeURIComponent(scope.projectId)}/secrets`,
+      { body: secrets }
+    );
+    if (Array.isArray(raw)) {
+      return raw.map((secret) => fromSnakeKeys(secret));
+    }
+    return fromSnakeKeys(raw);
+  }
+  async deleteSecret(secretId, options) {
+    const scope = this.resolveScope(options?.organizationId, options?.projectId);
+    await this.http.requestResponse(
+      "DELETE",
+      `/platform/v1/organizations/${encodeURIComponent(scope.organizationId)}/projects/${encodeURIComponent(scope.projectId)}/secrets/${encodeURIComponent(secretId)}`
+    );
+  }
+  async startImageBuild(buildServicePath, request) {
+    const form = new FormData();
+    form.append("graph_name", request.applicationName);
+    form.append("graph_version", request.applicationVersion);
+    form.append("graph_function_name", request.functionName);
+    form.append("image_name", request.imageName);
+    form.append("image_id", request.imageId);
+    form.append(
+      "context",
+      new Blob([toBlobPart(request.buildContext)]),
+      "context.tar.gz"
+    );
+    const response = await this.http.requestResponse(
+      "PUT",
+      `${trimTrailingSlashes(buildServicePath)}/builds`,
+      { body: form }
+    );
+    const raw = await parseJsonResponse(response);
+    return fromSnakeKeys(raw);
+  }
+  async createApplicationBuild(buildServicePath, request, imageContexts) {
+    const form = createApplicationBuildForm(request, imageContexts);
+    const response = await this.http.requestResponse(
+      "POST",
+      trimTrailingSlashes(buildServicePath),
+      { body: form }
+    );
+    const raw = await parseJsonResponse(response);
+    return fromSnakeKeys(raw);
+  }
+  async applicationBuildInfo(buildServicePath, applicationBuildId) {
+    const raw = await this.http.requestJson(
+      "GET",
+      `${trimTrailingSlashes(buildServicePath)}/${encodeURIComponent(applicationBuildId)}`
+    );
+    return fromSnakeKeys(raw);
+  }
+  async cancelApplicationBuild(buildServicePath, applicationBuildId) {
+    const raw = await this.http.requestJson(
+      "POST",
+      `${trimTrailingSlashes(buildServicePath)}/${encodeURIComponent(applicationBuildId)}/cancel`
+    );
+    return fromSnakeKeys(raw);
+  }
+  async buildInfo(buildServicePath, buildId) {
+    const raw = await this.http.requestJson(
+      "GET",
+      `${trimTrailingSlashes(buildServicePath)}/builds/${encodeURIComponent(buildId)}`
+    );
+    return fromSnakeKeys(raw);
+  }
+  async cancelBuild(buildServicePath, buildId) {
+    await this.http.requestResponse(
+      "POST",
+      `${trimTrailingSlashes(buildServicePath)}/builds/${encodeURIComponent(buildId)}/cancel`
+    );
+  }
+  async *streamBuildLogs(buildServicePath, buildId, signal) {
+    const stream = await this.http.requestStream(
+      "GET",
+      `${trimTrailingSlashes(buildServicePath)}/builds/${encodeURIComponent(buildId)}/logs`,
+      { signal }
+    );
+    for await (const event of parseSSEStream(stream, signal)) {
+      yield fromSnakeKeys(event);
+    }
+  }
+  async runMultipartRequest(path, inputs) {
+    const form = new FormData();
+    for (const input of inputs) {
+      form.append(
+        input.name,
+        new Blob([toBlobPart(input.data)], { type: input.contentType }),
+        input.name
+      );
+    }
+    return this.http.requestResponse("POST", path, {
+      body: form,
+      headers: { Accept: "application/json" }
+    });
+  }
+  namespacePath(subpath) {
+    return `/v1/namespaces/${encodeURIComponent(this.namespace)}/${subpath.replace(/^\/+/, "")}`;
+  }
+  resolveScope(organizationId, projectId) {
+    const resolvedOrganizationId = organizationId ?? this.organizationId;
+    const resolvedProjectId = projectId ?? this.projectId;
+    if (!resolvedOrganizationId || !resolvedProjectId) {
+      throw new Error(
+        "organizationId and projectId are required for this operation"
+      );
+    }
+    return {
+      organizationId: resolvedOrganizationId,
+      projectId: resolvedProjectId
+    };
+  }
+};
+function createApplicationBuildForm(request, imageContexts) {
+  const contextsByPartName = /* @__PURE__ */ new Map();
+  for (const context of imageContexts) {
+    if (contextsByPartName.has(context.contextTarPartName)) {
+      throw new Error(
+        `duplicate image context part name '${context.contextTarPartName}'`
+      );
+    }
+    contextsByPartName.set(context.contextTarPartName, context);
+  }
+  const form = new FormData();
+  form.append(
+    "app_version",
+    new Blob([JSON.stringify(request)], { type: "application/json" }),
+    "app_version"
+  );
+  for (const image of request.images) {
+    const context = contextsByPartName.get(image.contextTarPartName);
+    if (!context) {
+      throw new Error(
+        `missing image context for part '${image.contextTarPartName}'`
+      );
+    }
+    form.append(
+      image.contextTarPartName,
+      new Blob([toBlobPart(context.contextTarGz)]),
+      `${image.contextTarPartName}.tar.gz`
+    );
+  }
+  for (const context of imageContexts) {
+    if (!request.images.some((image) => image.contextTarPartName === context.contextTarPartName)) {
+      throw new Error(
+        `unexpected image context for part '${context.contextTarPartName}'`
+      );
+    }
+  }
+  return form;
+}
+function trimTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function toBlobPart(data) {
+  if (typeof data === "string" || data instanceof Blob) {
+    return data;
+  }
+  if (data instanceof Uint8Array) {
+    return Uint8Array.from(data).buffer;
+  }
+  return data;
+}
+function toRequestBody(data) {
+  return toBlobPart(data);
+}
+async function parseJsonResponse(response) {
+  const text = await response.text();
+  if (!text) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+
+// src/api-client.ts
+var APIClient = class {
+  cloudClient;
+  constructor(options) {
+    this.cloudClient = new CloudClient(options);
+  }
+  close() {
+    this.cloudClient.close();
+  }
+  async upsertApplication(manifest, codeZip, upgradeRunningRequests = false) {
+    await this.cloudClient.upsertApplication(
+      manifest,
+      codeZip,
+      upgradeRunningRequests
+    );
+  }
+  async deleteApplication(applicationName) {
+    await this.cloudClient.deleteApplication(applicationName);
+  }
+  async applications() {
+    return this.cloudClient.applications();
+  }
+  async application(applicationName) {
+    return this.cloudClient.applicationManifest(applicationName);
+  }
+  async runRequest(applicationName, inputs) {
+    return this.cloudClient.runRequest(applicationName, inputs);
+  }
+  async waitOnRequestCompletion(applicationName, requestId) {
+    await this.cloudClient.waitOnRequestCompletion(applicationName, requestId);
+  }
+  async requestOutput(applicationName, requestId) {
+    const metadata = await this.cloudClient.requestMetadata(
+      applicationName,
+      requestId
+    );
+    if (metadata.outcome == null) {
+      throw new RequestNotFinishedError();
+    }
+    if (typeof metadata.outcome === "object") {
+      if (metadata.requestError?.message) {
+        throw new RequestExecutionError(
+          metadata.requestError.message,
+          metadata.requestError.functionName
+        );
+      }
+      const failure = typeof metadata.outcome.failure === "string" ? metadata.outcome.failure : JSON.stringify(metadata.outcome);
+      throw new RequestFailedError(failure);
+    }
+    return this.cloudClient.requestOutput(applicationName, requestId);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIClient,
+  CloudClient,
+  ContainerState,
+  OutputMode,
+  PoolInUseError,
+  PoolNotFoundError,
+  ProcessStatus,
+  RemoteAPIError,
+  RequestExecutionError,
+  RequestFailedError,
+  RequestNotFinishedError,
+  Sandbox,
+  SandboxClient,
+  SandboxConnectionError,
+  SandboxError,
+  SandboxException,
+  SandboxNotFoundError,
+  SandboxStatus,
+  SnapshotStatus,
+  StdinMode
+});
+//# sourceMappingURL=index.cjs.map