@cloudflare/sandbox 0.9.1 → 0.9.3

package/dist/{sandbox-Bb3n0SeC.d.ts → sandbox-CW4QeITP.d.ts}

@@ -411,64 +411,6 @@ interface PtyOptions {
   shell?: string;
 }
 //#endregion
-//#region ../shared/dist/request-types.d.ts
-/**
- * Request types for API calls to the container
- * Single source of truth for the contract between SDK clients and container handlers
- */
-/**
- * Request to execute a command
- */
-interface ExecuteRequest {
-  command: string;
-  sessionId?: string;
-  background?: boolean;
-  timeoutMs?: number;
-  env?: Record<string, string | undefined>;
-  cwd?: string;
-  origin?: 'user' | 'internal';
-}
-/**
- * Request to start a background process
- * Uses flat structure consistent with other endpoints
- */
-interface StartProcessRequest {
-  command: string;
-  sessionId?: string;
-  processId?: string;
-  timeoutMs?: number;
-  env?: Record<string, string | undefined>;
-  cwd?: string;
-  encoding?: string;
-  autoCleanup?: boolean;
-  origin?: 'user' | 'internal';
-}
-/**
- * Request to expose a port
- */
-interface ExposePortRequest {
-  port: number;
-  name?: string;
-}
-/**
- * Response from the container after creating a backup archive
- */
-interface CreateBackupResponse {
-  success: boolean;
-  /** Size of the archive in bytes */
-  sizeBytes: number;
-  /** Path to the archive file in the container */
-  archivePath: string;
-}
-/**
- * Response from the container after restoring a backup
- */
-interface RestoreBackupResponse {
-  success: boolean;
-  /** Directory that was restored */
-  dir: string;
-}
-//#endregion
 //#region ../shared/dist/types.d.ts
 interface BaseExecOptions {
   /**
@@ -791,6 +733,7 @@ interface SessionOptions {
    */
   commandTimeoutMs?: number;
 }
+type SandboxTransport = 'http' | 'websocket' | 'rpc';
 interface SandboxOptions {
   /**
    * Duration after which the sandbox instance will sleep if no requests are received
@@ -879,13 +822,13 @@ interface SandboxOptions {
     waitIntervalMS?: number;
   };
   /**
-   * Transport protocol for communication between the Sandbox DO and the container runtime.
+   * Transport/control path for communication between the Sandbox DO and the
+   * container runtime.
    *
-   * - `"http"` (default): Standard HTTP request/response. Works everywhere.
-   * - `"websocket"`: Multiplexes requests over a single WebSocket connection,
-   *   avoiding sub-request limits in Workers and Durable Objects.
-   * - `"capnweb"`: Direct RPC over a single WebSocket using the capnweb protocol.
-   *   Lowest latency; automatically disconnects when idle to respect `sleepAfter`.
+   * - `"http"` (default): Route-based HTTP compatibility path.
+   * - `"websocket"`: Route-based compatibility path multiplexed over a custom
+   *   WebSocket connection.
+   * - `"rpc"`: Primary container-control path over capnweb RPC.
    *
    * When set via `getSandbox()` options, this overrides the `SANDBOX_TRANSPORT` env var.
    *
@@ -896,7 +839,7 @@ interface SandboxOptions {
    *
    * @default "http"
    */
-  transport?: 'http' | 'websocket' | 'rpc';
+  transport?: SandboxTransport;
 }
 /**
  * Execution session - isolated execution context within a sandbox
@@ -1266,6 +1209,10 @@ interface ExecutionSession {
 /**
  * Options for creating a directory backup
  */
