@cloudflare/sandbox 0.12.1 → 0.13.0-next.632.1

package/dist/{sandbox-C8l-pMlL.d.ts → sandbox-Cz8DRoAm.d.ts}

@@ -1,5 +1,5 @@
 import { Container, ContainerProxy } from "@cloudflare/containers";
-import "capnweb";
+import { RpcTarget } from "capnweb";
 
 //#region ../shared/dist/logger/types.d.ts
 
@@ -688,7 +688,6 @@ interface SessionOptions {
    */
   commandTimeoutMs?: number;
 }
-type SandboxTransport = 'http' | 'websocket' | 'rpc';
 interface SandboxOptions {
   /**
    * Duration after which the sandbox instance will sleep if no requests are received
@@ -786,25 +785,6 @@ interface SandboxOptions {
      */
     waitIntervalMS?: number;
   };
-  /**
-   * Transport/control path for communication between the Sandbox DO and the
-   * container runtime.
-   *
-   * - `"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.
-   *
-   * **Important:** Set this once at creation time and pass the same value on every
-   * subsequent `getSandbox()` call for a given sandbox ID. Changing the transport after
-   * the sandbox is in use disconnects the active client, which drops any in-flight
-   * requests and resets WebSocket connections.
-   *
-   * @default "http"
-   */
-  transport?: SandboxTransport;
 }
 /**
  * Execution session - isolated execution context within a sandbox
@@ -829,7 +809,7 @@ interface WriteFileResult {
  *
  * - `'utf-8'` / `'utf8'` — treat content as text.
  * - `'base64'` — treat content as base64-encoded binary.
- * - `'none'` — RPC-only streaming variant of `readFile`, returns a
+ * - `'none'` — streaming variant of `readFile`, returns a
  *   `ReadableStream<Uint8Array>` of raw bytes (see `ReadFileStreamResult`).
  */
 type FileEncoding = 'utf-8' | 'utf8' | 'base64' | 'none';
@@ -857,11 +837,10 @@ interface ReadFileResult {
   size?: number;
 }
 /**
- * Result of `readFile()` with `encoding: 'none'` on the RPC transport.
+ * Result of `readFile()` with `encoding: 'none'`.
  *
  * `content` is a raw binary `ReadableStream<Uint8Array>` delivered directly
  * over the capnp channel — no base64 encoding, no SSE framing, no buffering.
- * Only supported on the `rpc` transport; HTTP/WebSocket transports throw.
  */
 interface ReadFileStreamResult {
   success: true;
@@ -1456,79 +1435,6 @@ 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 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).
  */
@@ -1756,693 +1662,23 @@ interface SandboxTunnelsAPI {
   /** List tunnels currently running inside the container. */
   listTunnels(): Promise<TunnelInfo[]>;
 }
-//#endregion
-//#region src/clients/types.d.ts
 /**
- * Minimal interface for container fetch functionality
- */
-interface ContainerStub {
-  containerFetch(url: string, options: RequestInit, port?: number): Promise<Response>;
-  /**
-   * Fetch that can handle WebSocket upgrades (routes through parent Container class).
-   * Required for WebSocket transport to establish control plane connections.
-   */
-  fetch(request: Request): Promise<Response>;
-}
-/**
- * Shared HTTP client configuration options
- */
-interface HttpClientOptions {
-  logger?: Logger;
-  baseUrl?: string;
-  port?: number;
-  stub?: ContainerStub;
-  onCommandComplete?: (success: boolean, exitCode: number, stdout: string, stderr: string, command: string) => void;
-  onError?: (error: string, command?: string) => void;
-  /**
-   * Route-based transport mode: 'http' (default) or 'websocket'.
-   * WebSocket mode multiplexes HTTP API requests over a single connection.
-   */
-  transportMode?: RouteTransportMode;
-  /**
-   * WebSocket URL for WebSocket transport mode.
-   * Required when transportMode is 'websocket'.
-   */
-  wsUrl?: string;
-  /**
-   * Shared transport instance (for internal use).
-   * When provided, clients will use this transport instead of creating their own.
-   */
-  transport?: ITransport;
-  /**
-   * Total retry budget in milliseconds for retryable transport responses.
-   * Used for WebSocket upgrade retries and HTTP 503 startup retries.
-   * Passed through to the transport layer. Defaults to 120_000 (2 minutes).
-   */
-  retryTimeoutMs?: number;
-  /**
-   * Headers merged into every outgoing container request.
-   * Used to propagate stable context (e.g. sandboxId) from the Durable Object
-   * to the container so container logs carry the same identifiers as DO logs.
-   */
-  defaultHeaders?: Record<string, string>;
-}
-/**
- * Base response interface for all API responses
- */
-interface BaseApiResponse {
-  success: boolean;
-  timestamp: string;
-}
-/**
- * Legacy error response interface - deprecated, use ApiErrorResponse
- */
-interface ErrorResponse {
-  error: string;
-  details?: string;
-  code?: string;
-}
-/**
- * HTTP request configuration
- */
-interface RequestConfig extends RequestInit {
-  endpoint: string;
-  data?: Record<string, any>;
-}
-/**
- * Typed response handler
- */
-type ResponseHandler<T> = (response: Response) => Promise<T>;
-/**
- * Common session-aware request interface
- */
-interface SessionRequest {
-  sessionId?: string;
-}
-//#endregion
-//#region src/clients/transport/types.d.ts
-/**
- * Transport modes supported by the route-based compatibility layer.
- */
-type RouteTransportMode = 'http' | 'websocket';
-interface TransportRequestInit extends RequestInit {
-  /** Override the non-streaming request timeout for this single request. */
-  requestTimeoutMs?: number;
-}
-/**
- * Route transport interface.
+ * RPC surface the Sandbox DO exposes to the container over the existing
+ * capnweb session. The container reaches it via
+ * `session.getRemoteMain<SandboxControlCallback>()` and invokes methods
+ * to push control-plane events (today: tunnel exits) back to the DO.
  *
- * Provides a unified abstraction over the route-based HTTP and custom
- * WebSocket compatibility paths. Both transports support fetch-compatible
- * requests and streaming.
+ * One stable target per sandbox; not per-tunnel. Reusable seam for
+ * future container→DO events.
  */
