computesdk 3.0.0 → 4.0.0

package/dist/index.d.mts

@@ -1,44 +1,13 @@
 /**
  * Universal Sandbox Interface
  *
- * The canonical interface for all ComputeSDK sandboxes.
- *
- * Core methods (required):
- * - runCode, runCommand, getInfo, getUrl, destroy, filesystem
- *
- * Advanced features (optional):
- * - terminal, server, watcher, auth, env, etc.
- *
- * Providers can implement as much or as little as makes sense for their platform.
- * The gateway Sandbox class implements the full specification.
- *
- * **Note on naming:** This interface is named "Sandbox" in this file for clarity,
- * but is exported as "SandboxInterface" from the main computesdk package to avoid
- * collision with the gateway Sandbox class. The rename happens at export time in
- * src/index.ts. Providers using @computesdk/provider will only see "SandboxInterface".
- *
- * @example Minimal implementation
- * ```typescript
- * class MinimalSandbox implements Pick<Sandbox, 'sandboxId' | 'provider' | 'runCode' | 'runCommand' | 'getInfo' | 'getUrl' | 'destroy' | 'filesystem'> {
- *   // Just implement core methods
- * }
- * ```
- *
- * @example Full implementation
- * ```typescript
- * class FullSandbox implements Sandbox {
- *   // Implement everything - core + advanced features
- * }
- * ```
- */
-/**
- * Supported runtime environments
+ * The canonical interface for all ComputeSDK sandboxes. Providers using
+ * @computesdk/provider implement this shape (re-exported as SandboxInterface).
  */
-type Runtime = 'node' | 'python' | 'deno' | 'bun';
 /**
  * Code execution result
  */
