computesdk 1.10.0 → 1.10.2

package/dist/index.d.ts

@@ -1,97 +1,2963 @@
-import { Runtime, CodeResult, RunCommandOptions, CommandResult, ProviderSandboxInfo, SandboxFileSystem, CreateSandboxOptions, FileEntry, Sandbox } from '@computesdk/client';
-export { CodeLanguage, CodeResult, CodeRunOptions, CommandExitError, CommandResult, CommandRunOptions, CreateSandboxOptions, FileEntry, RunCommandOptions, Runtime, Sandbox, SandboxConfig, SandboxFileSystem, SandboxStatus, isCommandExitError } from '@computesdk/client';
-
-/**
- * Information about a sandbox (provider-agnostic)
- * @see ProviderSandboxInfo in @computesdk/client for the canonical definition
- */
-type SandboxInfo = ProviderSandboxInfo;
-
 /**
- * Provider sandbox interface - what external providers (e2b, railway, etc.) return
+ * 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.
  *
- * This is the base interface that all provider sandboxes must implement.
- * The gateway provider returns the full Sandbox from @computesdk/client which
- * extends this with ComputeClient features (terminals, watchers, signals).
+ * **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 Provider implementation
+ * @example Minimal implementation
  * ```typescript
- * // In @computesdk/e2b
- * const e2bProvider = createProvider<E2BSandbox, E2BConfig>({
- *   name: 'e2b',
- *   methods: {
- *     sandbox: {
- *       create: async (config, options) => {
- *         const sandbox = await E2BSandbox.create({ ... });
- *         return { sandbox, sandboxId: sandbox.id };
- *       },
- *       // ... other methods
- *     }
- *   }
- * });
+ * 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
+ * }
  * ```
  */