-interface ITransport {
-  /**
-   * Make a fetch-compatible request
-   * @returns Standard Response object
-   */
-  fetch(path: string, options?: TransportRequestInit): Promise<Response>;
-  /**
-   * Make a streaming request
-   * @returns ReadableStream for consuming SSE/streaming data
-   */
-  fetchStream(path: string, body?: unknown, method?: 'GET' | 'POST', headers?: Record<string, string>): Promise<ReadableStream<Uint8Array>>;
+interface SandboxControlCallback {
   /**
-   * Get the transport mode
+   * Called by the container when a `cloudflared` process exits for any
+   * reason — SIGTERM from `destroyTunnel`, container-initiated SIGKILL,
+   * network failure, segfault. `exitCode` is `null` if the process was
+   * signalled rather than exited cleanly.
    */
-  getMode(): RouteTransportMode;
-  /**
-   * Connect the transport (no-op for HTTP)
-   */
-  connect(): Promise<void>;
-  /**
-   * Disconnect the transport (no-op for HTTP)
-   */
-  disconnect(): void;
-  /**
-   * Check if connected (always true for HTTP)
-   */
-  isConnected(): boolean;
-  /**
-   * Update the upgrade retry budget without recreating the transport
-   */
-  setRetryTimeoutMs(ms: number): void;
-}
-//#endregion
-//#region src/clients/base-client.d.ts
-/**
- * Abstract base class for route-based HTTP/WebSocket compatibility clients.
- *
- * 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
- *
- * 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;
-  protected logger: Logger;
-  protected transport: ITransport;
-  constructor(options?: HttpClientOptions);
-  /**
-   * Update the transport's 503 retry budget
-   */
-  setRetryTimeoutMs(ms: number): void;
-  /**
-   * Check if using WebSocket transport
-   */
-  protected isWebSocketMode(): boolean;
-  /**
-   * Core fetch method - delegates to Transport which handles retry logic
-   */
-  protected doFetch(path: string, options?: TransportRequestInit): Promise<Response>;
-  /**
-   * Make a POST request with JSON body
-   */
-  protected post<T>(endpoint: string, data: unknown, responseHandler?: ResponseHandler<T>, requestOptions?: Pick<TransportRequestInit, 'requestTimeoutMs'>): Promise<T>;
-  /**
-   * Make a GET request
-   */
-  protected get<T>(endpoint: string, responseHandler?: ResponseHandler<T>): Promise<T>;
-  /**
-   * Make a DELETE request
-   */
-  protected delete<T>(endpoint: string, responseHandler?: ResponseHandler<T>): Promise<T>;
-  /**
-   * Handle HTTP response with error checking and parsing
-   */
-  protected handleResponse<T>(response: Response, customHandler?: ResponseHandler<T>): Promise<T>;
-  /**
-   * Handle error responses with consistent error throwing
-   */
-  protected handleErrorResponse(response: Response): Promise<never>;
-  /**
-   * Create a streaming response handler for Server-Sent Events
-   */
-  protected handleStreamResponse(response: Response): Promise<ReadableStream<Uint8Array>>;
-  /**
-   * Stream request handler
-   *
-   * HTTP mode uses doFetch + handleStreamResponse for typed error handling.
-   * For WebSocket mode, uses Transport's streaming support.
-   *
-   * @param path - The API path to call
-   * @param body - Optional request body (for POST requests)
-   * @param method - HTTP method (default: POST, use GET for process logs)
-   */
-  protected doStreamFetch(path: string, body?: unknown, method?: 'GET' | 'POST'): Promise<ReadableStream<Uint8Array>>;
-}
-//#endregion
-//#region src/clients/backup-client.d.ts
-/**
- * Client for backup operations.
- *
- * Handles communication with the container's backup endpoints.
- * The container creates/extracts squashfs archives locally.
- * R2 upload/download is handled by the Sandbox DO, not by this client.
- */
-declare class BackupClient extends BaseHttpClient implements SandboxBackupAPI {
-  /**
-   * Tell the container to create a squashfs archive from a directory.
-   * @param dir - Directory to back up
-   * @param archivePath - Where the container should write the archive
-   * @param sessionId - Session context
-   */
-  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.
-   * @param dir - Target directory
-   * @param archivePath - Path to the archive file in the container
-   * @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
-/**
- * Response interface for command execution
- */
-interface ExecuteResponse extends BaseApiResponse {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  command: string;
-}
-/**
- * Client for command execution operations
- */
-declare class CommandClient extends BaseHttpClient implements SandboxCommandsAPI {
-  /**
-   * Execute a command and return the complete result
-   * @param command - The command to execute
-   * @param sessionId - The session ID for this command execution
-   * @param timeoutMs - Optional timeout in milliseconds (unlimited by default)
-   * @param env - Optional environment variables for this command
-   * @param cwd - Optional working directory for this command
-   */
-  execute(command: string, sessionId: string, options?: {
-    timeoutMs?: number;
-    env?: Record<string, string | undefined>;
-    cwd?: string;
-    origin?: 'user' | 'internal';
-  }): Promise<ExecuteResponse>;
-  /**
-   * Execute a command and return a stream of events
-   * @param command - The command to execute
-   * @param sessionId - The session ID for this command execution
-   * @param options - Optional per-command execution settings
-   */
-  executeStream(command: string, sessionId: string, options?: {
-    timeoutMs?: number;
-    env?: Record<string, string | undefined>;
-    cwd?: string;
-    origin?: 'user' | 'internal';
-  }): Promise<ReadableStream<Uint8Array>>;
-}
-//#endregion
-//#region src/clients/file-client.d.ts
-/**
- * Request interface for creating directories
- */
-interface MkdirRequest extends SessionRequest {
-  path: string;
-  recursive?: boolean;
-}
-/**
- * Request interface for writing files
- */
-interface WriteFileRequest extends SessionRequest {
-  path: string;
-  content: string;
-  encoding?: string;
-}
-/**
- * Request interface for reading files
- */
-interface ReadFileRequest extends SessionRequest {
-  path: string;
-  encoding?: string;
-}
-/**
- * Request interface for file operations (delete, rename, move)
- */
-interface FileOperationRequest extends SessionRequest {
-  path: string;
-  newPath?: string;
-}
-/**
- * Client for file system operations
- */
-declare class FileClient extends BaseHttpClient implements SandboxFilesAPI {
-  /**
-   * Create a directory
-   * @param path - Directory path to create
-   * @param sessionId - The session ID for this operation
-   * @param options - Optional settings (recursive)
-   */
-  mkdir(path: string, sessionId: string, options?: {
-    recursive?: boolean;
-  }): Promise<MkdirResult>;
-  /**
-   * Write content to a file
-   * @param path - File path to write to
-   * @param content - Content to write
-   * @param sessionId - The session ID for this operation
-   * @param options - Optional settings (encoding)
-   */
-  writeFile(path: string, content: string, sessionId: string, options?: {
-    encoding?: string;
-  }): Promise<WriteFileResult>;
-  /**
-   * Read content from a file.
-   *
-   * @param path - File path to read from
-   * @param sessionId - The session ID for this operation
-   * @param options - Optional settings (encoding)
-   *
-   * When `encoding` is `'none'`, returns a `ReadFileStreamResult` whose
-   * `content` is a raw `ReadableStream<Uint8Array>`. This variant only works
-   * on the `rpc` transport; HTTP and WebSocket transports throw at runtime.
-   */
-  readFile(path: string, sessionId: string, options: {
-    encoding: 'none';
-  }): Promise<ReadFileStreamResult>;
-  readFile(path: string, sessionId: string, options?: {
-    encoding?: Exclude<FileEncoding, 'none'>;
-  }): Promise<ReadFileResult>;
-  /**
-   * Stream a file using Server-Sent Events
-   * Returns a ReadableStream of SSE events containing metadata, chunks, and completion
-   * @param path - File path to stream
-   * @param sessionId - The session ID for this operation
-   */
-  readFileStream(path: string, sessionId: string): Promise<ReadableStream<Uint8Array>>;
-  /**
-   * Delete a file
-   * @param path - File path to delete
-   * @param sessionId - The session ID for this operation
-   */
-  deleteFile(path: string, sessionId: string): Promise<DeleteFileResult>;
-  /**
-   * Rename a file
-   * @param path - Current file path
-   * @param newPath - New file path
-   * @param sessionId - The session ID for this operation
-   */
-  renameFile(path: string, newPath: string, sessionId: string): Promise<RenameFileResult>;
-  /**
-   * Move a file
-   * @param path - Current file path
-   * @param newPath - Destination file path
-   * @param sessionId - The session ID for this operation
-   */
-  moveFile(path: string, newPath: string, sessionId: string): Promise<MoveFileResult>;
-  /**
-   * List files in a directory
-   * @param path - Directory path to list
-   * @param sessionId - The session ID for this operation
-   * @param options - Optional settings (recursive, includeHidden)
-   */
-  listFiles(path: string, sessionId: string, options?: ListFilesOptions): Promise<ListFilesResult>;
-  /**
-   * Check if a file or directory exists
-   * @param path - Path to check
-   * @param sessionId - The session ID for this operation
-   */
-  exists(path: string, sessionId: string): Promise<FileExistsResult>;
-  /**
-   * Write a file via a raw binary stream over the RPC transport.
-   * Throws on HTTP and WebSocket transports — use writeFile() with a string instead.
-   */
-  writeFileStream(_path: string, _content: ReadableStream<Uint8Array>, _sessionId: string): Promise<{
-    success: boolean;
-    path: string;
-    bytesWritten: number;
-    timestamp: string;
-  }>;
-}
-//#endregion
-//#region src/clients/git-client.d.ts
-/**
- * Request interface for Git checkout operations
- */
-interface GitCheckoutRequest extends SessionRequest {
-  repoUrl: string;
-  branch?: string;
-  targetDir?: string;
-  /** Clone depth for shallow clones (e.g., 1 for latest commit only) */
-  depth?: number;
-  /** Maximum wall-clock time for the git clone subprocess in milliseconds */
-  timeoutMs?: number;
-}
-/**
- * Client for Git repository operations
- */
-declare class GitClient extends BaseHttpClient implements SandboxGitAPI {
-  private static readonly REQUEST_TIMEOUT_BUFFER_MS;
-  constructor(options?: HttpClientOptions);
-  /**
-   * Clone a Git repository
-   * @param repoUrl - URL of the Git repository to clone
-   * @param sessionId - The session ID for this operation
-   * @param options - Optional settings (branch, targetDir, depth, timeoutMs)
-   */
-  checkout(repoUrl: string, sessionId: string, options?: {
-    branch?: string;
-    targetDir?: string;
-    /** Clone depth for shallow clones (e.g., 1 for latest commit only) */
-    depth?: number;
-    /** Maximum wall-clock time for the git clone subprocess in milliseconds */
-    timeoutMs?: number;
-  }): Promise<GitCheckoutResult>;
-}
-//#endregion
-//#region src/clients/interpreter-client.d.ts
-interface ExecutionCallbacks {
-  onStdout?: (output: OutputMessage) => void | Promise<void>;
-  onStderr?: (output: OutputMessage) => void | Promise<void>;
-  onResult?: (result: Result) => void | Promise<void>;
-  onError?: (error: ExecutionError) => void | Promise<void>;
-}
-declare class InterpreterClient extends BaseHttpClient implements SandboxInterpreterAPI {
-  private readonly maxRetries;
-  private readonly retryDelayMs;
-  createCodeContext(options?: CreateContextOptions): Promise<CodeContext>;
-  runCodeStream(contextId: string | undefined, code: string, language: string | undefined, callbacks: ExecutionCallbacks, timeoutMs?: number): Promise<void>;
-  listCodeContexts(): Promise<CodeContext[]>;
-  deleteCodeContext(contextId: string): Promise<void>;
-  /**
-   * Get a raw stream for code execution.
-   * Used by CodeInterpreter.runCodeStreaming() for direct stream access.
-   */
-  streamCode(contextId: string, code: string, language?: string): Promise<ReadableStream<Uint8Array>>;
-  /**
-   * Execute an operation with automatic retry for transient errors
-   */
-  private executeWithRetry;
-  private isRetryableError;
-  private parseErrorResponse;
-  private readLines;
-  private parseExecutionResult;
-}
-//#endregion
-//#region src/clients/port-client.d.ts
-/**
- * Client for port readiness operations.
- */
-declare class PortClient extends BaseHttpClient {
-  /**
-   * Watch a port for readiness via SSE stream
-   * @param request - Port watch configuration
-   * @returns SSE stream that emits PortWatchEvent objects
-   */
-  watchPort(request: PortWatchRequest): Promise<ReadableStream<Uint8Array>>;
-}
-//#endregion
-//#region src/clients/process-client.d.ts
-/**
- * Client for background process management
- */
-declare class ProcessClient extends BaseHttpClient implements SandboxProcessesAPI {
-  /**
-   * Start a background process
-   * @param command - Command to execute as a background process
-   * @param sessionId - The session ID for this operation
-   * @param options - Optional settings (processId)
-   */
-  startProcess(command: string, sessionId: string, options?: {
-    processId?: string;
-    timeoutMs?: number;
-    env?: Record<string, string | undefined>;
-    cwd?: string;
-    encoding?: string;
-    autoCleanup?: boolean;
-    origin?: 'user' | 'internal';
-  }): Promise<ProcessStartResult>;
-  /**
-   * List all processes (sandbox-scoped, not session-scoped)
-   */
-  listProcesses(): Promise<ProcessListResult>;
-  /**
-   * Get information about a specific process (sandbox-scoped, not session-scoped)
-   * @param processId - ID of the process to retrieve
-   */
-  getProcess(processId: string): Promise<ProcessInfoResult>;
-  /**
-   * Kill a specific process (sandbox-scoped, not session-scoped)
-   * @param processId - ID of the process to kill
-   */
-  killProcess(processId: string): Promise<ProcessKillResult>;
-  /**
-   * Kill all running processes (sandbox-scoped, not session-scoped)
-   */
-  killAllProcesses(): Promise<ProcessCleanupResult>;
-  /**
-   * Get logs from a specific process (sandbox-scoped, not session-scoped)
-   * @param processId - ID of the process to get logs from
-   */
-  getProcessLogs(processId: string): Promise<ProcessLogsResult>;
-  /**
-   * Stream logs from a specific process (sandbox-scoped, not session-scoped)
-   * @param processId - ID of the process to stream logs from
-   */
-  streamProcessLogs(processId: string): Promise<ReadableStream<Uint8Array>>;
-}
-//#endregion
-//#region src/clients/utility-client.d.ts
-/**
- * Response interface for ping operations
- */
-interface PingResponse extends BaseApiResponse {
-  message: string;
-  uptime?: number;
-}
-/**
- * Response interface for getting available commands
- */
-interface CommandsResponse extends BaseApiResponse {
-  availableCommands: string[];
-  count: number;
-}
-/**
- * Request interface for creating sessions
- */
-interface CreateSessionRequest {
-  id: string;
-  env?: Record<string, string | undefined>;
-  cwd?: string;
-  commandTimeoutMs?: number;
-}
-/**
- * Response interface for creating sessions.
- *
- * `containerPlacementId` carries the container's `CLOUDFLARE_PLACEMENT_ID` at session
- * creation time so the DO can capture it without a separate request. It is
- * `null` when the environment variable is not set, such as in local dev.
- */
-interface CreateSessionResponse extends BaseApiResponse {
-  id: string;
-  message: string;
-  containerPlacementId?: string | null;
-}
-/**
- * Request interface for deleting sessions
- */
-interface DeleteSessionRequest {
-  sessionId: string;
-}
-/**
- * Response interface for deleting sessions
- */
-interface DeleteSessionResponse extends BaseApiResponse {
-  sessionId: string;
-}
-/**
- * Client for health checks and utility operations
- */
-declare class UtilityClient extends BaseHttpClient implements SandboxUtilsAPI {
-  /**
-   * Ping the sandbox to check if it's responsive
-   */
-  ping(): Promise<string>;
-  /**
-   * Get list of available commands in the sandbox environment
-   */
-  getCommands(): Promise<string[]>;
-  /**
-   * Create a new execution session
-   * @param options - Session configuration (id, env, cwd)
-   */
-  createSession(options: CreateSessionRequest): Promise<CreateSessionResponse>;
-  /**
-   * Delete an execution session
-   * @param sessionId - Session ID to delete
-   */
-  deleteSession(sessionId: string): Promise<DeleteSessionResponse>;
-  /**
-   * Get the container version
-   * Returns the version embedded in the Docker image during build
-   */
-  getVersion(): Promise<string>;
-  listSessions(): Promise<{
-    sessions: string[];
-  }>;
-}
-//#endregion
-//#region src/clients/watch-client.d.ts
-/**
- * Client for file watch operations
- * Uses inotify under the hood for native filesystem event notifications
- *
- * @internal This client is used internally by the SDK.
- * Users should use `sandbox.watch()` or `sandbox.checkChanges()` instead.
- */
-declare class WatchClient extends BaseHttpClient implements SandboxWatchAPI {
-  /**
-   * Check whether a path changed since a previously returned version.
-   */
-  checkChanges(request: CheckChangesRequest): Promise<CheckChangesResult>;
-  /**
-   * Start watching a directory for changes.
-   * The returned promise resolves only after the watcher is established
-   * on the filesystem (i.e. the `watching` SSE event has been received).
-   * The returned stream still contains the `watching` event so consumers
-   * using `parseSSEStream` will see the full event sequence.
-   *
-   * @param request - Watch request with path and options
-   */
-  watch(request: WatchRequest): Promise<ReadableStream<Uint8Array>>;
-  /**
-   * Read SSE chunks until the `watching` event appears, then return a
-   * wrapper stream that replays the buffered chunks followed by the
-   * remaining original stream data.
-   */
-  private waitForReadiness;
-}
-//#endregion
-//#region src/clients/sandbox-client.d.ts
-/**
- * Route-based compatibility sandbox client that composes all domain-specific
- * HTTP API clients.
- *
- * 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;
-  readonly commands: CommandClient;
-  readonly files: FileClient;
-  readonly processes: ProcessClient;
-  readonly ports: PortClient;
-  readonly git: GitClient;
-  readonly interpreter: InterpreterClient;
-  readonly utils: UtilityClient;
-  readonly watch: WatchClient;
-  /**
-   * Tunnels are RPC-only — the route-based transport does not implement them.
-   * This getter exists so the `PublicKeys<SandboxClient> satisfies
-   * PublicKeys<SandboxAPI>` compile-time check holds. Calling any method on
-   * the returned proxy throws a clear `RPC transport required` error.
-   */
-  readonly tunnels: never;
-  private transport;
-  constructor(options: HttpClientOptions);
-  /**
-   * Update the transport retry budget without recreating the client.
-   *
-   * In WebSocket mode a single shared transport is used, so one update covers
-   * every sub-client. In HTTP mode each sub-client owns its own transport, so
-   * all of them are updated individually.
-   */
-  setRetryTimeoutMs(ms: number): void;
-  /**
-   * Get the current transport mode
-   */
-  getTransportMode(): RouteTransportMode;
-  /**
-   * Check if WebSocket is connected (only relevant in WebSocket mode)
-   */
-  isWebSocketConnected(): boolean;
-  /**
-   * Connect WebSocket transport (no-op in HTTP mode)
-   * Called automatically on first request, but can be called explicitly
-   * to establish connection upfront.
-   */
-  connect(): Promise<void>;
-  /**
-   * Disconnect WebSocket transport (no-op in HTTP mode)
-   * Should be called when the sandbox is destroyed.
-   */
-  disconnect(): void;
+  onTunnelExit(id: string, port: number, exitCode: number | null): Promise<void>;
 }
 //#endregion
 //#region src/container-control/connection.d.ts