-interface CodeResult$1 {
+interface CodeResult {
     output: string;
     exitCode: number;
     language: string;
@@ -46,7 +15,7 @@ interface CodeResult$1 {
 /**
  * Command execution result
  */
-interface CommandResult$1 {
+interface CommandResult {
     stdout: string;
     stderr: string;
     exitCode: number;
@@ -55,13 +24,11 @@ interface CommandResult$1 {
 /**
  * Sandbox information
  */
-interface SandboxInfo$1 {
+interface SandboxInfo {
     /** Unique identifier for the sandbox */
     id: string;
     /** Provider hosting the sandbox */
     provider: string;
-    /** Runtime environment in the sandbox */
-    runtime: Runtime;
     /** Current status of the sandbox */
     status: 'running' | 'stopped' | 'error';
     /** When the sandbox was created */
@@ -89,6 +56,19 @@ interface RunCommandOptions {
     timeout?: number;
     background?: boolean;
 }
+/**
+ * Snapshot information
+ */
+interface Snapshot {
+    /** Unique identifier for the snapshot */
+    id: string;
+    /** Provider hosting the snapshot */
+    provider: string;
+    /** When the snapshot was created */
+    createdAt: Date;
+    /** Additional provider-specific metadata */
+    metadata?: Record<string, any>;
+}
 /**
  * Filesystem operations interface
  */
@@ -106,7 +86,6 @@ interface SandboxFileSystem {
  * Providers can extend this with additional properties specific to their implementation
  */
 interface CreateSandboxOptions$1 {
-    runtime?: Runtime;
     timeout?: number;
     templateId?: string;
     metadata?: Record<string, any>;
@@ -114,49 +93,8 @@ interface CreateSandboxOptions$1 {
     name?: string;
     namespace?: string;
     directory?: string;
-    overlays?: SandboxOverlayConfig[];
-    servers?: SandboxServerConfig[];
     [key: string]: any;
 }
-interface SandboxOverlayConfig {
-    source: string;
-    target: string;
-    ignore?: string[];
-    strategy?: 'copy' | 'smart';
-}
-type SandboxRestartPolicy = 'never' | 'on-failure' | 'always';
-/**
- * Health check configuration for servers
- */
-interface SandboxHealthCheckConfig {
-    /** Path to poll for health checks (default: "/") */
-    path?: string;
-    /** Interval between health checks in milliseconds (default: 2000) */
-    interval_ms?: number;
-    /** Timeout for each health check request in milliseconds (default: 1500) */
-    timeout_ms?: number;
-    /** Delay before starting health checks after port detection in milliseconds (default: 5000) */
-    delay_ms?: number;
-}
-interface SandboxServerConfig {
-    slug: string;
-    start: string;
-    install?: string;
-    path?: string;
-    port?: number;
-    strict_port?: boolean;
-    autostart?: boolean;
-    env_file?: string;
-    environment?: Record<string, string>;
-    restart_policy?: SandboxRestartPolicy;
-    max_restarts?: number;
-    restart_delay_ms?: number;
-    stop_timeout_ms?: number;
-    depends_on?: string[];
-    overlay?: SandboxOverlayConfig;
-    overlays?: SandboxOverlayConfig[];
-    health_check?: SandboxHealthCheckConfig;
-}
 /**
  * Universal Sandbox Interface
  *
@@ -167,22 +105,20 @@ interface SandboxServerConfig {
  * as long as they are structurally compatible. For example, getInfo() might
  * return additional fields beyond the base SandboxInfo.
  */
-interface Sandbox$1 {
+interface Sandbox {
     /** Unique identifier for the sandbox */
     readonly sandboxId: string;
-    /** Provider name (e2b, railway, modal, gateway, etc.) */
+    /** Provider name (e2b, railway, modal, etc.) */
     readonly provider: string;
-    /** Execute code in the sandbox */
-    runCode(code: string, runtime?: Runtime): Promise<CodeResult$1>;
     /**
      * Execute shell command
      *
      * Send raw command string to the sandbox - no preprocessing.
      * The provider/server handles shell invocation and execution details.
      */
-    runCommand(command: string, options?: RunCommandOptions): Promise<CommandResult$1>;
+    runCommand(command: string, options?: RunCommandOptions): Promise<CommandResult>;
     /** Get information about the sandbox */
-    getInfo(): Promise<SandboxInfo$1>;
+    getInfo(): Promise<SandboxInfo>;
     /** Get URL for accessing the sandbox on a specific port */
     getUrl(options: {
         port: number;
@@ -192,4005 +128,110 @@ interface Sandbox$1 {
     destroy(): Promise<void>;
     /** File system operations */
     readonly filesystem: SandboxFileSystem;
-    /**
-     * Terminal management (interactive PTY and exec modes)
-     * Available in: gateway, e2b (potentially)
-     */
-    readonly terminal?: any;
-    /**
-     * Code and command execution namespace
-     * Available in: gateway
-     */
-    readonly run?: any;
-    /**
-     * Managed server operations
-     * Available in: gateway
-     */
-    readonly server?: any;
-    /**
-     * File watcher with real-time change events
-     * Available in: gateway
-     */
-    readonly watcher?: any;
-    /**
-     * Session token management
-     * Available in: gateway
-     */
-    readonly sessionToken?: any;
-    /**
-     * Magic link authentication
-     * Available in: gateway
-     */
-    readonly magicLink?: any;
-    /**
-     * Signal service for port/error events
-     * Available in: gateway
-     */
-    readonly signal?: any;
-    /**
-     * File operations namespace
-     * Available in: gateway
-     */
-    readonly file?: any;
-    /**
-     * Environment variable management
-     * Available in: gateway
-     */
-    readonly env?: any;
-    /**
-     * Authentication operations
-     * Available in: gateway
-     */
-    readonly auth?: any;
-    /**
-     * Child sandbox management
-     * Available in: gateway
-     */
-    readonly child?: any;
 }
 
 /**
- * Terminal created notification
- */
-interface TerminalCreatedMessage {
-    type: 'terminal:created';
-    channel: string;
-    data: {
-        id: string;
-        status: 'running' | 'stopped';
-    };
-}
-/**
- * Terminal output data
- * Note: output field may be base64 encoded depending on encoding field
+ * Compute API - Direct Provider Implementation
+ *
+ * `compute` delegates to one or more configured provider instances directly.
  */
-interface TerminalOutputMessage {
-    type: 'terminal:output';
-    channel: string;
-    data: {
-        output: string;
-        encoding?: 'raw' | 'base64';
-    };
+
+interface CreateSandboxOptions extends CreateSandboxOptions$1 {
+    /** Optional provider name override (must match provider.name) */
+    provider?: string;
 }
-/**
- * Terminal destroyed notification
- */
-interface TerminalDestroyedMessage {
-    type: 'terminal:destroyed';
-    channel: string;
-    data: {
+interface CreateSnapshotOptions {
+    name?: string;
+    metadata?: Record<string, any>;
+    /** Optional provider name override (must match provider.name) */
+    provider?: string;
+}
+interface ProviderSandboxManager {
+    create(options?: CreateSandboxOptions): Promise<Sandbox>;
+    getById(sandboxId: string): Promise<Sandbox | null>;
+    list?(): Promise<Sandbox[]>;
+    destroy(sandboxId: string): Promise<void>;
+}
+interface ProviderSnapshotManager {
+    create(sandboxId: string, options?: {
+        name?: string;
+        metadata?: Record<string, any>;
+    }): Promise<{
         id: string;
-    };
-}
-/**
- * Terminal error notification
- */
-interface TerminalErrorMessage {
-    type: 'terminal:error';
-    channel: string;
-    data: {
-        error: string;
-    };
-}
-/**
- * Command stdout streaming message (exec mode with stream: true)
- */
-interface CommandStdoutMessage {
-    type: 'command:stdout';
-    channel: string;
-    data: {
-        terminal_id: string;
-        cmd_id: string;
-        output: string;
-    };
-}
-/**
- * Command stderr streaming message (exec mode with stream: true)
- */
-interface CommandStderrMessage {
-    type: 'command:stderr';
-    channel: string;
-    data: {
-        terminal_id: string;
-        cmd_id: string;
-        output: string;
-    };
-}
-/**
- * Command exit message (exec mode with stream: true)
- */
-interface CommandExitMessage {
-    type: 'command:exit';
-    channel: string;
-    data: {
-        terminal_id: string;
-        cmd_id: string;
-        exit_code: number;
-    };
-}
-/**
- * File watcher created notification
- */
-interface WatcherCreatedMessage {
-    type: 'watcher:created';
-    channel: string;
-    data: {
+        provider: string;
+        createdAt: Date | string;
+        metadata?: Record<string, any>;
+    }>;
+    list(): Promise<Array<{
         id: string;
-        path: string;
-    };
-}
-/**
- * File change event
- * Note: content field may be base64 encoded depending on encoding field
- */
-interface FileChangedMessage {
-    type: 'file:changed';
-    channel: string;
-    data: {
-        event: 'add' | 'change' | 'unlink' | 'addDir' | 'unlinkDir';
-        path: string;
-        content?: string;
-        encoding?: 'raw' | 'base64';
-    };
+        provider: string;
+        createdAt: Date | string;
+        metadata?: Record<string, any>;
+    }>>;
+    delete(snapshotId: string): Promise<void>;
 }
-/**
- * File watcher destroyed notification
- */
-interface WatcherDestroyedMessage {
-    type: 'watcher:destroyed';
-    channel: string;
-    data: {
-        id: string;
-    };
+interface DirectProvider {
+    readonly name?: string;
+    readonly sandbox: ProviderSandboxManager;
+    readonly snapshot?: ProviderSnapshotManager;
 }
 /**
- * System signal event
+ * Explicit compute configuration for callable mode.
+ *
+ * Use `provider` for single-provider mode or `providers` for multi-provider mode.
  */
-interface SignalMessage {
-    type: 'signal';
-    channel: 'signals';
-    data: {
-        signal: 'port' | 'error' | 'server-ready';
-        port?: number;
-        url?: string;
-        message?: string;
-    };
+interface ExplicitComputeConfig {
+    /** Single-provider mode */
+    provider?: DirectProvider;
+    /** Multi-provider mode (recommended for resilient routing) */
+    providers?: DirectProvider[];
+    /** Provider selection strategy when no explicit provider is passed */
+    providerStrategy?: 'priority' | 'round-robin';
+    /** Retry the next provider when create fails */
+    fallbackOnError?: boolean;
 }
-/**
- * Sandbox created notification
- */
-interface SandboxCreatedMessage {
-    type: 'sandbox.created';
-    data: {
-        subdomain: string;
-        url: string;
+declare class ComputeManager {
+    private providers;
+    private providerStrategy;
+    private fallbackOnError;
+    private roundRobinCursor;
+    private sandboxProviders;
+    private snapshotProviders;
+    private getProviders;
+    private getProviderByName;
+    private registerSandboxProvider;
+    private getCreateCandidates;
+    private getByIdCandidates;
+    private getSnapshotDeleteCandidates;
+    private getSnapshotCreateCandidates;
+    private createWithFallback;
+    setConfig(config: ExplicitComputeConfig): void;
+    sandbox: {
+        create: (options?: CreateSandboxOptions) => Promise<Sandbox>;
+        getById: (sandboxId: string) => Promise<Sandbox | null>;
+        list: () => Promise<Sandbox[]>;
+        destroy: (sandboxId: string) => Promise<void>;
     };
-}
-/**
- * Sandbox deleted notification
- */
-interface SandboxDeletedMessage {
-    type: 'sandbox.deleted';
-    data: {
-        subdomain: string;
+    snapshot: {
+        create: (sandboxId: string, options?: CreateSnapshotOptions) => Promise<{
+            id: string;
+            provider: string;
+            createdAt: Date;
+            metadata?: Record<string, any>;
+        }>;
+        list: () => Promise<Array<{
+            id: string;
+            provider: string;
+            createdAt: Date;
+            metadata?: Record<string, any>;
+        }>>;
+        delete: (snapshotId: string) => Promise<void>;
     };
 }
-type WebSocketConstructor$1 = new (url: string) => WebSocket;
-interface WebSocketManagerConfig {
-    /** WebSocket URL (will be generated from client config if not provided) */
-    url: string;
-    /** WebSocket implementation */
-    WebSocket: WebSocketConstructor$1;
-    /** Enable automatic reconnection on disconnect (default: true) */
-    autoReconnect?: boolean;
-    /** Reconnection delay in milliseconds (default: 1000) */
-    reconnectDelay?: number;
-    /** Maximum reconnection attempts (default: 5, 0 = infinite) */
-    maxReconnectAttempts?: number;
-    /** Enable debug logging (default: false) */
-    debug?: boolean;
-    /** WebSocket protocol: 'binary' (default, recommended) or 'json' (for debugging) */
-    protocol?: 'json' | 'binary';
-}
-type MessageHandler<T = any> = (message: T) => void;
-type ErrorHandler = (error: Event) => void;
-type ConnectionHandler = () => void;
-/**
- * WebSocket Manager for handling real-time communication
- *
- * @example
- * ```typescript
- * import { ComputeClient } from '@computesdk/client'
- *
- * const client = new ComputeClient({ sandboxUrl: 'https://sandbox-123.sandbox.computesdk.com' });
- * await client.generateToken();
- *
- * // Create WebSocket manager
- * const ws = client.createWebSocketManager();
- *
- * // Listen for connection
- * ws.on('open', () => {
- *   console.log('Connected!');
- * });
- *
- * // Subscribe to terminal output
- * ws.subscribe('terminal:term_abc123');
- * ws.on('terminal:output', (msg) => {
- *   console.log('Terminal output:', msg.data.output);
- * });
- *
- * // Send terminal input
- * ws.sendTerminalInput('term_abc123', 'ls -la\n');
- *
- * // Subscribe to file changes
- * ws.subscribe('watcher:watcher_xyz789');
- * ws.on('file:changed', (msg) => {
- *   console.log('File changed:', msg.data.path, msg.data.event);
- * });
- *
- * // Subscribe to signals
- * ws.subscribe('signals');
- * ws.on('signal', (msg) => {
- *   console.log('Signal:', msg.data);
- * });
- * ```
- */
-declare class WebSocketManager {
-    private config;
-    private ws;
-    private eventHandlers;
-    private reconnectAttempts;
-    private reconnectTimer;
-    private subscribedChannels;
-    private isManualClose;
-    constructor(config: WebSocketManagerConfig);
-    /**
-     * Connect to WebSocket server
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from WebSocket server
-     */
-    disconnect(): void;
-    /**
-     * Check if WebSocket is connected
-     */
-    isConnected(): boolean;
-    /**
-     * Attempt to reconnect to WebSocket server
-     */
-    private attemptReconnect;
-    /**
-     * Subscribe to a channel
-     * @param channel - Channel name (e.g., 'terminal:term_abc123', 'watcher:watcher_xyz789', 'signals')
-     */
-    subscribe(channel: string): void;
-    /**
-     * Unsubscribe from a channel
-     */
-    unsubscribe(channel: string): void;
-    /**
-     * Get list of subscribed channels
-     */
-    getSubscribedChannels(): string[];
-    /**
-     * Send raw message to server
-     */
-    private sendRaw;
-    /**
-     * Send input to a terminal (sent as-is, not encoded)
-     */
-    sendTerminalInput(terminalId: string, input: string): void;
-    /**
-     * Resize terminal window
-     */
-    resizeTerminal(terminalId: string, cols: number, rows: number): void;
-    /**
-     * Start a pending streaming command
-     * Used in two-phase streaming flow: HTTP request creates pending command,
-     * then this signal triggers execution after client has subscribed.
-     */
-    startCommand(cmdId: string): void;
-    /**
-     * Register event handler
-     */
-    on(event: 'open', handler: ConnectionHandler): void;
-    on(event: 'close', handler: ConnectionHandler): void;
-    on(event: 'error', handler: ErrorHandler): void;
-    on(event: 'reconnect-failed', handler: ConnectionHandler): void;
-    on(event: 'terminal:created', handler: MessageHandler<TerminalCreatedMessage>): void;
-    on(event: 'terminal:output', handler: MessageHandler<TerminalOutputMessage>): void;
-    on(event: 'terminal:destroyed', handler: MessageHandler<TerminalDestroyedMessage>): void;
-    on(event: 'terminal:error', handler: MessageHandler<TerminalErrorMessage>): void;
-    on(event: 'command:stdout', handler: MessageHandler<CommandStdoutMessage>): void;
-    on(event: 'command:stderr', handler: MessageHandler<CommandStderrMessage>): void;
-    on(event: 'command:exit', handler: MessageHandler<CommandExitMessage>): void;
-    on(event: 'watcher:created', handler: MessageHandler<WatcherCreatedMessage>): void;
-    on(event: 'file:changed', handler: MessageHandler<FileChangedMessage>): void;
-    on(event: 'watcher:destroyed', handler: MessageHandler<WatcherDestroyedMessage>): void;
-    on(event: 'signal', handler: MessageHandler<SignalMessage>): void;
-    on(event: 'sandbox.created', handler: MessageHandler<SandboxCreatedMessage>): void;
-    on(event: 'sandbox.deleted', handler: MessageHandler<SandboxDeletedMessage>): void;
-    /**
-     * Unregister event handler
-     */
-    off(event: string, handler: MessageHandler): void;
-    /**
-     * Unregister all event handlers for an event
-     */
-    offAll(event: string): void;
-    /**
-     * Emit event to registered handlers
-     */
-    private emit;
-    /**
-     * Handle incoming message
-     */
-    private handleMessage;
-    /**
-     * Log debug message if debug mode is enabled
-     */
-    private log;
-    /**
-     * Get current connection state
-     */
-    getState(): 'connecting' | 'open' | 'closing' | 'closed';
-    /**
-     * Get reconnection attempt count
-     */
-    getReconnectAttempts(): number;
-}
-
-/**
- * Command - Represents a command execution in a terminal
- */
-
-/**
- * Command execution result with wait capability
- */
-declare class Command {
-    readonly id: string;
-    readonly terminalId: string;
-    readonly command: string;
-    private _status;
-    private _stdout;
-    private _stderr;
-    private _exitCode?;
-    private _durationMs?;
-    private _startedAt;
-    private _finishedAt?;
-    private waitHandler?;
-    private retrieveHandler?;
-    constructor(data: {
-        cmdId: string;
-        terminalId: string;
-        command: string;
-        status: 'running' | 'completed' | 'failed';
-        stdout: string;
-        stderr: string;
-        exitCode?: number;
-        durationMs?: number;
-        startedAt: string;
-        finishedAt?: string;
-    });
-    get status(): 'running' | 'completed' | 'failed';
-    get stdout(): string;
-    get stderr(): string;
-    get exitCode(): number | undefined;
-    get durationMs(): number | undefined;
-    get startedAt(): string;
-    get finishedAt(): string | undefined;
-    /**
-     * Set the wait handler (called by TerminalCommands)
-     * @internal
-     */
-    setWaitHandler(handler: (timeout?: number) => Promise<CommandDetailsResponse>): void;
-    /**
-     * Set the retrieve handler (called by TerminalCommands)
-     * @internal
-     */
-    setRetrieveHandler(handler: () => Promise<CommandDetailsResponse>): void;
-    /**
-     * Wait for the command to complete
-     * @param timeout - Optional timeout in seconds (0 = no timeout)
-     * @returns This command with updated status
-     */
-    wait(timeout?: number): Promise<this>;
-    /**
-     * Refresh the command status from the server
-     * @returns This command with updated status
-     */
-    refresh(): Promise<this>;
-    /**
-     * Update internal state from API response
-     */
-    private updateFromResponse;
-}
-
-/**
- * TerminalCommand - Resource namespace for terminal commands
- */
-
-/**
- * Command resource namespace for a terminal
- *
- * @example
- * ```typescript
- * const terminal = await sandbox.terminal.create({ pty: false });
- *
- * // Run a command
- * const cmd = await terminal.command.run('npm test');
- * console.log(cmd.stdout);
- *
- * // Run in background and wait
- * const cmd = await terminal.command.run('npm install', { background: true });
- * await cmd.wait();
- * console.log(cmd.exitCode);
- *
- * // List commands
- * const commands = await terminal.command.list();
- *
- * // Retrieve a specific command
- * const cmd = await terminal.command.retrieve(cmdId);
- * ```
- */
-declare class TerminalCommand {
-    private terminalId;
-    private runHandler;
-    private listHandler;
-    private retrieveHandler;
-    private waitHandler;
-    constructor(terminalId: string, handlers: {
-        run: (command: string, background?: boolean) => Promise<CommandExecutionResponse>;
-        list: () => Promise<CommandsListResponse>;
-        retrieve: (cmdId: string) => Promise<CommandDetailsResponse>;
-        wait: (cmdId: string, timeout?: number) => Promise<CommandDetailsResponse>;
-    });
-    /**
-     * Run a command in the terminal
-     * @param command - The command to execute
-     * @param options - Execution options
-     * @param options.background - If true, returns immediately without waiting for completion
-     * @returns Command object with results or status
-     */
-    run(command: string, options?: {
-        background?: boolean;
-    }): Promise<Command>;
-    /**
-     * List all commands executed in this terminal
-     * @returns Array of Command objects
-     */
-    list(): Promise<Command[]>;
-    /**
-     * Retrieve a specific command by ID
-     * @param cmdId - The command ID
-     * @returns Command object with full details
-     */
-    retrieve(cmdId: string): Promise<Command>;
+interface CallableCompute extends ComputeManager {
+    (config: ExplicitComputeConfig): ComputeManager;
+    setConfig(config: ExplicitComputeConfig): void;
 }
-
-/**
- * Terminal class for managing terminal sessions with WebSocket integration
- */
-
-/**
- * Terminal event handlers
- */
-type TerminalEventHandler = {
-    output: (data: string) => void;
-    error: (error: string) => void;
-    destroyed: () => void;
-};
-/**
- * TerminalInstance - A connected terminal session with WebSocket support
- *
- * This is the object returned by sandbox.terminal.create()
- *
- * @example
- * ```typescript
- * // PTY mode - Interactive shell
- * const pty = await sandbox.terminal.create({ pty: true });
- * pty.on('output', (data) => console.log(data));
- * pty.write('ls -la\n');
- * await pty.destroy();
- *
- * // Exec mode - Command tracking
- * const exec = await sandbox.terminal.create({ pty: false });
- * const cmd = await exec.command.run('npm test');
- * console.log(cmd.exitCode);
- *
- * // Background execution with wait
- * const cmd = await exec.command.run('npm install', { background: true });
- * await cmd.wait();
- * console.log(cmd.stdout);
- * ```
- */
-declare class TerminalInstance {
-    private _id;
-    private _pty;
-    private _status;
-    private _channel;
-    private _ws;
-    private _encoding;
-    private _eventHandlers;
-    /**
-     * Command namespace for exec mode terminals
-     */
-    readonly command: TerminalCommand;
-    private _executeHandler?;
-    private _listCommandsHandler?;
-    private _retrieveCommandHandler?;
-    private _waitCommandHandler?;
-    private _destroyHandler?;
-    constructor(id: string, pty: boolean, status: 'running' | 'stopped' | 'active' | 'ready', channel: string | null, ws: WebSocketManager | null, encoding?: 'raw' | 'base64');
-    /**
-     * Set up WebSocket event handlers (PTY mode only)
-     */
-    private setupWebSocketHandlers;
-    /**
-     * Terminal ID
-     */
-    get id(): string;
-    /**
-     * Get terminal ID (deprecated, use .id property)
-     * @deprecated Use .id property instead
-     */
-    getId(): string;
-    /**
-     * Terminal status
-     */
-    get status(): 'running' | 'stopped' | 'active' | 'ready';
-    /**
-     * Get terminal status (deprecated, use .status property)
-     * @deprecated Use .status property instead
-     */
-    getStatus(): 'running' | 'stopped' | 'active' | 'ready';
-    /**
-     * Terminal channel (null for exec mode)
-     */
-    get channel(): string | null;
-    /**
-     * Get terminal channel (deprecated, use .channel property)
-     * @deprecated Use .channel property instead
-     */
-    getChannel(): string | null;
-    /**
-     * Whether this is a PTY terminal
-     */
-    get pty(): boolean;
-    /**
-     * Get terminal PTY mode (deprecated, use .pty property)
-     * @deprecated Use .pty property instead
-     */
-    isPTY(): boolean;
-    /**
-     * Check if terminal is running
-     */
-    isRunning(): boolean;
-    /**
-     * Write input to the terminal (PTY mode only)
-     */
-    write(input: string): void;
-    /**
-     * Resize terminal window (PTY mode only)
-     */
-    resize(cols: number, rows: number): void;
-    /**
-     * Set execute command handler (called by Sandbox)
-     * @internal
-     */
-    setExecuteHandler(handler: (command: string, background?: boolean) => Promise<CommandExecutionResponse>): void;
-    /**
-     * Set list commands handler (called by Sandbox)
-     * @internal
-     */
-    setListCommandsHandler(handler: () => Promise<CommandsListResponse>): void;
-    /**
-     * Set retrieve command handler (called by Sandbox)
-     * @internal
-     */
-    setRetrieveCommandHandler(handler: (cmdId: string) => Promise<CommandDetailsResponse>): void;
-    /**
-     * Set wait command handler (called by Sandbox)
-     * @internal
-     */
-    setWaitCommandHandler(handler: (cmdId: string, timeout?: number) => Promise<CommandDetailsResponse>): void;
-    /**
-     * Set destroy handler (called by Sandbox)
-     * @internal
-     */
-    setDestroyHandler(handler: () => Promise<void>): void;
-    /**
-     * Execute a command in the terminal (deprecated, use command.run())
-     * @deprecated Use terminal.command.run() instead
-     */
-    execute(command: string, options?: {
-        background?: boolean;
-    }): Promise<CommandExecutionResponse>;
-    /**
-     * Destroy the terminal
-     */
-    destroy(): Promise<void>;
-    /**
-     * Clean up resources
-     */
-    private cleanup;
-    /**
-     * Register event handler
-     */
-    on<K extends keyof TerminalEventHandler>(event: K, handler: TerminalEventHandler[K]): void;
-    /**
-     * Unregister event handler
-     */
-    off<K extends keyof TerminalEventHandler>(event: K, handler: TerminalEventHandler[K]): void;
-    /**
-     * Emit event to registered handlers
-     */
-    private emit;
-}
-
-/**
- * FileWatcher class for monitoring file system changes with WebSocket integration
- */
-
-/**
- * File change event data
- */
-interface FileChangeEvent {
-    event: 'add' | 'change' | 'unlink' | 'addDir' | 'unlinkDir';
-    path: string;
-    content?: string;
-}
-/**
- * FileWatcher event handlers
- */
-type FileWatcherEventHandler = {
-    change: (event: FileChangeEvent) => void;
-    destroyed: () => void;
-};
-/**
- * FileWatcher class for monitoring file system changes
- *
- * @example
- * ```typescript
- * const client = new ComputeClient({ sandboxUrl: '...' });
- * await client.generateToken();
- *
- * const watcher = await client.createWatcher('/home/project', {
- *   ignored: ['node_modules', '.git']
- * });
- *
- * watcher.on('change', (event) => {
- *   console.log(`File ${event.event}: ${event.path}`);
- * });
- *
- * await watcher.destroy();
- * ```
- */
-declare class FileWatcher {
-    private id;
-    private path;
-    private status;
-    private channel;
-    private includeContent;
-    private ignored;
-    private encoding;
-    private ws;
-    private eventHandlers;
-    constructor(id: string, path: string, status: 'active' | 'stopped', channel: string, includeContent: boolean, ignored: string[], ws: WebSocketManager, encoding?: 'raw' | 'base64');
-    /**
-     * Set up WebSocket event handlers
-     */
-    private setupWebSocketHandlers;
-    /**
-     * Get watcher ID
-     */
-    getId(): string;
-    /**
-     * Get watched path
-     */
-    getPath(): string;
-    /**
-     * Get watcher status
-     */
-    getStatus(): 'active' | 'stopped';
-    /**
-     * Get watcher channel
-     */
-    getChannel(): string;
-    /**
-     * Check if content is included in events
-     */
-    isIncludingContent(): boolean;
-    /**
-     * Get ignored patterns
-     */
-    getIgnoredPatterns(): string[];
-    /**
-     * Check if watcher is active
-     */
-    isActive(): boolean;
-    /**
-     * Destroy the watcher (uses REST API, not WebSocket)
-     */
-    private destroyWatcher?;
-    /**
-     * Set destroy handler (called by client)
-     */
-    setDestroyHandler(handler: () => Promise<void>): void;
-    /**
-     * Destroy the watcher
-     */
-    destroy(): Promise<void>;
-    /**
-     * Clean up resources
-     */
-    private cleanup;
-    /**
-     * Register event handler
-     */
-    on<K extends keyof FileWatcherEventHandler>(event: K, handler: FileWatcherEventHandler[K]): void;
-    /**
-     * Unregister event handler
-     */
-    off<K extends keyof FileWatcherEventHandler>(event: K, handler: FileWatcherEventHandler[K]): void;
-    /**
-     * Emit event to registered handlers
-     */
-    private emit;
-}
-
-/**
- * SignalService class for monitoring system signals with WebSocket integration
- */
-
-/**
- * Port signal data
- */
-interface PortSignalEvent {
-    signal: 'port' | 'server-ready';
-    port: number;
-    url: string;
-    type?: 'open' | 'close';
-}
-/**
- * Error signal data
- */
-interface ErrorSignalEvent {
-    signal: 'error';
-    message: string;
-}
-/**
- * Generic signal event (union type)
- */
-type SignalEvent = PortSignalEvent | ErrorSignalEvent;
-/**
- * SignalService event handlers
- */
-type SignalServiceEventHandler = {
-    port: (event: PortSignalEvent) => void;
-    error: (event: ErrorSignalEvent) => void;
-    signal: (event: SignalEvent) => void;
-};
-/**
- * SignalService class for monitoring system signals and events
- *
- * @example
- * ```typescript
- * const client = new ComputeClient({ sandboxUrl: '...' });
- * await client.generateToken();
- *
- * const signals = await client.startSignals();
- *
- * signals.on('port', (event) => {
- *   console.log(`Port ${event.port} ${event.type}: ${event.url}`);
- * });
- *
- * signals.on('error', (event) => {
- *   console.error(`Error: ${event.message}`);
- * });
- *
- * await signals.stop();
- * ```
- */
-declare class SignalService {
-    private status;
-    private channel;
-    private ws;
-    private eventHandlers;
-    constructor(status: 'active' | 'stopped', channel: string, ws: WebSocketManager);
-    /**
-     * Set up WebSocket event handlers
-     */
-    private setupWebSocketHandlers;
-    /**
-     * Get service status
-     */
-    getStatus(): 'active' | 'stopped';
-    /**
-     * Get service channel
-     */
-    getChannel(): string;
-    /**
-     * Check if service is active
-     */
-    isActive(): boolean;
-    /**
-     * Stop the signal service (uses REST API, not WebSocket)
-     */
-    private stopService?;
-    /**
-     * Set stop handler (called by client)
-     */
-    setStopHandler(handler: () => Promise<void>): void;
-    /**
-     * Stop the signal service
-     */
-    stop(): Promise<void>;
-    /**
-     * Clean up resources
-     */
-    private cleanup;
-    /**
-     * Register event handler
-     */
-    on<K extends keyof SignalServiceEventHandler>(event: K, handler: SignalServiceEventHandler[K]): void;
-    /**
-     * Unregister event handler
-     */
-    off<K extends keyof SignalServiceEventHandler>(event: K, handler: SignalServiceEventHandler[K]): void;
-    /**
-     * Emit event to registered handlers
-     */
-    private emit;
-}
-
-/**
- * Terminal - Resource namespace for terminal management
- */
-
-/**
- * Terminal resource namespace
- *
- * @example
- * ```typescript
- * // Create a PTY terminal (interactive shell)
- * const pty = await sandbox.terminal.create({ pty: true, shell: '/bin/bash' });
- * pty.on('output', (data) => console.log(data));
- * pty.write('ls -la\n');
- *
- * // Create an exec terminal (command tracking)
- * const exec = await sandbox.terminal.create({ pty: false });
- * const cmd = await exec.command.run('npm test');
- * console.log(cmd.exitCode);
- *
- * // List all terminals
- * const terminals = await sandbox.terminal.list();
- *
- * // Retrieve a specific terminal
- * const terminal = await sandbox.terminal.retrieve(id);
- *
- * // Destroy a terminal
- * await sandbox.terminal.destroy(id);
- * ```
- */
-declare class Terminal {
-    private createHandler;
-    private listHandler;
-    private retrieveHandler;
-    private destroyHandler;
-    constructor(handlers: {
-        create: (options?: {
-            shell?: string;
-            encoding?: 'raw' | 'base64';
-            pty?: boolean;
-        }) => Promise<TerminalInstance>;
-        list: () => Promise<TerminalResponse[]>;
-        retrieve: (id: string) => Promise<TerminalInstance>;
-        destroy: (id: string) => Promise<void>;
-    });
-    /**
-     * Create a new terminal session
-     *
-     * @param options - Terminal creation options
-     * @param options.shell - Shell to use (e.g., '/bin/bash') - PTY mode only
-     * @param options.encoding - Encoding: 'raw' (default) or 'base64' (binary-safe)
-     * @param options.pty - Terminal mode: true = PTY (interactive), false = exec (command tracking)
-     * @returns TerminalInstance
-     */
-    create(options?: {
-        shell?: string;
-        encoding?: 'raw' | 'base64';
-        pty?: boolean;
-    }): Promise<TerminalInstance>;
-    /**
-     * List all active terminals
-     * @returns Array of terminal responses
-     */
-    list(): Promise<TerminalResponse[]>;
-    /**
-     * Retrieve a specific terminal by ID
-     * @param id - The terminal ID
-     * @returns Terminal instance
-     */
-    retrieve(id: string): Promise<TerminalInstance>;
-    /**
-     * Destroy a terminal by ID
-     * @param id - The terminal ID
-     */
-    destroy(id: string): Promise<void>;
-}
-
-/**
- * Overlay - Resource namespace for filesystem overlay operations
- *
- * Overlays enable instant sandbox setup from template directories by copying
- * files directly for isolation, with heavy directories copied in the background.
- */
-/**
- * Options for waiting for overlay copy completion
- */
-interface WaitForCompletionOptions {
-    /** Maximum number of retry attempts (default: 60) */
-    maxRetries?: number;
-    /** Initial delay between retries in milliseconds (default: 500) */
-    initialDelayMs?: number;
-    /** Maximum delay between retries in milliseconds (default: 5000) */
-    maxDelayMs?: number;
-    /** Backoff multiplier for exponential backoff (default: 1.5) */
-    backoffFactor?: number;
-}
-/**
- * Strategy for creating an overlay
- * - 'copy': Full copy of all files (standard behavior)
- * - 'smart': Use symlinks for immutable packages (e.g. node_modules) for instant creation
- */
-type OverlayStrategy = 'copy' | 'smart';
-/**
- * Options for creating an overlay
- */
-interface CreateOverlayOptions {
-    /** Absolute path to source directory (template) */
-    source: string;
-    /** Relative path in sandbox where overlay will be mounted */
-    target: string;
-    /** Glob patterns to ignore (e.g., ["node_modules", "*.log"]) */
-    ignore?: string[];
-    /** Strategy to use (default: 'smart') */
-    strategy?: OverlayStrategy;
-    /** If true, wait for background copy to complete before returning (default: false) */
-    waitForCompletion?: boolean | WaitForCompletionOptions;
-}
-/**
- * Copy status for overlay background operations
- */
-type OverlayCopyStatus = 'pending' | 'in_progress' | 'complete' | 'failed';
-/**
- * Statistics about an overlay
- */
-interface OverlayStats {
-    /** Number of copied files */
-    copiedFiles: number;
-    /** Number of copied directories (heavy dirs copied in background) */
-    copiedDirs: number;
-    /** Paths that were skipped (e.g., .git, ignored patterns) */
-    skipped: string[];
-}
-/**
- * Overlay information (client-side normalized type)
- */
-interface OverlayInfo {
-    /** Unique overlay identifier */
-    id: string;
-    /** Absolute path to source directory */
-    source: string;
-    /** Relative path in sandbox */
-    target: string;
-    /** Strategy used for the overlay */
-    strategy: OverlayStrategy;
-    /** When the overlay was created */
-    createdAt: string;
-    /** Statistics about the overlay */
-    stats: OverlayStats;
-    /** Copy status for background operations */
-    copyStatus: OverlayCopyStatus;
-    /** Error message if copy failed */
-    copyError?: string;
-}
-/**
- * API response for overlay operations (snake_case from server)
- */
-interface OverlayResponse {
-    id: string;
-    source: string;
-    target: string;
-    strategy?: string;
-    created_at: string;
-    stats: {
-        copied_files: number;
-        copied_dirs: number;
-        skipped: string[];
-    };
-    copy_status: string;
-    copy_error?: string;
-}
-/**
- * API response for listing overlays
- */
-interface OverlayListResponse {
-    overlays: OverlayResponse[];
-}
-/**
- * Overlay resource namespace
- *
- * @example
- * ```typescript
- * // Create an overlay from a template directory
- * const overlay = await sandbox.filesystem.overlay.create({
- *   source: '/templates/nextjs',
- *   target: 'project',
- * });
- * console.log(overlay.copyStatus); // 'pending' | 'in_progress' | 'complete' | 'failed'
- *
- * // Create an overlay and wait for background copy to complete
- * const overlay = await sandbox.filesystem.overlay.create({
- *   source: '/templates/nextjs',
- *   target: 'project',
- *   waitForCompletion: true, // blocks until copy is complete
- * });
- *
- * // Wait for an existing overlay's copy to complete
- * const overlay = await sandbox.filesystem.overlay.waitForCompletion('overlay-id');
- *
- * // List all overlays
- * const overlays = await sandbox.filesystem.overlay.list();
- *
- * // Get a specific overlay (useful for polling copy status)
- * const overlay = await sandbox.filesystem.overlay.retrieve('overlay-id');
- * if (overlay.copyStatus === 'complete') {
- *   console.log('Background copy finished!');
- * }
- *
- * // Delete an overlay
- * await sandbox.filesystem.overlay.destroy('overlay-id');
- * ```
- */
-declare class Overlay {
-    private createHandler;
-    private listHandler;
-    private retrieveHandler;
-    private destroyHandler;
-    constructor(handlers: {
-        create: (options: CreateOverlayOptions) => Promise<OverlayResponse>;
-        list: () => Promise<OverlayListResponse>;
-        retrieve: (id: string) => Promise<OverlayResponse>;
-        destroy: (id: string) => Promise<void>;
-    });
-    /**
-     * Create a new overlay from a template directory
-     *
-     * The overlay copies files from the source directory into the target path
-     * for better isolation. Heavy directories (node_modules, .venv, etc.) are
-     * copied in the background. Use the `ignore` option to exclude files/directories.
-     *
-     * @param options - Overlay creation options
-     * @param options.source - Absolute path to source directory
-     * @param options.target - Relative path in sandbox
-     * @param options.ignore - Glob patterns to ignore (e.g., ["node_modules", "*.log"])
-     * @param options.strategy - Strategy to use ('copy' or 'smart')
-     * @param options.waitForCompletion - If true or options object, wait for background copy to complete
-     * @returns Overlay info with copy status
-     */
-    create(options: CreateOverlayOptions): Promise<OverlayInfo>;
-    /**
-     * List all overlays for the current sandbox
-     * @returns Array of overlay info
-     */
-    list(): Promise<OverlayInfo[]>;
-    /**
-     * Retrieve a specific overlay by ID
-     *
-     * Useful for polling the copy status of an overlay.
-     *
-     * @param id - Overlay ID
-     * @returns Overlay info
-     */
-    retrieve(id: string): Promise<OverlayInfo>;
-    /**
-     * Destroy (delete) an overlay
-     * @param id - Overlay ID
-     */
-    destroy(id: string): Promise<void>;
-    /**
-     * Wait for an overlay's background copy to complete
-     *
-     * Polls the overlay status with exponential backoff until the copy
-     * is complete or fails. Throws an error if the copy fails or times out.
-     *
-     * @param id - Overlay ID
-     * @param options - Polling options
-     * @returns Overlay info with final copy status
-     * @throws Error if copy fails or times out
-     */
-    waitForCompletion(id: string, options?: WaitForCompletionOptions): Promise<OverlayInfo>;
-    /**
-     * Convert API response to OverlayInfo
-     */
-    private toOverlayInfo;
-    /**
-     * Validate and return strategy, defaulting to 'copy' for unknown/missing values (legacy support)
-     */
-    private validateStrategy;
-    /**
-     * Validate and return copy status, defaulting to 'pending' for unknown values
-     */
-    private validateCopyStatus;
-}
-
-/**
- * Server - Resource namespace for managed server operations
- */
-
-/**
- * Options for starting a managed server
- */
-interface ServerStartOptions {
-    /** Unique server identifier (URL-safe) */
-    slug: string;
-    /** Install command to run before starting (optional, runs blocking, e.g., "npm install") */
-    install?: string;
-    /** Command to start the server (e.g., "npm run dev") */
-    start: string;
-    /** Working directory (optional) */
-    path?: string;
-    /** Path to .env file relative to path (optional) */
-    env_file?: string;
-    /** Inline environment variables (merged with env_file if both provided) */
-    environment?: Record<string, string>;
-    /** Requested port number (preallocated before start) */
-    port?: number;
-    /** If true, fail instead of auto-incrementing when port is taken */
-    strict_port?: boolean;
-    /** Whether to auto-start the server on daemon boot (default: true) */
-    autostart?: boolean;
-    /** Inline overlay to create before starting the server */
-    overlay?: Omit<CreateOverlayOptions, 'waitForCompletion'>;
-    /** Additional overlays to create before starting the server */
-    overlays?: Array<Omit<CreateOverlayOptions, 'waitForCompletion'>>;
-    /** Overlay IDs this server depends on (waits for copy completion) */
-    depends_on?: string[];
-    /**
-     * When to automatically restart the server:
-     * - `never`: No automatic restart (default)
-     * - `on-failure`: Restart only on non-zero exit code
-     * - `always`: Always restart on exit (including exit code 0)
-     */
-    restart_policy?: RestartPolicy;
-    /** Maximum restart attempts (0 = unlimited, default: 0) */
-    max_restarts?: number;
-    /** Delay between restart attempts in milliseconds (default: 1000) */
-    restart_delay_ms?: number;
-    /** Graceful shutdown timeout in milliseconds - SIGTERM → wait → SIGKILL (default: 10000) */
-    stop_timeout_ms?: number;
-    /**
-     * Health check configuration for monitoring server availability
-     * When configured, the server will be polled to verify it's responding to requests
-     */
-    health_check?: HealthCheckConfig;
-}
-/**
- * Server resource namespace
- *
- * @example
- * ```typescript
- * // Start a basic server
- * const server = await sandbox.server.start({
- *   slug: 'api',
- *   start: 'npm start',
- *   path: '/app',
- * });
- *
- * // Start with install command (runs before start)
- * const server = await sandbox.server.start({
- *   slug: 'web',
- *   install: 'npm install',
- *   start: 'npm run dev',
- *   path: '/app',
- * });
- *
- * // Start with supervisor settings (auto-restart on failure)
- * const server = await sandbox.server.start({
- *   slug: 'web',
- *   start: 'node server.js',
- *   path: '/app',
- *   environment: { NODE_ENV: 'production', PORT: '3000' },
- *   restart_policy: 'on-failure',
- *   max_restarts: 5,
- *   restart_delay_ms: 2000,
- * });
- *
- * // Start with inline overlay dependencies
- * const server = await sandbox.server.start({
- *   slug: 'web',
- *   start: 'npm run dev',
- *   path: '/app',
- *   overlay: {
- *     source: '/templates/nextjs',
- *     target: 'app',
- *     strategy: 'smart',
- *   },
- * });
- *
- * // List all servers
- * const servers = await sandbox.server.list();
- *
- * // Retrieve a specific server
- * const server = await sandbox.server.retrieve('api');
- *
- * // Stop a server (graceful shutdown with SIGTERM → SIGKILL)
- * await sandbox.server.stop('api');
- *
- * // Delete a server config
- * await sandbox.server.delete('api');
- *
- * // Restart a server
- * await sandbox.server.restart('api');
- * ```
- */
-/**
- * Options for retrieving server logs
- */
-interface ServerLogsOptions {
-    /** Which output stream to return: 'stdout', 'stderr', or 'combined' (default) */
-    stream?: ServerLogStream;
-}
-/**
- * Server logs info returned from the logs method
- */
-interface ServerLogsInfo {
-    /** Server slug identifier */
-    slug: string;
-    /** Which stream was returned */
-    stream: ServerLogStream;
-    /** The captured logs */
-    logs: string;
-}
-declare class Server {
-    private startHandler;
-    private listHandler;
-    private retrieveHandler;
-    private stopHandler;
-    private deleteHandler;
-    private restartHandler;
-    private updateStatusHandler;
-    private logsHandler;
-    constructor(handlers: {
-        start: (options: ServerStartOptions) => Promise<ServerResponse>;
-        list: () => Promise<ServersListResponse>;
-        retrieve: (slug: string) => Promise<ServerResponse>;
-        stop: (slug: string) => Promise<ServerStopResponse | void>;
-        delete: (slug: string) => Promise<void>;
-        restart: (slug: string) => Promise<ServerResponse>;
-        updateStatus: (slug: string, status: ServerStatus) => Promise<void>;
-        logs: (slug: string, options?: ServerLogsOptions) => Promise<ServerLogsResponse>;
-    });
-    /**
-     * Start a new managed server with optional supervisor settings
-     *
-     * **Install Phase:**
-     * If `install` is provided, it runs blocking before `start` (e.g., "npm install").
-     * The server status will be `installing` during this phase.
-     *
-     * **Restart Policies:**
-     * - `never` (default): No automatic restart on exit
-     * - `on-failure`: Restart only on non-zero exit code
-     * - `always`: Always restart on exit (including exit code 0)
-     *
-     * **Graceful Shutdown:**
-     * When stopping a server, it first sends SIGTERM and waits for `stop_timeout_ms`
-     * before sending SIGKILL if the process hasn't exited.
-     *
-     * @param options - Server configuration
-     * @returns Server info
-     *
-     * @example
-     * ```typescript
-     * // Basic server
-     * const server = await sandbox.server.start({
-     *   slug: 'web',
-     *   start: 'npm run dev',
-     *   path: '/app',
-     * });
-     *
-     * // With install command
-     * const server = await sandbox.server.start({
-     *   slug: 'api',
-     *   install: 'npm install',
-     *   start: 'node server.js',
-     *   environment: { NODE_ENV: 'production' },
-     *   restart_policy: 'always',
-     *   max_restarts: 0, // unlimited
-     * });
-     * ```
-     */
-    start(options: ServerStartOptions): Promise<ServerInfo>;
-    /**
-     * List all managed servers
-     * @returns Array of server info
-     */
-    list(): Promise<ServerInfo[]>;
-    /**
-     * Retrieve a specific server by slug
-     * @param slug - The server slug
-     * @returns Server info
-     */
-    retrieve(slug: string): Promise<ServerInfo>;
-    /**
-     * Stop a server by slug (non-destructive)
-     * @param slug - The server slug
-     */
-    stop(slug: string): Promise<void>;
-    /**
-     * Delete a server config by slug (stops + removes persistence)
-     * @param slug - The server slug
-     */
-    delete(slug: string): Promise<void>;
-    /**
-     * Restart a server by slug
-     * @param slug - The server slug
-     * @returns Server info
-     */
-    restart(slug: string): Promise<ServerInfo>;
-    /**
-     * Update server status (internal use)
-     * @param slug - The server slug
-     * @param status - New status
-     */
-    updateStatus(slug: string, status: ServerStatus): Promise<void>;
-    /**
-     * Retrieve captured output (logs) for a managed server
-     * @param slug - The server slug
-     * @param options - Options for log retrieval
-     * @returns Server logs info
-     *
-     * @example
-     * ```typescript
-     * // Get combined logs (default)
-     * const logs = await sandbox.server.logs('api');
-     * console.log(logs.logs);
-     *
-     * // Get only stdout
-     * const stdout = await sandbox.server.logs('api', { stream: 'stdout' });
-     *
-     * // Get only stderr
-     * const stderr = await sandbox.server.logs('api', { stream: 'stderr' });
-     * ```
-     */
-    logs(slug: string, options?: ServerLogsOptions): Promise<ServerLogsInfo>;
-}
-
-/**
- * Watcher - Resource namespace for file watcher operations
- */
-
-/**
- * Watcher resource namespace
- *
- * @example
- * ```typescript
- * // Create a file watcher
- * const watcher = await sandbox.watcher.create('/project', {
- *   ignored: ['node_modules', '.git'],
- *   includeContent: true,
- * });
- * watcher.on('change', (event) => {
- *   console.log(`${event.event}: ${event.path}`);
- * });
- *
- * // List all watchers
- * const watchers = await sandbox.watcher.list();
- *
- * // Retrieve a specific watcher
- * const watcher = await sandbox.watcher.retrieve(id);
- *
- * // Destroy a watcher
- * await sandbox.watcher.destroy(id);
- * ```
- */
-declare class Watcher {
-    private createHandler;
-    private listHandler;
-    private retrieveHandler;
-    private destroyHandler;
-    constructor(handlers: {
-        create: (path: string, options?: {
-            includeContent?: boolean;
-            ignored?: string[];
-            encoding?: 'raw' | 'base64';
-        }) => Promise<FileWatcher>;
-        list: () => Promise<WatchersListResponse>;
-        retrieve: (id: string) => Promise<WatcherResponse>;
-        destroy: (id: string) => Promise<void>;
-    });
-    /**
-     * Create a new file watcher
-     * @param path - Path to watch
-     * @param options - Watcher options
-     * @param options.includeContent - Include file content in change events
-     * @param options.ignored - Patterns to ignore
-     * @param options.encoding - Encoding: 'raw' (default) or 'base64' (binary-safe)
-     * @returns FileWatcher instance
-     */
-    create(path: string, options?: {
-        includeContent?: boolean;
-        ignored?: string[];
-        encoding?: 'raw' | 'base64';
-    }): Promise<FileWatcher>;
-    /**
-     * List all active file watchers
-     * @returns Array of watcher info
-     */
-    list(): Promise<WatcherInfo[]>;
-    /**
-     * Retrieve a specific watcher by ID
-     * @param id - The watcher ID
-     * @returns Watcher info
-     */
-    retrieve(id: string): Promise<WatcherInfo>;
-    /**
-     * Destroy a watcher by ID
-     * @param id - The watcher ID
-     */
-    destroy(id: string): Promise<void>;
-}
-
-/**
- * SessionToken - Resource namespace for session token management
- */
-
-/**
- * Session token info
- */
-interface SessionTokenInfo {
-    id: string;
-    token?: string;
-    description?: string;
-    createdAt: string;
-    expiresAt: string;
-    lastUsedAt?: string;
-}
-/**
- * SessionToken resource namespace
- *
- * @example
- * ```typescript
- * // Create a session token (requires access token)
- * const token = await sandbox.sessionToken.create({
- *   description: 'My Application',
- *   expiresIn: 604800, // 7 days
- * });
- * console.log(token.token);
- *
- * // List all session tokens
- * const tokens = await sandbox.sessionToken.list();
- *
- * // Retrieve a specific token
- * const token = await sandbox.sessionToken.retrieve(id);
- *
- * // Revoke a token
- * await sandbox.sessionToken.revoke(id);
- * ```
- */
-declare class SessionToken {
-    private createHandler;
-    private listHandler;
-    private retrieveHandler;
-    private revokeHandler;
-    constructor(handlers: {
-        create: (options?: {
-            description?: string;
-            expiresIn?: number;
-        }) => Promise<SessionTokenResponse>;
-        list: () => Promise<SessionTokenListResponse>;
-        retrieve: (id: string) => Promise<SessionTokenResponse>;
-        revoke: (id: string) => Promise<void>;
-    });
-    /**
-     * Create a new session token (requires access token)
-     * @param options - Token configuration
-     * @param options.description - Description for the token
-     * @param options.expiresIn - Expiration time in seconds (default: 7 days)
-     * @returns Session token info including the token value
-     */
-    create(options?: {
-        description?: string;
-        expiresIn?: number;
-    }): Promise<SessionTokenInfo>;
-    /**
-     * List all session tokens
-     * @returns Array of session token info
-     */
-    list(): Promise<SessionTokenInfo[]>;
-    /**
-     * Retrieve a specific session token by ID
-     * @param id - The token ID
-     * @returns Session token info
-     */
-    retrieve(id: string): Promise<SessionTokenInfo>;
-    /**
-     * Revoke a session token
-     * @param id - The token ID to revoke
-     */
-    revoke(id: string): Promise<void>;
-}
-
-/**
- * MagicLink - Resource namespace for magic link operations
- */
-
-/**
- * Magic link info
- */
-interface MagicLinkInfo {
-    url: string;
-    expiresAt: string;
-    redirectUrl: string;
-}
-/**
- * MagicLink resource namespace
- *
- * @example
- * ```typescript
- * // Create a magic link (requires access token)
- * const link = await sandbox.magicLink.create({
- *   redirectUrl: '/dashboard',
- * });
- * console.log(link.url);
- * ```
- */
-declare class MagicLink {
-    private createHandler;
-    constructor(handlers: {
-        create: (options?: {
-            redirectUrl?: string;
-        }) => Promise<MagicLinkResponse>;
-    });
-    /**
-     * Create a magic link for browser authentication (requires access token)
-     *
-     * Magic links are one-time URLs that automatically create a session token
-     * and set it as a cookie in the user's browser.
-     *
-     * @param options - Magic link configuration
-     * @param options.redirectUrl - URL to redirect to after authentication
-     * @returns Magic link info including the URL
-     */
-    create(options?: {
-        redirectUrl?: string;
-    }): Promise<MagicLinkInfo>;
-}
-
-/**
- * Signal - Resource namespace for signal service operations
- */
-
-/**
- * Signal service status info
- */
-interface SignalStatusInfo {
-    status: 'active' | 'stopped';
-    channel: string;
-    wsUrl: string;
-}
-/**
- * Signal resource namespace
- *
- * @example
- * ```typescript
- * // Start the signal service
- * const signals = await sandbox.signal.start();
- * signals.on('port', (event) => {
- *   console.log(`Port ${event.port} opened: ${event.url}`);
- * });
- *
- * // Get signal service status
- * const status = await sandbox.signal.status();
- *
- * // Emit signals
- * await sandbox.signal.emitPort(3000, 'open', 'http://localhost:3000');
- * await sandbox.signal.emitError('Something went wrong');
- *
- * // Stop the signal service
- * await sandbox.signal.stop();
- * ```
- */
-declare class Signal {
-    private startHandler;
-    private statusHandler;
-    private stopHandler;
-    private emitPortHandler;
-    private emitErrorHandler;
-    private emitServerReadyHandler;
-    constructor(handlers: {
-        start: () => Promise<SignalService>;
-        status: () => Promise<SignalServiceResponse>;
-        stop: () => Promise<void>;
-        emitPort: (port: number, type: 'open' | 'close', url: string) => Promise<PortSignalResponse>;
-        emitError: (message: string) => Promise<GenericSignalResponse>;
-        emitServerReady: (port: number, url: string) => Promise<PortSignalResponse>;
-    });
-    /**
-     * Start the signal service
-     * @returns SignalService instance with event handling
-     */
-    start(): Promise<SignalService>;
-    /**
-     * Get the signal service status
-     * @returns Signal service status info
-     */
-    status(): Promise<SignalStatusInfo>;
-    /**
-     * Stop the signal service
-     */
-    stop(): Promise<void>;
-    /**
-     * Emit a port signal
-     * @param port - Port number
-     * @param type - Signal type ('open' or 'close')
-     * @param url - URL associated with the port
-     */
-    emitPort(port: number, type: 'open' | 'close', url: string): Promise<void>;
-    /**
-     * Emit an error signal
-     * @param message - Error message
-     */
-    emitError(message: string): Promise<void>;
-    /**
-     * Emit a server ready signal
-     * @param port - Port number
-     * @param url - Server URL
-     */
-    emitServerReady(port: number, url: string): Promise<void>;
-}
-
-/**
- * File - Resource namespace for file operations
- */
-
-/**
- * File resource namespace
- *
- * @example
- * ```typescript
- * // Create a file
- * const file = await sandbox.file.create('/project/hello.txt', 'Hello, World!');
- *
- * // List files in a directory
- * const files = await sandbox.file.list('/project');
- *
- * // Retrieve file content
- * const content = await sandbox.file.retrieve('/project/hello.txt');
- *
- * // Destroy (delete) a file
- * await sandbox.file.destroy('/project/hello.txt');
- *
- * // Batch write multiple files
- * const results = await sandbox.file.batchWrite([
- *   { path: '/project/a.txt', operation: 'write', content: 'A' },
- *   { path: '/project/b.txt', operation: 'write', content: 'B' },
- * ]);
- *
- * // Batch delete files
- * const results = await sandbox.file.batchWrite([
- *   { path: '/project/old.txt', operation: 'delete' },
- * ]);
- * ```
- */
-declare class File {
-    private createHandler;
-    private listHandler;
-    private retrieveHandler;
-    private destroyHandler;
-    private batchWriteHandler;
-    private existsHandler;
-    constructor(handlers: {
-        create: (path: string, content?: string) => Promise<FileResponse>;
-        list: (path: string) => Promise<FilesListResponse>;
-        retrieve: (path: string) => Promise<string>;
-        destroy: (path: string) => Promise<void>;
-        batchWrite: (files: Array<{
-            path: string;
-            operation: BatchFileOperation;
-            content?: string;
-        }>) => Promise<BatchWriteResponse>;
-        exists: (path: string) => Promise<boolean>;
-    });
-    /**
-     * Create a new file with optional content
-     * @param path - File path
-     * @param content - File content (optional)
-     * @returns File info
-     */
-    create(path: string, content?: string): Promise<FileInfo>;
-    /**
-     * List files at the specified path
-     * @param path - Directory path (default: '/')
-     * @returns Array of file info
-     */
-    list(path?: string): Promise<FileInfo[]>;
-    /**
-     * Retrieve file content
-     * @param path - File path
-     * @returns File content as string
-     */
-    retrieve(path: string): Promise<string>;
-    /**
-     * Destroy (delete) a file or directory
-     * @param path - File or directory path
-     */
-    destroy(path: string): Promise<void>;
-    /**
-     * Batch file operations (write or delete multiple files)
-     *
-     * Features:
-     * - Deduplication: Last operation wins per path
-     * - File locking: Prevents race conditions
-     * - Deterministic ordering: Alphabetical path sorting
-     * - Partial failure handling: Returns per-file results
-     *
-     * @param files - Array of file operations
-     * @returns Results for each file operation
-     */
-    batchWrite(files: Array<{
-        path: string;
-        operation: BatchFileOperation;
-        content?: string;
-    }>): Promise<BatchWriteResult[]>;
-    /**
-     * Check if a file exists
-     * @param path - File path
-     * @returns True if file exists
-     */
-    exists(path: string): Promise<boolean>;
-}
-
-/**
- * Env - Resource namespace for environment variable operations
- */
-
-/**
- * Env resource namespace
- *
- * @example
- * ```typescript
- * // Retrieve environment variables
- * const vars = await sandbox.env.retrieve('.env');
- * console.log(vars);
- *
- * // Update environment variables (merges with existing)
- * await sandbox.env.update('.env', {
- *   API_KEY: 'secret',
- *   DEBUG: 'true',
- * });
- *
- * // Remove environment variables
- * await sandbox.env.remove('.env', ['OLD_KEY', 'DEPRECATED']);
- * ```
- */
-declare class Env {
-    private retrieveHandler;
-    private updateHandler;
-    private removeHandler;
-    private existsHandler;
-    constructor(handlers: {
-        retrieve: (file: string) => Promise<EnvGetResponse>;
-        update: (file: string, variables: Record<string, string>) => Promise<EnvSetResponse>;
-        remove: (file: string, keys: string[]) => Promise<EnvDeleteResponse>;
-        exists: (file: string) => Promise<boolean>;
-    });
-    /**
-     * Retrieve environment variables from a file
-     * @param file - Path to the .env file (relative to sandbox root)
-     * @returns Key-value map of environment variables
-     */
-    retrieve(file: string): Promise<Record<string, string>>;
-    /**
-     * Update (merge) environment variables in a file
-     * @param file - Path to the .env file (relative to sandbox root)
-     * @param variables - Key-value pairs to set
-     * @returns Keys that were updated
-     */
-    update(file: string, variables: Record<string, string>): Promise<string[]>;
-    /**
-     * Remove environment variables from a file
-     * @param file - Path to the .env file (relative to sandbox root)
-     * @param keys - Keys to remove
-     * @returns Keys that were removed
-     */
-    remove(file: string, keys: string[]): Promise<string[]>;
-    /**
-     * Check if an environment file exists
-     * @param file - Path to the .env file (relative to sandbox root)
-     * @returns True if file exists
-     */
-    exists(file: string): Promise<boolean>;
-}
-
-/**
- * Auth - Resource namespace for authentication info
- */
-
-/**
- * Authentication status info
- */
-interface AuthStatusInfo {
-    authenticated: boolean;
-    tokenType?: 'access_token' | 'session_token';
-    expiresAt?: string;
-}
-/**
- * Authentication endpoints info
- */
-interface AuthEndpointsInfo {
-    createSessionToken: string;
-    listSessionTokens: string;
-    getSessionToken: string;
-    revokeSessionToken: string;
-    createMagicLink: string;
-    authStatus: string;
-    authInfo: string;
-}
-/**
- * Authentication info
- */
-interface AuthInfo {
-    message: string;
-    instructions: string;
-    endpoints: AuthEndpointsInfo;
-}
-/**
- * Auth resource namespace
- *
- * @example
- * ```typescript
- * // Check authentication status
- * const status = await sandbox.auth.status();
- * console.log(status.authenticated);
- * console.log(status.tokenType);
- *
- * // Get authentication info and instructions
- * const info = await sandbox.auth.info();
- * console.log(info.instructions);
- * ```
- */
-declare class Auth {
-    private statusHandler;
-    private infoHandler;
-    constructor(handlers: {
-        status: () => Promise<AuthStatusResponse>;
-        info: () => Promise<AuthInfoResponse>;
-    });
-    /**
-     * Check authentication status
-     * @returns Authentication status info
-     */
-    status(): Promise<AuthStatusInfo>;
-    /**
-     * Get authentication information and usage instructions
-     * @returns Authentication info
-     */
-    info(): Promise<AuthInfo>;
-}
-
-/**
- * Run - Resource namespace for code and command execution
- */
-/**
- * Code execution result
- */
-interface CodeResult {
-    output: string;
-    exitCode: number;
-    language: string;
-}
-/**
- * Command execution result
- */
-interface CommandResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-    durationMs: number;
-    /** Command ID (present for background commands) */
-    cmdId?: string;
-    /** Terminal ID (present for background commands) */
-    terminalId?: string;
-    /** Command status (present for background commands) */
-    status?: 'running' | 'completed' | 'failed';
-}
-/**
- * Supported languages for code execution
- */
-type CodeLanguage = 'python' | 'python3' | 'node' | 'javascript' | 'js' | 'bash' | 'sh' | 'ruby';
-/**
- * Code execution options
- */
-interface CodeRunOptions {
-    /** Programming language (optional - will auto-detect if not specified) */
-    language?: CodeLanguage;
-}
-/**
- * Options for waiting for command completion
- */
-interface CommandWaitOptions {
-    /** Timeout in seconds to wait for command completion (default: 300, max: 300) */
-    timeoutSeconds?: number;
-}
-/**
- * Command execution options
- */
-interface CommandRunOptions {
-    /** Shell to use (optional) */
-    shell?: string;
-    /** Run in background (optional) */
-    background?: boolean;
-    /** Working directory for the command (optional) */
-    cwd?: string;
-    /** Environment variables (optional) */
-    env?: Record<string, string>;
-    /** If true, wait for background command to complete before returning (default: false) */
-    waitForCompletion?: boolean | CommandWaitOptions;
-}
-/**
- * Run - Resource namespace for executing code and commands
- *
- * @example
- * ```typescript
- * // Run code with auto-detection
- * const result = await sandbox.run.code('print("Hello from Python")');
- * console.log(result.output); // "Hello from Python\n"
- * console.log(result.language); // "python"
- *
- * // Run code with explicit language
- * const result = await sandbox.run.code('console.log("Hello")', { language: 'node' });
- *
- * // Run a command
- * const result = await sandbox.run.command('ls -la');
- * console.log(result.stdout);
- * console.log(result.exitCode);
- *
- * // Run a command in background and wait for completion
- * const result = await sandbox.run.command('npm install', {
- *   background: true,
- *   waitForCompletion: true, // blocks until command completes
- * });
- * console.log(result.exitCode);
- *
- * // Run in background without waiting (fire-and-forget)
- * const result = await sandbox.run.command('npm install', { background: true });
- * console.log(result.cmdId); // command ID for manual tracking
- * console.log(result.terminalId); // terminal ID for manual tracking
- * ```
- */
-declare class Run {
-    private codeHandler;
-    private commandHandler;
-    private waitHandler?;
-    constructor(handlers: {
-        code: (code: string, options?: CodeRunOptions) => Promise<CodeResult>;
-        command: (command: string, options?: CommandRunOptions) => Promise<CommandResult>;
-        wait?: (terminalId: string, cmdId: string, options?: CommandWaitOptions) => Promise<CommandResult>;
-    });
-    /**
-     * Execute code with automatic language detection
-     *
-     * Supports: python, python3, node, javascript, js, bash, sh, ruby
-     *
-     * @param code - The code to execute
-     * @param options - Execution options
-     * @param options.language - Programming language (auto-detected if not specified)
-     * @returns Code execution result with output, exit code, and detected language
-     */
-    code(code: string, options?: CodeRunOptions): Promise<CodeResult>;
-    /**
-     * Execute a shell command
-     *
-     * @param command - The command to execute
-     * @param options - Execution options
-     * @param options.shell - Shell to use (optional)
-     * @param options.background - Run in background (optional)
-     * @param options.cwd - Working directory for the command (optional)
-     * @param options.env - Environment variables (optional)
-     * @param options.waitForCompletion - If true (with background), wait for command to complete
-     * @returns Command execution result with stdout, stderr, exit code, and duration
-     */
-    command(command: string, options?: CommandRunOptions): Promise<CommandResult>;
-    /**
-     * Wait for a background command to complete
-     *
-     * Uses the configured wait handler to block until the command
-     * is complete or fails (typically via server-side long-polling).
-     * Throws an error if the command fails or times out.
-     *
-     * @param terminalId - Terminal ID from background command result
-     * @param cmdId - Command ID from background command result
-     * @param options - Wait options passed to the handler
-     * @returns Command result with final status
-     * @throws Error if command fails or times out
-     */
-    waitForCompletion(terminalId: string, cmdId: string, options?: CommandWaitOptions): Promise<CommandResult>;
-}
-
-/**
- * Client Types
- *
- * Types specific to the gateway Sandbox client implementation.
- * Core universal types are imported from ../types/universal-sandbox
- */
-
-/**
- * Sandbox status types (client-specific, more limited than universal)
- */
-type SandboxStatus = 'running' | 'stopped' | 'error';
-/**
- * Provider-agnostic sandbox info (alias for SandboxInfo for backward compatibility)
- */
-interface ProviderSandboxInfo {
-    /** Unique identifier for the sandbox */
-    id: string;
-    /** Provider hosting the sandbox */
-    provider: string;
-    /** Runtime environment in the sandbox */
-    runtime: Runtime;
-    /** Current status of the sandbox */
-    status: SandboxStatus;
-    /** When the sandbox was created */
-    createdAt: Date;
-    /** Execution timeout in milliseconds */
-    timeout: number;
-    /** Additional provider-specific metadata */
-    metadata?: Record<string, any>;
-}
-/**
- * Error thrown when a command exits with a non-zero status
- */
-declare class CommandExitError extends Error {
-    result: {
-        exitCode: number;
-        stdout: string;
-        stderr: string;
-        error: boolean;
-    };
-    name: string;
-    constructor(result: {
-        exitCode: number;
-        stdout: string;
-        stderr: string;
-        error: boolean;
-    });
-}
-/**
- * Type guard to check if an error is a CommandExitError
- */
-declare function isCommandExitError(error: unknown): error is CommandExitError;
-
-/**
- * Child - Resource namespace for child sandbox operations
- */
-
-/**
- * Child resource namespace for managing child sandboxes
- *
- * Child sandboxes are isolated environments within the parent sandbox,
- * each with their own filesystem. Available only in multi-tenant mode.
- *
- * @example
- * ```typescript
- * // Create a new child sandbox
- * const child = await sandbox.child.create({
- *   directory: '/custom/path',
- *   overlays: [
- *     {
- *       source: '/templates/nextjs',
- *       target: 'app',
- *       strategy: 'smart',
- *     },
- *   ],
- *   servers: [
- *     {
- *       slug: 'web',
- *       start: 'npm run dev',
- *       path: '/app',
- *     },
- *   ],
- * });
- * console.log(child.url); // https://sandbox-12345.sandbox.computesdk.com
- *
- * // List all children
- * const all = await sandbox.child.list();
- *
- * // Get a specific child
- * const info = await sandbox.child.retrieve('sandbox-12345');
- *
- * // Delete a child sandbox
- * await sandbox.child.destroy('sandbox-12345');
- *
- * // Delete child and its files
- * await sandbox.child.destroy('sandbox-12345', { deleteFiles: true });
- * ```
- */
-declare class Child {
-    private createHandler;
-    private listHandler;
-    private retrieveHandler;
-    private destroyHandler;
-    constructor(handlers: {
-        create: (options?: CreateSandboxOptions$1) => Promise<SandboxInfo>;
-        list: () => Promise<SandboxesListResponse>;
-        retrieve: (subdomain: string) => Promise<SandboxInfo>;
-        destroy: (subdomain: string, deleteFiles: boolean) => Promise<void>;
-    });
-    /**
-     * Create a new child sandbox
-     * @returns Child sandbox info including URL and subdomain
-     */
-    create(options?: CreateSandboxOptions$1): Promise<SandboxInfo>;
-    /**
-     * List all child sandboxes
-     * @returns Array of child sandbox info
-     */
-    list(): Promise<SandboxInfo[]>;
-    /**
-     * Retrieve a specific child sandbox by subdomain
-     * @param subdomain - The child subdomain (e.g., 'sandbox-12345')
-     * @returns Child sandbox info
-     */
-    retrieve(subdomain: string): Promise<SandboxInfo>;
-    /**
-     * Destroy (delete) a child sandbox
-     * @param subdomain - The child subdomain
-     * @param options - Destroy options
-     * @param options.deleteFiles - Whether to delete the child's files (default: false)
-     */
-    destroy(subdomain: string, options?: {
-        deleteFiles?: boolean;
-    }): Promise<void>;
-}
-
-/**
- * Binary WebSocket Protocol Implementation
- *
- * Implements the ComputeSDK binary protocol for WebSocket communication.
- * Provides 50-90% size reduction compared to JSON protocol.
- *
- * Binary Message Format:
- * [1 byte: message type]
- * [2 bytes: channel length (uint16, big-endian)]
- * [N bytes: channel string (UTF-8)]
- * [2 bytes: msg type length (uint16, big-endian)]
- * [N bytes: msg type string (UTF-8)]
- * [4 bytes: data length (uint32, big-endian)]
- * [N bytes: data (key-value encoded for complex objects, raw bytes for binary data)]
- *
- * Key-Value Encoding Format:
- * [2 bytes: num_fields (uint16, big-endian)]
- * For each field:
- *   [2 bytes: key_length (uint16, big-endian)]
- *   [N bytes: key string (UTF-8)]
- *   [1 byte: value_type (0x01=string, 0x02=number, 0x03=boolean, 0x04=bytes)]
- *   [4 bytes: value_length (uint32, big-endian)]
- *   [N bytes: value data]
- */
-declare enum MessageType {
-    Subscribe = 1,
-    Unsubscribe = 2,
-    Data = 3,
-    Error = 4,
-    Connected = 5
-}
-/**
- * Encode a WebSocket message to binary format
- * @param message - The message object to encode
- * @returns ArrayBuffer containing the encoded binary message
- */
-declare function encodeBinaryMessage(message: any): ArrayBuffer;
-/**
- * Decode a binary WebSocket message
- * @param buffer - The binary data to decode (ArrayBuffer or Uint8Array)
- * @returns Decoded message object
- */
-declare function decodeBinaryMessage(buffer: ArrayBuffer | Uint8Array): any;
-
-/**
- * ComputeSDK Client - Universal Sandbox Implementation
- *
- * This package provides a Sandbox for interacting with ComputeSDK sandboxes
- * through API endpoints at ${sandboxId}.sandbox.computesdk.com
- *
- * Works in browser, Node.js, and edge runtimes.
- * Browser: Uses native WebSocket and fetch
- * Node.js: Pass WebSocket implementation (e.g., 'ws' library)
- */
-
-/**
- * Extended filesystem interface with overlay support
- */
-interface ExtendedFileSystem extends SandboxFileSystem {
-    /** Overlay operations for template directories */
-    readonly overlay: Overlay;
-}
-
-/**
- * WebSocket constructor type
- */
-type WebSocketConstructor = new (url: string) => WebSocket;
-/**
- * Configuration options for creating a Sandbox
- */
-interface SandboxConfig {
-    /** API endpoint URL (e.g., https://sandbox-123.sandbox.computesdk.com). Optional in browser - can be auto-detected from URL query param or localStorage */
-    sandboxUrl?: string;
-    /** Sandbox ID */
-    sandboxId: string;
-    /** Provider name (e.g., 'e2b', 'gateway') */
-    provider: string;
-    /** Access token or session token for authentication. Optional in browser - can be auto-detected from URL query param or localStorage */
-    token?: string;
-    /** Optional headers to include with all requests */
-    headers?: Record<string, string>;
-    /** Request timeout in milliseconds (default: 30000) */
-    timeout?: number;
-    /** WebSocket implementation (optional, uses global WebSocket if not provided) */
-    WebSocket?: WebSocketConstructor;
-    /** WebSocket protocol: 'binary' (default, recommended) or 'json' (for debugging) */
-    protocol?: 'json' | 'binary';
-    /** Optional metadata associated with the sandbox */
-    metadata?: Record<string, unknown>;
-    /**
-     * Handler called when destroy() is invoked.
-     * If provided, this is called to destroy the sandbox (e.g., via gateway API).
-     * If not provided, destroy() only disconnects the WebSocket.
-     * @internal
-     */
-    destroyHandler?: () => Promise<void>;
-}
-/**
- * Health check response
- */
-interface HealthResponse {
-    status: string;
-    timestamp: string;
-}
-/**
- * Server info response
- */
-interface InfoResponse {
-    message: string;
-    data: {
-        auth_enabled: boolean;
-        main_subdomain: string;
-        sandbox_count: number;
-        sandbox_url: string;
-        version: string;
-    };
-}
-/**
- * Session token response
- */
-interface SessionTokenResponse {
-    id: string;
-    token: string;
-    description?: string;
-    createdAt: string;
-    expiresAt: string;
-    expiresIn: number;
-}
-/**
- * Session token list response
- */
-interface SessionTokenListResponse {
-    message: string;
-    data: {
-        tokens: Array<{
-            id: string;
-            description?: string;
-            created_at: string;
-            expires_at: string;
-            last_used_at?: string;
-        }>;
-    };
-}
-/**
- * Magic link response
- */
-interface MagicLinkResponse {
-    message: string;
-    data: {
-        magic_url: string;
-        expires_at: string;
-        redirect_url: string;
-    };
-}
-/**
- * Authentication status response
- */
-interface AuthStatusResponse {
-    message: string;
-    data: {
-        authenticated: boolean;
-        token_type?: 'access_token' | 'session_token';
-        expires_at?: string;
-    };
-}
-/**
- * Authentication information response
- */
-interface AuthInfoResponse {
-    message: string;
-    data: {
-        message: string;
-        instructions: string;
-        endpoints: {
-            create_session_token: string;
-            list_session_tokens: string;
-            get_session_token: string;
-            revoke_session_token: string;
-            create_magic_link: string;
-            auth_status: string;
-            auth_info: string;
-        };
-    };
-}
-/**
- * File information
- */
-interface FileInfo {
-    name: string;
-    path: string;
-    size: number;
-    is_dir: boolean;
-    modified_at: string;
-}
-/**
- * Files list response
- */
-interface FilesListResponse {
-    message: string;
-    data: {
-        files: FileInfo[];
-        path: string;
-    };
-}
-/**
- * File response
- */
-interface FileResponse {
-    message: string;
-    data: {
-        file: FileInfo;
-        content?: string;
-    };
-}
-/**
- * Command execution response (used by both /run/command and /terminals/{id}/execute)
- */
-interface CommandExecutionResponse {
-    message: string;
-    data: {
-        terminal_id?: string;
-        cmd_id?: string;
-        command: string;
-        stdout: string;
-        stderr: string;
-        exit_code?: number;
-        duration_ms?: number;
-        status?: 'running' | 'completed' | 'failed';
-        channel?: string;
-        pty?: boolean;
-    };
-}
-/**
- * Command details response
- */
-interface CommandDetailsResponse {
-    message: string;
-    data: {
-        cmd_id: string;
-        command: string;
-        status: 'running' | 'completed' | 'failed';
-        stdout: string;
-        stderr: string;
-        started_at: string;
-        finished_at?: string;
-        duration_ms?: number;
-        exit_code?: number;
-    };
-}
-/**
- * Command list item
- */
-interface CommandListItem {
-    cmd_id: string;
-    command: string;
-    status: 'running' | 'completed' | 'failed';
-    started_at: string;
-    finished_at?: string;
-    duration_ms?: number;
-    exit_code?: number;
-}
-/**
- * Commands list response
- */
-interface CommandsListResponse {
-    message: string;
-    data: {
-        commands: CommandListItem[];
-        count: number;
-    };
-}
-/**
- * Code execution response (POST /run/code)
- */
-interface CodeExecutionResponse {
-    data: {
-        output: string;
-        exit_code: number;
-        language: string;
-    };
-}
-/**
- * File watcher information
- */
-interface WatcherInfo {
-    id: string;
-    path: string;
-    includeContent: boolean;
-    ignored: string[];
-    status: 'active' | 'stopped';
-    channel: string;
-    encoding?: 'raw' | 'base64';
-}
-/**
- * File watcher response
- */
-interface WatcherResponse {
-    message: string;
-    data: WatcherInfo & {
-        ws_url: string;
-    };
-}
-/**
- * File watchers list response
- */
-interface WatchersListResponse {
-    message: string;
-    data: {
-        watchers: WatcherInfo[];
-    };
-}
-/**
- * Signal service response
- */
-interface SignalServiceResponse {
-    message: string;
-    data: {
-        status: 'active' | 'stopped';
-        channel: string;
-        ws_url: string;
-    };
-}
-/**
- * Port signal response
- */
-interface PortSignalResponse {
-    message: string;
-    data: {
-        port: number;
-        type: 'open' | 'close';
-        url: string;
-    };
-}
-/**
- * Generic signal response
- */
-interface GenericSignalResponse {
-    message: string;
-    data: {
-        message: string;
-    };
-}
-/**
- * Sandbox information
- */
-interface SandboxInfo {
-    subdomain: string;
-    directory: string;
-    is_main: boolean;
-    created_at: string;
-    url: string;
-    overlays?: SandboxOverlayInfo[];
-    servers?: SandboxServerInfo[];
-}
-/**
- * Sandboxes list response
- */
-interface SandboxesListResponse {
-    sandboxes: SandboxInfo[];
-}
-/**
- * Terminal response
- */
-interface TerminalResponse {
-    message: string;
-    data: {
-        id: string;
-        pty: boolean;
-        status: 'running' | 'stopped' | 'ready' | 'active';
-        channel?: string;
-        ws_url?: string;
-        encoding?: 'raw' | 'base64';
-    };
-}
-/**
- * Terminal response
- */
-interface TerminalResponse {
-    message: string;
-    data: {
-        id: string;
-        pty: boolean;
-        status: 'running' | 'stopped' | 'ready' | 'active';
-        channel?: string;
-        ws_url?: string;
-        encoding?: 'raw' | 'base64';
-    };
-}
-/**
- * Server status types
- *
- * - `installing`: Running install command (e.g., npm install) before starting
- * - `starting`: Initial startup of the server process
- * - `running`: Server process is running
- * - `ready`: Server is running and ready to accept traffic
- * - `failed`: Server failed to start or encountered a fatal error
- * - `stopped`: Server was intentionally stopped
- * - `restarting`: Server is being automatically restarted by the supervisor
- */
-type ServerStatus = 'installing' | 'starting' | 'running' | 'ready' | 'failed' | 'stopped' | 'restarting';
-/**
- * Server restart policy
- * - `never`: No automatic restart (default)
- * - `on-failure`: Restart only on non-zero exit code
- * - `always`: Always restart on exit (including exit code 0)
- */
-type RestartPolicy = 'never' | 'on-failure' | 'always';
-/**
- * Health check configuration for servers
- * Polls the server to verify it's responding to requests
- */
-interface HealthCheckConfig {
-    /** Path to poll for health checks (default: "/") */
-    path?: string;
-    /** Interval between health checks in milliseconds (default: 2000) */
-    interval_ms?: number;
-    /** Timeout for each health check request in milliseconds (default: 1500) */
-    timeout_ms?: number;
-    /** Delay before starting health checks after port detection in milliseconds (default: 5000) */
-    delay_ms?: number;
-}
-/**
- * Health check status information returned from server
- */
-interface HealthCheckStatus {
-    /** When the last health check was performed (ISO 8601) */
-    last_check?: string;
-    /** HTTP status code from the last health check */
-    last_status?: number;
-    /** Number of consecutive failed health checks */
-    consecutive_failures: number;
-}
-/**
- * Server information
- */
-interface ServerInfo {
-    /** Unique server identifier */
-    slug: string;
-    /** Install command (optional, runs blocking before start) */
-    install?: string;
-    /** Command used to start the server */
-    start: string;
-    /** Working directory path */
-    path: string;
-    /** Original path before resolution */
-    original_path?: string;
-    /** Path to .env file */
-    env_file?: string;
-    /** Inline environment variables */
-    environment?: Record<string, string>;
-    /** Whether to auto-start the server on daemon boot */
-    autostart?: boolean;
-    /** If true, port allocation is strict (no auto-increment) */
-    strict_port?: boolean;
-    /** Overlay IDs this server depends on */
-    depends_on?: string[];
-    /** Auto-detected port number (populated when port monitor detects listening port) */
-    port?: number;
-    /** Generated URL from subdomain + port (populated when port is detected) */
-    url?: string;
-    /** Server lifecycle status */
-    status: ServerStatus;
-    /** Process ID (direct process, not shell wrapper) */
-    pid?: number;
-    /** Configured restart policy */
-    restart_policy?: RestartPolicy;
-    /** Maximum restart attempts (0 = unlimited) */
-    max_restarts?: number;
-    /** Delay between restarts in nanoseconds (input uses milliseconds via restart_delay_ms) */
-    restart_delay?: number;
-    /** Graceful shutdown timeout in nanoseconds (input uses milliseconds via stop_timeout_ms) */
-    stop_timeout?: number;
-    /** Number of times the server has been automatically restarted */
-    restart_count?: number;
-    /** Last exit code (null if process is still running) */
-    exit_code?: number | null;
-    /** Health check configuration (if configured) */
-    health_check?: HealthCheckConfig;
-    /** Whether the server is healthy (only present if health_check is configured) */
-    healthy?: boolean;
-    /** Health check status details (only present if health_check is configured) */
-    health_status?: HealthCheckStatus;
-    /** When the server was created */
-    created_at: string;
-    /** When the server was last updated */
-    updated_at: string;
-}
-/**
- * Sandbox server info returned by setup flows
- */
-interface SandboxServerInfo {
-    slug: string;
-    port?: number;
-    url?: string;
-    status: ServerStatus;
-    /** Whether the server is healthy (only present if health_check is configured) */
-    healthy?: boolean;
-    /** Health check status details (only present if health_check is configured) */
-    health_check?: HealthCheckStatus;
-}
-/**
- * Sandbox overlay info returned by setup flows
- */
-interface SandboxOverlayInfo {
-    id: string;
-    source: string;
-    target: string;
-    copy_status: string;
-}
-/**
- * Ready response (public endpoint)
- */
-interface ReadyResponse {
-    /** Whether all servers have ports allocated (URLs available) */
-    ready: boolean;
-    /** Whether all servers with health checks are passing */
-    healthy?: boolean;
-    servers: SandboxServerInfo[];
-    overlays: SandboxOverlayInfo[];
-}
-/**
- * Servers list response
- */
-interface ServersListResponse {
-    status: string;
-    message: string;
-    data: {
-        servers: ServerInfo[];
-    };
-}
-/**
- * Server response
- */
-interface ServerResponse {
-    status: string;
-    message: string;
-    data: {
-        server: ServerInfo;
-    };
-}
-/**
- * Server stop response
- */
-interface ServerStopResponse {
-    status: string;
-    message: string;
-    data: {
-        slug: string;
-    };
-}
-/**
- * Server logs stream type
- */
-type ServerLogStream = 'stdout' | 'stderr' | 'combined';
-/**
- * Server logs response
- */
-interface ServerLogsResponse {
-    status: string;
-    message: string;
-    data: {
-        slug: string;
-        stream: ServerLogStream;
-        logs: string;
-    };
-}
-/**
- * Server status update response
- */
-interface ServerStatusUpdateResponse {
-    status: string;
-    message: string;
-    data: {
-        slug: string;
-        status: ServerStatus;
-    };
-}
-/**
- * Environment variables response
- */
-interface EnvGetResponse {
-    status: string;
-    message: string;
-    data: {
-        file: string;
-        variables: Record<string, string>;
-    };
-}
-/**
- * Environment set response
- */
-interface EnvSetResponse {
-    status: string;
-    message: string;
-    data: {
-        file: string;
-        keys: string[];
-    };
-}
-/**
- * Environment delete response
- */
-interface EnvDeleteResponse {
-    status: string;
-    message: string;
-    data: {
-        file: string;
-        keys: string[];
-    };
-}
-/**
- * Batch file operation type
- */
-type BatchFileOperation = 'write' | 'delete';
-/**
- * Batch file operation result
- */
-interface BatchWriteResult {
-    path: string;
-    success: boolean;
-    error?: string;
-    file?: FileInfo;
-}
-/**
- * Batch file operation response
- */
-interface BatchWriteResponse {
-    message: string;
-    data: {
-        results: BatchWriteResult[];
-    };
-}
-/**
- * Sandbox - Full-featured gateway sandbox implementation
- *
- * Provides complete feature set including:
- * - Interactive terminals (PTY and exec modes)
- * - Managed servers
- * - File watchers with real-time events
- * - Authentication (session tokens, magic links)
- * - Environment management
- * - Signal service for port/error events
- * - Child sandbox creation
- *
- * This is the most feature-rich implementation available.
- *
- * @example
- * ```typescript
- * import { Sandbox } from 'computesdk'
- *
- * // Pattern 1: Admin operations (requires access token)
- * const sandbox = new Sandbox({
- *   sandboxUrl: 'https://sandbox-123.sandbox.computesdk.com',
- *   token: accessToken, // From edge service
- * });
- *
- * // Create session token for delegated operations
- * const sessionToken = await sandbox.createSessionToken({
- *   description: 'My Application',
- *   expiresIn: 604800, // 7 days
- * });
- *
- * // Pattern 2: Delegated operations (binary protocol by default)
- * const sandbox2 = new Sandbox({
- *   sandboxUrl: 'https://sandbox-123.sandbox.computesdk.com',
- *   token: sessionToken.data.token,
- *   // protocol: 'binary' is the default (50-90% size reduction)
- * });
- *
- * // Execute a one-off command
- * const result = await sandbox.execute({ command: 'ls -la' });
- * console.log(result.data.stdout);
- *
- * // Run code
- * const codeResult = await sandbox.runCode('console.log("Hello!")', 'node');
- *
- * // Work with files
- * const files = await sandbox.listFiles('/home/project');
- * await sandbox.writeFile('/home/project/test.txt', 'Hello, World!');
- * const content = await sandbox.readFile('/home/project/test.txt');
- *
- * // Create a PTY terminal with real-time output (interactive shell)
- * const terminal = await sandbox.createTerminal({ pty: true });
- * terminal.on('output', (data) => console.log(data));
- * terminal.write('ls -la\n');
- * await terminal.destroy();
- *
- * // Create an exec terminal for command tracking
- * const execTerminal = await sandbox.createTerminal({ pty: false });
- * const result = await execTerminal.execute('npm install', { background: true });
- * const cmd = await sandbox.getCommand(execTerminal.getId(), result.data.cmd_id);
- * console.log(cmd.data.status); // "running" | "completed" | "failed"
- * await execTerminal.destroy();
- *
- * // Watch for file changes
- * const watcher = await sandbox.createWatcher('/home/project', {
- *   ignored: ['node_modules', '.git']
- * });
- * watcher.on('change', (event) => {
- *   console.log(`${event.event}: ${event.path}`);
- * });
- * await watcher.destroy();
- *
- * // Monitor system signals
- * const signals = await sandbox.startSignals();
- * signals.on('port', (event) => {
- *   console.log(`Port ${event.port} opened: ${event.url}`);
- * });
- * await signals.stop();
- *
- * // Clean up
- * await sandbox.disconnect();
- * ```
- */
-declare class Sandbox {
-    readonly sandboxId: string;
-    readonly provider: string;
-    readonly filesystem: ExtendedFileSystem;
-    readonly terminal: Terminal;
-    readonly run: Run;
-    readonly server: Server;
-    readonly watcher: Watcher;
-    readonly sessionToken: SessionToken;
-    readonly magicLink: MagicLink;
-    readonly signal: Signal;
-    readonly file: File;
-    readonly env: Env;
-    readonly auth: Auth;
-    readonly child: Child;
-    private config;
-    private _token;
-    private _ws;
-    private WebSocketImpl;
-    private _terminals;
-    constructor(config: SandboxConfig);
-    /**
-     * Get or create internal WebSocket manager
-     */
-    private ensureWebSocket;
-    /**
-     * Create and configure a TerminalInstance from response data
-     */
-    private hydrateTerminal;
-    private request;
-    /**
-     * Check service health
-     */
-    health(): Promise<HealthResponse>;
-    /**
-     * Create a session token (requires access token)
-     *
-     * Session tokens are delegated credentials that can authenticate API requests
-     * without exposing your access token. Only access tokens can create session tokens.
-     *
-     * @param options - Token configuration
-     * @throws {Error} 403 Forbidden if called with a session token
-     */
-    createSessionToken(options?: {
-        description?: string;
-        expiresIn?: number;
-    }): Promise<SessionTokenResponse>;
-    /**
-     * List all session tokens (requires access token)
-     *
-     * @throws {Error} 403 Forbidden if called with a session token
-     */
-    listSessionTokens(): Promise<SessionTokenListResponse>;
-    /**
-     * Get details of a specific session token (requires access token)
-     *
-     * @param tokenId - The token ID
-     * @throws {Error} 403 Forbidden if called with a session token
-     */
-    getSessionToken(tokenId: string): Promise<SessionTokenResponse>;
-    /**
-     * Revoke a session token (requires access token)
-     *
-     * @param tokenId - The token ID to revoke
-     * @throws {Error} 403 Forbidden if called with a session token
-     */
-    revokeSessionToken(tokenId: string): Promise<void>;
-    /**
-     * Generate a magic link for browser authentication (requires access token)
-     *
-     * Magic links are one-time URLs that automatically create a session token
-     * and set it as a cookie in the user's browser. This provides an easy way
-     * to authenticate users in browser-based applications.
-     *
-     * The generated link:
-     * - Expires after 5 minutes or first use (whichever comes first)
-     * - Automatically creates a new session token (7 day expiry)
-     * - Sets the session token as an HttpOnly cookie
-     * - Redirects to the specified URL
-     *
-     * @param options - Magic link configuration
-     * @throws {Error} 403 Forbidden if called with a session token
-     */
-    createMagicLink(options?: {
-        redirectUrl?: string;
-    }): Promise<MagicLinkResponse>;
-    /**
-     * Check authentication status
-     * Does not require authentication
-     */
-    getAuthStatus(): Promise<AuthStatusResponse>;
-    /**
-     * Get authentication information and usage instructions
-     * Does not require authentication
-     */
-    getAuthInfo(): Promise<AuthInfoResponse>;
-    /**
-     * Set authentication token manually
-     * @param token - Access token or session token
-     */
-    setToken(token: string): void;
-    /**
-     * Get current authentication token
-     */
-    getToken(): string | null;
-    /**
-     * Get current sandbox URL
-     */
-    getSandboxUrl(): string;
-    /**
-     * Execute a one-off command without creating a persistent terminal
-     *
-     * @example
-     * ```typescript
-     * // Synchronous execution (waits for completion)
-     * const result = await sandbox.execute({ command: 'npm test' });
-     * console.log(result.data.exit_code);
-     *
-     * // Background execution (returns immediately)
-     * const result = await sandbox.execute({
-     *   command: 'npm install',
-     *   background: true
-     * });
-     * // Use result.data.terminal_id and result.data.cmd_id to track
-     * const cmd = await sandbox.getCommand(result.data.terminal_id!, result.data.cmd_id!);
-     * ```
-     */
-    execute(options: {
-        command: string;
-        shell?: string;
-        background?: boolean;
-    }): Promise<CommandExecutionResponse>;
-    /**
-     * Execute code with automatic language detection (POST /run/code)
-     *
-     * @param code - The code to execute
-     * @param language - Programming language (optional - auto-detects if not specified)
-     * @returns Code execution result with output, exit code, and detected language
-     *
-     * @example
-     * ```typescript
-     * // Auto-detect language
-     * const result = await sandbox.runCodeRequest('print("Hello")');
-     * console.log(result.data.output); // "Hello\n"
-     * console.log(result.data.language); // "python"
-     *
-     * // Explicit language
-     * const result = await sandbox.runCodeRequest('console.log("Hi")', 'node');
-     * ```
-     */
-    runCodeRequest(code: string, language?: string): Promise<CodeExecutionResponse>;
-    /**
-     * Execute a command and get the result
-     * Lower-level method that returns the raw API response
-     *
-     * @param options.command - Command to execute
-     * @param options.shell - Shell to use (optional)
-     * @param options.background - Run in background (optional)
-     * @param options.cwd - Working directory for the command (optional)
-     * @param options.env - Environment variables (optional)
-     * @returns Command execution result
-     *
-     * @example
-     * ```typescript
-     * const result = await sandbox.runCommandRequest({ command: 'ls -la' });
-     * console.log(result.data.stdout);
-     * ```
-     */
-    runCommandRequest(options: {
-        command: string;
-        shell?: string;
-        background?: boolean;
-        stream?: boolean;
-        cwd?: string;
-        env?: Record<string, string>;
-    }): Promise<CommandExecutionResponse>;
-    /**
-     * List files at the specified path
-     */
-    listFiles(path?: string): Promise<FilesListResponse>;
-    /**
-     * Create a new file with optional content
-     */
-    createFile(path: string, content?: string): Promise<FileResponse>;
-    /**
-     * Get file metadata (without content)
-     */
-    getFile(path: string): Promise<FileResponse>;
-    /**
-     * Encode a file path for use in URLs
-     * Strips leading slash and encodes each segment separately to preserve path structure
-     */
-    private encodeFilePath;
-    /**
-     * Read file content
-     */
-    readFile(path: string): Promise<string>;
-    /**
-     * Write file content (creates or updates)
-     */
-    writeFile(path: string, content: string): Promise<FileResponse>;
-    /**
-     * Delete a file or directory
-     */
-    deleteFile(path: string): Promise<void>;
-    /**
-     * Check if a file exists (HEAD request)
-     * @returns true if file exists, false otherwise
-     */
-    checkFileExists(path: string): Promise<boolean>;
-    /**
-     * Batch file operations (write or delete multiple files)
-     *
-     * Features:
-     * - Deduplication: Last operation wins per path
-     * - File locking: Prevents race conditions
-     * - Deterministic ordering: Alphabetical path sorting
-     * - Partial failure handling: Returns 207 Multi-Status with per-file results
-     *
-     * @param files - Array of file operations
-     * @returns Results for each file operation
-     *
-     * @example
-     * ```typescript
-     * // Write multiple files
-     * const results = await sandbox.batchWriteFiles([
-     *   { path: '/app/file1.txt', operation: 'write', content: 'Hello' },
-     *   { path: '/app/file2.txt', operation: 'write', content: 'World' },
-     * ]);
-     *
-     * // Mixed operations (write and delete)
-     * const results = await sandbox.batchWriteFiles([
-     *   { path: '/app/new.txt', operation: 'write', content: 'New file' },
-     *   { path: '/app/old.txt', operation: 'delete' },
-     * ]);
-     * ```
-     */
-    batchWriteFiles(files: Array<{
-        path: string;
-        operation: 'write' | 'delete';
-        content?: string;
-    }>): Promise<BatchWriteResponse>;
-    /**
-     * Create a new filesystem overlay from a template directory
-     *
-     * Overlays enable instant sandbox setup by symlinking template files first,
-     * then copying heavy directories (node_modules, .venv, etc.) in the background.
-     *
-     * @param options - Overlay creation options
-     * @param options.source - Absolute path to source directory (template)
-     * @param options.target - Relative path in sandbox where overlay will be mounted
-     * @returns Overlay response with copy status
-     *
-     * @example
-     * ```typescript
-     * // Prefer using sandbox.filesystem.overlay.create() for camelCase response
-     * const overlay = await sandbox.filesystem.overlay.create({
-     *   source: '/templates/nextjs',
-     *   target: 'project',
-     * });
-     * console.log(overlay.copyStatus); // 'pending' | 'in_progress' | 'complete' | 'failed'
-     * ```
-     */
-    createOverlay(options: CreateOverlayOptions): Promise<OverlayResponse>;
-    /**
-     * List all filesystem overlays for the current sandbox
-     * @returns List of overlays with their copy status
-     */
-    listOverlays(): Promise<OverlayListResponse>;
-    /**
-     * Get a specific filesystem overlay by ID
-     *
-     * Useful for polling the copy status of an overlay.
-     *
-     * @param id - Overlay ID
-     * @returns Overlay details with current copy status
-     */
-    getOverlay(id: string): Promise<OverlayResponse>;
-    /**
-     * Delete a filesystem overlay
-     * @param id - Overlay ID
-     */
-    deleteOverlay(id: string): Promise<void>;
-    /**
-     * Create a new persistent terminal session
-     *
-     * Terminal Modes:
-     * - **PTY mode** (pty: true): Interactive shell with real-time WebSocket streaming
-     *   - Use for: Interactive shells, vim/nano, real-time output
-     *   - Methods: write(), resize(), on('output')
-     *
-     * - **Exec mode** (pty: false, default): Command tracking with HTTP polling
-     *   - Use for: CI/CD, automation, command tracking, exit codes
-     *   - Methods: execute(), getCommand(), listCommands(), waitForCommand()
-     *
-     * @example
-     * ```typescript
-     * // PTY mode - Interactive shell
-     * const pty = await sandbox.createTerminal({ pty: true, shell: '/bin/bash' });
-     * pty.on('output', (data) => console.log(data));
-     * pty.write('npm install\n');
-     *
-     * // Exec mode - Command tracking
-     * const exec = await sandbox.createTerminal({ pty: false });
-     * const result = await exec.execute('npm test', { background: true });
-     * const cmd = await sandbox.waitForCommand(exec.getId(), result.data.cmd_id);
-     * console.log(cmd.data.exit_code);
-     *
-     * // Backward compatible - creates PTY terminal
-     * const terminal = await sandbox.createTerminal('/bin/bash');
-     * ```
-     *
-     * @param options - Terminal creation options
-     * @param options.shell - Shell to use (e.g., '/bin/bash', '/bin/sh') - PTY mode only
-     * @param options.encoding - Encoding for terminal I/O: 'raw' (default) or 'base64' (binary-safe)
-     * @param options.pty - Terminal mode: true = PTY (interactive shell), false = exec (command tracking, default)
-     * @returns Terminal instance with event handling
-     */
-    createTerminal(shellOrOptions?: string | {
-        shell?: string;
-        encoding?: 'raw' | 'base64';
-        pty?: boolean;
-    }, encoding?: 'raw' | 'base64'): Promise<TerminalInstance>;
-    /**
-     * List all active terminals (fetches from API)
-     */
-    listTerminals(): Promise<TerminalResponse[]>;
-    /**
-     * Get terminal by ID
-     */
-    getTerminal(id: string): Promise<TerminalInstance>;
-    /**
-     * List all commands executed in a terminal (exec mode only)
-     * @param terminalId - The terminal ID
-     * @returns List of all commands with their status
-     * @throws {Error} If terminal is in PTY mode (command tracking not available)
-     */
-    listCommands(terminalId: string): Promise<CommandsListResponse>;
-    /**
-     * Get details of a specific command execution (exec mode only)
-     * @param terminalId - The terminal ID
-     * @param cmdId - The command ID
-     * @returns Command execution details including stdout, stderr, and exit code
-     * @throws {Error} If terminal is in PTY mode or command not found
-     */
-    getCommand(terminalId: string, cmdId: string): Promise<CommandDetailsResponse>;
-    /**
-     * Wait for a command to complete (HTTP long-polling, exec mode only)
-     * @param terminalId - The terminal ID
-     * @param cmdId - The command ID
-     * @param timeout - Optional timeout in seconds (0 = no timeout)
-     * @returns Command execution details when completed
-     * @throws {Error} If terminal is in PTY mode, command not found, or timeout occurs
-     */
-    waitForCommand(terminalId: string, cmdId: string, timeout?: number): Promise<CommandDetailsResponse>;
-    /**
-     * Wait for a background command to complete using long-polling
-     *
-     * Uses the server's long-polling endpoint with configurable timeout.
-     * The tunnel supports up to 5 minutes (300 seconds) via X-Request-Timeout header.
-     *
-     * @param terminalId - The terminal ID
-     * @param cmdId - The command ID
-     * @param options - Wait options (timeoutSeconds, default 300)
-     * @returns Command result with final status
-     * @throws Error if command fails or times out
-     * @internal
-     */
-    private waitForCommandCompletion;
-    /**
-     * Wait for a command with extended timeout support
-     * Uses X-Request-Timeout header for tunnel timeout configuration
-     * @internal
-     */
-    private waitForCommandWithTimeout;
-    /**
-     * Create a new file watcher with WebSocket integration
-     * @param path - Path to watch
-     * @param options - Watcher options
-     * @param options.includeContent - Include file content in change events
-     * @param options.ignored - Patterns to ignore
-     * @param options.encoding - Encoding for file content: 'raw' (default) or 'base64' (binary-safe)
-     * @returns FileWatcher instance with event handling
-     */
-    createWatcher(path: string, options?: {
-        includeContent?: boolean;
-        ignored?: string[];
-        encoding?: 'raw' | 'base64';
-    }): Promise<FileWatcher>;
-    /**
-     * List all active file watchers (fetches from API)
-     */
-    listWatchers(): Promise<WatchersListResponse>;
-    /**
-     * Get file watcher by ID
-     */
-    getWatcher(id: string): Promise<WatcherResponse>;
-    /**
-     * Start the signal service with WebSocket integration
-     * @returns SignalService instance with event handling
-     */
-    startSignals(): Promise<SignalService>;
-    /**
-     * Get the signal service status (fetches from API)
-     */
-    getSignalStatus(): Promise<SignalServiceResponse>;
-    /**
-     * Emit a port signal
-     */
-    emitPortSignal(port: number, type: 'open' | 'close', url: string): Promise<PortSignalResponse>;
-    /**
-     * Emit a port signal (alternative endpoint using path parameters)
-     */
-    emitPortSignalAlt(port: number, type: 'open' | 'close'): Promise<PortSignalResponse>;
-    /**
-     * Emit an error signal
-     */
-    emitErrorSignal(message: string): Promise<GenericSignalResponse>;
-    /**
-     * Emit a server ready signal
-     */
-    emitServerReadySignal(port: number, url: string): Promise<PortSignalResponse>;
-    /**
-     * Get environment variables from a .env file
-     * @param file - Path to the .env file (relative to sandbox root)
-     */
-    getEnv(file: string): Promise<EnvGetResponse>;
-    /**
-     * Set (merge) environment variables in a .env file
-     * @param file - Path to the .env file (relative to sandbox root)
-     * @param variables - Key-value pairs to set
-     */
-    setEnv(file: string, variables: Record<string, string>): Promise<EnvSetResponse>;
-    /**
-     * Delete environment variables from a .env file
-     * @param file - Path to the .env file (relative to sandbox root)
-     * @param keys - Keys to delete
-     */
-    deleteEnv(file: string, keys: string[]): Promise<EnvDeleteResponse>;
-    /**
-     * Check if an environment file exists (HEAD request)
-     * @param file - Path to the .env file (relative to sandbox root)
-     * @returns true if file exists, false otherwise
-     */
-    checkEnvFile(file: string): Promise<boolean>;
-    /**
-     * List all managed servers
-     */
-    listServers(): Promise<ServersListResponse>;
-    /**
-     * Start a new managed server with optional supervisor settings
-     *
-     * @param options - Server configuration
-     * @param options.slug - Unique server identifier
-     * @param options.install - Install command (optional, runs blocking before start, e.g., "npm install")
-     * @param options.start - Command to start the server (e.g., "npm run dev")
-     * @param options.path - Working directory (optional)
-     * @param options.env_file - Path to .env file relative to path (optional)
-     * @param options.environment - Inline environment variables (merged with env_file if both provided)
-     * @param options.port - Requested port (preallocated before start)
-     * @param options.strict_port - If true, fail instead of auto-incrementing when port is taken
-     * @param options.autostart - Auto-start on daemon boot (default: true)
-     * @param options.overlay - Inline overlay to create before starting
-     * @param options.overlays - Additional overlays to create before starting
-     * @param options.depends_on - Overlay IDs this server depends on
-     * @param options.restart_policy - When to automatically restart: 'never' (default), 'on-failure', 'always'
-     * @param options.max_restarts - Maximum restart attempts, 0 = unlimited (default: 0)
-     * @param options.restart_delay_ms - Delay between restart attempts in milliseconds (default: 1000)
-     * @param options.stop_timeout_ms - Graceful shutdown timeout in milliseconds (default: 10000)
-     *
-     * @example
-     * ```typescript
-     * // Basic server
-     * await sandbox.startServer({
-     *   slug: 'web',
-     *   start: 'npm run dev',
-     *   path: '/app',
-     * });
-     *
-     * // With install command and supervisor settings
-     * await sandbox.startServer({
-     *   slug: 'api',
-     *   install: 'npm install',
-     *   start: 'node server.js',
-     *   path: '/app',
-     *   environment: { NODE_ENV: 'production', PORT: '3000' },
-     *   restart_policy: 'on-failure',
-     *   max_restarts: 5,
-     *   restart_delay_ms: 2000,
-     *   stop_timeout_ms: 5000,
-     * });
-     *
-     * // With inline overlay dependencies
-     * await sandbox.startServer({
-     *   slug: 'web',
-     *   start: 'npm run dev',
-     *   path: '/app',
-     *   overlay: {
-     *     source: '/templates/nextjs',
-     *     target: 'app',
-     *     strategy: 'smart',
-     *   },
-     * });
-     * ```
-     */
-    startServer(options: {
-        slug: string;
-        install?: string;
-        start: string;
-        path?: string;
-        env_file?: string;
-        environment?: Record<string, string>;
-        port?: number;
-        strict_port?: boolean;
-        autostart?: boolean;
-        overlay?: Omit<CreateOverlayOptions, 'waitForCompletion'>;
-        overlays?: Array<Omit<CreateOverlayOptions, 'waitForCompletion'>>;
-        depends_on?: string[];
-        restart_policy?: RestartPolicy;
-        max_restarts?: number;
-        restart_delay_ms?: number;
-        stop_timeout_ms?: number;
-    }): Promise<ServerResponse>;
-    /**
-     * Get information about a specific server
-     * @param slug - Server slug
-     */
-    getServer(slug: string): Promise<ServerResponse>;
-    /**
-     * Stop a managed server (non-destructive)
-     * @param slug - Server slug
-     */
-    stopServer(slug: string): Promise<ServerStopResponse>;
-    /**
-     * Delete a managed server configuration
-     * @param slug - Server slug
-     */
-    deleteServer(slug: string): Promise<void>;
-    /**
-     * Restart a managed server
-     * @param slug - Server slug
-     */
-    restartServer(slug: string): Promise<ServerResponse>;
-    /**
-     * Get logs for a managed server
-     * @param slug - Server slug
-     * @param options - Options for log retrieval
-     */
-    getServerLogs(slug: string, options?: {
-        stream?: ServerLogStream;
-    }): Promise<ServerLogsResponse>;
-    /**
-     * Update server status (internal use)
-     * @param slug - Server slug
-     * @param status - New server status
-     */
-    updateServerStatus(slug: string, status: ServerStatus): Promise<ServerStatusUpdateResponse>;
-    /**
-     * Get readiness status for autostarted servers and overlays
-     */
-    ready(): Promise<ReadyResponse>;
-    /**
-     * Create a new sandbox environment
-     */
-    createSandbox(options?: CreateSandboxOptions$1): Promise<SandboxInfo>;
-    /**
-     * List all sandboxes
-     */
-    listSandboxes(): Promise<SandboxesListResponse>;
-    /**
-     * Get sandbox details
-     */
-    getSandbox(subdomain: string): Promise<SandboxInfo>;
-    /**
-     * Delete a sandbox
-     */
-    deleteSandbox(subdomain: string, deleteFiles?: boolean): Promise<void>;
-    /**
-     * Get WebSocket URL for real-time communication
-     * @private
-     */
-    private getWebSocketUrl;
-    /**
-     * Execute code in the sandbox (convenience method)
-     *
-     * Delegates to sandbox.run.code() - prefer using that directly for new code.
-     *
-     * @param code - The code to execute
-     * @param language - Programming language (auto-detected if not specified)
-     * @returns Code execution result
-     */
-    runCode(code: string, language?: 'node' | 'python'): Promise<{
-        output: string;
-        exitCode: number;
-        language: string;
-    }>;
-    /**
-     * Execute shell command in the sandbox
-     *
-     * Sends clean command string to server - no preprocessing or shell wrapping.
-     * The server handles shell invocation, working directory, and backgrounding.
-     *
-     * @param command - The command to execute (raw string, e.g., "npm install")
-     * @param options - Execution options
-     * @param options.background - Run in background (server uses goroutines)
-     * @param options.cwd - Working directory (server uses cmd.Dir)
-     * @param options.env - Environment variables (server uses cmd.Env)
-     * @param options.onStdout - Callback for streaming stdout data
-     * @param options.onStderr - Callback for streaming stderr data
-     * @returns Command execution result
-     *
-     * @example
-     * ```typescript
-     * // Simple command
-     * await sandbox.runCommand('ls -la')
-     *
-     * // With working directory
-     * await sandbox.runCommand('npm install', { cwd: '/app' })
-     *
-     * // Background with env vars
-     * await sandbox.runCommand('node server.js', {
-     *   background: true,
-     *   env: { PORT: '3000' }
-     * })
-     *
-     * // With streaming output
-     * await sandbox.runCommand('npm install', {
-     *   onStdout: (data) => console.log(data),
-     *   onStderr: (data) => console.error(data),
-     * })
-     * ```
-     */
-    runCommand(command: string, options?: {
-        background?: boolean;
-        cwd?: string;
-        env?: Record<string, string>;
-        onStdout?: (data: string) => void;
-        onStderr?: (data: string) => void;
-    }): Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-        durationMs: number;
-    }>;
-    /**
-     * Get server information
-     * Returns details about the server including auth status, main subdomain, sandbox count, and version
-     */
-    getServerInfo(): Promise<InfoResponse>;
-    /**
-     * Get sandbox information
-     */
-    getInfo(): Promise<{
-        id: string;
-        provider: string;
-        runtime: 'node' | 'python';
-        status: 'running' | 'stopped' | 'error';
-        createdAt: Date;
-        timeout: number;
-        metadata?: Record<string, any>;
-    }>;
-    /**
-     * Get URL for accessing sandbox on a specific port (Sandbox interface method)
-     */
-    getUrl(options: {
-        port: number;
-        protocol?: string;
-    }): Promise<string>;
-    /**
-     * Get provider instance
-     * Note: Not available when using Sandbox directly - only available through gateway provider
-     */
-    getProvider(): never;
-    /**
-     * Get native provider instance
-     * Returns the Sandbox itself since this IS the sandbox implementation
-     */
-    getInstance(): this;
-    /**
-     * Destroy the sandbox (Sandbox interface method)
-     *
-     * If a destroyHandler was provided (e.g., from gateway), calls it to destroy
-     * the sandbox on the backend. Otherwise, only disconnects the WebSocket.
-     */
-    destroy(): Promise<void>;
-    /**
-     * Disconnect WebSocket
-     *
-     * Note: This only disconnects the WebSocket. Terminals, watchers, and signals
-     * will continue running on the server until explicitly destroyed via their
-     * respective destroy() methods or the DELETE endpoints.
-     */
-    disconnect(): Promise<void>;
-}
-
-/**
- * Helpers for building setup payloads used by COMPUTESDK_SETUP_B64 or POST /sandboxes
- */
-
-type SetupOverlayConfig = Omit<CreateOverlayOptions, 'waitForCompletion'>;
-interface SetupPayload {
-    overlays?: SetupOverlayConfig[];
-    servers?: ServerStartOptions[];
-}
-interface BuildSetupPayloadOptions {
-    overlays?: CreateOverlayOptions[];
-    servers?: ServerStartOptions[];
-}
-/**
- * Build a setup payload for COMPUTESDK_SETUP_B64 or POST /sandboxes
- */
-declare const buildSetupPayload: (options: BuildSetupPayloadOptions) => SetupPayload;
-/**
- * Build and base64-encode a setup payload for COMPUTESDK_SETUP_B64
- */
-declare const encodeSetupPayload: (options: BuildSetupPayloadOptions) => string;
-
-/**
- * Unified Provider Configuration
- *
- * Single source of truth for all provider auth requirements.
- * Used by both explicit mode (computesdk) and magic mode (workbench).
- */
-/**
- * Provider auth requirements
- *
- * Structure: { provider: [[option1_vars], [option2_vars], ...] }
- * - Outer array: OR conditions (any option can satisfy auth)
- * - Inner arrays: AND conditions (all vars in option must be present)
- *
- * Example: vercel: [['OIDC_TOKEN'], ['TOKEN', 'TEAM_ID', 'PROJECT_ID']]
- *   -> Ready if OIDC_TOKEN is set, OR if all three traditional vars are set
- */
-declare const PROVIDER_AUTH: {
-    readonly e2b: readonly [readonly ["E2B_API_KEY"]];
-    readonly modal: readonly [readonly ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]];
-    readonly railway: readonly [readonly ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"]];
-    readonly render: readonly [readonly ["RENDER_API_KEY", "RENDER_OWNER_ID"]];
-    readonly daytona: readonly [readonly ["DAYTONA_API_KEY"]];
-    readonly vercel: readonly [readonly ["VERCEL_OIDC_TOKEN"], readonly ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"]];
-    readonly runloop: readonly [readonly ["RUNLOOP_API_KEY"]];
-    readonly cloudflare: readonly [readonly ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]];
-    readonly codesandbox: readonly [readonly ["CSB_API_KEY"]];
-    readonly blaxel: readonly [readonly ["BL_API_KEY", "BL_WORKSPACE"]];
-    readonly namespace: readonly [readonly ["NSC_TOKEN"]];
-};
-/**
- * All supported provider names (excluding gateway which is special)
- */
-declare const PROVIDER_NAMES: ProviderName[];
-/**
- * Provider name type derived from PROVIDER_AUTH
- */
-type ProviderName = keyof typeof PROVIDER_AUTH;
-/**
- * Header mapping for each provider
- * Maps config field names to HTTP header names
- */
-declare const PROVIDER_HEADERS: Record<ProviderName, Record<string, string>>;
-/**
- * Environment variable to config field mapping for each provider
- */
-declare const PROVIDER_ENV_MAP: Record<ProviderName, Record<string, string>>;
-/**
- * Dashboard URLs for each provider (for error messages)
- */
-declare const PROVIDER_DASHBOARD_URLS: Record<ProviderName, string>;
-/**
- * Check if a provider name is valid
- */
-declare function isValidProvider(name: string): name is ProviderName;
-/**
- * Build headers from provider config
- */
-declare function buildProviderHeaders(provider: ProviderName, config: Record<string, string | undefined>): Record<string, string>;
-/**
- * Get provider config from environment variables
- */
-declare function getProviderConfigFromEnv(provider: ProviderName): Record<string, string>;
-/**
- * Check if provider has complete auth from environment
- */
-declare function isProviderAuthComplete(provider: ProviderName): boolean;
-/**
- * Get missing env vars for a provider (returns the option closest to completion)
- */
-declare function getMissingEnvVars(provider: ProviderName): string[];
-
-/**
- * Compute API - Gateway HTTP Implementation
- *
- * Provides the unified compute.* API using direct HTTP calls to the gateway.
- * The `compute` export works as both a singleton and a callable function:
- *
- * - Singleton: `compute.sandbox.create()` (auto-detects from env vars)
- * - Callable: `compute({ provider: 'e2b', ... }).sandbox.create()` (explicit config)
- */
-
-/**
- * Explicit compute configuration for callable mode
- */
-interface ExplicitComputeConfig {
-    /** Provider name to use */
-    provider: ProviderName;
-    /**
-     * ComputeSDK API key (required for gateway mode)
-     * @deprecated Use `computesdkApiKey` for clarity
-     */
-    apiKey?: string;
-    /** ComputeSDK API key (required for gateway mode) */
-    computesdkApiKey?: string;
-    /** Optional gateway URL override */
-    gatewayUrl?: string;
-    /** HTTP request timeout for gateway calls in milliseconds */
-    requestTimeoutMs?: number;
-    /**
-     * WebSocket implementation for environments without native WebSocket support.
-     * In Node.js < 22, pass the 'ws' package: `import WebSocket from 'ws'`
-     */
-    WebSocket?: WebSocketConstructor;
-    /** Provider-specific configurations */
-    e2b?: {
-        apiKey?: string;
-        projectId?: string;
-        templateId?: string;
-    };
-    modal?: {
-        tokenId?: string;
-        tokenSecret?: string;
-    };
-    railway?: {
-        apiToken?: string;
-        projectId?: string;
-        environmentId?: string;
-    };
-    render?: {
-        apiKey?: string;
-        serviceId?: string;
-    };
-    daytona?: {
-        apiKey?: string;
-    };
-    vercel?: {
-        oidcToken?: string;
-        token?: string;
-        teamId?: string;
-        projectId?: string;
-    };
-    runloop?: {
-        apiKey?: string;
-    };
-    cloudflare?: {
-        apiToken?: string;
-        accountId?: string;
-    };
-    codesandbox?: {
-        apiKey?: string;
-    };
-    blaxel?: {
-        apiKey?: string;
-        workspace?: string;
-    };
-    namespace?: {
-        token?: string;
-    };
-}
-/**
- * Options for creating a sandbox via the gateway
- *
- * Note: Runtime is determined by the provider, not specified at creation time.
- * Use sandbox.runCode(code, runtime) to specify which runtime to use for execution.
- */
-interface CreateSandboxOptions {
-    timeout?: number;
-    templateId?: string;
-    metadata?: Record<string, any>;
-    envs?: Record<string, string>;
-    name?: string;
-    namespace?: string;
-    directory?: string;
-    overlays?: SetupOverlayConfig[];
-    servers?: ServerStartOptions[];
-    /** Docker image to use for the sandbox (for infrastructure providers like Railway) */
-    image?: string;
-    /** Provider-specific snapshot to create from (e.g., Vercel snapshots) */
-    snapshotId?: string;
-}
-/**
- * Options for finding or creating a named sandbox
- */
-interface FindOrCreateSandboxOptions extends CreateSandboxOptions {
-    name: string;
-    namespace?: string;
-}
-/**
- * Options for finding a named sandbox
- */
-interface FindSandboxOptions {
-    name: string;
-    namespace?: string;
-}
-/**
- * Options for extending sandbox timeout
- */
-interface ExtendTimeoutOptions {
-    duration?: number;
-}
-/**
- * Compute singleton implementation
- */
-declare class ComputeManager {
-    private config;
-    private autoConfigured;
-    /**
-     * Lazy auto-configure from environment if not explicitly configured
-     */
-    private ensureConfigured;
-    /**
-     * Get gateway config, throwing if not configured
-     */
-    private getGatewayConfig;
-    /**
-     * Explicitly configure the compute singleton
-     *
-     * @example
-     * ```typescript
-     * import { compute } from 'computesdk';
-     *
-     * compute.setConfig({
-     *   provider: 'e2b',
-     *   apiKey: 'computesdk_xxx',
-     *   e2b: { apiKey: 'e2b_xxx' }
-     * });
-     *
-     * const sandbox = await compute.sandbox.create();
-     * ```
-     */
-    setConfig(config: ExplicitComputeConfig): void;
-    sandbox: {
-        /**
-         * Create a new sandbox
-         *
-         * @example
-         * ```typescript
-         * const sandbox = await compute.sandbox.create({
-         *   directory: '/custom/path',
-         *   overlays: [
-         *     {
-         *       source: '/templates/nextjs',
-         *       target: 'app',
-         *       strategy: 'smart',
-         *     },
-         *   ],
-         *   servers: [
-         *     {
-         *       slug: 'web',
-         *       start: 'npm run dev',
-         *       path: '/app',
-         *     },
-         *   ],
-         * });
-         * ```
-         */
-        create: (options?: CreateSandboxOptions) => Promise<Sandbox>;
-        /**
-         * Get an existing sandbox by ID
-         */
-        getById: (sandboxId: string) => Promise<Sandbox | null>;
-        /**
-         * List all active sandboxes
-         */
-        list: () => Promise<Sandbox[]>;
-        /**
-         * Destroy a sandbox
-         */
-        destroy: (sandboxId: string) => Promise<void>;
-        /**
-         * Find existing or create new sandbox by (namespace, name)
-         */
-        findOrCreate: (options: FindOrCreateSandboxOptions) => Promise<Sandbox>;
-        /**
-         * Find existing sandbox by (namespace, name) without creating
-         */
-        find: (options: FindSandboxOptions) => Promise<Sandbox | null>;
-        /**
-         * Extend sandbox timeout/expiration
-         */
-        extendTimeout: (sandboxId: string, options?: ExtendTimeoutOptions) => Promise<void>;
-    };
-}
-/**
- * Callable compute interface - dual nature as both singleton and factory
- *
- * This interface represents the compute export's two modes:
- * 1. As a ComputeManager singleton (accessed via properties like compute.sandbox)
- * 2. As a factory function (called with config to create new instances)
- */
-interface CallableCompute extends ComputeManager {
-    /** Create a new compute instance with explicit configuration */
-    (config: ExplicitComputeConfig): ComputeManager;
-    /** Explicitly configure the singleton */
-    setConfig(config: ExplicitComputeConfig): void;
-}
-/**
- * Callable compute - works as both singleton and factory function
- *
- * @example
- * ```typescript
- * import { compute } from 'computesdk';
- *
- * // Singleton mode (auto-detects from env vars)
- * const sandbox1 = await compute.sandbox.create();
- *
- * // Callable mode (explicit config)
- * const sandbox2 = await compute({
- *   provider: 'e2b',
- *   apiKey: 'computesdk_xxx',
- *   e2b: { apiKey: 'e2b_xxx' }
- * }).sandbox.create();
- * ```
- */
 declare const compute: CallableCompute;
 
-/**
- * Auto-Detection Module
- *
- * Automatically detects gateway mode and provider from environment variables.
- * Enables zero-config usage of ComputeSDK.
- */
-
-/**
- * Check if gateway mode is enabled
- * Gateway mode requires COMPUTESDK_API_KEY to be set
- */
-declare function isGatewayModeEnabled(): boolean;
-/**
- * Detect which provider to use from environment variables
- *
- * Detection order:
- * 1. Check for explicit COMPUTESDK_PROVIDER override
- * 2. Auto-detect based on PROVIDER_PRIORITY order
- *
- * @returns Provider name or null if none detected
- */
-declare function detectProvider(): string | null;
-/**
- * Build provider-specific headers from environment variables
- * These headers are passed through to the gateway
- */
-declare function getProviderHeaders(provider: string): Record<string, string>;
-/**
- * Gateway configuration object
- */
-interface GatewayConfig {
-    apiKey: string;
-    gatewayUrl: string;
-    provider: string;
-    providerHeaders: Record<string, string>;
-    requestTimeoutMs?: number;
-    WebSocket?: WebSocketConstructor;
-}
-/**
- * Main auto-configuration function
- * Returns gateway configuration or null if auto-detection not possible
- *
- * @throws Error if COMPUTESDK_API_KEY is set but no provider detected
- */
-declare function autoConfigureCompute(): GatewayConfig | null;
-
-/**
- * ComputeSDK Constants
- *
- * Default configuration values and provider definitions
- */
-
-/**
- * Default gateway URL for sandbox lifecycle operations
- */
-declare const GATEWAY_URL = "https://gateway.computesdk.com";
-/**
- * Provider detection priority order
- * When multiple provider credentials are detected, use the first one in this list
- */
-declare const PROVIDER_PRIORITY: readonly ["e2b", "railway", "render", "daytona", "modal", "runloop", "vercel", "cloudflare", "codesandbox", "blaxel", "namespace"];
-/**
- * Required environment variables for each provider
- * @deprecated Use PROVIDER_AUTH from provider-config instead
- */
-declare const PROVIDER_ENV_VARS: {
-    readonly e2b: readonly ["E2B_API_KEY"];
-    readonly railway: readonly ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"];
-    readonly render: readonly ["RENDER_API_KEY", "RENDER_OWNER_ID"];
-    readonly daytona: readonly ["DAYTONA_API_KEY"];
-    readonly modal: readonly ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"];
-    readonly runloop: readonly ["RUNLOOP_API_KEY"];
-    readonly vercel: readonly ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"];
-    readonly cloudflare: readonly ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"];
-    readonly codesandbox: readonly ["CSB_API_KEY"];
-    readonly blaxel: readonly ["BL_API_KEY", "BL_WORKSPACE"];
-    readonly namespace: readonly ["NSC_TOKEN"];
-};
-
-export { type CallableCompute, type CodeResult$1 as CodeResult, CommandExitError, type CommandResult$1 as CommandResult, type CreateSandboxOptions$1 as CreateSandboxOptions, type ExplicitComputeConfig, type FileEntry, FileWatcher, GATEWAY_URL, Sandbox as GatewaySandbox, MessageType, PROVIDER_AUTH, PROVIDER_DASHBOARD_URLS, PROVIDER_ENV_MAP, PROVIDER_ENV_VARS, PROVIDER_HEADERS, PROVIDER_NAMES, PROVIDER_PRIORITY, type ProviderName, type ProviderSandboxInfo, type RunCommandOptions, type Runtime, Sandbox, type SandboxFileSystem, type SandboxInfo$1 as SandboxInfo, type Sandbox$1 as SandboxInterface, type SandboxStatus, type SetupOverlayConfig, type SetupPayload, SignalService, TerminalInstance, type WebSocketConstructor, autoConfigureCompute, buildProviderHeaders, buildSetupPayload, compute, decodeBinaryMessage, detectProvider, encodeBinaryMessage, encodeSetupPayload, getMissingEnvVars, getProviderConfigFromEnv, getProviderHeaders, isCommandExitError, isGatewayModeEnabled, isProviderAuthComplete, isValidProvider };
+export { type CallableCompute, type CodeResult, type CommandResult, type CreateSandboxOptions$1 as CreateSandboxOptions, type ExplicitComputeConfig, type FileEntry, type RunCommandOptions, type SandboxFileSystem, type SandboxInfo, type Sandbox as SandboxInterface, type Snapshot, compute };