@phpsandbox/sdk 0.0.51 → 0.0.53

package/dist/socket/index.js

@@ -8,12 +8,14 @@ import { nanoid } from 'nanoid';
 import { encode, decode } from '@msgpack/msgpack';
 import { ErrorEvent as SDKErrorEvent, RateLimitError } from '../types.js';
 import { retry } from '../utils/retry.js';
-import ReconnectingWebSocket from 'reconnecting-websocket';
+import * as ReconnectingWebSocketModule from 'reconnecting-websocket';
 import { timeout } from '../utils/promise.js';
 import { describeWebSocketEvent } from '../utils/websocket.js';
 import WebSocket from 'isomorphic-ws';
 import { NamedDisposable } from '../utils/disposable.js';
 import { NotebookUnavailableError, PromiseTimeoutError, SendTimeoutError } from '../errors/index.js';
+const ReconnectingWebSocket = (ReconnectingWebSocketModule.default
+    ?? ReconnectingWebSocketModule);
 export var SocketEvent;
 (function (SocketEvent) {
     SocketEvent["BootError"] = "Events.BootError";
@@ -60,21 +62,6 @@ export class Transport {
         this.connectPromise = null;
         this.terminalError = null;
         this.pingIntervalStarted = false;
-        // Connection health monitoring
-        this.connectionStats = {
-            connectTime: 0,
-            reconnectCount: 0,
-            lastPingTime: 0,
-            lastPongTime: 0,
-            avgResponseTime: 0,
-            totalMessages: 0,
-            totalErrors: 0,
-            connectionStartTime: 0,
-        };
-        // Message queue for disconnection handling
-        this.messageQueue = [];
-        this.MAX_QUEUE_SIZE = 100;
-        this.QUEUE_TIMEOUT = 30000; // 30 seconds
         this.incomingMessageChain = Promise.resolve();
         // Validate configuration
         this.validateConfiguration(options);
@@ -82,11 +69,8 @@ export class Transport {
         // Use configurable ping interval
         this.PING_INTERVAL = options.pingInterval ?? 30000;
         this.CONNECT_WAIT_TIMEOUT = options.connectWaitTimeout ?? 30000;
-        // Initialize connection stats
-        this.connectionStats.connectionStartTime = Date.now();
         // Always start closed by default (lazy initialization)
         const startClosed = options.startClosed !== false;
-        // @ts-expect-error
         this.rws = new ReconnectingWebSocket(this.url.toString(), [], {
             WebSocket: options.webSocket ?? globalThis.WebSocket ?? WebSocket,
             connectionTimeout: options.connectionTimeout,
@@ -101,8 +85,6 @@ export class Transport {
             options,
         });
         this.registerWatchers();
-        this.setupConnectionHealthMonitoring();
-        this.startPeriodicMaintenance();
     }
     /**
      * Validate configuration options
@@ -149,7 +131,6 @@ export class Transport {
                 .catch(() => undefined)
                 .then(() => this.processIncomingMessage(ev))
                 .catch((error) => {
-                this.connectionStats.totalErrors++;
                 this.log('error', 'Failed to process queued WebSocket frame', {
                     error: error instanceof Error ? error.message : String(error),
                 });
@@ -169,11 +150,13 @@ export class Transport {
         });
     }
     async processIncomingMessage(ev) {
-        if (!(ev.data instanceof Blob)) {
-            const error = new Error('Unexpected message type: ' + typeof ev.data);
-            this.connectionStats.totalErrors++;
+        let buffer;
+        try {
+            buffer = await this.toArrayBuffer(ev.data);
+        }
+        catch (error) {
             this.log('error', 'Unexpected WebSocket message type', {
-                error: error.message,
+                error: error instanceof Error ? error.message : String(error),
                 messageType: typeof ev.data,
             });
             this.eventEmitter.emit('transport.error', {
@@ -184,7 +167,6 @@ export class Transport {
             });
             return;
         }
-        const buffer = await ev.data.arrayBuffer();
         if (buffer.byteLength === 0) {
             this.log('warn', 'Ignoring empty WebSocket frame');
             return;
@@ -194,7 +176,6 @@ export class Transport {
             decoded = decode(buffer);
         }
         catch (error) {
-            this.connectionStats.totalErrors++;
             this.log('error', 'Failed to decode WebSocket frame', {
                 error: error instanceof Error ? error.message : String(error),
                 byteLength: buffer.byteLength,
@@ -211,7 +192,6 @@ export class Transport {
             await this.handleRawMessage(decoded);
         }
         catch (error) {
-            this.connectionStats.totalErrors++;
             this.log('error', 'Failed to process WebSocket frame', {
                 error: error instanceof Error ? error.message : String(error),
                 byteLength: buffer.byteLength,
@@ -224,6 +204,19 @@ export class Transport {
             });
         }
     }
+    async toArrayBuffer(data) {
+        if (data instanceof Blob) {
+            return data.arrayBuffer();
+        }
+        if (data instanceof ArrayBuffer) {
+            return data;
+        }
+        if (ArrayBuffer.isView(data)) {
+            const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+            return bytes.slice().buffer;
+        }
+        throw new Error('Unexpected message type: ' + typeof data);
+    }
     async handleRawMessage(ev) {
         if (this.closed) {
             this.log('debug', 'Ignoring message received after transport was closed');
@@ -246,7 +239,8 @@ export class Transport {
                 return;
             }
             if (event === SocketEvent.BootError) {
-                const error = new NotebookUnavailableError(data?.message || 'Notebook is no longer available', data || {});
+                const errorData = data;
+                const error = new NotebookUnavailableError(errorData?.message || 'Notebook is no longer available', errorData || {});
                 this.log('error', 'Boot error received', { data });
                 this.terminate(error, 4000, error.message);
                 return;
@@ -277,19 +271,16 @@ export class Transport {
             await this.handleMessage(event, data, as);
         }
         catch (e) {
-            this.connectionStats.totalErrors++;
             if (e instanceof InvalidMessageError) {
                 this.log('error', 'Invalid message format', {
                     error: e.message,
                     data: e.data,
-                    totalErrors: this.connectionStats.totalErrors,
                 });
             }
             else {
                 this.log('error', 'Failed to parse message', {
                     ev,
                     error: e instanceof Error ? e.message : String(e),
-                    totalErrors: this.connectionStats.totalErrors,
                 });
             }
             // Don't throw - we want to continue processing other messages
@@ -305,7 +296,7 @@ export class Transport {
     async handleMessage(event, data, as) {
         if (event === SocketEvent.ClientId) {
             this.clientId = data.id;
-            this.eventEmitter.emit(event, data.id);
+            this.eventEmitter.emit(event, this.clientId);
             return;
         }
         event && this.eventEmitter.emit(as || event, data);
@@ -314,7 +305,7 @@ export class Transport {
         return this.eventEmitter.listen(event, listener);
     }
     onDidBootError(listener) {
-        this.eventEmitter.listen('transport.boot_error', (event) => {
+        return this.eventEmitter.listen('transport.boot_error', (event) => {
             listener(event.error);
         });
     }
@@ -322,12 +313,7 @@ export class Transport {
         this.eventEmitter.removeListener(event, listener);
     }
     listenOnce(event, listener, context) {
-        this.eventEmitter.once(event, listener, context);
-        this.disposables.add(`once_${event}_${nanoid()}`, {
-            dispose: () => {
-                this.eventEmitter.removeListener(event, listener);
-            },
-        });
+        return this.eventEmitter.once(event, listener, context);
     }
     emit(event, ...data) {
         this.eventEmitter.emit(event, ...data);
@@ -359,20 +345,23 @@ export class Transport {
         if (this.terminalError) {
             throw this.terminalError;
         }
-        // Clear old queued messages periodically
-        this.clearOldQueuedMessages();
         const responseEvent = options.responseEvent || `${action}_${nanoid()}_response`;
         const errorEvent = `${responseEvent}_error`;
         let closeHandler;
+        let abortHandler;
         const removeListeners = () => {
             if (closeHandler) {
                 this.rws.removeEventListener('close', closeHandler);
                 this.rws.removeEventListener('error', closeHandler);
             }
+            if (abortHandler) {
+                options.abortSignal?.removeEventListener('abort', abortHandler);
+                abortHandler = undefined;
+            }
             this.eventEmitter.removeListener(responseEvent);
             this.eventEmitter.removeListener(errorEvent);
         };
-        const handler = async (resolve, reject) => {
+        const handler = (resolve, reject) => {
             if (this.terminalError) {
                 reject(this.terminalError);
                 return;
@@ -380,51 +369,28 @@ export class Transport {
             const abortError = new DOMException('Request aborted', 'AbortError');
             if (options.abortSignal?.aborted) {
                 reject(abortError);
+                return;
             }
             if (options.abortSignal) {
-                options.abortSignal.addEventListener('abort', () => {
+                abortHandler = () => {
                     reject(abortError);
-                });
+                };
+                options.abortSignal.addEventListener('abort', abortHandler, { once: true });
             }
-            // If not connected, queue the message
-            if (!this.isConnected && !this.isClosed) {
-                this.log('debug', 'Connection not available, queuing message', {
-                    action,
-                });
-                // Check queue size limit
-                if (this.messageQueue.length >= this.MAX_QUEUE_SIZE) {
-                    const oldestMessage = this.messageQueue.shift();
-                    if (oldestMessage) {
-                        oldestMessage.reject(new Error('Message queue full, oldest message dropped'));
-                    }
-                }
-                this.messageQueue.push({
-                    action,
-                    data,
-                    options,
-                    resolve,
-                    reject,
-                    timestamp: Date.now(),
-                });
+            if (!this.isConnected || this.isClosed) {
+                reject(new ConnectionFailedError(`Connection is not open while sending ${action}. Current status: ${this.status}`));
                 return;
             }
-            const startTime = Date.now();
             this.listenOnce(responseEvent, (response) => {
-                // Update response time stats
-                const responseTime = Date.now() - startTime;
-                this.connectionStats.avgResponseTime = (this.connectionStats.avgResponseTime + responseTime) / 2;
-                this.connectionStats.totalMessages++;
                 this.log('debug', 'Message response received', {
                     action,
-                    responseTime,
-                    avgResponseTime: this.connectionStats.avgResponseTime,
                 });
                 resolve(response);
             });
             this.listenOnce(errorEvent, (e) => {
-                this.connectionStats.totalErrors++;
                 this.log('error', 'Message error received', { action, error: e });
-                reject(new SDKErrorEvent(e.code, e.message, e));
+                const error = e;
+                reject(new SDKErrorEvent(error.code, error.message, error));
             });
             closeHandler = (_ev) => {
                 if (_ev.code === 1008 && (_ev.reason || '').includes('rate limit')) {
@@ -442,12 +408,18 @@ export class Transport {
             }
             catch (error) {
                 this.log('error', 'Failed to send message', { action, error });
-                throw error;
+                reject(error);
             }
         };
         const send = async () => {
+            if (options.abortSignal?.aborted) {
+                throw new DOMException('Request aborted', 'AbortError');
+            }
             // Ensure connection is established before making calls
             await __classPrivateFieldGet(this, _Transport_instances, "m", _Transport_connect).call(this);
+            if (options.abortSignal?.aborted) {
+                throw new DOMException('Request aborted', 'AbortError');
+            }
             const promise = new Promise(handler).finally(removeListeners);
             if (!options.timeout) {
                 return promise;
@@ -459,7 +431,8 @@ export class Transport {
                 throw error;
             }).finally(removeListeners);
         };
-        return this.sendWithRetry(async () => await send(), options.retries || 10);
+        const retries = options.retries === false ? 0 : options.retries ?? 0;
+        return this.sendWithRetry(async () => await send(), retries);
     }
     send(action, data = {}) {
         if (this.terminalError) {
@@ -473,12 +446,10 @@ export class Transport {
         }
         try {
             this.rws.send(this.pack({ action, data }));
-            this.connectionStats.totalMessages++;
             this.log('debug', 'One-way message sent', { action, data });
             return true;
         }
         catch (error) {
-            this.connectionStats.totalErrors++;
             this.log('error', 'Failed to send one-way message', { action, error });
             return false;
         }
@@ -486,7 +457,7 @@ export class Transport {
     pack(data) {
         return new Blob([encode(data)]);
     }
-    sendWithRetry(sender, retries = 10) {
+    sendWithRetry(sender, retries) {
         /**
          * Enhanced retry with exponential backoff and intelligent error handling
          */
@@ -523,7 +494,6 @@ export class Transport {
                 this.log('debug', 'Retrying send operation', {
                     attempt,
                     error: e instanceof Error ? e.message : String(e),
-                    nextDelay: this.getBackoffDelay(attempt - 1),
                 });
                 throw e;
             }
@@ -571,7 +541,6 @@ export class Transport {
     }
     disconnect() {
         if (this.closed) {
-            console.trace('Transport is already closed, cannot disconnect again');
             return;
         }
         this.close();
@@ -593,16 +562,6 @@ export class Transport {
         this.log('info', 'Closing transport connection', { code, reason });
         // Clear any pending connection promise
         this.connectPromise = null;
-        // Reject all queued messages
-        const queuedCount = this.messageQueue.length;
-        const closeError = this.terminalError || new Error('Connection closed while message was queued');
-        this.messageQueue.forEach((msg) => {
-            msg.reject(closeError);
-        });
-        this.messageQueue = [];
-        if (queuedCount > 0) {
-            this.log('debug', `Rejected ${queuedCount} queued messages due to connection close`);
-        }
         // Dispose all event disposables
         this.disposables.dispose();
         // Close WebSocket connection
@@ -618,7 +577,6 @@ export class Transport {
         this.eventEmitter.emit('transport.closed', {
             code,
             reason,
-            metrics: this.getConnectionMetrics(),
             timestamp: Date.now(),
         });
         this.eventEmitter.removeListener('*'); // Remove all event listeners
@@ -627,261 +585,23 @@ export class Transport {
     }
     onDidConnect(listener) {
         this.rws.addEventListener('open', listener);
-        this.disposables.add('connect', {
+        const disposable = {
             dispose: () => {
                 this.rws.removeEventListener('open', listener);
             },
-        });
+        };
+        this.disposables.add(`connect_${nanoid()}`, disposable);
+        return disposable;
     }
     onDidClose(listener) {
         this.rws.addEventListener('close', listener);
-        this.disposables.add('close', {
+        const disposable = {
             dispose: () => {
                 this.rws.removeEventListener('close', listener);
             },
-        });
-    }
-    /**
-     * Setup connection health monitoring
-     */
-    setupConnectionHealthMonitoring() {
-        this.rws.addEventListener('open', () => {
-            this.connectionStats.connectTime = Date.now();
-            this.connectionStats.reconnectCount++;
-            this.log('info', 'Connection established', {
-                reconnectCount: this.connectionStats.reconnectCount,
-                timeSinceStart: Date.now() - this.connectionStats.connectionStartTime,
-            });
-            this.processMessageQueue();
-        });
-        this.rws.addEventListener('close', (event) => {
-            this.log('warn', 'Connection closed', {
-                code: event.code,
-                reason: event.reason,
-                wasClean: event.wasClean,
-            });
-            this.handleConnectionClose(event.code);
-        });
-        this.rws.addEventListener('error', (event) => {
-            this.connectionStats.totalErrors++;
-            const detail = describeWebSocketEvent(event);
-            this.log('error', 'Connection error', {
-                error: detail,
-                rawError: event,
-                totalErrors: this.connectionStats.totalErrors,
-            });
-        });
-    }
-    /**
-     * Handle different WebSocket close codes appropriately
-     */
-    handleConnectionClose(code) {
-        switch (code) {
-            case 1000: // Normal closure
-                this.log('info', 'Normal connection closure');
-                return 'stop';
-            case 1001: // Going away
-                this.log('info', 'Connection going away, will reconnect');
-                return 'reconnect';
-            case 1006: // Abnormal closure
-                this.log('warn', 'Abnormal connection closure, will retry');
-                return 'retry';
-            case 1008: // Policy violation (rate limit)
-                this.log('error', 'Connection closed due to policy violation');
-                this.clearOldQueuedMessages();
-                return 'stop';
-            case 4000:
-                this.log('info', 'Connection closed due to terminal notebook error');
-                return 'stop';
-            default:
-                this.log('warn', `Unknown close code: ${code}, will reconnect`);
-                return 'reconnect';
-        }
-    }
-    /**
-     * Process queued messages when connection is restored
-     */
-    processMessageQueue() {
-        if (this.messageQueue.length === 0) {
-            return;
-        }
-        this.log('debug', `Processing ${this.messageQueue.length} queued messages`);
-        const queue = [...this.messageQueue];
-        this.messageQueue = [];
-        for (const queuedMessage of queue) {
-            // Check if message hasn't timed out
-            if (Date.now() - queuedMessage.timestamp > this.QUEUE_TIMEOUT) {
-                queuedMessage.reject(new Error('Queued message timed out'));
-                continue;
-            }
-            // Retry the message
-            this.call(queuedMessage.action, queuedMessage.data, queuedMessage.options)
-                .then(queuedMessage.resolve)
-                .catch(queuedMessage.reject);
-        }
-    }
-    /**
-     * Clear old queued messages to prevent memory leaks
-     */
-    clearOldQueuedMessages() {
-        const now = Date.now();
-        const originalLength = this.messageQueue.length;
-        this.messageQueue = this.messageQueue.filter((msg) => {
-            const isExpired = now - msg.timestamp > this.QUEUE_TIMEOUT;
-            if (isExpired) {
-                msg.reject(new Error('Queued message expired'));
-            }
-            return !isExpired;
-        });
-        if (originalLength !== this.messageQueue.length) {
-            this.log('debug', `Cleared ${originalLength - this.messageQueue.length} expired messages`);
-        }
-    }
-    /**
-     * Calculate exponential backoff delay
-     */
-    getBackoffDelay(retryCount) {
-        const baseDelay = 1000; // 1 second
-        const maxDelay = 30000; // 30 seconds
-        const delay = Math.min(baseDelay * Math.pow(2, retryCount), maxDelay);
-        // Add jitter to prevent thundering herd
-        return delay + Math.random() * 1000;
-    }
-    /**
-     * Get comprehensive connection metrics
-     */
-    getConnectionMetrics() {
-        const now = Date.now();
-        const connectionDuration = this.connectionStats.connectTime > 0 ? now - this.connectionStats.connectTime : 0;
-        return {
-            status: this.status,
-            clientId: this.clientId,
-            isConnected: this.isConnected,
-            isConnecting: this.isConnecting,
-            connectionStats: {
-                ...this.connectionStats,
-                connectionDuration,
-                uptime: now - this.connectionStats.connectionStartTime,
-                messagesPerSecond: connectionDuration > 0 ? (this.connectionStats.totalMessages / (connectionDuration / 1000)).toFixed(2) : '0',
-                errorRate: this.connectionStats.totalMessages > 0
-                    ? ((this.connectionStats.totalErrors / this.connectionStats.totalMessages) * 100).toFixed(2) + '%'
-                    : '0%',
-                timeSinceLastPing: this.connectionStats.lastPingTime > 0 ? now - this.connectionStats.lastPingTime : 0,
-                timeSinceLastPong: this.connectionStats.lastPongTime > 0 ? now - this.connectionStats.lastPongTime : 0,
-            },
-            messageQueue: {
-                length: this.messageQueue.length,
-                maxSize: this.MAX_QUEUE_SIZE,
-                oldestMessageAge: this.messageQueue.length > 0 ? now - Math.min(...this.messageQueue.map((m) => m.timestamp)) : 0,
-            },
-            config: {
-                pingInterval: this.PING_INTERVAL,
-                queueTimeout: this.QUEUE_TIMEOUT,
-                url: this.url.toString(),
-            },
         };
-    }
-    /**
-     * Get connection health status
-     */
-    getHealthStatus() {
-        const metrics = this.getConnectionMetrics();
-        const stats = metrics.connectionStats;
-        // Unhealthy conditions
-        if (!this.isConnected || stats.timeSinceLastPong > this.PING_INTERVAL * 2 || Number.parseFloat(stats.errorRate) > 50) {
-            return 'unhealthy';
-        }
-        // Degraded conditions
-        if (stats.avgResponseTime > 5000 ||
-            Number.parseFloat(stats.errorRate) > 10 ||
-            stats.timeSinceLastPong > this.PING_INTERVAL * 1.5) {
-            return 'degraded';
-        }
-        return 'healthy';
-    }
-    /**
-     * Reset connection statistics
-     */
-    resetStats() {
-        this.connectionStats = {
-            connectTime: Date.now(),
-            reconnectCount: 0,
-            lastPingTime: 0,
-            lastPongTime: 0,
-            avgResponseTime: 0,
-            totalMessages: 0,
-            totalErrors: 0,
-            connectionStartTime: Date.now(),
-        };
-        this.log('debug', 'Connection statistics reset');
-    }
-    /**
-     * Run connection diagnostics
-     */
-    async runDiagnostics() {
-        const metrics = this.getConnectionMetrics();
-        const status = this.getHealthStatus();
-        const issues = [];
-        const recommendations = [];
-        // Check for issues
-        if (!this.isConnected) {
-            issues.push('Connection is not established');
-            recommendations.push('Check network connectivity and server availability');
-        }
-        if (metrics.connectionStats.timeSinceLastPong > this.PING_INTERVAL * 2) {
-            issues.push('No pong received recently - connection may be stale');
-            recommendations.push('Consider forcing a reconnection');
-        }
-        if (Number.parseFloat(metrics.connectionStats.errorRate) > 10) {
-            issues.push(`High error rate: ${metrics.connectionStats.errorRate}`);
-            recommendations.push('Check server logs and network stability');
-        }
-        if (metrics.messageQueue.length > this.MAX_QUEUE_SIZE * 0.8) {
-            issues.push('Message queue is nearly full');
-            recommendations.push('Check connection stability and consider reducing message frequency');
-        }
-        if (metrics.connectionStats.avgResponseTime > 5000) {
-            issues.push('High average response time');
-            recommendations.push('Check network latency and server performance');
-        }
-        this.log('info', 'Connection diagnostics completed', {
-            status,
-            issueCount: issues.length,
-            recommendationCount: recommendations.length,
-        });
-        return {
-            status,
-            metrics,
-            issues,
-            recommendations,
-        };
-    }
-    /**
-     * Periodic maintenance - clean up old data, run health checks
-     */
-    startPeriodicMaintenance() {
-        this.disposables.add('maintenance', () => {
-            // Run maintenance every 5 minutes
-            const maintenanceInterval = setInterval(() => {
-                this.clearOldQueuedMessages();
-                // Log health status if debug is enabled
-                if (this.options.debug) {
-                    const health = this.getHealthStatus();
-                    const metrics = this.getConnectionMetrics();
-                    this.log('debug', 'Periodic health check', {
-                        health,
-                        messageCount: metrics.connectionStats.totalMessages,
-                        errorCount: metrics.connectionStats.totalErrors,
-                        queueLength: metrics.messageQueue.length,
-                    });
-                }
-            }, 5 * 60 * 1000); // 5 minutes
-            return {
-                dispose: () => {
-                    clearInterval(maintenanceInterval);
-                },
-            };
-        });
+        this.disposables.add(`close_${nanoid()}`, disposable);
+        return disposable;
     }
 }
 _Transport_instances = new WeakSet(), _Transport_connect = function _Transport_connect() {
@@ -927,7 +647,7 @@ _Transport_instances = new WeakSet(), _Transport_connect = function _Transport_c
         };
         const closeHandler = (event) => {
             const detail = describeWebSocketEvent(event);
-            if ('code' in event && (event.code === 1008 || event.code === 4000)) {
+            if (event.code === 1008 || event.code === 4000) {
                 cleanup();
                 this.connectPromise = null;
                 reject(new ConnectionFailedError(`WebSocket connection failed: ${detail}`, event));
@@ -961,23 +681,14 @@ _Transport_instances = new WeakSet(), _Transport_connect = function _Transport_c
     this.disposables.add('pingInterval', () => {
         const interval = setInterval(async () => {
             try {
-                this.connectionStats.lastPingTime = Date.now();
                 this.log('debug', 'Sending periodic ping');
-                const startTime = Date.now();
                 await this.invoke('ping');
-                this.connectionStats.lastPongTime = Date.now();
-                const pingTime = this.connectionStats.lastPongTime - startTime;
-                this.log('debug', `Ping successful`, { pingTime });
+                this.log('debug', 'Ping successful');
             }
             catch (error) {
                 this.log('error', 'Ping failed', {
                     error: error instanceof Error ? error.message : String(error),
                 });
-                // If ping fails consistently, the connection might be dead
-                if (Date.now() - this.connectionStats.lastPongTime > this.PING_INTERVAL * 3) {
-                    this.log('warn', 'Connection appears dead, forcing reconnection');
-                    this.rws.reconnect();
-                }
             }
         }, this.PING_INTERVAL);
         return {
@@ -988,4 +699,3 @@ _Transport_instances = new WeakSet(), _Transport_connect = function _Transport_c
         };
     });
 };
-//# sourceMappingURL=index.js.map

package/dist/terminal.d.ts

@@ -94,9 +94,9 @@ export default class Terminal {
     list(): Promise<Task[]>;
     start(): Promise<void>;
     create(input: TerminalCreateInput): Promise<Task>;
-    onStarted(handler: (t: Task) => void): void;
+    onStarted(handler: (t: Task) => void): Disposable;
     resize(id: string, size: [number, number]): Promise<boolean>;
-    onOutput(id: string, handler: (data: TerminalEvents['terminal.output']) => void): void;
+    onOutput(id: string, handler: (data: TerminalEvents['terminal.output']) => void): Disposable;
     input(id: string, input: string): Promise<boolean>;
     listen<T extends keyof TerminalEvents>(event: T, handler: (data: TerminalEvents[T]) => void): Disposable;
     attach(id: string, opts?: {
@@ -107,4 +107,3 @@ export default class Terminal {
     private processHandle;
 }
 export {};
-//# sourceMappingURL=terminal.d.ts.map