@@ -2456,8 +1692,8 @@ interface ContainerControlConnectionOptions {
   logger?: Logger;
   /**
    * Total retry budget (ms) for retryable upgrade responses while the
-   * container is unavailable. Defaults to 120 000 (2 minutes), matching the
-   * route-based `WebSocketTransport`. Set to 0 to disable retries.
+   * container is unavailable. Defaults to 120 000 (2 minutes). Set to 0 to
+   * disable retries.
    */
   retryTimeoutMs?: number;
   /**
@@ -2467,7 +1703,7 @@ interface ContainerControlConnectionOptions {
    * (e.g. notifying the DO when a tunnel's cloudflared process has
    * exited). When omitted, the container sees an empty remote main.
    */
-  localMain?: any;
+  localMain?: SandboxControlCallback & RpcTarget;
   /**
    * Invoked when an active WebSocket transitions to closed/errored.
    * Fired at most once per successful connection from the WS event
@@ -2475,8 +1711,10 @@ interface ContainerControlConnectionOptions {
    * signal so recovery doesn't depend on a periodic poller running
    * inside what may be an idle isolate.
    *
-   * Not fired for `doConnect` failures (the rejected `connect()`
-   * promise is the signal in that case) nor for `disconnect()`.
+   * Also fired for `doConnect` failures after the deferred transport is
+   * aborted. A failed upgrade poisons the transport, so owners must discard
+   * the connection and create a fresh one for subsequent calls. Not fired for
+   * `disconnect()`.
    */
   onClose?: () => void;
 }
