@cloudflare/sandbox 0.13.0-next.649.1 → 0.13.0-next.681.1

package/dist/sandbox-44kEJjAc.d.ts

@@ -1,2652 +0,0 @@
-import { Container, ContainerProxy } from "@cloudflare/containers";
-import { RpcTarget } from "capnweb";
-
-//#region ../shared/dist/logger/types.d.ts
-
-type LogComponent = 'container' | 'sandbox-do' | 'executor';
-/**
- * Context metadata included in every log entry
- */
-interface LogContext {
-  /**
-   * Unique trace ID for request correlation across distributed components
-   * Format: "tr_" + 16 hex chars (e.g., "tr_7f3a9b2c4e5d6f1a")
-   */
-  traceId: string;
-  /**
-   * Component that generated the log
-   */
-  component: LogComponent;
-  /**
-   * Sandbox identifier (which sandbox instance)
-   */
-  sandboxId?: string;
-  /**
-   * Session identifier (which session within sandbox)
-   */
-  sessionId?: string;
-  /**
-   * Process identifier (which background process)
-   */
-  processId?: string;
-  /**
-   * Command identifier (which command execution)
-   */
-  commandId?: string;
-  /**
-   * Duration in milliseconds
-   */
-  durationMs?: number;
-  /**
-   * Service version (from SANDBOX_VERSION env var)
-   */
-  serviceVersion?: string;
-  /**
-   * Instance identifier (hostname or container ID)
-   */
-  instanceId?: string;
-  /**
-   * Extensible for additional metadata
-   */
-  [key: string]: unknown;
-}
-/**
- * Logger interface for structured logging
- *
- * All methods accept optional context that gets merged with the logger's base context.
- */
-interface Logger {
-  /**
-   * Log debug-level message (most verbose, typically disabled in production)
-   *
-   * @param message Human-readable message
-   * @param context Optional additional context
-   */
-  debug(message: string, context?: Partial<LogContext>): void;
-  /**
-   * Log info-level message (normal operational events)
-   *
-   * @param message Human-readable message
-   * @param context Optional additional context
-   */
-  info(message: string, context?: Partial<LogContext>): void;
-  /**
-   * Log warning-level message (recoverable issues, degraded state)
-   *
-   * @param message Human-readable message
-   * @param context Optional additional context
-   */
-  warn(message: string, context?: Partial<LogContext>): void;
-  /**
-   * Log error-level message (failures, exceptions)
-   *
-   * @param message Human-readable message
-   * @param error Optional Error object to include
-   * @param context Optional additional context
-   */
-  error(message: string, error?: Error, context?: Partial<LogContext>): void;
-  /**
-   * Create a child logger with additional context
-   *
-   * The child logger inherits all context from the parent and adds new context.
-   * This is useful for adding request-specific context without passing through parameters.
-   *
-   * @param context Additional context to merge
-   * @returns New logger instance with merged context
-   *
-   * @example
-   * const logger = createLogger({ component: 'sandbox-do', traceId: 'tr_abc123' });
-   * const execLogger = logger.child({ commandId: 'cmd-456' });
-   * execLogger.info('Command started'); // Includes all context: component, traceId, commandId
-   */
-  child(context: Partial<LogContext>): Logger;
-}
-//#endregion
-//#region ../shared/dist/interpreter-types.d.ts
-interface CreateContextOptions {
-  /**
-   * Programming language for the context
-   * @default 'python'
-   */
-  language?: 'python' | 'javascript' | 'typescript';
-  /**
-   * Working directory for the context
-   * @default '/workspace'
-   */
-  cwd?: string;
-  /**
-   * Environment variables for the context.
-   * Undefined values are skipped (treated as "not configured").
-   */
-  envVars?: Record<string, string | undefined>;
-  /**
-   * Request timeout in milliseconds
-   * @default 30000
-   */
-  timeout?: number;
-}
-interface CodeContext {
-  /**
-   * Unique identifier for the context
-   */
-  readonly id: string;
-  /**
-   * Programming language of the context
-   */
-  readonly language: string;
-  /**
-   * Current working directory
-   */
-  readonly cwd: string;
-  /**
-   * When the context was created
-   */
-  readonly createdAt: Date;
-  /**
-   * When the context was last used
-   */
-  readonly lastUsed: Date;
-}
-interface RunCodeOptions {
-  /**
-   * Context to run the code in. If not provided, uses default context for the language
-   */
-  context?: CodeContext;
-  /**
-   * Language to use if context is not provided
-   * @default 'python'
-   */
-  language?: 'python' | 'javascript' | 'typescript';
-  /**
-   * Environment variables for this execution.
-   * Undefined values are skipped (treated as "not configured").
-   */
-  envVars?: Record<string, string | undefined>;
-  /**
-   * Execution timeout in milliseconds
-   * @default 60000
-   */
-  timeout?: number;
-  /**
-   * AbortSignal for cancelling execution
-   */
-  signal?: AbortSignal;
-  /**
-   * Callback for stdout output
-   */
-  onStdout?: (output: OutputMessage) => void | Promise<void>;
-  /**
-   * Callback for stderr output
-   */
-  onStderr?: (output: OutputMessage) => void | Promise<void>;
-  /**
-   * Callback for execution results (charts, tables, etc)
-   */
-  onResult?: (result: Result) => void | Promise<void>;
-  /**
-   * Callback for execution errors
-   */
-  onError?: (error: ExecutionError) => void | Promise<void>;
-}
-interface OutputMessage {
-  /**
-   * The output text
-   */
-  text: string;
-  /**
-   * Timestamp of the output
-   */
-  timestamp: number;
-}
-interface Result {
-  /**
-   * Plain text representation
-   */
-  text?: string;
-  /**
-   * HTML representation (tables, formatted output)
-   */
-  html?: string;
-  /**
-   * PNG image data (base64 encoded)
-   */
-  png?: string;
-  /**
-   * JPEG image data (base64 encoded)
-   */
-  jpeg?: string;
-  /**
-   * SVG image data
-   */
-  svg?: string;
-  /**
-   * LaTeX representation
-   */
-  latex?: string;
-  /**
-   * Markdown representation
-   */
-  markdown?: string;
-  /**
-   * JavaScript code to execute
-   */
-  javascript?: string;
-  /**
-   * JSON data
-   */
-  json?: any;
-  /**
-   * Chart data if the result is a visualization
-   */
-  chart?: ChartData;
-  /**
-   * Raw data object
-   */
-  data?: any;
-  /**
-   * Available output formats
-   */
-  formats(): string[];
-}
-interface ChartData {
-  /**
-   * Type of chart
-   */
-  type: 'line' | 'bar' | 'scatter' | 'pie' | 'histogram' | 'heatmap' | 'unknown';
-  /**
-   * Chart title
-   */
-  title?: string;
-  /**
-   * Chart data (format depends on library)
-   */
-  data: any;
-  /**
-   * Chart layout/configuration
-   */
-  layout?: any;
-  /**
-   * Additional configuration
-   */
-  config?: any;
-  /**
-   * Library that generated the chart
-   */
-  library?: 'matplotlib' | 'plotly' | 'altair' | 'seaborn' | 'unknown';
-  /**
-   * Base64 encoded image if available
-   */
-  image?: string;
-}
-interface ExecutionError {
-  /**
-   * Error name/type (e.g., 'NameError', 'SyntaxError')
-   */
-  name: string;
-  /**
-   * Error message
-   */
-  message: string;
-  /**
-   * Stack trace
-   */
-  traceback: string[];
-  /**
-   * Line number where error occurred
-   */
-  lineNumber?: number;
-}
-interface ExecutionResult {
-  code: string;
-  logs: {
-    stdout: string[];
-    stderr: string[];
-  };
-  error?: ExecutionError;
-  executionCount?: number;
-  results: Array<{
-    text?: string;
-    html?: string;
-    png?: string;
-    jpeg?: string;
-    svg?: string;
-    latex?: string;
-    markdown?: string;
-    javascript?: string;
-    json?: any;
-    chart?: ChartData;
-    data?: any;
-  }>;
-}
-declare class Execution {
-  readonly code: string;
-  readonly context: CodeContext;
-  /**
-   * All results from the execution
-   */
-  results: Result[];
-  /**
-   * Accumulated stdout and stderr
-   */
-  logs: {
-    stdout: string[];
-    stderr: string[];
-  };
-  /**
-   * Execution error if any
-   */
-  error?: ExecutionError;
-  /**
-   * Execution count (for interpreter)
-   */
-  executionCount?: number;
-  constructor(code: string, context: CodeContext);
-  /**
-   * Convert to a plain object for serialization
-   */
-  toJSON(): ExecutionResult;
-}
-//#endregion
-//#region ../shared/dist/pty-types.d.ts
-interface PtyOptions {
-  cols?: number;
-  rows?: number;
-  shell?: string;
-}
-//#endregion
-//#region ../shared/dist/types.d.ts
-interface BaseExecOptions {
-  /**
-   * Maximum execution time in milliseconds
-   */
-  timeout?: number;
-  /**
-   * Environment variables for this command invocation.
-   * Values temporarily override session-level/container-level env for the
-   * duration of the command but do not persist after it completes.
-   * Undefined values are skipped (treated as "not configured").
-   */
-  env?: Record<string, string | undefined>;
-  /**
-   * Working directory for command execution
-   */
-  cwd?: string;
-  /**
-   * Text encoding for output (default: 'utf8')
-   */
-  encoding?: string;
-}
-interface ExecOptions extends BaseExecOptions {
-  /**
-   * Enable real-time output streaming via callbacks
-   */
-  stream?: boolean;
-  /**
-   * Callback for real-time output data
-   */
-  onOutput?: (stream: 'stdout' | 'stderr', data: string) => void;
-  /**
-   * Callback when command completes (only when stream: true)
-   */
-  onComplete?: (result: ExecResult) => void;
-  /**
-   * Callback for execution errors
-   */
-  onError?: (error: Error) => void;
-  /**
-   * AbortSignal for cancelling execution
-   */
-  signal?: AbortSignal;
-  /**
-   * Whether this command was initiated by the user or by internal
-   * infrastructure (backup, bucket mount, env setup, etc.).
-   * Defaults to 'user' when omitted.
-   */
-  origin?: 'user' | 'internal';
-}
-interface ExecResult {
-  /**
-   * Whether the command succeeded (exitCode === 0)
-   */
-  success: boolean;
-  /**
-   * Process exit code
-   */
-  exitCode: number;
-  /**
-   * Standard output content
-   */
-  stdout: string;
-  /**
-   * Standard error content
-   */
-  stderr: string;
-  /**
-   * Command that was executed
-   */
-  command: string;
-  /**
-   * Execution duration in milliseconds
-   */
-  duration: number;
-  /**
-   * ISO timestamp when command started
-   */
-  timestamp: string;
-  /**
-   * Session ID if provided
-   */
-  sessionId?: string;
-}
-/**
- * Result from waiting for a log pattern
- */
-interface WaitForLogResult {
-  /** The log line that matched */
-  line: string;
-  /** Regex capture groups (if condition was a RegExp) */
-  match?: RegExpMatchArray;
-}
-/**
- * Result from waiting for process exit
- */
-interface WaitForExitResult {
-  /** Process exit code */
-  exitCode: number;
-}
-/**
- * Options for waiting for a port to become ready
- */
-interface WaitForPortOptions {
-  /**
-   * Check mode
-   * - 'http': Make an HTTP request and check for success status (default)
-   * - 'tcp': Just check if TCP connection succeeds
-   * @default 'http'
-   */
-  mode?: 'http' | 'tcp';
-  /**
-   * HTTP path to check (only used when mode is 'http')
-   * @default '/'
-   */
-  path?: string;
-  /**
-   * Expected HTTP status code or range (only used when mode is 'http')
-   * - Single number: exact match (e.g., 200)
-   * - Object with min/max: range match (e.g., { min: 200, max: 399 })
-   * @default { min: 200, max: 399 }
-   */
-  status?: number | {
-    min: number;
-    max: number;
-  };
-  /**
-   * Maximum time to wait in milliseconds
-   * @default no timeout
-   */
-  timeout?: number;
-  /**
-   * Interval between checks in milliseconds
-   * @default 500
-   */
-  interval?: number;
-}
-/**
- * Request body for port readiness check endpoint
- */
-interface PortCheckRequest {
-  port: number;
-  mode: 'http' | 'tcp';
-  path?: string;
-  statusMin?: number;
-  statusMax?: number;
-}
-/**
- * Request body for streaming port watch endpoint
- */
-interface PortWatchRequest extends PortCheckRequest {
-  /** Process ID to monitor - stream closes if process exits */
-  processId?: string;
-  /** Internal polling interval in ms (default: 500) */
-  interval?: number;
-}
-interface ProcessOptions extends BaseExecOptions {
-  /**
-   * Optional session ID to run the background process in.
-   *
-   * When omitted, the sandbox's default execution policy applies.
-   */
-  sessionId?: string;
-  /**
-   * Custom process ID for later reference
-   * If not provided, a UUID will be generated
-   */
-  processId?: string;
-  /**
-   * Automatically cleanup process record after exit (default: true)
-   */
-  autoCleanup?: boolean;
-  /**
-   * Callback when process exits
-   */
-  onExit?: (code: number | null) => void;
-  /**
-   * Callback for real-time output (background processes)
-   */
-  onOutput?: (stream: 'stdout' | 'stderr', data: string) => void;
-  /**
-   * Callback when process starts successfully
-   */
-  onStart?: (process: Process) => void;
-  /**
-   * Callback for process errors
-   */
-  onError?: (error: Error) => void;
-}
-type ProcessStatus = 'starting' | 'running' | 'completed' | 'failed' | 'killed' | 'error';
-interface Process {
-  /**
-   * Unique process identifier
-   */
-  readonly id: string;
-  /**
-   * System process ID (if available and running)
-   */
-  readonly pid?: number;
-  /**
-   * Command that was executed
-   */
-  readonly command: string;
-  /**
-   * Current process status
-   */
-  readonly status: ProcessStatus;
-  /**
-   * When the process was started
-   */
-  readonly startTime: Date;
-  /**
-   * When the process ended (if completed)
-   */
-  readonly endTime?: Date;
-  /**
-   * Process exit code (if completed)
-   */
-  readonly exitCode?: number;
-  /**
-   * Session ID if provided
-   */
-  readonly sessionId?: string;
-  /**
-   * Kill the process
-   */
-  kill(signal?: string): Promise<void>;
-  /**
-   * Get current process status (refreshed)
-   */
-  getStatus(): Promise<ProcessStatus>;
-  /**
-   * Get accumulated logs
-   */
-  getLogs(): Promise<{
-    stdout: string;
-    stderr: string;
-  }>;
-  /**
-   * Wait for a log pattern to appear in process output
-   *
-   * @example
-   * const proc = await sandbox.startProcess("python train.py");
-   * await proc.waitForLog("Epoch 1 complete");
-   * await proc.waitForLog(/Epoch (\d+) complete/);
-   */
-  waitForLog(pattern: string | RegExp, timeout?: number): Promise<WaitForLogResult>;
-  /**
-   * Wait for a port to become ready
-   *
-   * @example
-   * // Wait for HTTP endpoint to return 200-399
-   * const proc = await sandbox.startProcess("npm run dev");
-   * await proc.waitForPort(3000);
-   *
-   * @example
-   * // Wait for specific health endpoint
-   * await proc.waitForPort(3000, { path: '/health', status: 200 });
-   *
-   * @example
-   * // TCP-only check (just verify port is accepting connections)
-   * await proc.waitForPort(5432, { mode: 'tcp' });
-   */
-  waitForPort(port: number, options?: WaitForPortOptions): Promise<void>;
-  /**
-   * Wait for the process to exit
-   *
-   * Returns the exit code. Use getProcessLogs() or streamProcessLogs()
-   * to retrieve output after the process exits.
-   */
-  waitForExit(timeout?: number): Promise<WaitForExitResult>;
-}
-interface ExecEvent {
-  type: 'start' | 'stdout' | 'stderr' | 'complete' | 'error';
-  timestamp: string;
-  data?: string;
-  command?: string;
-  exitCode?: number;
-  result?: ExecResult;
-  error?: string;
-  sessionId?: string;
-  pid?: number;
-}
-interface LogEvent {
-  type: 'stdout' | 'stderr' | 'exit' | 'error';
-  timestamp: string;
-  data: string;
-  processId: string;
-  sessionId?: string;
-  exitCode?: number;
-}
-interface StreamOptions extends BaseExecOptions {
-  /**
-   * Optional session ID to run the streaming command in.
-   *
-   * When omitted, the sandbox's default execution policy applies.
-   */
-  sessionId?: string;
-  /**
-   * Buffer size for streaming output
-   */
-  bufferSize?: number;
-  /**
-   * AbortSignal for cancelling stream
-   */
-  signal?: AbortSignal;
-}
-interface SessionOptions {
-  /**
-   * Optional session ID (auto-generated if not provided)
-   */
-  id?: string;
-  /**
-   * Session name for identification
-   */
-  name?: string;
-  /**
-   * Environment variables for this session.
-   * Undefined values are skipped (treated as "not configured").
-   */
-  env?: Record<string, string | undefined>;
-  /**
-   * Working directory
-   */
-  cwd?: string;
-  /**
-   * Enable PID namespace isolation (requires CAP_SYS_ADMIN)
-   */
-  isolation?: boolean;
-  /**
-   * Maximum amount of time a command can run in milliseconds
-   */
-  commandTimeoutMs?: number;
-}
-interface SandboxOptions {
-  /**
-   * Duration after which the sandbox instance will sleep if no requests are received
-   * Can be:
-   * - A string like "30s", "3m", "5m", "1h" (seconds, minutes, or hours)
-   * - A number representing seconds (e.g., 180 for 3 minutes)
-   * Default: "10m" (10 minutes)
-   *
-   * Note: Ignored when keepAlive is true
-   */
-  sleepAfter?: string | number;
-  /**
-   * Keep the container alive indefinitely by preventing automatic shutdown
-   * When true, the container will never auto-timeout and must be explicitly destroyed
-   * - Any scenario where activity can't be automatically detected
-   *
-   * Important: You MUST call sandbox.destroy() when done to avoid resource leaks
-   *
-   * Default: false
-   */
-  keepAlive?: boolean;
-  /**
-   * When true (the default), implicit operations automatically create and reuse
-   * a persistent default shell session. Set to false to run implicit top-level
-   * operations sessionlessly, where each command spawns a fresh process with no
-   * shared shell state. Explicit per-call session IDs continue to work normally
-   * when this is false.
-   *
-   * Default: true
-   */
-  enableDefaultSession?: boolean;
-  /**
-   * Normalize sandbox ID to lowercase for preview URL compatibility
-   *
-   * Required for preview URLs because hostnames are case-insensitive (RFC 3986), which
-   * would route requests to a different Durable Object instance with IDs containing uppercase letters.
-   *
-   * **Important:** Different normalizeId values create different Durable Object instances:
-   * - `getSandbox(ns, "MyProject")` → DO key: "MyProject"
-   * - `getSandbox(ns, "MyProject", {normalizeId: true})` → DO key: "myproject"
-   *
-   * **Future change:** In a future version, this will default to `true` (automatically lowercase all IDs).
-   * IDs with uppercase letters will trigger a warning. To prepare, use lowercase IDs or explicitly
-   * pass `normalizeId: true`.
-   *
-   * @example
-   * getSandbox(ns, "my-project")  // Works with preview URLs (lowercase)
-   * getSandbox(ns, "MyProject", {normalizeId: true})  // Normalized to "myproject"
-   *
-   * @default false
-   */
-  normalizeId?: boolean;
-  /**
-   * Container startup timeout configuration
-   *
-   * Tune timeouts based on your container's characteristics. SDK defaults (30s instance, 90s ports)
-   * work for most use cases. Adjust for heavy containers or fail-fast applications.
-   *
-   * Can also be configured via environment variables:
-   * - SANDBOX_INSTANCE_TIMEOUT_MS
-   * - SANDBOX_PORT_TIMEOUT_MS
-   * - SANDBOX_POLL_INTERVAL_MS
-   *
-   * Precedence: options > env vars > SDK defaults
-   *
-   * @example
-   * // Heavy containers (ML models, large apps)
-   * getSandbox(ns, id, {
-   *   containerTimeouts: { portReadyTimeoutMS: 180_000 }
-   * })
-   *
-   * @example
-   * // Fail-fast for latency-sensitive apps
-   * getSandbox(ns, id, {
-   *   containerTimeouts: {
-   *     instanceGetTimeoutMS: 15_000,
-   *     portReadyTimeoutMS: 30_000
-   *   }
-   * })
-   */
-  containerTimeouts?: {
-    /**
-     * Time to wait for container instance provisioning
-     * @default 30000 (30s) - or SANDBOX_INSTANCE_TIMEOUT_MS env var
-     */
-    instanceGetTimeoutMS?: number;
-    /**
-     * Time to wait for application startup and ports to be ready
-     * @default 90000 (90s) - or SANDBOX_PORT_TIMEOUT_MS env var
-     */
-    portReadyTimeoutMS?: number;
-    /**
-     * How often to poll for container readiness
-     * @default 300 (300ms) - or SANDBOX_POLL_INTERVAL_MS env var
-     */
-    waitIntervalMS?: number;
-  };
-}
-/**
- * Execution session - isolated execution context within a sandbox
- * Returned by sandbox.createSession()
- * Provides the same API as ISandbox but bound to a specific session
- */
-interface MkdirResult {
-  success: boolean;
-  path: string;
-  recursive: boolean;
-  timestamp: string;
-  exitCode?: number;
-}
-interface WriteFileResult {
-  success: boolean;
-  path: string;
-  timestamp: string;
-  exitCode?: number;
-}
-/**
- * Valid `encoding` values accepted by `readFile` / `writeFile` options.
- *
- * - `'utf-8'` / `'utf8'` — treat content as text.
- * - `'base64'` — treat content as base64-encoded binary.
- * - `'none'` — streaming variant of `readFile`, returns a
- *   `ReadableStream<Uint8Array>` of raw bytes (see `ReadFileStreamResult`).
- */
-type FileEncoding = 'utf-8' | 'utf8' | 'base64' | 'none';
-interface ReadFileResult {
-  success: boolean;
-  path: string;
-  content: string;
-  timestamp: string;
-  exitCode?: number;
-  /**
-   * Encoding used for content (utf-8 for text, base64 for binary)
-   */
-  encoding?: 'utf-8' | 'base64';
-  /**
-   * Whether the file is detected as binary
-   */
-  isBinary?: boolean;
-  /**
-   * MIME type of the file (e.g., 'image/png', 'text/plain')
-   */
-  mimeType?: string;
-  /**
-   * File size in bytes
-   */
-  size?: number;
-}
-/**
- * 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.
- */
-interface ReadFileStreamResult {
-  success: true;
-  path: string;
-  content: ReadableStream<Uint8Array>;
-  size: number;
-  mimeType: string;
-  timestamp: string;
-}
-interface DeleteFileResult {
-  success: boolean;
-  path: string;
-  timestamp: string;
-  exitCode?: number;
-}
-interface RenameFileResult {
-  success: boolean;
-  path: string;
-  newPath: string;
-  timestamp: string;
-  exitCode?: number;
-}
-interface MoveFileResult {
-  success: boolean;
-  path: string;
-  newPath: string;
-  timestamp: string;
-  exitCode?: number;
-}
-interface FileExistsResult {
-  success: boolean;
-  path: string;
-  exists: boolean;
-  timestamp: string;
-}
-interface FileInfo {
-  name: string;
-  absolutePath: string;
-  relativePath: string;
-  type: 'file' | 'directory' | 'symlink' | 'other';
-  size: number;
-  modifiedAt: string;
-  mode: string;
-  permissions: {
-    readable: boolean;
-    writable: boolean;
-    executable: boolean;
-  };
-}
-interface ListFilesOptions {
-  recursive?: boolean;
-  includeHidden?: boolean;
-  /**
-   * Optional session ID used to resolve relative paths and execution context.
-   *
-   * When omitted, the sandbox's default execution policy applies.
-   */
-  sessionId?: string;
-}
-interface ListFilesResult {
-  success: boolean;
-  path: string;
-  files: FileInfo[];
-  count: number;
-  timestamp: string;
-  exitCode?: number;
-}
-interface GitCheckoutResult {
-  success: boolean;
-  repoUrl: string;
-  branch: string;
-  targetDir: string;
-  timestamp: string;
-  exitCode?: number;
-}
-/**
- * SSE events for file streaming
- */
-type FileStreamEvent = {
-  type: 'metadata';
-  mimeType: string;
-  size: number;
-  isBinary: boolean;
-  encoding: 'utf-8' | 'base64';
-} | {
-  type: 'chunk';
-  data: string;
-} | {
-  type: 'complete';
-  bytesRead: number;
-} | {
-  type: 'error';
-  error: string;
-};
-/**
- * File metadata from streaming
- */
-interface FileMetadata {
-  mimeType: string;
-  size: number;
-  isBinary: boolean;
-  encoding: 'utf-8' | 'base64';
-}
-/**
- * File stream chunk - either string (text) or Uint8Array (binary, auto-decoded)
- */
-type FileChunk = string | Uint8Array;
-/**
- * Options for watching a directory.
- *
- * `watch()` resolves only after the watcher is established on the filesystem.
- * The returned SSE stream can be consumed with `parseSSEStream()`.
- */
-interface WatchOptions {
-  /**
-   * Watch subdirectories recursively
-   * @default true
-   */
-  recursive?: boolean;
-  /**
-   * Glob patterns to include (e.g., '*.ts', '*.js').
-   * If not specified, all files are included.
-   * Cannot be used together with `exclude`.
-   */
-  include?: string[];
-  /**
-   * Glob patterns to exclude (e.g., 'node_modules', '.git').
-   * Cannot be used together with `include`.
-   * @default ['.git', 'node_modules', '.DS_Store']
-   */
-  exclude?: string[];
-  /**
-   * Session to run the watch in.
-   * If omitted, the default session is used.
-   */
-  sessionId?: string;
-}
-/**
- * Options for checking whether a path changed while disconnected.
- *
- * Pass the `version` returned from a previous `checkChanges()` call to learn
- * whether the path is unchanged, changed, or needs a full resync because the
- * retained change state was reset. Change state lives only for the current
- * container lifetime and may expire while idle.
- */
-interface CheckChangesOptions extends WatchOptions {
-  /**
-   * Version returned by a previous `checkChanges()` call.
-   */
-  since?: string;
-}
-/**
- * @internal SSE event types for container communication
- */
-type FileWatchEventType = 'create' | 'modify' | 'delete' | 'move_from' | 'move_to' | 'attrib';
-/**
- * @internal Request body for starting a file watch
- */
-interface WatchRequest {
-  path: string;
-  recursive?: boolean;
-  events?: FileWatchEventType[];
-  include?: string[];
-  exclude?: string[];
-  sessionId?: string;
-}
-/**
- * @internal Request body for checking retained change state.
- */
-interface CheckChangesRequest extends WatchRequest {
-  since?: string;
-}
-/**
- * SSE events emitted by `sandbox.watch()`.
- */
-type FileWatchSSEEvent = {
-  type: 'watching';
-  path: string;
-  watchId: string;
-} | {
-  type: 'event';
-  eventType: FileWatchEventType;
-  path: string;
-  isDirectory: boolean;
-  timestamp: string;
-} | {
-  type: 'error';
-  error: string;
-} | {
-  type: 'stopped';
-  reason: string;
-};
-/**
- * Result returned by `checkChanges()`.
- */
-type CheckChangesResult = {
-  success: true;
-  status: 'unchanged' | 'changed';
-  version: string;
-  timestamp: string;
-} | {
-  success: true;
-  status: 'resync';
-  reason: 'expired' | 'restarted';
-  version: string;
-  timestamp: string;
-};
-interface ProcessStartResult {
-  success: boolean;
-  processId: string;
-  pid?: number;
-  command: string;
-  timestamp: string;
-}
-interface ProcessListResult {
-  success: boolean;
-  processes: Array<{
-    id: string;
-    pid?: number;
-    command: string;
-    status: ProcessStatus;
-    startTime: string;
-    endTime?: string;
-    exitCode?: number;
-  }>;
-  timestamp: string;
-}
-interface ProcessInfoResult {
-  success: boolean;
-  process: {
-    id: string;
-    pid?: number;
-    command: string;
-    status: ProcessStatus;
-    startTime: string;
-    endTime?: string;
-    exitCode?: number;
-  };
-  timestamp: string;
-}
-interface ProcessKillResult {
-  success: boolean;
-  processId: string;
-  signal?: string;
-  timestamp: string;
-}
-interface ProcessLogsResult {
-  success: boolean;
-  processId: string;
-  stdout: string;
-  stderr: string;
-  timestamp: string;
-}
-interface ProcessCleanupResult {
-  success: boolean;
-  message?: string;
-  killedCount?: number;
-  cleanedCount: number;
-  timestamp: string;
-}
-interface SessionDeleteResult {
-  success: boolean;
-  sessionId: string;
-  timestamp: string;
-}
-interface ExecutionSession {
-  /** Unique session identifier */
-  readonly id: string;
-  exec(command: string, options?: ExecOptions): Promise<ExecResult>;
-  execStream(command: string, options?: StreamOptions): Promise<ReadableStream<Uint8Array>>;
-  startProcess(command: string, options?: ProcessOptions): Promise<Process>;
-  listProcesses(sessionId?: string): Promise<Process[]>;
-  getProcess(id: string, sessionId?: string): Promise<Process | null>;
-  killProcess(id: string, signal?: string): Promise<void>;
-  killAllProcesses(): Promise<number>;
-  cleanupCompletedProcesses(): Promise<number>;
-  getProcessLogs(id: string): Promise<{
-    stdout: string;
-    stderr: string;
-    processId: string;
-  }>;
-  streamProcessLogs(processId: string, options?: {
-    signal?: AbortSignal;
-  }): Promise<ReadableStream<Uint8Array>>;
-  writeFile(path: string, content: string | ReadableStream<Uint8Array>, options?: {
-    encoding?: string;
-  }): Promise<WriteFileResult>;
-  readFile(path: string, options: {
-    encoding: 'none';
-  }): Promise<ReadFileStreamResult>;
-  readFile(path: string, options?: {
-    encoding?: Exclude<FileEncoding, 'none'>;
-  }): Promise<ReadFileResult>;
-  readFileStream(path: string): Promise<ReadableStream<Uint8Array>>;
-  watch(path: string, options?: Omit<WatchOptions, 'sessionId'>): Promise<ReadableStream<Uint8Array>>;
-  checkChanges(path: string, options?: Omit<CheckChangesOptions, 'sessionId'>): Promise<CheckChangesResult>;
-  mkdir(path: string, options?: {
-    recursive?: boolean;
-  }): Promise<MkdirResult>;
-  deleteFile(path: string): Promise<DeleteFileResult>;
-  renameFile(oldPath: string, newPath: string): Promise<RenameFileResult>;
-  moveFile(sourcePath: string, destinationPath: string): Promise<MoveFileResult>;
-  listFiles(path: string, options?: ListFilesOptions): Promise<ListFilesResult>;
-  exists(path: string): Promise<FileExistsResult>;
-  gitCheckout(repoUrl: 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 */
-    cloneTimeoutMs?: number;
-  }): Promise<GitCheckoutResult>;
-  setEnvVars(envVars: Record<string, string | undefined>): Promise<void>;
-  createCodeContext(options?: CreateContextOptions): Promise<CodeContext>;
-  runCode(code: string, options?: RunCodeOptions): Promise<ExecutionResult>;
-  runCodeStream(code: string, options?: RunCodeOptions): Promise<ReadableStream<Uint8Array>>;
-  listCodeContexts(): Promise<CodeContext[]>;
-  deleteCodeContext(contextId: string): Promise<void>;
-  mountBucket(bucket: string, mountPath: string, options: MountBucketOptions): Promise<void>;
-  unmountBucket(mountPath: string): Promise<void>;
-  createBackup(options: BackupOptions): Promise<DirectoryBackup>;
-  restoreBackup(backup: DirectoryBackup): Promise<RestoreBackupResult>;
-  terminal(request: Request, options?: PtyOptions): Promise<Response>;
-}
-/**
- * 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;
-  /** Human-readable name for this backup. Optional. */
-  name?: string;
-  /** Seconds until automatic garbage collection. Default: 259200 (3 days). No upper limit. */
-  ttl?: number;
-  /**
-   * Respect git ignore rules for the backup directory when it is inside a git repository.
-   *
-   * Default: false.
-   * If the directory is not inside a git repository, no git-based exclusions are applied.
-   * If git is not installed in the container, a warning is logged and gitignore rules are skipped.
-   */
-  gitignore?: boolean;
-  /**
-   * Glob patterns to exclude from the backup.
-   * These are passed directly to mksquashfs as wildcard exclude patterns.
-   *
-   * @example ['node_modules', '*.log', '.cache']
-   */
-  excludes?: string[];
-  /**
-   * Use local R2 binding for backup storage instead of presigned URLs.
-   * Required for local development where presigned URLs and FUSE are unavailable.
-   * 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.
- * Serializable metadata returned by createBackup().
- * Store it anywhere and later pass it to restoreBackup().
- */
-interface DirectoryBackup {
-  /** Unique backup identifier */
-  readonly id: string;
-  /** Directory to restore into. Must be under `/workspace`, `/home`, `/tmp`, `/var/tmp`, or `/app`. */
-  readonly dir: string;
-  /** Whether this backup was created with local R2 binding mode. */
-  readonly localBucket?: boolean;
-}
-/**
- * Result returned from a successful restoreBackup() call
- */
-interface RestoreBackupResult {
-  success: boolean;
-  /** The directory that was restored */
-  dir: string;
-  /** Backup ID that was restored */
-  id: string;
-}
-/**
- * Supported S3-compatible storage providers
- */
-type BucketProvider = 'r2' | 's3' | 'gcs';
-/**
- * Credentials for S3-compatible storage
- */
-interface BucketCredentials {
-  accessKeyId: string;
-  secretAccessKey: string;
-}
-/**
- * Options for mounting an S3-compatible bucket via s3fs-FUSE (production)
- */
-interface RemoteMountBucketOptions {
-  /**
-   * S3-compatible endpoint URL
-   *
-   * Examples:
-   * - R2: 'https://abc123.r2.cloudflarestorage.com'
-   * - AWS S3: 'https://s3.us-west-2.amazonaws.com'
-   * - GCS: 'https://storage.googleapis.com'
-   */
-  endpoint: string;
-  /**
-   * Optional provider hint for automatic s3fs flag configuration
-   * If not specified, will attempt to detect from endpoint URL.
-   *
-   * Examples:
-   * - 'r2' - Cloudflare R2 (adds nomixupload)
-   * - 's3' - Amazon S3 (standard configuration)
-   * - 'gcs' - Google Cloud Storage (no special flags needed)
-   */
-  provider?: BucketProvider;
-  /**
-   * Explicit credentials (overrides env var auto-detection)
-   */
-  credentials?: BucketCredentials;
-  /**
-   * Mount filesystem as read-only
-   * Default: false
-   */
-  readOnly?: boolean;
-  /**
-   * Advanced: Override or extend s3fs options
-   *
-   * These will be merged with provider-specific defaults.
-   * To override defaults completely, specify all options here.
-   *
-   * Common options:
-   * - 'use_path_request_style' - Use path-style URLs (bucket/path vs bucket.host/path)
-   * - 'nomixupload' - Disable mixed multipart uploads (needed for some providers)
-   * - 'nomultipart' - Disable all multipart operations
-   * - 'sigv2' - Use signature version 2 instead of v4
-   * - 'no_check_certificate' - Skip SSL certificate validation (dev/testing only)
-   */
-  s3fsOptions?: string[];
-  /**
-   * Optional prefix/subdirectory within the bucket to mount.
-   *
-   * When specified, only the contents under this prefix are visible at the
-   * mount point, scoping the mount to a subdirectory of the bucket.
-   *
-   * Must start with '/' (e.g., '/workspaces/project123' or '/data/uploads/')
-   */
-  prefix?: string;
-  /**
-   * Keep real credentials in the Durable Object; write dummy credentials into
-   * the container-side s3fs password file. Outbound s3fs requests are
-   * intercepted by the DO, signed with real credentials, and forwarded to the
-   * configured endpoint.
-   *
-   * Default: false (real credentials are written into the container)
-   */
-  credentialProxy?: boolean;
-}
-/**
- * Options for mounting a local R2 binding via bidirectional sync (local dev)
- *
- * Used during local development with `wrangler dev`. The Durable Object
- * resolves the R2 binding from its own env using the `bucket` parameter
- * and syncs files via polling instead of s3fs-FUSE.
- */
-interface LocalMountBucketOptions {
-  /**
-   * Must be true to indicate local R2 binding mode.
-   */
-  localBucket: true;
-  /**
-   * Optional prefix/subdirectory within the bucket to sync.
-   *
-   * When specified, only the contents under this prefix will be visible
-   * at the mount point.
-   */
-  prefix?: string;
-  /**
-   * Mount filesystem as read-only
-   * Default: false
-   */
-  readOnly?: boolean;
-}
-/**
- * Options for mounting an R2 binding via credential-less egress interception.
- */
-interface R2BindingMountBucketOptions {
-  /**
-   * Must not be set — distinguishes this variant from RemoteMountBucketOptions.
-   */
-  endpoint?: never;
-  /**
-   * Optional prefix/subdirectory within the bucket to mount.
-   *
-   * When specified, only the contents under this prefix will be visible
-   * at the mount point.
-   */
-  prefix?: string;
-  /**
-   * Mount filesystem as read-only
-   * Default: false
-   */
-  readOnly?: boolean;
-  /**
-   * Advanced: Override or extend s3fs options.
-   * Provider defaults for R2 are still applied automatically.
-   */
-  s3fsOptions?: string[];
-}
-/**
- * Options for mounting a bucket — remote (s3fs-FUSE), local (R2 binding sync),
- * or R2 egress (credential-less s3fs via egress interception).
- */
-type MountBucketOptions = RemoteMountBucketOptions | LocalMountBucketOptions | R2BindingMountBucketOptions;
-interface ISandbox {
-  exec(command: string, options?: ExecOptions): Promise<ExecResult>;
-  startProcess(command: string, options?: ProcessOptions): Promise<Process>;
-  listProcesses(sessionId?: string): Promise<Process[]>;
-  getProcess(id: string, sessionId?: string): Promise<Process | null>;
-  killProcess(id: string, signal?: string): Promise<void>;
-  killAllProcesses(): Promise<number>;
-  execStream(command: string, options?: StreamOptions): Promise<ReadableStream<Uint8Array>>;
-  streamProcessLogs(processId: string, options?: {
-    signal?: AbortSignal;
-  }): Promise<ReadableStream<Uint8Array>>;
-  cleanupCompletedProcesses(): Promise<number>;
-  getProcessLogs(id: string): Promise<{
-    stdout: string;
-    stderr: string;
-    processId: string;
-  }>;
-  writeFile(path: string, content: string | ReadableStream<Uint8Array>, options?: {
-    encoding?: string;
-  }): Promise<WriteFileResult>;
-  readFile(path: string, options: {
-    encoding: 'none';
-  }): Promise<ReadFileStreamResult>;
-  readFile(path: string, options?: {
-    encoding?: Exclude<FileEncoding, 'none'>;
-  }): Promise<ReadFileResult>;
-  readFileStream(path: string): Promise<ReadableStream<Uint8Array>>;
-  watch(path: string, options?: WatchOptions): Promise<ReadableStream<Uint8Array>>;
-  checkChanges(path: string, options?: CheckChangesOptions): Promise<CheckChangesResult>;
-  mkdir(path: string, options?: {
-    recursive?: boolean;
-  }): Promise<MkdirResult>;
-  deleteFile(path: string): Promise<DeleteFileResult>;
-  renameFile(oldPath: string, newPath: string): Promise<RenameFileResult>;
-  moveFile(sourcePath: string, destinationPath: string): Promise<MoveFileResult>;
-  listFiles(path: string, options?: ListFilesOptions): Promise<ListFilesResult>;
-  exists(path: string, sessionId?: string): Promise<FileExistsResult>;
-  gitCheckout(repoUrl: string, options?: {
-    branch?: string;
-    targetDir?: string;
-    sessionId?: 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 */
-    cloneTimeoutMs?: number;
-  }): Promise<GitCheckoutResult>;
-  setEnvVars(envVars: Record<string, string | undefined>): Promise<void>;
-  mountBucket(bucket: string, mountPath: string, options: MountBucketOptions): Promise<void>;
-  unmountBucket(mountPath: string): Promise<void>;
-  createSession(options?: SessionOptions): Promise<ExecutionSession>;
-  deleteSession(sessionId: string): Promise<SessionDeleteResult>;
-  /**
-   * Returns the Cloudflare placement ID observed during the most recent
-   * session-create handshake with the container. `null` when the container
-   * does not expose `CLOUDFLARE_PLACEMENT_ID` (local development). `undefined`
-   * when no handshake has been observed yet on this sandbox.
-   */
-  getContainerPlacementId(): Promise<string | null | undefined>;
-  createCodeContext(options?: CreateContextOptions): Promise<CodeContext>;
-  runCode(code: string, options?: RunCodeOptions): Promise<ExecutionResult>;
-  runCodeStream(code: string, options?: RunCodeOptions): Promise<ReadableStream>;
-  listCodeContexts(): Promise<CodeContext[]>;
-  deleteCodeContext(contextId: string): Promise<void>;
-  createBackup(options: BackupOptions): Promise<DirectoryBackup>;
-  restoreBackup(backup: DirectoryBackup): Promise<RestoreBackupResult>;
-  wsConnect(request: Request, port: number): Promise<Response>;
-}
-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
-/**
- * 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?: {
-    timeoutMs?: number;
-    env?: Record<string, string | undefined>;
-    cwd?: string;
-    origin?: 'user' | 'internal';
-  }): Promise<{
-    success: boolean;
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-    command: string;
-    timestamp: string;
-  }>;
-  executeStream(command: string, sessionId: string, options?: {
-    timeoutMs?: number;
-    env?: Record<string, string | undefined>;
-    cwd?: string;
-    origin?: 'user' | 'internal';
-  }): Promise<ReadableStream<Uint8Array>>;
-}
-interface SandboxFilesAPI {
-  readFile(path: string, sessionId: string, options: {
-    encoding: 'none';
-  }): Promise<ReadFileStreamResult>;
-  readFile(path: string, sessionId: string, options?: {
-    encoding?: Exclude<FileEncoding, 'none'>;
-  }): Promise<ReadFileResult>;
-  readFileStream(path: string, sessionId: string): Promise<ReadableStream<Uint8Array>>;
-  writeFile(path: string, content: string, sessionId: string, options?: {
-    encoding?: string;
-    permissions?: string;
-  }): Promise<WriteFileResult>;
-  writeFileStream(path: string, stream: ReadableStream<Uint8Array>, sessionId: string): Promise<{
-    success: boolean;
-    path: string;
-    bytesWritten: number;
-    timestamp: string;
-  }>;
-  deleteFile(path: string, sessionId: string): Promise<DeleteFileResult>;
-  renameFile(oldPath: string, newPath: string, sessionId: string): Promise<RenameFileResult>;
-  moveFile(sourcePath: string, destinationPath: string, sessionId: string): Promise<MoveFileResult>;
-  mkdir(path: string, sessionId: string, options?: {
-    recursive?: boolean;
-  }): Promise<MkdirResult>;
-  listFiles(path: string, sessionId: string, options?: ListFilesOptions): Promise<ListFilesResult>;
-  exists(path: string, sessionId: string): Promise<FileExistsResult>;
-}
-interface SandboxProcessesAPI {
-  startProcess(command: string, sessionId: string, options?: {
-    processId?: string;
-    timeoutMs?: number;
-  }): Promise<ProcessStartResult>;
-  listProcesses(): Promise<ProcessListResult>;
-  getProcess(id: string): Promise<ProcessInfoResult>;
-  killProcess(id: string): Promise<ProcessKillResult>;
-  killAllProcesses(): Promise<ProcessCleanupResult>;
-  getProcessLogs(id: string): Promise<ProcessLogsResult>;
-  streamProcessLogs(id: string): Promise<ReadableStream<Uint8Array>>;
-}
-interface SandboxPortsAPI {
-  watchPort(request: PortWatchRequest): Promise<ReadableStream<Uint8Array>>;
-}
-interface SandboxGitAPI {
-  checkout(repoUrl: string, sessionId: string, options?: {
-    branch?: string;
-    targetDir?: string;
-    depth?: number;
-    timeoutMs?: number;
-  }): Promise<GitCheckoutResult>;
-}
-interface SandboxInterpreterAPI {
-  createCodeContext(options?: CreateContextOptions): Promise<CodeContext>;
-  streamCode(contextId: string, code: string, language?: string): Promise<ReadableStream<Uint8Array>>;
-  runCodeStream(contextId: string | undefined, code: string, language: string | undefined, callbacks: {
-    onStdout?: (output: OutputMessage) => void | Promise<void>;
-    onStderr?: (output: OutputMessage) => void | Promise<void>;
-    onResult?: (result: Result) => void | Promise<void>;
-    onError?: (error: ExecutionError) => void | Promise<void>;
-  }, timeoutMs?: number): Promise<void>;
-  listCodeContexts(): Promise<CodeContext[]>;
-  deleteCodeContext(contextId: string): Promise<void>;
-}
-interface SandboxUtilsAPI {
-  ping(): Promise<string>;
-  getVersion(): Promise<string>;
-  getCommands(): Promise<string[]>;
-  createSession(options: {
-    id: string;
-    env?: Record<string, string | undefined>;
-    cwd?: string;
-  }): Promise<{
-    success: boolean;
-    id: string;
-    message: string;
-    timestamp: string;
-    containerPlacementId?: string | null;
-  }>;
-  deleteSession(sessionId: string): Promise<{
-    success: boolean;
-    sessionId: string;
-    timestamp: string;
-  }>;
-  listSessions(): Promise<{
-    sessions: string[];
-  }>;
-}
-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 SandboxWatchAPI {
-  watch(request: WatchRequest): Promise<ReadableStream<Uint8Array>>;
-  checkChanges(request: CheckChangesRequest): Promise<CheckChangesResult>;
-}
-/**
- * Public-facing tunnel record. Discriminated on the presence of `name`:
- * quick tunnels (`*.trycloudflare.com`) omit it, named tunnels carry the
- * label that was passed to `get(port, { name })`.
- */
-type TunnelInfo = QuickTunnelInfo | NamedTunnelInfo;
-interface QuickTunnelInfo {
-  id: string;
-  port: number;
-  /** `https://<random>.trycloudflare.com`. */
-  url: string;
-  /** Hostname portion of `url`. */
-  hostname: string;
-  createdAt: string;
-  /** Absent on quick tunnels; narrows the union. */
-  name?: never;
-}
-interface NamedTunnelInfo {
-  /** Cloudflare tunnel UUID (8-4-4-4-12). */
-  id: string;
-  port: number;
-  /** `https://<hostname>`. */
-  url: string;
-  /** Full hostname bound to the tunnel (without scheme). */
-  hostname: string;
-  createdAt: string;
-  /** Label originally passed via `TunnelOptions.name`. */
-  name: string;
-}
-/**
- * Options accepted by `sandbox.tunnels.get(port, options)`. Omitting
- * `name` (or omitting the options object) selects the zero-config quick
- * tunnel; setting `name` selects the named-tunnel flow.
- */
-interface TunnelOptions {
-  /**
-   * Single DNS label under the configured zone. The full hostname is
-   * `<name>.<zone-name>`. See `validateTunnelName` for the format rules.
-   */
-  name?: string;
-}
-interface SandboxTunnelsAPI {
-  /** Spawn `cloudflared tunnel --url`. No credentials required. */
-  runQuickTunnel(id: string, port: number): Promise<TunnelInfo>;
-  /**
-   * Spawn `cloudflared tunnel run --token <token> --url http://localhost:<port>`.
-   *
-   * The SDK is the source of truth for the hostname this tunnel binds to;
-   * the container only sees the opaque token and the local port. The
-   * returned `TunnelInfo` carries empty `url`/`hostname` fields — the SDK
-   * enriches them with the values from the Cloudflare API before handing
-   * the record to user code.
-   *
-   * The token must never be logged, persisted, or echoed back to callers.
-   */
-  runNamedTunnel(id: string, token: string, port: number): Promise<TunnelInfo>;
-  /** Stop the cloudflared process for the given tunnel id. */
-  destroyTunnel(id: string): Promise<{
-    success: true;
-    id: string;
-  }>;
-  /** List tunnels currently running inside the container. */
-  listTunnels(): Promise<TunnelInfo[]>;
-}
-/**
- * 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.
- *
- * One stable target per sandbox; not per-tunnel. Reusable seam for
- * future container→DO events.
- */
-interface SandboxControlCallback {
-  /**
-   * 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.
-   */
-  onTunnelExit(id: string, port: number, exitCode: number | null): Promise<void>;
-}
-//#endregion
-//#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 ContainerControlConnectionOptions {
-  stub: ContainerFetchStub;
-  port?: number;
-  logger?: Logger;
-  /**
-   * Total retry budget (ms) for retryable upgrade responses while the
-   * container is unavailable. Defaults to 120 000 (2 minutes). Set to 0 to
-   * disable retries.
-   */
-  retryTimeoutMs?: number;
-  /**
-   * Optional `localMain` exposed to the container side of the capnweb
-   * session. The container reaches it via
-   * `session.getRemoteMain()` and uses it for control-plane callbacks
-   * (e.g. notifying the DO when a tunnel's cloudflared process has
-   * exited). When omitted, the container sees an empty remote main.
-   */
-  localMain?: SandboxControlCallback & RpcTarget;
-  /**
-   * Invoked when an active WebSocket transitions to closed/errored.
-   * Fired at most once per successful connection from the WS event
-   * handlers in `doConnect`. Gives owners a synchronous teardown
-   * signal so recovery doesn't depend on a periodic poller running
-   * inside what may be an idle isolate.
-   *
-   * 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;
-}
-//#endregion
-//#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. */
-  busyPollIntervalMs?: number;
-  /**
-   * Renew the DO's activity timeout. Fires at the start of every RPC call
-   * and on every busy-poll tick while the session has work in flight.
-   * Mirrors what `containerFetch()` does at the top of each HTTP request.
-   */
-  onActivity?: () => void;
-  /**
-   * 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 increment the Container base class's
-   * in-flight request counter, which makes `isActivityExpired()` skip the
-   * sleepAfter comparison.
-   */
-  onSessionBusy?: () => void;
-  /**
-   * Fires once when the session transitions from busy back to idle
-   * (all RPC promises settled and all stream exports released). The
-   * Sandbox DO wires this to `inflightRequests = max(0, n-1)` and a
-   * final `renewActivityTimeout()`, matching containerFetch's finally
-   * block.
-   */
-  onSessionIdle?: () => void;
-}
-/**
- * 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.
- *
- * 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 ContainerControlClient {
-  private readonly connOptions;
-  private readonly idleDisconnectMs;
-  private readonly busyPollIntervalMs;
-  private readonly logger;
-  private readonly onActivity;
-  private readonly onSessionBusy;
-  private readonly onSessionIdle;
-  private conn;
-  private idleTimer;
-  private busyPollTimer;
-  /** Tracks whether we currently believe the session is busy. */
-  private busy;
-  constructor(options: ContainerControlClientOptions);
-  /**
-   * 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;
-  /**
-   * Called synchronously at the start of each RPC method invocation.
-   * Renews the DO activity timeout so the sleepAfter alarm is pushed
-   * forward before the container processes the call.
-   */
-  private renewActivity;
-  /**
-   * Sample `getStats()` and update busy/idle state. While busy, renews the
-   * activity timeout each tick so an in-flight stream keeps pushing the
-   * sleepAfter deadline forward. On the busy → idle edge, fires
-   * `onSessionIdle` and schedules the WebSocket disconnect.
-   *
-   * If the WebSocket has dropped underneath us (container crash, network
-   * blip) we tear the connection down here. `destroyConnection()` fires
-   * `onSessionIdle` if we were busy, so the DO's inflight counter doesn't
-   * stay pinned forever waiting for a peer that's never going to reply.
-   */
-  private pollBusyState;
-  private startBusyPoll;
-  private stopBusyPoll;
-  private scheduleIdleDisconnect;
-  private clearIdleTimer;
-  private destroyConnection;
-  get commands(): SandboxCommandsAPI;
-  get files(): SandboxFilesAPI;
-  get processes(): SandboxProcessesAPI;
-  get ports(): SandboxPortsAPI;
-  get git(): SandboxGitAPI;
-  get utils(): SandboxUtilsAPI;
-  get backup(): SandboxBackupAPI;
-  get watch(): SandboxWatchAPI;
-  get tunnels(): SandboxTunnelsAPI;
-  get interpreter(): SandboxInterpreterAPI;
-  /**
-   * Update the upgrade retry budget. Applies to the current connection
-   * (if any) and is remembered for any future connections created after the
-   * client is torn down and reconnected.
-   */
-  setRetryTimeoutMs(ms: number): void;
-  isWebSocketConnected(): boolean;
-  connect(): Promise<void>;
-  disconnect(): void;
-}
-//#endregion
-//#region src/tunnels/tunnels-handler.d.ts
-interface TunnelsHandler {
-  get(port: number, options?: TunnelOptions): Promise<TunnelInfo>;
-  list(): Promise<TunnelInfo[]>;
-  destroy(portOrInfo: number | TunnelInfo): Promise<void>;
-}
-//#endregion
-//#region src/sandbox.d.ts
-type SandboxConfiguration = {
-  sandboxName?: {
-    name: string;
-    normalizeId?: boolean;
-  };
-  sleepAfter?: string | number;
-  keepAlive?: boolean;
-  containerTimeouts?: NonNullable<SandboxOptions['containerTimeouts']>;
-};
-/**
- * SDK-level ContainerProxy that directly dispatches SDK-internal mount hosts
- * (r2.internal, s3-credential-proxy.internal) without relying on
- * outboundHandlersRegistry lookups, which are NOT shared between the Durable
- * Object's execution context and the ContainerProxy WorkerEntrypoint context.
- *
- * Users must export this class from their Worker entrypoint so the Sandbox DO
- * can create outbound-interception fetchers that reference it.
- */
-declare class ContainerProxy$1 extends ContainerProxy {
-  fetch(request: Request): Promise<Response>;
-}
-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: ContainerControlClient;
-  private codeInterpreter;
-  private sandboxName;
-  private tunnelsHandler;
-  private tunnelExitHandler;
-  private destroyAllTunnels;
-  private readonly controlCallback;
-  private normalizeId;
-  private defaultSession;
-  private containerGeneration;
-  private defaultSessionInit;
-  envVars: Record<string, string>;
-  private logger;
-  private keepAliveEnabled;
-  private activeMounts;
-  private mountOperationQueue;
-  private currentRuntime;
-  private backupBucket;
-  /**
-   * Serializes backup operations to prevent concurrent create/restore on the same sandbox.
-   *
-   * This is in-memory state — it resets if the Durable Object is evicted and
-   * re-instantiated (e.g. after sleep). This is acceptable because the container
-   * filesystem is also lost on eviction, so there is no archive to race on.
-   */
-  private backupInProgress;
-  /**
-   * R2 presigned URL credentials for direct container-to-R2 transfers.
-   * All four fields plus the R2 binding must be configured for backup to work.
-   */
-  private r2AccessKeyId;
-  private r2SecretAccessKey;
-  private r2AccountId;
-  private backupBucketName;
-  private backupBucketEndpoint;
-  private r2Client;
-  /**
-   * Lazily-resolved Cloudflare account id for named-tunnel provisioning.
-   * Resolved on first access via `tunnels/credentials.ts` and cached for
-   * the lifetime of this DO instance. See the credentials helper for
-   * the precedence chain.
-   */
-  private tunnelAccountIdPromise;
-  /**
-   * Lazily-resolved Cloudflare zone id for named-tunnel provisioning.
-   * Falls back to the single zone the token can see under the resolved
-   * account id when `CLOUDFLARE_ZONE_ID` is not set. Cached for the
-   * lifetime of this DO instance.
-   */
-  private tunnelZoneIdPromise;
-  /**
-   * Default container startup timeouts (conservative for production)
-   * Based on Cloudflare docs: "Containers take several minutes to provision"
-   */
-  private readonly DEFAULT_CONTAINER_TIMEOUTS;
-  /**
-   * Active container timeout configuration
-   * Can be set via options, env vars, or defaults
-   */
-  private containerTimeouts;
-  /**
-   * True once containerTimeouts has been written to storage at least once
-   * (either via setContainerTimeouts or restored on cold start). Gates the
-   * idempotency check in setContainerTimeouts so a first explicit call
-   * persists even when the requested values already equal the in-memory
-   * defaults, distinguishing "user intent recorded" from "running on
-   * env/SDK defaults".
-   */
-  private hasStoredContainerTimeouts;
-  /**
-   * Dispatch method for tunnel operations.
-   * Called by the client-side proxy created in getSandbox() to provide
-   * the `sandbox.tunnels` API without relying on RPC pipelining
-   * through property getters which is broken when using vite-plugin.
-   */
-  callTunnels(method: string, args: unknown[]): Promise<unknown>;
-  /**
-   * 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.
-   * The 120s floor preserves the default for short timeout configurations.
-   */
-  private computeRetryTimeoutMs;
-  /**
-   * Create the single control-plane client used for all SDK operations.
-   */
-  private createClient;
-  constructor(ctx: DurableObjectState<{}>, env: Env);
-  setSandboxName(name: string, normalizeId?: boolean): Promise<void>;
-  configure(configuration: SandboxConfiguration): Promise<void>;
-  setSleepAfter(sleepAfter: string | number): Promise<void>;
-  setKeepAlive(keepAlive: boolean): Promise<void>;
-  setEnvVars(envVars: Record<string, string | undefined>): Promise<void>;
-  setContainerTimeouts(timeouts: NonNullable<SandboxOptions['containerTimeouts']>): Promise<void>;
-  private validateTimeout;
-  private getDefaultTimeouts;
-  /**
-   * Mount an S3-compatible bucket as a local directory.
-   *
-   * Requires explicit endpoint URL for production. Credentials are auto-detected from environment
-   * variables or can be provided explicitly.
-   *
-   * @param bucket - Bucket name (or R2 binding name when localBucket is true)
-   * @param mountPath - Absolute path in container to mount at
-   * @param options - Mount configuration
-   * @throws MissingCredentialsError if no credentials found in environment
-   * @throws S3FSMountError if S3FS mount command fails
-   * @throws InvalidMountConfigError if bucket name, mount path, or endpoint is invalid
-   */
-  mountBucket(bucket: string, mountPath: string, options: MountBucketOptions): Promise<void>;
-  private runMountOperation;
-  private mountBucketUnlocked;
-  /**
-   * Local dev mount: bidirectional sync via R2 binding + file/watch APIs
-   */
-  private mountBucketLocal;
-  private getR2EgressParams;
-  private validateProtectedS3fsOptions;
-  private getS3CredentialProxyParams;
-  private resolveCredentialProxyAuthStrategy;
-  /**
-   * Credential-less R2 mount: egress interception routes s3fs requests to the
-   * R2 binding. No S3 credentials are needed in the container or Worker env.
-   */
-  private mountBucketR2Egress;
-  /**
-   * Production mount: S3FS-FUSE inside the container
-   */
-  private mountBucketFuse;
-  /**
-   * Manually unmount a bucket filesystem
-   *
-   * @param mountPath - Absolute path where the bucket is mounted
-   * @throws InvalidMountConfigError if mount path doesn't exist or isn't mounted
-   */
-  unmountBucket(mountPath: string): Promise<void>;
-  private unmountBucketUnlocked;
-  /**
-   * Shared validation for mount path (absolute, not already in use).
-   */
-  private validateMountPath;
-  /**
-   * Validate mount options for remote (FUSE) mounts
-   */
-  private validateMountOptions;
-  /**
-   * Generate unique password file path for s3fs credentials
-   */
-  private generatePasswordFilePath;
-  /**
-   * Generate unique ahbe_conf file path for s3fs additional header config
-   */
-  private generateS3FSAdditionalHeaderFilePath;
-  /**
-   * Create s3fs ahbe_conf file that suppresses the Expect: 100-continue header.
-   * Restricted to 0600 so s3fs will accept it (same requirement as passwd files).
-   */
-  private createDisableExpectHeaderFile;
-  /**
-   * Create password file with s3fs credentials
-   * Format: bucket:accessKeyId:secretAccessKey
-   */
-  private createPasswordFile;
-  /**
-   * Delete password file
-   */
-  private deletePasswordFile;
-  private deleteAdditionalHeaderFile;
-  /**
-   * Execute S3FS mount command
-   */
-  private executeS3FSMount;
-  private unmountTrackedFuseMount;
-  /**
-   * In-flight `destroy()` promise. While set, concurrent callers coalesce
-   * onto the same teardown instead of triggering a second one. Cleared when
-   * the underlying work settles, so a later call that genuinely needs to
-   * recreate a destroyed sandbox still runs.
-   *
-   * If the underlying teardown hangs (e.g. `super.destroy()` never resolves
-   * because the Containers control plane is unresponsive), every coalesced
-   * caller hangs on the same promise until the Durable Object is evicted.
-   * This is deliberate: a second concurrent teardown would not make a stuck
-   * control plane unstuck, and spawning one would defeat the point of
-   * coalescing. Callers that need bounded waits must apply their own
-   * timeout around `destroy()`.
-   */
-  private inflightDestroy;
-  /**
-   * Cleanup and destroy the sandbox container.
-   *
-   * Concurrent calls coalesce: if a previous `destroy()` is still in flight,
-   * subsequent calls await the same underlying work instead of starting a
-   * second teardown. A canonical `sandbox.destroy.coalesced` event is logged
-   * per coalesced call so repeated destroy traffic is observable.
-   */
-  destroy(): Promise<void>;
-  private doDestroy;
-  onStart(): Promise<void>;
-  stop(signal?: Parameters<Container<Env>['stop']>[0]): Promise<void>;
-  /**
-   * Read the `portTokens` map from DO storage, normalizing the legacy
-   * string-valued format (just a token) to the current object format
-   * ({ token, name? }). The legacy format predates port-name persistence and
-   * can appear on any DO whose storage was written before that change.
-   */
-  private readPortTokens;
-  private readActivePreviewPorts;
-  private writeActivePreviewPorts;
-  private readPreviewState;
-  private clearActivePreviewPorts;
-  /**
-   * Check if the container version matches the SDK version
-   * Logs a warning if there's a mismatch
-   */
-  private checkVersionCompatibility;
-  onStop(): Promise<void>;
-  onError(error: unknown): void;
-  /**
-   * Override Container.containerFetch to use production-friendly timeouts
-   * Automatically starts container with longer timeouts if not running
-   */
-  containerFetch(requestOrUrl: Request | string | URL, portOrInit?: number | RequestInit, portParam?: number): Promise<Response>;
-  /**
-   * Helper: Check if error is "no container instance available"
-   * This indicates the container VM is still being provisioned.
-   */
-  private isNoInstanceError;
-  /**
-   * Helper: Check if error is a transient startup error that should trigger retry
-   *
-   * These errors occur during normal container startup and are recoverable:
-   * - Port not yet mapped (container starting, app not listening yet)
-   * - Connection refused (port mapped but app not ready)
-   * - Timeouts during startup (recoverable with retry)
-   * - Network transients (temporary connectivity issues)
-   *
-   * Errors NOT included (permanent failures):
-   * - "no such image" - missing Docker image
-   * - "container already exists" - name collision
-   * - Configuration errors
-   */
-  private isTransientStartupError;
-  /**
-   * Helper: Check if error is a permanent startup failure that will never recover
-   *
-   * These errors indicate resource exhaustion, misconfiguration, or missing images.
-   * Retrying will never succeed, so the SDK should fail fast with HTTP 500.
-   *
-   * Error sources (traced from platform internals):
-   *   - Container runtime: OOM, PID limit
-   *   - Scheduling/provisioning: no matching app, no namespace configured
-   *   - workerd container-client.c++: no such image
-   *   - @cloudflare/containers: did not call start
-   */
-  private isPermanentStartupError;
-  /**
-   * Helper: Parse containerFetch arguments (supports multiple signatures)
-   */
-  private parseContainerFetchArgs;
-  /**
-   * Override onActivityExpired to prevent automatic shutdown when keepAlive is enabled
-   * When keepAlive is disabled, calls parent implementation which stops the container
-   */
-  onActivityExpired(): Promise<void>;
-  private isPreviewProxyRequest;
-  private invalidPreviewTokenResponse;
-  private stalePreviewURLResponse;
-  private getPreviewForwardingContainer;
-  private beginPreviewForward;
-  private fetchPreviewIfRunning;
-  private buildPreviewProxyRequest;
-  private proxyPreviewRequest;
-  fetch(request: Request): Promise<Response>;
-  wsConnect(request: Request, port: number): Promise<Response>;
-  private determinePort;
-  /**
-   * Return the default session id, lazily creating the container session
-   * on first use. Called by every public method that needs a session.
-   * Concurrent callers that target the same sessionId share one
-   * in-flight initialization promise.
-   */
-  private ensureDefaultSession;
-  private getOrInitializeDefaultSession;
-  private isDefaultSessionInitContainerRestart;
-  private initializeDefaultSession;
-  /**
-   * Persist the container's placement ID in DO storage.
-   *
-   * Called from the session-create handshake so subsequent reads via
-   * `getContainerPlacementId()` do not require a round-trip to the container. The value
-   * is overwritten on every handshake so that container replacements (which
-   * assign a new placement ID) are reflected on the next session-create.
-   *
-   * A value of `undefined` means the handshake response omitted the field
-   * (older container, unexpected error shape) and the stored value is left
-   * untouched. `null` means the env var is not set in the container and is
-   * stored as-is so callers can distinguish "observed and absent" from "not
-   * yet observed."
-   */
-  private capturePlacementId;
-  private resolveExecution;
-  private validateExplicitSessionId;
-  private serializeExecutionContext;
-  private getPublicExecutionSessionId;
-  /**
-   * Resolves the session ID to annotate returned Process objects.
-   *
-   * Unlike `resolveExecution`, this is synchronous and never creates a
-   * session. When the default session hasn't been established yet, it returns
-   * `undefined` rather than triggering session creation. The resolved value is
-   * only used to populate `Process.sessionId` on the returned object — it is
-   * never sent to the container API.
-   */
-  private getProcessSessionBinding;
-  private resolveExecutionEnv;
-  private buildExecutionRequestOptions;
-  exec(command: string, options?: ExecOptions): Promise<ExecResult>;
-  execWithSessionToken(command: string, sessionId: string, options?: ExecOptions): Promise<ExecResult>;
-  /**
-   * Execute an infrastructure command (backup, mount, env setup, etc.)
-   * tagged with origin: 'internal' so logging demotes it to debug level.
-   */
-  private execInternal;
-  /**
-   * Internal session-aware exec implementation
-   * Used by both public exec() and session wrappers
-   */
-  private execWithSession;
-  private executeWithStreaming;
-  private mapExecuteResponseToExecResult;
-  /**
-   * Create a Process domain object from HTTP client DTO
-   * Centralizes process object creation with bound methods
-   * This eliminates duplication across startProcess, listProcesses, getProcess, and session wrappers
-   */
-  private createProcessFromDTO;
-  /**
-   * Wait for a log pattern to appear in process output
-   */
-  private waitForLogPattern;
-  /**
-   * Wait for a port to become available (for process readiness checking)
-   */
-  private waitForPortReady;
-  /**
-   * Wait for a process to exit
-   * Returns the exit code
-   */
-  private waitForProcessExit;
-  /**
-   * Match a pattern against text
-   */
-  private matchPattern;
-  /**
-   * Convert a log pattern to a human-readable string
-   */
-  private conditionToString;
-  /**
-   * Create a ProcessReadyTimeoutError
-   */
-  private createReadyTimeoutError;
-  /**
-   * Create a ProcessExitedBeforeReadyError
-   */
-  private createExitedBeforeReadyError;
-  startProcess(command: string, options?: ProcessOptions, sessionId?: string): Promise<Process>;
-  /**
-   * Start background streaming for process callbacks
-   * Opens SSE stream to container and routes events to callbacks
-   */
-  private startProcessCallbackStream;
-  listProcesses(sessionId?: string): Promise<Process[]>;
-  getProcess(id: string, sessionId?: string): Promise<Process | null>;
-  killProcess(id: string, signal?: string, sessionId?: string): Promise<void>;
-  killAllProcesses(sessionId?: string): Promise<number>;
-  cleanupCompletedProcesses(sessionId?: string): Promise<number>;
-  getProcessLogs(id: string, sessionId?: string): Promise<{
-    stdout: string;
-    stderr: string;
-    processId: string;
-  }>;
-  execStream(command: string, options?: StreamOptions): Promise<ReadableStream<Uint8Array>>;
-  execStreamWithSessionToken(command: string, sessionId: string, options?: StreamOptions): Promise<ReadableStream<Uint8Array>>;
-  /**
-   * Internal session-aware execStream implementation
-   */
-  private execStreamWithSession;
-  /**
-   * Stream logs from a background process as a ReadableStream.
-   */
-  streamProcessLogs(processId: string, options?: {
-    signal?: AbortSignal;
-  }): Promise<ReadableStream<Uint8Array>>;
-  gitCheckout(repoUrl: string, options?: {
-    branch?: string;
-    targetDir?: string;
-    sessionId?: 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 */
-    cloneTimeoutMs?: number;
-  }): Promise<GitCheckoutResult>;
-  mkdir(path: string, options?: {
-    recursive?: boolean;
-    sessionId?: string;
-  }): Promise<MkdirResult>;
-  writeFile(path: string, content: string | ReadableStream<Uint8Array>, options?: {
-    encoding?: string;
-    sessionId?: string;
-  }): Promise<{
-    success: boolean;
-    path: string;
-    bytesWritten: number;
-    timestamp: string;
-  } | WriteFileResult>;
-  deleteFile(path: string, sessionId?: string): Promise<DeleteFileResult>;
-  renameFile(oldPath: string, newPath: string, sessionId?: string): Promise<RenameFileResult>;
-  moveFile(sourcePath: string, destinationPath: string, sessionId?: string): Promise<MoveFileResult>;
-  /**
-   * Read a file from the sandbox.
-   *
-   * @param encoding - How to encode the returned content:
-   *   - `undefined` (default): auto-detect from MIME type (text → UTF-8 string, binary → base64 string)
-   *   - `'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.
-   */
-  readFile(path: string, options: {
-    encoding: 'none';
-    sessionId?: string;
-  }): Promise<ReadFileStreamResult>;
-  readFile(path: string, options?: {
-    encoding?: Exclude<FileEncoding, 'none'>;
-    sessionId?: string;
-  }): Promise<ReadFileResult>;
-  /**
-   * Stream a file from the sandbox using Server-Sent Events
-   * Returns a ReadableStream that can be consumed with streamFile() or collectFile() utilities
-   * @param path - Path to the file to stream
-   * @param options - Optional session ID
-   */
-  readFileStream(path: string, options?: {
-    sessionId?: string;
-  }): Promise<ReadableStream<Uint8Array>>;
-  listFiles(path: string, options?: ListFilesOptions): Promise<ListFilesResult>;
-  exists(path: string, sessionId?: string): Promise<FileExistsResult>;
-  /**
-   * Watch a directory for file system changes using native inotify.
-   *
-   * The returned promise resolves only after the watcher is established on the
-   * filesystem, so callers can immediately perform actions that depend on the
-   * watch being active. The returned stream contains the full event sequence
-   * starting with the `watching` event.
-   *
-   * Consume the stream with `parseSSEStream<FileWatchSSEEvent>(stream)`.
-   *
-   * @param path - Path to watch (absolute or relative to /workspace)
-   * @param options - Watch options
-   */
-  watch(path: string, options?: WatchOptions): Promise<ReadableStream<Uint8Array>>;
-  /**
-   * Check whether a path changed while this caller was disconnected.
-   *
-   * Pass the `version` returned from a prior call in `options.since` to learn
-   * whether the path is unchanged, changed, or needs a full resync because the
-   * retained change state was reset.
-   *
-   * @param path - Path to check (absolute or relative to /workspace)
-   * @param options - Change-check options
-   */
-  checkChanges(path: string, options?: CheckChangesOptions): Promise<CheckChangesResult>;
-  /**
-   * Expose a port and get a preview URL for accessing services running in the sandbox
-   *
-   * Preview URL authorization survives transient container restarts, but
-   * forwarding is active only for the runtime where `exposePort()` was last
-   * called. Call `exposePort()` again after a restart to reactivate an
-   * existing URL for the current runtime.
-   *
-   * @param port - Port number to expose (1024-65535)
-   * @param options - Configuration options
-   * @param options.hostname - Your Worker's domain name (required for preview URL construction)
-   * @param options.name - Optional friendly name for the port
-   * @param options.token - Optional custom token for the preview URL (1-16 characters: lowercase letters, numbers, underscores)
-   *                       If not provided, a random 16-character token will be generated automatically
-   * @returns Preview URL information including the full URL, port number, and optional name
-   *
-   * @example
-   * // With auto-generated token
-   * const { url } = await sandbox.exposePort(8080, { hostname: 'example.com' });
-   * // url: https://8080-sandbox-id-abc123random4567.example.com
-   *
-   * @example
-   * // With custom token for stable URLs across deployments
-   * const { url } = await sandbox.exposePort(8080, {
-   *   hostname: 'example.com',
-   *   token: 'my_token_v1'
-   * });
-   * // url: https://8080-sandbox-id-my_token_v1.example.com
-   */
-  exposePort(port: number, options: {
-    name?: string;
-    hostname: string;
-    token?: string;
-  }): Promise<{
-    url: string;
-    port: number;
-    name: string | undefined;
-  }>;
-  /**
-   * Revoke preview URL authorization and current-runtime activation for a port.
-   *
-   * Revocation is idempotent: calling this for a port with no preview state is
-   * still successful. The operation clears Durable Object-owned preview state
-   * only and does not contact, probe, wake, or clean up the container runtime.
-   */
-  unexposePort(port: number): Promise<void>;
-  /**
-   * Returns preview URLs that are currently forwardable in the active runtime.
-   * Durable authorization without current-runtime activation is omitted.
-   */
-  getExposedPorts(hostname: string): Promise<{
-    url: string;
-    port: number;
-    status: "active";
-  }[]>;
-  /**
-   * Namespaced tunnel API. Quick tunnels are zero-config preview URLs
-   * 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
-   *   cloudflared process and persists the record.
-   * - `tunnels.list()` — records currently known to this sandbox, from
-   *   DO storage.
-   * - `tunnels.destroy(portOrInfo)` — tear down by port number or by
-   *   the record returned from `get()`.
-   *
-   * 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.
-   */
-  private ensureTunnelsBuilt;
-  /**
-   * Resolve the Cloudflare account id used for named-tunnel provisioning.
-   *
-   * Memoised for the lifetime of this DO instance. The first call may hit
-   * `GET /user/tokens/verify` to derive the account id from the configured
-   * `CLOUDFLARE_API_TOKEN`; subsequent calls return the cached promise.
-   *
-   * Only successful resolutions are cached: a rejected lookup clears the
-   * slot so the next caller retries. Otherwise a transient failure on
-   * first use would permanently poison every later named-tunnel `get()`
-   * on this DO instance.
-   */
-  private getTunnelAccountId;
-  /**
-   * Resolve the Cloudflare zone id used for named-tunnel provisioning.
-   *
-   * Memoised for the lifetime of this DO instance. Falls back to the
-   * single zone the token can see under `accountId` via `GET /zones`
-   * when `CLOUDFLARE_ZONE_ID` is not set. Failed lookups clear the cache
-   * so the next caller retries — see `getTunnelAccountId` for the
-   * rationale.
-   */
-  private getTunnelZoneId;
-  /**
-   * Returns whether a port is currently preview-forwardable.
-   * This checks Durable Object-owned auth and runtime activation without
-   * contacting or waking the container.
-   */
-  isPortExposed(port: number): Promise<boolean>;
-  /**
-   * Checks durable preview URL authorization for a port/token pair.
-   *
-   * This does not check whether the port is activated for the current runtime
-   * and is not sufficient to decide whether preview traffic may forward.
-   */
-  validatePortToken(port: number, token: string): Promise<boolean>;
-  private validatePreviewURLForRuntime;
-  private getCurrentPreviewPorts;
-  private previewTokensMatch;
-  private validateCustomToken;
-  private generatePortToken;
-  private constructPreviewUrl;
-  /**
-   * Create isolated execution session for advanced use cases
-   * Returns ExecutionSession with full sandbox API bound to specific session
-   */
-  createSession(options?: SessionOptions): Promise<ExecutionSession>;
-  /**
-   * Get an existing session by ID
-   * Returns ExecutionSession wrapper bound to the specified session
-   *
-   * This is useful for retrieving sessions across different requests/contexts
-   * without storing the ExecutionSession object (which has RPC lifecycle limitations)
-   *
-   * @param sessionId - The ID of an existing session
-   * @returns ExecutionSession wrapper bound to the session
-   */
-  getSession(sessionId: string): Promise<ExecutionSession>;
-  /**
-   * Delete an execution session
-   * Cleans up session resources and removes it from the container
-   * Note: Cannot delete the default session. To reset the default session,
-   * use sandbox.destroy() to terminate the entire sandbox.
-   *
-   * @param sessionId - The ID of the session to delete
-   * @returns Result with success status, sessionId, and timestamp
-   * @throws Error if attempting to delete the default session
-   */
-  deleteSession(sessionId: string): Promise<SessionDeleteResult>;
-  /**
-   * Get the Cloudflare placement ID observed for the underlying container.
-   *
-   * The placement ID is captured during the first session-create handshake
-   * after a container start and stored in Durable Object storage, so this
-   * method returns the cached value without contacting the container. A new
-   * placement ID is captured on each subsequent session-create handshake,
-   * which occurs whenever the container has been replaced.
-   *
-   * Returns `null` when a handshake has completed but the container's
-   * `CLOUDFLARE_PLACEMENT_ID` environment variable is not set (for example,
-   * in local development).
-   *
-   * Returns `undefined` when no handshake has been observed yet on this
-   * sandbox. Call any method that triggers session creation (such as
-   * `exec()`) to populate the value.
-   */
-  getContainerPlacementId(): Promise<string | null | undefined>;
-  private getSessionWrapper;
-  createCodeContext(options?: CreateContextOptions): Promise<CodeContext>;
-  runCode(code: string, options?: RunCodeOptions): Promise<ExecutionResult>;
-  runCodeStream(code: string, options?: RunCodeOptions): Promise<ReadableStream>;
-  listCodeContexts(): Promise<CodeContext[]>;
-  deleteCodeContext(contextId: string): Promise<void>;
-  /** UUID v4 format validator for backup IDs */
-  private static readonly UUID_REGEX;
-  /**
-   * Validate that a directory path is safe for backup operations.
-   * Rejects empty, relative, traversal, null-byte, and unsupported-root paths.
-   */
-  private static validateBackupDir;
-  /**
-   * 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.
-   * Each call produces a fresh session ID so concurrent or sequential
-   * operations never share shell state. Callers must destroy the session
-   * in a finally block via `client.utils.deleteSession()`.
-   */
-  private ensureBackupSession;
-  /**
-   * Returns validated presigned URL configuration or throws if not configured.
-   * All credential fields plus the R2 binding are required for backup to work.
-   */
-  private requirePresignedURLSupport;
-  private getBackupBucketEndpoint;
-  private getBackupObjectURL;
-  /**
-   * 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.
-   */
-  private generatePresignedPutURL;
-  /**
-   * Upload a backup archive via presigned PUT URL.
-   * The container curls the archive directly to R2, bypassing the DO.
-   * ~24 MB/s throughput vs ~0.6 MB/s for base64 readFile.
-   */
-  private uploadBackupPresigned;
-  /**
-   * 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 downloadBackupParallel;
-  /**
-   * Serialize backup operations on this sandbox instance.
-   * Concurrent backup/restore calls are queued so the multi-step
-   * create-archive → read → upload (or mount → extract) flow
-   * is not interleaved with another backup operation on the same directory.
-   */
-  private enqueueBackupOp;
-  /**
-   * Create a backup of a directory and upload it to R2.
-   *
-   * Flow:
-   *   1. Container creates squashfs archive from the directory
-   *   2. Container uploads the archive directly to R2 via presigned URL
-   *   3. DO writes metadata to R2
-   *   4. Container cleans up the local archive
-   *
-   * The returned DirectoryBackup handle is serializable. Store it anywhere
-   * (KV, D1, DO storage) and pass it to restoreBackup() later.
-   *
-   * Concurrent backup/restore calls on the same sandbox are serialized.
-   *
-   * Partially-written files in the target directory may not be captured
-   * consistently. Completed writes are captured.
-   *
-   * NOTE: Expired backups are not automatically deleted from R2. Configure
-   * R2 lifecycle rules on the BACKUP_BUCKET to garbage-collect objects
-   * under the `backups/` prefix after the desired retention period.
-   */
-  createBackup(options: BackupOptions): Promise<DirectoryBackup>;
-  private doCreateBackup;
-  /**
-   * Local-dev implementation of createBackup.
-   * Uses the R2 binding directly instead of presigned URLs.
-   * Archive format is identical to production (squashfs + meta.json).
-   */
-  private doCreateBackupLocal;
-  /**
-   * Restore a backup from R2 into a directory.
-   *
-   * **Production flow** (`localBucket` not set):
-   *   1. DO reads metadata from R2 and checks TTL
-   *   2. Container mounts the backup archive from R2 via s3fs
-   *   3. Container mounts the squashfs archive with FUSE overlayfs
-   *
-   * The target directory becomes an overlay mount with the backup as a
-   * read-only lower layer and a writable upper layer for copy-on-write.
-   * Any processes writing to the directory should be stopped first.
-   *
-   * **Mount Lifecycle**: The FUSE overlay mount persists only while the
-   * container is running. When the sandbox sleeps or the container restarts,
-   * the mount is lost and the directory becomes empty. Re-restore from the
-   * backup handle to recover. This is an ephemeral restore, not a persistent
-   * extraction.
-   *
-   * **Local-dev flow** (`localBucket: true` on the originating `createBackup` call):
-   *   1. DO reads metadata and checks TTL via R2 binding
-   *   2. DO downloads the archive from R2 and writes it to the container
-   *   3. Container extracts the archive with `unsquashfs` (no FUSE needed)
-   *
-   * The backup is restored into `backup.dir`. This may differ from the
-   * directory that was originally backed up, allowing cross-directory restore.
-   *
-   * Overlapping backups are independent: restoring a parent directory
-   * overwrites everything inside it, including subdirectories that were
-   * backed up separately. When restoring both, restore the parent first.
-   *
-   * Concurrent backup/restore calls on the same sandbox are serialized.
-   */
-  restoreBackup(backup: DirectoryBackup): Promise<RestoreBackupResult>;
-  private doRestoreBackup;
-  /**
-   * Local-dev implementation of restoreBackup.
-   * Uses the R2 binding directly instead of presigned URLs, and
-   * unsquashfs for extraction instead of squashfuse + fuse-overlayfs.
-   */
-  private doRestoreBackupLocal;
-  private configureR2EgressOutbound;
-  private configureS3CredentialProxyOutbound;
-}
-//#endregion
-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-44kEJjAc.d.ts.map