-interface ProviderSandbox<TSandbox = any> {
+/**
+ * Supported runtime environments
+ */
+type Runtime = 'node' | 'python' | 'deno' | 'bun';
+/**
+ * Code execution result
+ */
+interface CodeResult$1 {
+    output: string;
+    exitCode: number;
+    language: string;
+}
+/**
+ * Command execution result
+ */
+interface CommandResult$1 {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    durationMs: number;
+}
+/**
+ * Sandbox information
+ */
+interface SandboxInfo$1 {
+    /** 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 */
+    createdAt: Date;
+    /** Execution timeout in milliseconds */
+    timeout: number;
+    /** Additional provider-specific metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * File entry from directory listing
+ */
+interface FileEntry {
+    name: string;
+    type: 'file' | 'directory';
+    size?: number;
+    modified?: Date;
+}
+/**
+ * Options for running a command
+ */
+interface RunCommandOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    background?: boolean;
+}
+/**
+ * Filesystem operations interface
+ */
+interface SandboxFileSystem {
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    readdir(path: string): Promise<FileEntry[]>;
+    mkdir(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    remove(path: string): Promise<void>;
+}
+/**
+ * Options for creating a sandbox
+ *
+ * Providers can extend this with additional properties specific to their implementation
+ */
+interface CreateSandboxOptions$1 {
+    runtime?: Runtime;
+    timeout?: number;
+    templateId?: string;
+    metadata?: Record<string, any>;
+    envs?: Record<string, string>;
+    name?: string;
+    namespace?: string;
+    [key: string]: any;
+}
+/**
+ * Universal Sandbox Interface
+ *
+ * All ComputeSDK sandboxes implement this interface.
+ * Core methods are required, advanced features are optional.
+ *
+ * Note: Implementations may use slightly different types for return values
+ * as long as they are structurally compatible. For example, getInfo() might
+ * return additional fields beyond the base SandboxInfo.
+ */
+interface Sandbox$1 {
     /** Unique identifier for the sandbox */
     readonly sandboxId: string;
-    /** Provider that created this sandbox */
+    /** Provider name (e2b, railway, modal, gateway, etc.) */
     readonly provider: string;
     /** Execute code in the sandbox */
-    runCode(code: string, runtime?: Runtime): Promise<CodeResult>;
+    runCode(code: string, runtime?: Runtime): Promise<CodeResult$1>;
     /** Execute shell commands */
-    runCommand(commandOrArray: string | [string, ...string[]], argsOrOptions?: string[] | RunCommandOptions, maybeOptions?: RunCommandOptions): Promise<CommandResult>;
+    runCommand(commandOrArray: string | [string, ...string[]], argsOrOptions?: string[] | RunCommandOptions, maybeOptions?: RunCommandOptions): Promise<CommandResult$1>;
     /** Get information about the sandbox */
-    getInfo(): Promise<SandboxInfo>;
+    getInfo(): Promise<SandboxInfo$1>;
     /** Get URL for accessing the sandbox on a specific port */
     getUrl(options: {
         port: number;
         protocol?: string;
     }): Promise<string>;
-    /** Get the provider instance that created this sandbox */
-    getProvider(): Provider<TSandbox>;
-    /** Get the native provider sandbox instance with proper typing */
-    getInstance(): TSandbox;
-    /** Kill the sandbox */
-    kill(): Promise<void>;
-    /** Destroy the sandbox and clean up resources */
-    destroy(): Promise<void>;
-    /** File system operations */
-    readonly filesystem: SandboxFileSystem;
+    /** Destroy the sandbox and clean up resources */
+    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
+ */
+interface TerminalOutputMessage {
+    type: 'terminal:output';
+    channel: string;
+    data: {
+        output: string;
+        encoding?: 'raw' | 'base64';
+    };
+}
+/**
+ * Terminal destroyed notification
+ */
+interface TerminalDestroyedMessage {
+    type: 'terminal:destroyed';
+    channel: string;
+    data: {
+        id: string;
+    };
+}
+/**
+ * Terminal error notification
+ */
+interface TerminalErrorMessage {
+    type: 'terminal:error';
+    channel: string;
+    data: {
+        error: string;
+    };
+}
+/**
+ * File watcher created notification
+ */
+interface WatcherCreatedMessage {
+    type: 'watcher:created';
+    channel: string;
+    data: {
+        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';
+    };
+}
+/**
+ * File watcher destroyed notification
+ */
+interface WatcherDestroyedMessage {
+    type: 'watcher:destroyed';
+    channel: string;
+    data: {
+        id: string;
+    };
+}
+/**
+ * System signal event
+ */
+interface SignalMessage {
+    type: 'signal';
+    channel: 'signals';
+    data: {
+        signal: 'port' | 'error' | 'server-ready';
+        port?: number;
+        url?: string;
+        message?: string;
+    };
+}
+/**
+ * Sandbox created notification
+ */
+interface SandboxCreatedMessage {
+    type: 'sandbox.created';
+    data: {
+        subdomain: string;
+        url: string;
+    };
+}
+/**
+ * Sandbox deleted notification
+ */
+interface SandboxDeletedMessage {
+    type: 'sandbox.deleted';
+    data: {
+        subdomain: string;
+    };
+}
+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;
+    /**
+     * 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: '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>;
+}
+
+/**
+ * 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<TerminalResponse>;
+        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 response
+     */
+    retrieve(id: string): Promise<TerminalResponse>;
+    /**
+     * Destroy a terminal by ID
+     * @param id - The terminal ID
+     */
+    destroy(id: string): Promise<void>;
+}
+
+/**
+ * Server - Resource namespace for managed server operations
+ */
+
+/**
+ * Server resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Start a new server
+ * const server = await sandbox.server.start({
+ *   slug: 'api',
+ *   command: 'npm start',
+ *   path: '/app',
+ * });
+ *
+ * // List all servers
+ * const servers = await sandbox.server.list();
+ *
+ * // Retrieve a specific server
+ * const server = await sandbox.server.retrieve('api');
+ *
+ * // Stop a server
+ * await sandbox.server.stop('api');
+ *
+ * // Restart a server
+ * await sandbox.server.restart('api');
+ * ```
+ */
+declare class Server {
+    private startHandler;
+    private listHandler;
+    private retrieveHandler;
+    private stopHandler;
+    private restartHandler;
+    private updateStatusHandler;
+    constructor(handlers: {
+        start: (options: {
+            slug: string;
+            command: string;
+            path?: string;
+            env_file?: string;
+        }) => Promise<ServerResponse>;
+        list: () => Promise<ServersListResponse>;
+        retrieve: (slug: string) => Promise<ServerResponse>;
+        stop: (slug: string) => Promise<ServerStopResponse | void>;
+        restart: (slug: string) => Promise<ServerResponse>;
+        updateStatus: (slug: string, status: ServerStatus) => Promise<void>;
+    });
+    /**
+     * Start a new managed server
+     * @param options - Server configuration
+     * @param options.slug - Unique server slug (URL-safe identifier)
+     * @param options.command - Command to start the server
+     * @param options.path - Working directory (optional)
+     * @param options.env_file - Path to env file (optional)
+     * @returns Server info
+     */
+    start(options: {
+        slug: string;
+        command: string;
+        path?: string;
+        env_file?: string;
+    }): 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
+     * @param slug - The server slug
+     */
+    stop(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>;
+}
+
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * Command execution options
+ */
+interface CommandRunOptions {
+    /** Shell to use (optional) */
+    shell?: string;
+    /** Run in background (optional) */
+    background?: boolean;
+}
+/**
+ * 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);
+ * ```
+ */
+declare class Run {
+    private codeHandler;
+    private commandHandler;
+    constructor(handlers: {
+        code: (code: string, options?: CodeRunOptions) => Promise<CodeResult>;
+        command: (command: string, options?: CommandRunOptions) => 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)
+     * @returns Command execution result with stdout, stderr, exit code, and duration
+     */
+    command(command: string, options?: CommandRunOptions): Promise<CommandResult>;
+}
+
+/**
+ * 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();
+ * 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: () => 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(): 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;
+
+/**
+ * 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;
+
+/**
+ * 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)
+ */
+
+/**
+ * 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>;
+}
+/**
+ * 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
+ */
+interface CommandExecutionResponse {
+    message: string;
+    data: {
+        terminal_id?: string;
+        cmd_id?: string;
+        command: string;
+        output?: string;
+        stdout: string;
+        stderr: string;
+        exit_code?: number;
+        duration_ms?: number;
+        status?: 'running' | 'completed' | 'failed';
+        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;
+    };
+}
+/**
+ * Run command response (POST /run/command)
+ */
+interface RunCommandResponse {
+    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';
+    };
+}
+/**
+ * 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;
+}
+/**
+ * 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
+ */
+type ServerStatus = 'starting' | 'running' | 'ready' | 'failed' | 'stopped';
+/**
+ * Server information
+ */
+interface ServerInfo {
+    slug: string;
+    command: string;
+    path: string;
+    original_path?: string;
+    env_file?: string;
+    port?: number;
+    url?: string;
+    status: ServerStatus;
+    pid?: number;
+    terminal_id?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * 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 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: SandboxFileSystem;
+    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;
+    constructor(config: SandboxConfig);
+    /**
+     * Get or create internal WebSocket manager
+     */
+    private ensureWebSocket;
+    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 shell command (POST /run/command)
+     *
+     * @param options - Command options
+     * @param options.command - The command to execute
+     * @param options.shell - Shell to use (optional)
+     * @param options.background - Run in background (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;
+    }): Promise<RunCommandResponse>;
+    /**
+     * 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>;
+    /**
+     * 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 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<TerminalResponse>;
+    /**
+     * 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>;
+    /**
+     * 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
+     * @param options - Server configuration
+     */
+    startServer(options: {
+        slug: string;
+        command: string;
+        path?: string;
+        env_file?: string;
+    }): Promise<ServerResponse>;
+    /**
+     * Get information about a specific server
+     * @param slug - Server slug
+     */
+    getServer(slug: string): Promise<ServerResponse>;
+    /**
+     * Stop a managed server
+     * @param slug - Server slug
+     */
+    stopServer(slug: string): Promise<ServerStopResponse>;
+    /**
+     * Restart a managed server
+     * @param slug - Server slug
+     */
+    restartServer(slug: string): Promise<ServerResponse>;
+    /**
+     * Update server status (internal use)
+     * @param slug - Server slug
+     * @param status - New server status
+     */
+    updateServerStatus(slug: string, status: ServerStatus): Promise<ServerStatusUpdateResponse>;
+    /**
+     * Create a new sandbox environment
+     */
+    createSandbox(): 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 (convenience method)
+     *
+     * Delegates to sandbox.run.command() - prefer using that directly for new code.
+     *
+     * @param command - The command to execute (string or array form)
+     * @param argsOrOptions - Arguments array or options object
+     * @param maybeOptions - Options when using (command, args, options) form
+     * @returns Command execution result
+     */
+    runCommand(commandOrArray: string | [string, ...string[]], argsOrOptions?: string[] | {
+        background?: boolean;
+        cwd?: string;
+    }, maybeOptions?: {
+        background?: boolean;
+        cwd?: string;
+    }): 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>;
     /**
-     * Create an interactive terminal (PTY or exec mode)
-     * @optional Available when using gateway provider
+     * Get provider instance
+     * Note: Not available when using Sandbox directly - only available through gateway provider
      */
-    createTerminal?(options?: {
-        shell?: string;
-        pty?: boolean;
-        encoding?: 'utf8' | 'binary';
-    }): Promise<any>;
+    getProvider(): never;
     /**
-     * Create a file system watcher
-     * @optional Available when using gateway provider
+     * Get native provider instance
+     * Returns the Sandbox itself since this IS the sandbox implementation
      */
-    createWatcher?(path: string, options?: {
-        recursive?: boolean;
-        includeContent?: boolean;
-    }): Promise<any>;
+    getInstance(): this;
     /**
-     * Send a signal to a process
-     * @optional Available when using gateway provider
+     * Destroy the sandbox (Sandbox interface method)
      */
-    sendSignal?(pid: number, signal: string): Promise<void>;
-}
-/**
- * Extract the sandbox type from a provider using generic inference
- */
-type ExtractProviderSandboxType<TProvider> = TProvider extends Provider<infer TSandbox, any, any> ? TSandbox : any;
-/**
- * Typed provider sandbox interface that preserves the provider's native instance type
- */
-interface TypedProviderSandbox<TProvider extends Provider<any, any, any>> extends Omit<ProviderSandbox<ExtractProviderSandboxType<TProvider>>, 'getProvider'> {
-    /** Get the provider instance that created this sandbox with proper typing */
-    getProvider(): TProvider;
-    /** Get the native provider sandbox instance with proper typing */
-    getInstance(): ExtractProviderSandboxType<TProvider>;
+    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>;
 }
 
 /**
@@ -164,342 +3030,173 @@ declare function isProviderAuthComplete(provider: ProviderName): boolean;
 declare function getMissingEnvVars(provider: ProviderName): string[];
 
 /**
- * Common options for creating snapshots
- */
-interface CreateSnapshotOptions {
-    /** Optional name for the snapshot */
-    name?: string;
-    /** Optional metadata for the snapshot */
-    metadata?: Record<string, string>;
-}
-/**
- * Common options for listing snapshots
+ * 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)
  */
-interface ListSnapshotsOptions {
-    /** Filter by sandbox ID */
-    sandboxId?: string;
-    /** Limit the number of results */
-    limit?: number;
-}
+
 /**
- * Common options for creating templates/blueprints
+ * Explicit compute configuration for callable mode
  */
-interface CreateTemplateOptions {
-    /** Name of the template */
-    name: string;
-    /** Optional description */
-    description?: string;
-    /** Optional metadata for the template */
-    metadata?: Record<string, string>;
+interface ExplicitComputeConfig {
+    /** Provider name to use */
+    provider: ProviderName;
+    /** ComputeSDK API key (required for gateway mode) */
+    apiKey: string;
+    /** Optional gateway URL override */
+    gatewayUrl?: string;
+    /** Provider-specific configurations */
+    e2b?: {
+        apiKey?: string;
+        projectId?: string;
+        templateId?: string;
+    };
+    modal?: {
+        tokenId?: string;
+        tokenSecret?: string;
+    };
+    railway?: {
+        apiToken?: string;
+        projectId?: string;
+        environmentId?: 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;
+    };
 }
 /**
- * Common options for listing templates
+ * 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 ListTemplatesOptions {
-    /** Limit the number of results */
-    limit?: number;
+interface CreateSandboxOptions {
+    timeout?: number;
+    templateId?: string;
+    metadata?: Record<string, any>;
+    envs?: Record<string, string>;
+    name?: string;
+    namespace?: string;
 }
 /**
  * Options for finding or creating a named sandbox
  */
 interface FindOrCreateSandboxOptions extends CreateSandboxOptions {
-    /** User-provided stable identifier (e.g., "my-app", "frontend") */
     name: string;
-    /** Isolation scope (e.g., "user-123", "org-456"). Defaults to "default" */
     namespace?: string;
 }
 /**
- * Options for finding a named sandbox (without creating)
+ * Options for finding a named sandbox
  */
 interface FindSandboxOptions {
-    /** User-provided stable identifier */
     name: string;
-    /** Isolation scope. Defaults to "default" */
     namespace?: string;
 }
 /**
  * Options for extending sandbox timeout
  */
 interface ExtendTimeoutOptions {
-    /** Additional time to extend in milliseconds. Defaults to 900000 (15 minutes) */
     duration?: number;
 }
 /**
- * Provider sandbox manager interface - handles sandbox lifecycle
- *
- * For most providers (e2b, railway, etc.), this returns ProviderSandbox.
- * The gateway provider returns the full Sandbox with ComputeClient features.
- */
-interface ProviderSandboxManager<TSandbox = any> {
-    /** Create a new sandbox */
-    create(options?: CreateSandboxOptions): Promise<ProviderSandbox<TSandbox>>;
-    /** Get an existing sandbox by ID */
-    getById(sandboxId: string): Promise<ProviderSandbox<TSandbox> | null>;
-    /** List all active sandboxes */
-    list(): Promise<ProviderSandbox<TSandbox>[]>;
-    /** Destroy a sandbox */
-    destroy(sandboxId: string): Promise<void>;
-    /** Find existing or create new sandbox by (namespace, name) */
-    findOrCreate?(options: FindOrCreateSandboxOptions): Promise<ProviderSandbox<TSandbox>>;
-    /** Find existing sandbox by (namespace, name) without creating */
-    find?(options: FindSandboxOptions): Promise<ProviderSandbox<TSandbox> | null>;
-    /** Extend sandbox timeout/expiration */
-    extendTimeout?(sandboxId: string, options?: ExtendTimeoutOptions): Promise<void>;
-}
-/**
- * Provider template manager interface - handles template/blueprint lifecycle
- */
-interface ProviderTemplateManager<TTemplate = any, TCreateOptions extends CreateTemplateOptions = CreateTemplateOptions> {
-    /** Create a new template */
-    create(options: TCreateOptions): Promise<TTemplate>;
-    /** List all available templates */
-    list(options?: ListTemplatesOptions): Promise<TTemplate[]>;
-    /** Delete a template */
-    delete(templateId: string): Promise<void>;
-}
-/**
- * Provider snapshot manager interface - handles snapshot lifecycle
- */
-interface ProviderSnapshotManager<TSnapshot = any> {
-    /** Create a snapshot from a sandbox */
-    create(sandboxId: string, options?: CreateSnapshotOptions): Promise<TSnapshot>;
-    /** List all snapshots */
-    list(options?: ListSnapshotsOptions): Promise<TSnapshot[]>;
-    /** Delete a snapshot */
-    delete(snapshotId: string): Promise<void>;
-}
-/**
- * Provider interface - creates and manages resources
- */
-interface Provider<TSandbox = any, TTemplate = any, TSnapshot = any> {
-    /** Provider name/type */
-    readonly name: string;
-    /** Sandbox management operations */
-    readonly sandbox: ProviderSandboxManager<TSandbox>;
-    /** Optional template management operations */
-    readonly template?: ProviderTemplateManager<TTemplate>;
-    /** Optional snapshot management operations */
-    readonly snapshot?: ProviderSnapshotManager<TSnapshot>;
-    /** Get the list of supported runtime environments */
-    getSupportedRuntimes(): Runtime[];
-}
-/**
- * Configuration for the compute singleton
- */
-interface ComputeConfig<TProvider extends Provider = Provider> {
-    /** Default provider to use when none is specified */
-    defaultProvider?: TProvider;
-    /** @deprecated Use defaultProvider instead. Kept for backwards compatibility */
-    provider?: TProvider;
-    /** API key for compute CLI authentication */
-    apiKey?: string;
-    /** Access token for compute CLI authentication */
-    accessToken?: string;
-    /** @deprecated Use accessToken instead. Kept for backwards compatibility */
-    jwt?: string;
-}
-/**
- * Parameters for compute.sandbox.create()
- */
-interface CreateSandboxParams {
-    /** Provider instance to use */
-    provider: Provider;
-    /** Optional sandbox creation options */
-    options?: CreateSandboxOptions;
-}
-/**
- * Parameters for compute.sandbox.create() with optional provider
- */
-interface CreateSandboxParamsWithOptionalProvider {
-    /** Provider instance to use (optional if default is set) */
-    provider?: Provider;
-    /** Optional sandbox creation options */
-    options?: CreateSandboxOptions;
-}
-/**
- * Base Compute API interface (non-generic)
- *
- * Returns ProviderSandbox which is the common interface for all sandboxes.
- * When using gateway provider, the returned sandbox will have full Sandbox
- * capabilities (terminals, watchers, signals) accessible via getInstance().
+ * Compute singleton implementation
  */
-interface ComputeAPI {
-    /** Configuration management */
-    setConfig<TProvider extends Provider>(config: ComputeConfig<TProvider>): void;
-    getConfig(): ComputeConfig | null;
-    clearConfig(): void;
-    sandbox: {
-        /** Create a sandbox from a provider (or default provider if configured) */
-        create(params?: CreateSandboxParams | CreateSandboxParamsWithOptionalProvider): Promise<ProviderSandbox>;
-        /** Get an existing sandbox by ID from a provider (or default provider if configured) */
-        getById(providerOrSandboxId: Provider | string, sandboxId?: string): Promise<ProviderSandbox | null>;
-        /** List all active sandboxes from a provider (or default provider if configured) */
-        list(provider?: Provider): Promise<ProviderSandbox[]>;
-        /** Destroy a sandbox via a provider (or default provider if configured) */
-        destroy(providerOrSandboxId: Provider | string, sandboxId?: string): Promise<void>;
-        /** Find existing or create new sandbox by (namespace, name) */
-        findOrCreate(options: FindOrCreateSandboxOptions): Promise<ProviderSandbox>;
-        /** Find existing sandbox by (namespace, name) without creating */
-        find(options: FindSandboxOptions): Promise<ProviderSandbox | null>;
-        /** Extend sandbox timeout/expiration */
-        extendTimeout(sandboxId: string, options?: ExtendTimeoutOptions): Promise<void>;
-    };
-}
-/**
- * Typed Compute API interface that preserves provider type information
- *
- * When using gateway provider, returns full Sandbox with ComputeClient features.
- * When using other providers, returns TypedProviderSandbox.
- */
-interface TypedComputeAPI<TProvider extends Provider> extends Omit<ComputeAPI, 'sandbox' | 'setConfig'> {
-    /** Configuration management that returns typed compute instance */
-    setConfig<T extends Provider>(config: ComputeConfig<T>): TypedComputeAPI<T>;
+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 sandbox from the configured provider with proper typing */
-        create(params?: Omit<CreateSandboxParamsWithOptionalProvider, 'provider'>): Promise<TypedProviderSandbox<TProvider>>;
-        /** Get an existing sandbox by ID from the configured provider with proper typing */
-        getById(sandboxId: string): Promise<TypedProviderSandbox<TProvider> | null>;
-        /** List all active sandboxes from the configured provider with proper typing */
-        list(): Promise<TypedProviderSandbox<TProvider>[]>;
-        /** Destroy a sandbox via the configured provider */
-        destroy(sandboxId: string): Promise<void>;
-        /** Find existing or create new sandbox by (namespace, name) */
-        findOrCreate(options: FindOrCreateSandboxOptions): Promise<TypedProviderSandbox<TProvider>>;
-        /** Find existing sandbox by (namespace, name) without creating */
-        find(options: FindSandboxOptions): Promise<TypedProviderSandbox<TProvider> | null>;
-        /** Extend sandbox timeout/expiration */
-        extendTimeout(sandboxId: string, options?: ExtendTimeoutOptions): Promise<void>;
-    };
-}
-/**
- * E2B provider configuration for explicit compute mode
- */
-interface E2BProviderConfig {
-    /** E2B API key */
-    apiKey?: string;
-    /** E2B project ID */
-    projectId?: string;
-    /** E2B environment/template ID */
-    templateId?: string;
-}
-/**
- * Modal provider configuration for explicit compute mode
- */
-interface ModalProviderConfig {
-    /** Modal token ID */
-    tokenId?: string;
-    /** Modal token secret */
-    tokenSecret?: string;
-}
-/**
- * Railway provider configuration for explicit compute mode
- */
-interface RailwayProviderConfig {
-    /** Railway API token */
-    apiToken?: string;
-    /** Railway project ID */
-    projectId?: string;
-    /** Railway environment ID */
-    environmentId?: string;
-}
-/**
- * Daytona provider configuration for explicit compute mode
- */
-interface DaytonaProviderConfig {
-    /** Daytona API key */
-    apiKey?: string;
-}
-/**
- * Vercel provider configuration for explicit compute mode
- */
-interface VercelProviderConfig {
-    /** Vercel OIDC token (preferred, simpler auth) */
-    oidcToken?: string;
-    /** Vercel API token (traditional auth) */
-    token?: string;
-    /** Vercel team ID (required with token) */
-    teamId?: string;
-    /** Vercel project ID (required with token) */
-    projectId?: string;
-}
-/**
- * Runloop provider configuration for explicit compute mode
- */
-interface RunloopProviderConfig {
-    /** Runloop API key */
-    apiKey?: string;
-}
-/**
- * Cloudflare provider configuration for explicit compute mode
- */
-interface CloudflareProviderConfig {
-    /** Cloudflare API token */
-    apiToken?: string;
-    /** Cloudflare account ID */
-    accountId?: string;
-}
-/**
- * CodeSandbox provider configuration for explicit compute mode
- */
-interface CodesandboxProviderConfig {
-    /** CodeSandbox API key */
-    apiKey?: string;
-}
-/**
- * Blaxel provider configuration for explicit compute mode
- */
-interface BlaxelProviderConfig {
-    /** Blaxel API key */
-    apiKey?: string;
-    /** Blaxel workspace */
-    workspace?: string;
+        /**
+         * Create a new sandbox
+         */
+        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>;
+    };
 }
-
 /**
- * Explicit compute configuration for callable compute()
- *
- * Used when calling compute as a function: compute({ provider: 'e2b', ... })
- * Always uses gateway mode.
- */
-interface ExplicitComputeConfig {
-    /** Provider name to use */
-    provider: ProviderName;
-    /** ComputeSDK API key (required for gateway mode) */
-    apiKey: string;
-    /** E2B provider configuration */
-    e2b?: E2BProviderConfig;
-    /** Modal provider configuration */
-    modal?: ModalProviderConfig;
-    /** Railway provider configuration */
-    railway?: RailwayProviderConfig;
-    /** Daytona provider configuration */
-    daytona?: DaytonaProviderConfig;
-    /** Vercel provider configuration */
-    vercel?: VercelProviderConfig;
-    /** Runloop provider configuration */
-    runloop?: RunloopProviderConfig;
-    /** Cloudflare provider configuration */
-    cloudflare?: CloudflareProviderConfig;
-    /** CodeSandbox provider configuration */
-    codesandbox?: CodesandboxProviderConfig;
-    /** Blaxel provider configuration */
-    blaxel?: BlaxelProviderConfig;
-}
-/**
- * Callable compute type - works as both singleton and factory function
- */
-type CallableCompute = ComputeAPI & ((config: ExplicitComputeConfig) => ComputeAPI);
-
-/**
- * Compute Singleton - Main API Orchestrator
- *
- * Provides the unified compute.* API and delegates to specialized managers.
- * The `compute` export works as both a singleton and a callable function:
+ * Callable compute interface - dual nature as both singleton and factory
  *
- * - Singleton: `compute.sandbox.create()` (auto-detects from env vars)
- * - Callable: `compute({ provider: 'e2b', ... }).sandbox.create()` (explicit config, uses gateway)
- */
-
+ * 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
  *
@@ -510,7 +3207,7 @@ type CallableCompute = ComputeAPI & ((config: ExplicitComputeConfig) => ComputeA
  * // Singleton mode (auto-detects from env vars)
  * const sandbox1 = await compute.sandbox.create();
  *
- * // Callable mode (explicit config, uses gateway)
+ * // Callable mode (explicit config)
  * const sandbox2 = await compute({
  *   provider: 'e2b',
  *   apiKey: 'computesdk_xxx',
@@ -519,190 +3216,6 @@ type CallableCompute = ComputeAPI & ((config: ExplicitComputeConfig) => ComputeA
  * ```
  */
 declare const compute: CallableCompute;
-/**
- * Create a compute instance with proper typing
- *
- * @example
- * ```typescript
- * import { e2b } from '@computesdk/e2b'
- * import { createCompute } from 'computesdk'
- *
- * // Zero-config mode (auto-detects from environment)
- * const compute = createCompute();
- * const sandbox = await compute.sandbox.create();
- *
- * // Explicit mode
- * const compute2 = createCompute({
- *   defaultProvider: e2b({ apiKey: 'your-key' }),
- * });
- *
- * const sandbox2 = await compute2.sandbox.create();
- * const instance = sandbox2.getInstance(); // ✅ Properly typed!
- * ```
- */
-declare function createCompute(): ComputeAPI;
-declare function createCompute<TProvider extends Provider>(config: ComputeConfig<TProvider>): TypedComputeAPI<TProvider>;
-
-/**
- * Explicit Config
- *
- * Converts explicit compute configuration to a gateway provider.
- * Used when compute() is called as a function with configuration.
- */
-
-/**
- * Create a gateway provider from explicit configuration
- *
- * @param config - Explicit compute configuration
- * @returns A configured gateway provider
- */
-declare function createProviderFromConfig(config: ExplicitComputeConfig): Provider;
-
-/**
- * Provider Factory - Creates providers from method definitions
- *
- * Eliminates boilerplate by auto-generating Provider/Sandbox classes
- * from simple method definitions with automatic feature detection.
- */
-
-/**
- * Flat sandbox method implementations - all operations in one place
- */
-interface SandboxMethods<TSandbox = any, TConfig = any> {
-    create: (config: TConfig, options?: CreateSandboxOptions) => Promise<{
-        sandbox: TSandbox;
-        sandboxId: string;
-    }>;
-    getById: (config: TConfig, sandboxId: string) => Promise<{
-        sandbox: TSandbox;
-        sandboxId: string;
-    } | null>;
-    list: (config: TConfig) => Promise<Array<{
-        sandbox: TSandbox;
-        sandboxId: string;
-    }>>;
-    destroy: (config: TConfig, sandboxId: string) => Promise<void>;
-    findOrCreate?: (config: TConfig, options: FindOrCreateSandboxOptions) => Promise<{
-        sandbox: TSandbox;
-        sandboxId: string;
-    }>;
-    find?: (config: TConfig, options: FindSandboxOptions) => Promise<{
-        sandbox: TSandbox;
-        sandboxId: string;
-    } | null>;
-    extendTimeout?: (config: TConfig, sandboxId: string, options?: ExtendTimeoutOptions) => Promise<void>;
-    runCode: (sandbox: TSandbox, code: string, runtime?: Runtime, config?: TConfig) => Promise<CodeResult>;
-    runCommand: (sandbox: TSandbox, command: string, args?: string[], options?: RunCommandOptions) => Promise<CommandResult>;
-    getInfo: (sandbox: TSandbox) => Promise<SandboxInfo>;
-    getUrl: (sandbox: TSandbox, options: {
-        port: number;
-        protocol?: string;
-    }) => Promise<string>;
-    getInstance?: (sandbox: TSandbox) => TSandbox;
-    filesystem?: {
-        readFile: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, args?: string[]) => Promise<CommandResult>) => Promise<string>;
-        writeFile: (sandbox: TSandbox, path: string, content: string, runCommand: (sandbox: TSandbox, command: string, args?: string[]) => Promise<CommandResult>) => Promise<void>;
-        mkdir: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, args?: string[]) => Promise<CommandResult>) => Promise<void>;
-        readdir: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, args?: string[]) => Promise<CommandResult>) => Promise<FileEntry[]>;
-        exists: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, args?: string[]) => Promise<CommandResult>) => Promise<boolean>;
-        remove: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, args?: string[]) => Promise<CommandResult>) => Promise<void>;
-    };
-}
-/**
- * Template method implementations
- */
-interface TemplateMethods<TTemplate = any, TConfig = any, TCreateOptions extends CreateTemplateOptions = CreateTemplateOptions> {
-    create: (config: TConfig, options: TCreateOptions) => Promise<TTemplate>;
-    list: (config: TConfig, options?: ListTemplatesOptions) => Promise<TTemplate[]>;
-    delete: (config: TConfig, templateId: string) => Promise<void>;
-}
-/**
- * Snapshot method implementations
- */
-interface SnapshotMethods<TSnapshot = any, TConfig = any> {
-    create: (config: TConfig, sandboxId: string, options?: CreateSnapshotOptions) => Promise<TSnapshot>;
-    list: (config: TConfig, options?: ListSnapshotsOptions) => Promise<TSnapshot[]>;
-    delete: (config: TConfig, snapshotId: string) => Promise<void>;
-}
-/**
- * Provider execution modes
- *
- * - 'raw': Use raw provider methods directly (for gateway internal use)
- * - 'direct': Use provider's native SDK directly (for providers with sandbox capabilities)
- * - 'gateway': Route through ComputeSDK gateway (for providers without native sandbox)
- */
-type ProviderMode = 'raw' | 'direct' | 'gateway';
-/**
- * Provider configuration for createProvider()
- */
-interface ProviderConfig<TSandbox = any, TConfig = any, TTemplate = any, TSnapshot = any> {
-    name: string;
-    /**
-     * Default execution mode for this provider (defaults to 'gateway' if not specified)
-     *
-     * - 'direct': Provider has native sandbox capabilities (e.g., E2B) - uses provider SDK directly
-     * - 'gateway': Provider only has infrastructure (e.g., Railway) - routes through gateway
-     *
-     * Can be overridden at runtime with `mode` in config.
-     */
-    defaultMode?: 'direct' | 'gateway';
-    methods: {
-        sandbox: SandboxMethods<TSandbox, TConfig>;
-        template?: TemplateMethods<TTemplate, TConfig>;
-        snapshot?: SnapshotMethods<TSnapshot, TConfig>;
-    };
-}
-/**
- * Base config that all provider configs should extend
- * Includes the `mode` option for controlling execution mode
- */
-interface BaseProviderConfig {
-    /**
-     * Execution mode override
-     *
-     * - 'raw': Use raw provider methods directly (for gateway internal use)
-     * - 'direct': Use provider's native SDK directly
-     * - 'gateway': Route through ComputeSDK gateway
-     *
-     * If not specified, uses the provider's `defaultMode`.
-     */
-    mode?: ProviderMode;
-}
-/**
- * Create a provider from method definitions
- *
- * Auto-generates all boilerplate classes and provides feature detection
- * based on which methods are implemented.
- */
-declare function createProvider<TSandbox, TConfig = any, TTemplate = any, TSnapshot = any>(providerConfig: ProviderConfig<TSandbox, TConfig, TTemplate, TSnapshot>): (config: TConfig & BaseProviderConfig) => Provider<TSandbox, TTemplate, TSnapshot>;
-
-/**
- * Gateway provider configuration
- */
-interface GatewayConfig extends BaseProviderConfig {
-    /** Gateway URL (default: https://gateway.computesdk.com) */
-    gatewayUrl?: string;
-    /** ComputeSDK API key for authentication */
-    apiKey: string;
-    /** Backend provider name (e2b, railway, etc.) */
-    provider: string;
-    /** Provider-specific headers to pass through to gateway */
-    providerHeaders?: Record<string, string>;
-    /** Request timeout in milliseconds (default: 30000) */
-    requestTimeout?: number;
-    /** Maximum retry attempts for transient failures (default: 3) */
-    maxRetries?: number;
-    /** Initial retry delay in milliseconds (default: 1000) */
-    retryDelay?: number;
-    /** HTTP status codes that should trigger a retry (default: [408, 429, 502, 503, 504]) */
-    retryableStatuses?: number[];
-}
-/**
- * Gateway Provider factory
- *
- * Uses ClientSandbox directly as the sandbox type - no wrapper needed.
- */
-declare const gateway: (config: GatewayConfig & BaseProviderConfig) => Provider<Sandbox, any, any>;
 
 /**
  * Auto-Detection Module
@@ -710,7 +3223,6 @@ declare const gateway: (config: GatewayConfig & BaseProviderConfig) => Provider<
  * 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
@@ -731,13 +3243,22 @@ declare function detectProvider(): string | null;
  * 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>;
+}
 /**
  * Main auto-configuration function
- * Returns configured HTTP provider or null if auto-detection not possible
+ * 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(): Provider | null;
+declare function autoConfigureCompute(): GatewayConfig | null;
 
 /**
  * ComputeSDK Constants
@@ -770,87 +3291,4 @@ declare const PROVIDER_ENV_VARS: {
     readonly blaxel: readonly ["BL_API_KEY", "BL_WORKSPACE"];
 };
 
-/**
- * Utility functions for ComputeSDK
- */
-/**
- * Calculate exponential backoff delay with jitter
- *
- * Uses exponential backoff (2^attempt) multiplied by base delay,
- * plus random jitter to prevent thundering herd.
- *
- * @param attempt - Current retry attempt (0-indexed)
- * @param baseDelay - Base delay in milliseconds (default: 1000)
- * @param jitterMax - Maximum random jitter in milliseconds (default: 100)
- * @returns Delay in milliseconds
- *
- * @example
- * ```typescript
- * // First retry: 1000-1100ms
- * calculateBackoff(0);
- *
- * // Second retry: 2000-2100ms
- * calculateBackoff(1);
- *
- * // Third retry: 4000-4100ms
- * calculateBackoff(2);
- * ```
- */
-declare function calculateBackoff(attempt: number, baseDelay?: number, jitterMax?: number): number;
-
-/**
- * Simplified Request Handler for Web Framework Integration
- *
- * Handles JSON requests for sandbox and code execution operations.
- * Terminal support removed - will be re-added with WebSocket VM connections.
- */
-
-/**
- * Request structure supporting sandbox and code execution capabilities
- */
-interface ComputeRequest {
-    /** Action in dot notation (e.g., 'compute.sandbox.create') */
-    action: string;
-    /** Parameters for the action */
-    sandboxId?: string;
-    code?: string;
-    command?: string;
-    args?: string[];
-    runtime?: Runtime;
-    path?: string;
-    content?: string;
-    /** Command options (for runCommand action) */
-    commandOptions?: {
-        background?: boolean;
-    };
-    /** Sandbox creation options */
-    options?: {
-        runtime?: Runtime;
-        timeout?: number;
-        sandboxId?: string;
-    };
-}
-/**
- * Response structure for compute operations
- */
-interface ComputeResponse {
-    success: boolean;
-    error?: string;
-    sandboxId: string;
-    provider: string;
-    [key: string]: any;
-}
-/**
- * Main request handler - handles HTTP requests and pre-parsed bodies
- */
-declare function handleComputeRequest(params: HandleComputeRequestParams): Promise<ComputeResponse>;
-declare function handleComputeRequest(requestOrBody: Request | ComputeRequest, provider: Provider): Promise<Response>;
-/**
- * Legacy export for backward compatibility
- */
-interface HandleComputeRequestParams {
-    request: ComputeRequest;
-    provider: Provider;
-}
-
-export { type BaseProviderConfig, type BlaxelProviderConfig, type CallableCompute, type CloudflareProviderConfig, type CodesandboxProviderConfig, type ComputeAPI, type ComputeConfig, type ComputeRequest, type ComputeResponse, type CreateSandboxParams, type CreateSandboxParamsWithOptionalProvider, type CreateSnapshotOptions, type CreateTemplateOptions, type DaytonaProviderConfig, type E2BProviderConfig, type ExplicitComputeConfig, type ProviderName as ExplicitProviderName, type ExtendTimeoutOptions, type ExtractProviderSandboxType, type FindOrCreateSandboxOptions, type FindSandboxOptions, GATEWAY_URL, type GatewayConfig, type HandleComputeRequestParams, type ListSnapshotsOptions, type ListTemplatesOptions, type ModalProviderConfig, PROVIDER_AUTH, PROVIDER_DASHBOARD_URLS, PROVIDER_ENV_MAP, PROVIDER_ENV_VARS, PROVIDER_HEADERS, PROVIDER_NAMES, PROVIDER_PRIORITY, type Provider, type ProviderConfig, type ProviderMode, type ProviderName, type ProviderSandbox, type ProviderSandboxManager, type ProviderSnapshotManager, type ProviderTemplateManager, type RailwayProviderConfig, type RunloopProviderConfig, type SandboxInfo, type SandboxMethods, type SnapshotMethods, type TemplateMethods, type TypedComputeAPI, type TypedProviderSandbox, type VercelProviderConfig, autoConfigureCompute, buildProviderHeaders, calculateBackoff, compute, createCompute, createProvider, createProviderFromConfig, detectProvider, gateway, getMissingEnvVars, getProviderConfigFromEnv, getProviderHeaders, handleComputeRequest, isGatewayModeEnabled, isProviderAuthComplete, isValidProvider };
+export { type CodeResult$1 as CodeResult, CommandExitError, type CommandResult$1 as CommandResult, type CreateSandboxOptions$1 as CreateSandboxOptions, 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, SignalService, TerminalInstance, autoConfigureCompute, buildProviderHeaders, compute, decodeBinaryMessage, detectProvider, encodeBinaryMessage, getMissingEnvVars, getProviderConfigFromEnv, getProviderHeaders, isCommandExitError, isGatewayModeEnabled, isProviderAuthComplete, isValidProvider };