@@ -2496,8 +1734,9 @@ interface ContainerControlClientOptions extends ContainerControlConnectionOption
   /**
    * Fires once when the capnweb session transitions from idle to busy
    * (an RPC call was started or a stream return is now in flight). The
-   * Sandbox DO wires this to `inflightRequests++`, which makes
-   * `isActivityExpired()` skip the sleepAfter comparison.
+   * Sandbox DO wires this to increment the Container base class's
+   * in-flight request counter, which makes `isActivityExpired()` skip the
+   * sleepAfter comparison.
    */
   onSessionBusy?: () => void;
   /**
@@ -2510,7 +1749,7 @@ interface ContainerControlClientOptions extends ContainerControlConnectionOption
   onSessionIdle?: () => void;
 }
 /**
- * SandboxClient-compatible facade backed by direct capnweb RPC.
+ * Sandbox control facade backed by direct capnweb RPC.
  *
  * All operations call the container's SandboxAPI control interface directly
  * over capnweb, bypassing the HTTP handler/router layer entirely.
@@ -2580,7 +1819,6 @@ declare class ContainerControlClient {
    * client is torn down and reconnected.
    */
   setRetryTimeoutMs(ms: number): void;
-  getTransportMode(): SandboxTransport;
   isWebSocketConnected(): boolean;
   connect(): Promise<void>;
   disconnect(): void;