+interface BackupCompressionOptions {
+  format?: 'gzip' | 'lz4' | 'zstd';
+  threads?: number;
+}
 interface BackupOptions {
   /** Directory to back up. Must be absolute and under `/workspace`, `/home`, `/tmp`, `/var/tmp`, or `/app`. */
   dir: string;
@@ -1294,6 +1241,13 @@ interface BackupOptions {
    * When true, the DO resolves BACKUP_BUCKET from its own env as an R2 binding.
    */
   localBucket?: boolean;
+  compression?: BackupCompressionOptions;
+  /**
+   * Use parallel multipart upload to R2 for large archives.
+   * Significantly speeds up uploads for archives over 10 MiB.
+   * Default: true.
+   */
+  multipart?: boolean;
 }
 /**
  * Handle representing a stored directory backup.
@@ -1482,6 +1436,120 @@ declare function isExecResult(value: any): value is ExecResult;
 declare function isProcess(value: any): value is Process;
 declare function isProcessStatus(value: string): value is ProcessStatus;
 //#endregion
+//#region ../shared/dist/request-types.d.ts
+/**
+ * Request types for API calls to the container
+ * Single source of truth for the contract between SDK clients and container handlers
+ */
+/**
+ * Request to execute a command
+ */
+interface ExecuteRequest {
+  command: string;
+  sessionId?: string;
+  background?: boolean;
+  timeoutMs?: number;
+  env?: Record<string, string | undefined>;
+  cwd?: string;
+  origin?: 'user' | 'internal';
+}
+/**
+ * Request to start a background process
+ * Uses flat structure consistent with other endpoints
+ */
+interface StartProcessRequest {
+  command: string;
+  sessionId?: string;
+  processId?: string;
+  timeoutMs?: number;
+  env?: Record<string, string | undefined>;
+  cwd?: string;
+  encoding?: string;
+  autoCleanup?: boolean;
+  origin?: 'user' | 'internal';
+}
+/**
+ * Request to expose a port
+ */
+interface ExposePortRequest {
+  port: number;
+  name?: string;
+}
+/**
+ * Request to create a backup archive from a directory.
+ * The container creates a squashfs archive at archivePath.
+ * The DO then reads it and uploads to R2.
+ */
+interface CreateBackupRequest {
+  /** Directory to back up */
+  dir: string;
+  /** Path where the container should write the archive */
+  archivePath: string;
+  /** Respect git ignore rules when the directory is inside a git repository */
+  gitignore?: boolean;
+  /** Glob patterns to exclude from the backup */
+  excludes?: string[];
+  compression?: BackupCompressionOptions;
+  sessionId?: string;
+}
+/**
+ * A single part to upload in a multipart upload.
+ * The container reads the byte range from the local archive and PUTs it
+ * to the presigned URL.
+ */
+interface UploadPart {
+  partNumber: number;
+  /** Presigned PUT URL for this part */
+  url: string;
+  /** Byte offset within the archive file */
+  offset: number;
+  /** Number of bytes in this part */
+  size: number;
+}
+/**
+ * Request to upload parts of a backup archive directly from the container to R2.
+ * Used for parallel multipart upload of large archives.
+ */
+interface UploadPartsRequest {
+  /** Path to the archive file in the container */
+  archivePath: string;
+  /** Parts to upload in parallel */
+  parts: UploadPart[];
+  sessionId?: string;
+}
+/**
+ * Result for a single uploaded part (ETag returned by R2).
+ */
+interface UploadedPart {
+  partNumber: number;
+  etag: string;
+}
+/**
+ * Response after the container has uploaded all parts.
+ */
+interface UploadPartsResponse {
+  success: boolean;
+  parts: UploadedPart[];
+}
+/**
+ * Response from the container after creating a backup archive
+ */
+interface CreateBackupResponse {
+  success: boolean;
+  /** Size of the archive in bytes */
+  sizeBytes: number;
+  /** Path to the archive file in the container */
+  archivePath: string;
+}
+/**
+ * Response from the container after restoring a backup
+ */
+interface RestoreBackupResponse {
+  success: boolean;
+  /** Directory that was restored */
+  dir: string;
+}
+//#endregion
 //#region ../shared/dist/rpc-types.d.ts
 interface SandboxCommandsAPI {
   execute(command: string, sessionId: string, options?: {
@@ -1592,8 +1660,19 @@ interface SandboxBackupAPI {
   createArchive(dir: string, archivePath: string, sessionId: string, options?: {
     excludes?: string[];
     gitignore?: boolean;
+    compression?: BackupCompressionOptions;
   }): Promise<CreateBackupResponse>;
   restoreArchive(dir: string, archivePath: string, sessionId: string): Promise<RestoreBackupResponse>;
+  uploadParts(request: {
+    archivePath: string;
+    parts: Array<{
+      partNumber: number;
+      url: string;
+      offset: number;
+      size: number;
+    }>;
+    sessionId?: string;
+  }): Promise<UploadPartsResponse>;
 }
 interface SandboxDesktopAPI {
   start(options?: {
@@ -1661,11 +1740,10 @@ interface HttpClientOptions {
   onCommandComplete?: (success: boolean, exitCode: number, stdout: string, stderr: string, command: string) => void;
   onError?: (error: string, command?: string) => void;
   /**
-   * Transport mode: 'http' (default) or 'websocket'
-   * WebSocket mode multiplexes all requests over a single connection,
-   * reducing sub-request count in Workers/Durable Objects.
+   * Route-based transport mode: 'http' (default) or 'websocket'.
+   * WebSocket mode multiplexes HTTP API requests over a single connection.
    */
-  transportMode?: TransportMode;
+  transportMode?: RouteTransportMode;
   /**
    * WebSocket URL for WebSocket transport mode.
    * Required when transportMode is 'websocket'.
@@ -1723,18 +1801,19 @@ interface SessionRequest {
 //#endregion
 //#region src/clients/transport/types.d.ts
 /**
- * Transport mode for SDK communication
+ * Transport modes supported by the route-based compatibility layer.
  */
-type TransportMode = 'http' | 'websocket' | 'rpc';
+type RouteTransportMode = 'http' | 'websocket';
 interface TransportRequestInit extends RequestInit {
   /** Override the non-streaming request timeout for this single request. */
   requestTimeoutMs?: number;
 }
 /**
- * Transport interface - all transports must implement this
+ * Route transport interface.
  *
- * Provides a unified abstraction over HTTP and WebSocket communication.
- * Both transports support fetch-compatible requests and streaming.
+ * Provides a unified abstraction over the route-based HTTP and custom
+ * WebSocket compatibility paths. Both transports support fetch-compatible
+ * requests and streaming.
  */
 interface ITransport {
   /**
@@ -1750,7 +1829,7 @@ interface ITransport {
   /**
    * Get the transport mode
    */
-  getMode(): TransportMode;
+  getMode(): RouteTransportMode;
   /**
    * Connect the transport (no-op for HTTP)
    */
@@ -1771,15 +1850,15 @@ interface ITransport {
 //#endregion
 //#region src/clients/base-client.d.ts
 /**
- * Abstract base class providing common HTTP/WebSocket functionality for all domain clients
+ * Abstract base class for route-based HTTP/WebSocket compatibility clients.
  *
- * All requests go through the Transport abstraction layer, which handles:
- * - HTTP and WebSocket modes transparently
- * - Automatic retry for 503 errors (container starting)
- * - Streaming responses
+ * Requests go through the Transport abstraction layer, which handles:
+ * - HTTP and WebSocket route-based modes transparently
+ * - Automatic retry for 503 errors while the container is starting
+ * - Streaming responses for the existing route API
  *
- * WebSocket mode is useful when running inside Workers/Durable Objects
- * where sub-request limits apply.
+ * DO-to-container control-channel capabilities live in `container-control/`.
+ * This layer supports the route-based compatibility API.
  */
 declare abstract class BaseHttpClient {
   protected options: HttpClientOptions;
@@ -1825,7 +1904,7 @@ declare abstract class BaseHttpClient {
   /**
    * Stream request handler
    *
-   * For HTTP mode, uses doFetch + handleStreamResponse to get proper error typing.
+   * HTTP mode uses doFetch + handleStreamResponse for typed error handling.
    * For WebSocket mode, uses Transport's streaming support.
    *
    * @param path - The API path to call
@@ -1853,6 +1932,7 @@ declare class BackupClient extends BaseHttpClient {
   createArchive(dir: string, archivePath: string, sessionId: string, options?: {
     excludes?: string[];
     gitignore?: boolean;
+    compression?: CreateBackupRequest['compression'];
   }): Promise<CreateBackupResponse>;
   /**
    * Tell the container to restore a squashfs archive into a directory.
@@ -1861,6 +1941,7 @@ declare class BackupClient extends BaseHttpClient {
    * @param sessionId - Session context
    */
   restoreArchive(dir: string, archivePath: string, sessionId: string): Promise<RestoreBackupResponse>;
+  uploadParts(request: UploadPartsRequest, sessionId?: string): Promise<UploadPartsResponse>;
 }
 //#endregion
 //#region src/clients/command-client.d.ts
@@ -2489,13 +2570,13 @@ declare class WatchClient extends BaseHttpClient {
 //#endregion
 //#region src/clients/sandbox-client.d.ts
 /**
- * Main sandbox client that composes all domain-specific clients.
- * Provides organized access to all sandbox functionality.
+ * Route-based compatibility sandbox client that composes all domain-specific
+ * HTTP API clients.
  *
- * Supports two transport modes:
- * - HTTP (default): Each request is a separate HTTP call
- * - WebSocket: All requests multiplexed over a single connection,
- *   reducing sub-request count inside Workers/Durable Objects
+ * This client supports the route-based HTTP and custom WebSocket transports.
+ * The primary DO-to-container control path is ContainerControlClient under
+ * `container-control/`. This client supports route-based compatibility,
+ * debugging, local development, and fallback behavior.
  */
 declare class SandboxClient {
   readonly backup: BackupClient;
@@ -2521,7 +2602,7 @@ declare class SandboxClient {
   /**
    * Get the current transport mode
    */
-  getTransportMode(): TransportMode;
+  getTransportMode(): RouteTransportMode;
   /**
    * Check if WebSocket is connected (only relevant in WebSocket mode)
    */
@@ -2529,9 +2610,9 @@ declare class SandboxClient {
   /**
    * Stream a file directly to the container over a binary RPC channel.
    *
-   * Requires the capnweb transport (`useWebSocket: 'rpc'`). Calling this
-   * method with the HTTP or WebSocket transports throws an error because those
-   * transports do not support binary streaming.
+   * Requires the container-control path (`transport: 'rpc'`). Calling this
+   * method with the HTTP or WebSocket route transports throws an error because
+   * those transports do not support binary streaming.
    */
   writeFileStream(_path: string, _content: ReadableStream<Uint8Array>, _sessionId: string): Promise<{
     success: boolean;
@@ -2552,19 +2633,19 @@ declare class SandboxClient {
   disconnect(): void;
 }
 //#endregion
-//#region src/container-connection.d.ts
+//#region src/container-control/connection.d.ts
 /** Stub that can issue a WebSocket-upgrade fetch through the DO's Container base class. */
 interface ContainerFetchStub {
   fetch(request: Request): Promise<Response>;
 }
-interface ContainerConnectionOptions {
+interface ContainerControlConnectionOptions {
   stub: ContainerFetchStub;
   port?: number;
   logger?: Logger;
 }
 //#endregion
-//#region src/clients/rpc-sandbox-client.d.ts
-interface RPCSandboxClientOptions extends ContainerConnectionOptions {
+//#region src/container-control/client.d.ts
+interface ContainerControlClientOptions extends ContainerControlConnectionOptions {
   /** Idle timeout before disconnecting the WebSocket (ms). Defaults to 1 000. */
   idleDisconnectMs?: number;
   /** Busy/idle poll interval (ms). Defaults to 1 000. */
@@ -2592,20 +2673,19 @@ interface RPCSandboxClientOptions extends ContainerConnectionOptions {
   onSessionIdle?: () => void;
 }
 /**
- * SandboxClient backed by direct capnweb RPC.
+ * SandboxClient-compatible facade backed by direct capnweb RPC.
  *
- * Drop-in replacement for SandboxClient when the capnweb transport is active.
- * All operations call the container's SandboxRPCAPI directly over capnweb,
- * bypassing the HTTP handler/router layer entirely.
+ * All operations call the container's SandboxAPI control interface directly
+ * over capnweb, bypassing the HTTP handler/router layer entirely.
  *
- * Manages its own WebSocket lifecycle: a fresh `ContainerConnection` is
+ * Manages its own WebSocket lifecycle: a fresh `ContainerControlConnection` is
  * created on demand and torn down after `idleDisconnectMs` of inactivity.
  * Busy/idle detection relies on `RpcSession.getStats()` which tracks all
  * in-flight RPC calls and stream exports — including long-lived streaming
  * RPCs that would be invisible to a simple per-call request counter (see
  * the file-level comment for the full rationale).
  */
-declare class RPCSandboxClient {
+declare class ContainerControlClient {
   private readonly connOptions;
   private readonly idleDisconnectMs;
   private readonly busyPollIntervalMs;
@@ -2625,11 +2705,10 @@ declare class RPCSandboxClient {
    * connected and the peer went away" (do tear down).
    */
   private wasEverConnected;
-  constructor(options: RPCSandboxClientOptions);
+  constructor(options: ContainerControlClientOptions);
   /**
-   * Return the current connection, creating a new one if none exists or the
-   * previous one was torn down by an idle disconnect. Starts the busy-poll
-   * timer the first time a connection is materialized.
+   * Return the current connection, creating one when the client is disconnected.
+   * Starts the busy-poll timer the first time a connection is materialized.
    */
   private getConnection;
   /**
@@ -2666,7 +2745,7 @@ declare class RPCSandboxClient {
   get watch(): SandboxWatchAPI;
   get interpreter(): SandboxInterpreterAPI;
   setRetryTimeoutMs(_ms: number): void;
-  getTransportMode(): TransportMode;
+  getTransportMode(): SandboxTransport;
   isWebSocketConnected(): boolean;
   connect(): Promise<void>;
   disconnect(): void;
@@ -2687,13 +2766,13 @@ type SandboxConfiguration = {
   sleepAfter?: string | number;
   keepAlive?: boolean;
   containerTimeouts?: NonNullable<SandboxOptions['containerTimeouts']>;
-  transport?: 'http' | 'websocket' | 'rpc';
+  transport?: SandboxTransport;
 };
 declare function getSandbox<T extends Sandbox<any>>(ns: DurableObjectNamespace<T>, id: string, options?: SandboxOptions): T;
 declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
   defaultPort: number;
   sleepAfter: string | number;
-  client: SandboxClient | RPCSandboxClient;
+  client: SandboxClient | ContainerControlClient;
   private codeInterpreter;
   private sandboxName;
   private normalizeId;
@@ -2778,11 +2857,15 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
    */
   private computeRetryTimeoutMs;
   /**
-   * Create a SandboxClient with current transport settings
+   * Create the route-based compatibility client with current HTTP/WebSocket
+   * transport settings.
    */
   private createSandboxClient;
   /**
-   * Create the appropriate client for a given transport protocol.
+   * Create the appropriate client for the configured control path.
+   *
+   * `rpc` currently selects the primary container-control client. `http` and
+   * `websocket` select the route-based compatibility client.
    */
   private createClientForTransport;
   constructor(ctx: DurableObjectState<{}>, env: Env);
@@ -2804,7 +2887,7 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
    * has been persisted: re-applying the same transport is a no-op.
    * Storage is written before the in-memory state and client are updated.
    */
-  setTransport(transport: 'http' | 'websocket' | 'rpc'): Promise<void>;
+  setTransport(transport: SandboxTransport): Promise<void>;
   /**
    * Validate a timeout value is within acceptable range
    * Throws error if invalid - used for user-provided values
@@ -3262,6 +3345,8 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
    * Returns the R2 bucket or throws if backup is not configured.
    */
   private requireBackupBucket;
+  private normalizeBackupExcludes;
+  private resolveBackupCompression;
   private static readonly PRESIGNED_URL_EXPIRY_SECONDS;
   /**
    * Create a unique, dedicated session for a single backup operation.
@@ -3275,6 +3360,11 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
    * All credential fields plus the R2 binding are required for backup to work.
    */
   private requirePresignedUrlSupport;
+  /**
+   * Generate a presigned GET URL for downloading an object from R2.
+   * The container can curl this URL directly without credentials.
+   */
+  private generatePresignedGetUrl;
   /**
    * Generate a presigned PUT URL for uploading an object to R2.
    * The container can curl PUT to this URL directly without credentials.
@@ -3287,9 +3377,23 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
    */
   private uploadBackupPresigned;
   /**
-   * Mount a backup archive from R2 via s3fs so squashfuse can read it lazily.
+   * Generate a presigned PUT URL for a single part in a multipart upload.
+   */
+  private generatePresignedPartUrl;
+  /**
+   * Upload a backup archive to R2 using parallel multipart upload.
+   * Uses the S3-compatible API exclusively for create/complete/abort so that
+   * the uploadId is in the same namespace as the presigned part PUT URLs.
+   */
+  private uploadBackupMultipart;
+  /**
+   * Download a backup archive from R2 via presigned GET URL.
+   * For archives >= BACKUP_DOWNLOAD_PARALLEL_MIN_SIZE, uses BACKUP_DOWNLOAD_PARALLEL_PARTS
+   * concurrent curl processes (each downloading a byte-range) to maximise both
+   * network and disk-write throughput. Parts are written into a pre-sized file
+   * with dd using byte offsets, then atomically moved to the final path.
    */
-  private mountBackupR2;
+  private downloadBackupParallel;
   /**
    * Serialize backup operations on this sandbox instance.
    * Concurrent backup/restore calls are queued so the multi-step
@@ -3368,5 +3472,5 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
   private doRestoreBackupLocal;
 }
 //#endregion
-export { BucketProvider as $, DesktopStopResponse as A, RestoreBackupResult as At, ExecuteResponse as B, ExecuteRequest as Bt, ClickOptions as C, ProcessKillResult as Ct, DesktopStartOptions as D, ProcessStartResult as Dt, DesktopClient as E, ProcessOptions as Et, ScreenshotRegion as F, WaitForPortOptions as Ft, HttpClientOptions as G, CreateContextOptions as Gt, BaseApiResponse as H, StartProcessRequest as Ht, ScreenshotResponse as I, WatchOptions as It, SessionRequest as J, RunCodeOptions as Jt, RequestConfig as K, Execution as Kt, ScrollDirection as L, isExecResult as Lt, ScreenSizeResponse as M, SessionOptions as Mt, ScreenshotBytesResponse as N, StreamOptions as Nt, DesktopStartResponse as O, ProcessStatus as Ot, ScreenshotOptions as P, WaitForLogResult as Pt, BucketCredentials as Q, TypeOptions as R, isProcess as Rt, WriteFileRequest as S, ProcessInfoResult as St, Desktop as T, ProcessLogsResult as Tt, ContainerStub as U, PtyOptions as Ut, BackupClient as V, ExposePortRequest as Vt, ErrorResponse as W, CodeContext as Wt, BackupOptions as X, SandboxInterpreterAPI as Y, BaseExecOptions as Z, GitClient as _, PortCloseResult as _t, CreateSessionRequest as a, ExecResult as at, MkdirRequest as b, Process as bt, DeleteSessionResponse as c, FileMetadata as ct, ProcessClient as d, GitCheckoutResult as dt, CheckChangesOptions as et, PortClient as f, ISandbox as ft, GitCheckoutRequest as g, MountBucketOptions as gt, InterpreterClient as h, LogEvent as ht, CommandsResponse as i, ExecOptions as it, KeyInput as j, SandboxOptions as jt, DesktopStatusResponse as k, RemoteMountBucketOptions as kt, PingResponse as l, FileStreamEvent as lt, ExecutionCallbacks as m, LocalMountBucketOptions as mt, getSandbox as n, DirectoryBackup as nt, CreateSessionResponse as o, ExecutionSession as ot, UnexposePortRequest as p, ListFilesOptions as pt, ResponseHandler as q, ExecutionResult as qt, SandboxClient as r, ExecEvent as rt, DeleteSessionRequest as s, FileChunk as st, Sandbox as t, CheckChangesResult as tt, UtilityClient as u, FileWatchSSEEvent as ut, FileClient as v, PortExposeResult as vt, CursorPositionResponse as w, ProcessListResult as wt, ReadFileRequest as x, ProcessCleanupResult as xt, FileOperationRequest as y, PortListResult as yt, CommandClient as z, isProcessStatus as zt };
-//# sourceMappingURL=sandbox-Bb3n0SeC.d.ts.map
+export { BackupOptions as $, DesktopStopResponse as A, ProcessStartResult as At, ExecuteResponse as B, WatchOptions as Bt, ClickOptions as C, Process as Ct, DesktopStartOptions as D, ProcessListResult as Dt, DesktopClient as E, ProcessKillResult as Et, ScreenshotRegion as F, SandboxTransport as Ft, HttpClientOptions as G, CodeContext as Gt, BaseApiResponse as H, isProcess as Ht, ScreenshotResponse as I, SessionOptions as It, SessionRequest as J, ExecutionResult as Jt, RequestConfig as K, CreateContextOptions as Kt, ScrollDirection as L, StreamOptions as Lt, ScreenSizeResponse as M, RemoteMountBucketOptions as Mt, ScreenshotBytesResponse as N, RestoreBackupResult as Nt, DesktopStartResponse as O, ProcessLogsResult as Ot, ScreenshotOptions as P, SandboxOptions as Pt, StartProcessRequest as Q, TypeOptions as R, WaitForLogResult as Rt, WriteFileRequest as S, PortListResult as St, Desktop as T, ProcessInfoResult as Tt, ContainerStub as U, isProcessStatus as Ut, BackupClient as V, isExecResult as Vt, ErrorResponse as W, PtyOptions as Wt, ExecuteRequest as X, SandboxInterpreterAPI as Y, RunCodeOptions as Yt, ExposePortRequest as Z, GitClient as _, LocalMountBucketOptions as _t, CreateSessionRequest as a, DirectoryBackup as at, MkdirRequest as b, PortCloseResult as bt, DeleteSessionResponse as c, ExecResult as ct, ProcessClient as d, FileMetadata as dt, BaseExecOptions as et, PortClient as f, FileStreamEvent as ft, GitCheckoutRequest as g, ListFilesOptions as gt, InterpreterClient as h, ISandbox as ht, CommandsResponse as i, CheckChangesResult as it, KeyInput as j, ProcessStatus as jt, DesktopStatusResponse as k, ProcessOptions as kt, PingResponse as l, ExecutionSession as lt, ExecutionCallbacks as m, GitCheckoutResult as mt, getSandbox as n, BucketProvider as nt, CreateSessionResponse as o, ExecEvent as ot, UnexposePortRequest as p, FileWatchSSEEvent as pt, ResponseHandler as q, Execution as qt, SandboxClient as r, CheckChangesOptions as rt, DeleteSessionRequest as s, ExecOptions as st, Sandbox as t, BucketCredentials as tt, UtilityClient as u, FileChunk as ut, FileClient as v, LogEvent as vt, CursorPositionResponse as w, ProcessCleanupResult as wt, ReadFileRequest as x, PortExposeResult as xt, FileOperationRequest as y, MountBucketOptions as yt, CommandClient as z, WaitForPortOptions as zt };
+//# sourceMappingURL=sandbox-CW4QeITP.d.ts.map