@@ -2602,7 +1840,6 @@ type SandboxConfiguration = {
   sleepAfter?: string | number;
   keepAlive?: boolean;
   containerTimeouts?: NonNullable<SandboxOptions['containerTimeouts']>;
-  transport?: SandboxTransport;
 };
 /**
  * SDK-level ContainerProxy that directly dispatches SDK-internal mount hosts
@@ -2620,7 +1857,7 @@ declare function getSandbox<T extends Sandbox<any>>(ns: DurableObjectNamespace<T
 declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
   defaultPort: number;
   sleepAfter: string | number;
-  client: SandboxClient | ContainerControlClient;
+  client: ContainerControlClient;
   private codeInterpreter;
   private sandboxName;
   private tunnelsHandler;
@@ -2637,14 +1874,6 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
   private activeMounts;
   private mountOperationQueue;
   private currentRuntime;
-  private transport;
-  /**
-   * True once transport has been written to storage at least once (either
-   * via setTransport or restored on cold start). Gates the idempotency
-   * check so a first explicit call persists even when the requested value
-   * already equals the env-derived in-memory default.
-   */
-  private hasStoredTransport;
   private backupBucket;
   /**
    * Serializes backup operations to prevent concurrent create/restore on the same sandbox.
@@ -2705,26 +1934,18 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
    */
   callTunnels(method: string, args: unknown[]): Promise<unknown>;
   /**
-   * Compute the transport retry budget from current container timeouts.
+   * Compute the control-channel upgrade retry budget from current container
+   * timeouts.
    *
    * The budget covers the full container startup window (instance provisioning
-   * + port readiness) plus a 30s margin for the maximum single backoff delay
-   * (capped at 30s in BaseTransport). The 120s floor preserves the previous
-   * default for short timeout configurations.
+   * + port readiness) plus a 30s margin for the maximum single backoff delay.
+   * The 120s floor preserves the default for short timeout configurations.
    */
   private computeRetryTimeoutMs;
   /**
-   * Create the route-based compatibility client with current HTTP/WebSocket
-   * transport settings.
-   */
-  private createSandboxClient;
-  /**
-   * 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.
+   * Create the single control-plane client used for all SDK operations.
    */
-  private createClientForTransport;
+  private createClient;
   constructor(ctx: DurableObjectState<{}>, env: Env);
   setSandboxName(name: string, normalizeId?: boolean): Promise<void>;
   configure(configuration: SandboxConfiguration): Promise<void>;
@@ -2732,7 +1953,6 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
   setKeepAlive(keepAlive: boolean): Promise<void>;
   setEnvVars(envVars: Record<string, string | undefined>): Promise<void>;
   setContainerTimeouts(timeouts: NonNullable<SandboxOptions['containerTimeouts']>): Promise<void>;
-  setTransport(transport: SandboxTransport): Promise<void>;
   private validateTimeout;
   private getDefaultTimeouts;
   /**
@@ -3064,7 +2284,7 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
    *   - `'utf-8'` / `'utf8'`: always return as UTF-8 string
    *   - `'base64'`: always return as base64-encoded string
    *   - `'none'`: return a result whose `content` is a raw binary `ReadableStream<Uint8Array>`
-   *              with no encoding overhead. **Requires `SANDBOX_TRANSPORT=rpc`.** Throws on HTTP/WebSocket transports.
+   *              with no encoding overhead.
    */
   readFile(path: string, options: {
     encoding: 'none';
@@ -3167,7 +2387,8 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
   }[]>;
   /**
    * Namespaced tunnel API. Quick tunnels are zero-config preview URLs
-   * backed by Cloudflare's trycloudflare service.
+   * backed by Cloudflare's trycloudflare service. Named tunnels bind a
+   * stable hostname under the configured Cloudflare zone.
    *
    * - `tunnels.get(port)` — idempotent. Returns the cached tunnel for
    *   `port` if one exists in DO storage, otherwise spawns a fresh
@@ -3177,19 +2398,17 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
    * - `tunnels.destroy(portOrInfo)` — tear down by port number or by
    *   the record returned from `get()`.
    *
-   * Storage is cleared on container restart (`onStart`), so URLs do
-   * not survive a container restart — the next `get(port)` call will
-   * spawn a fresh tunnel with a new URL.
-   *
-   * Requires the RPC transport. Calling this on a route-based transport
-   * throws "RPC transport required".
+   * Container restarts drop quick-tunnel records because their
+   * `*.trycloudflare.com` URLs are tied to the dead cloudflared process.
+   * Named-tunnel records stay in storage and are marked for respawn so the
+   * next `get(port, { name })` call reuses the Cloudflare tunnel and DNS
+   * record while starting a fresh cloudflared process.
    */
   get tunnels(): TunnelsHandler;
   /**
    * Lazily construct both the public tunnels handler and its sibling
    * exit-handler callback. Called from the `tunnels` getter on first
-   * access and on every access after a transport swap clears both
-   * fields.
+   * access.
    */
   private ensureTunnelsBuilt;
   /**
@@ -3427,5 +2646,5 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
   private configureS3CredentialProxyOutbound;
 }
 //#endregion
-export { FileStreamEvent as $, RequestConfig as A, CreateContextOptions as At, BackupOptions as B, CommandClient as C, WaitForPortOptions as Ct, ContainerStub as D, isProcessStatus as Dt, BaseApiResponse as E, isProcess as Et, SandboxInterpreterAPI as F, CheckChangesResult as G, BucketCredentials as H, TunnelInfo as I, ExecOptions as J, DirectoryBackup as K, TunnelOptions as L, SessionRequest as M, ExecutionResult as Mt, NamedTunnelInfo as N, RunCodeOptions as Nt, ErrorResponse as O, PtyOptions as Ot, QuickTunnelInfo as P, FileMetadata as Q, ExecuteRequest as R, WriteFileRequest as S, WaitForLogResult as St, BackupClient as T, isExecResult as Tt, BucketProvider as U, BaseExecOptions as V, CheckChangesOptions as W, ExecutionSession as X, ExecResult as Y, FileChunk as Z, GitClient as _, RestoreBackupResult as _t, CommandsResponse as a, LogEvent as at, MkdirRequest as b, SessionOptions as bt, DeleteSessionRequest as c, ProcessCleanupResult as ct, UtilityClient as d, ProcessListResult as dt, FileWatchSSEEvent as et, ProcessClient as f, ProcessLogsResult as ft, GitCheckoutRequest as g, RemoteMountBucketOptions as gt, InterpreterClient as h, ProcessStatus as ht, SandboxClient as i, LocalMountBucketOptions as it, ResponseHandler as j, Execution as jt, HttpClientOptions as k, CodeContext as kt, DeleteSessionResponse as l, ProcessInfoResult as lt, ExecutionCallbacks as m, ProcessStartResult as mt, Sandbox as n, ISandbox as nt, CreateSessionRequest as o, MountBucketOptions as ot, PortClient as p, ProcessOptions as pt, ExecEvent as q, getSandbox as r, ListFilesOptions as rt, CreateSessionResponse as s, Process as st, ContainerProxy$1 as t, GitCheckoutResult as tt, PingResponse as u, ProcessKillResult as ut, FileClient as v, SandboxOptions as vt, ExecuteResponse as w, WatchOptions as wt, ReadFileRequest as x, StreamOptions as xt, FileOperationRequest as y, SandboxTransport as yt, StartProcessRequest as z };
-//# sourceMappingURL=sandbox-C8l-pMlL.d.ts.map
+export { Process as A, WatchOptions as B, FileWatchSSEEvent as C, LocalMountBucketOptions as D, ListFilesOptions as E, SandboxOptions as F, CodeContext as G, isProcess as H, SessionOptions as I, ExecutionResult as J, CreateContextOptions as K, StreamOptions as L, ProcessStatus as M, RemoteMountBucketOptions as N, LogEvent as O, RestoreBackupResult as P, WaitForLogResult as R, FileStreamEvent as S, ISandbox as T, isProcessStatus as U, isExecResult as V, PtyOptions as W, RunCodeOptions as Y, ExecOptions as _, QuickTunnelInfo as a, FileChunk as b, TunnelOptions as c, BucketCredentials as d, BucketProvider as f, ExecEvent as g, DirectoryBackup as h, NamedTunnelInfo as i, ProcessOptions as j, MountBucketOptions as k, BackupOptions as l, CheckChangesResult as m, Sandbox as n, SandboxInterpreterAPI as o, CheckChangesOptions as p, Execution as q, getSandbox as r, TunnelInfo as s, ContainerProxy$1 as t, BaseExecOptions as u, ExecResult as v, GitCheckoutResult as w, FileMetadata as x, ExecutionSession as y, WaitForPortOptions as z };
+//# sourceMappingURL=sandbox-Cz8DRoAm.d.ts.map