@lspeasy/core 1.0.1

package/dist/transport/stdio.js

@@ -0,0 +1,147 @@
+/**
+ * StdioTransport - Transport implementation using stdin/stdout
+ */
+import { MessageReader } from '../jsonrpc/reader.js';
+import { MessageWriter } from '../jsonrpc/writer.js';
+/**
+ * Transport implementation using stdin/stdout streams
+ */
+export class StdioTransport {
+    reader;
+    writer;
+    connected;
+    messageHandlers;
+    errorHandlers;
+    closeHandlers;
+    constructor(options = {}) {
+        const input = options.input ?? process.stdin;
+        const output = options.output ?? process.stdout;
+        this.reader = new MessageReader(input);
+        this.writer = new MessageWriter(output);
+        this.connected = true;
+        this.messageHandlers = new Set();
+        this.errorHandlers = new Set();
+        this.closeHandlers = new Set();
+        // Set up reader event handlers
+        this.reader.on('message', (message) => {
+            this.messageHandlers.forEach((handler) => {
+                try {
+                    handler(message);
+                }
+                catch (error) {
+                    console.error('Error in message handler:', error);
+                }
+            });
+        });
+        this.reader.on('error', (error) => {
+            this.errorHandlers.forEach((handler) => {
+                try {
+                    handler(error);
+                }
+                catch (err) {
+                    console.error('Error in error handler:', err);
+                }
+            });
+        });
+        this.reader.on('close', () => {
+            this.handleClose();
+        });
+        // Set up writer event handlers
+        this.writer.on('error', (error) => {
+            this.errorHandlers.forEach((handler) => {
+                try {
+                    handler(error);
+                }
+                catch (err) {
+                    console.error('Error in error handler:', err);
+                }
+            });
+        });
+        this.writer.on('close', () => {
+            this.handleClose();
+        });
+    }
+    /**
+     * Send a message
+     */
+    async send(message) {
+        if (!this.connected) {
+            throw new Error('Transport is not connected');
+        }
+        await this.writer.write(message);
+    }
+    /**
+     * Subscribe to incoming messages
+     */
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return {
+            dispose: () => {
+                this.messageHandlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Subscribe to errors
+     */
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return {
+            dispose: () => {
+                this.errorHandlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Subscribe to close events
+     */
+    onClose(handler) {
+        this.closeHandlers.add(handler);
+        return {
+            dispose: () => {
+                this.closeHandlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Close the transport
+     */
+    async close() {
+        if (!this.connected) {
+            return;
+        }
+        this.reader.close();
+        this.writer.close();
+        // Don't close stdin/stdout as they're shared resources
+        // Just clean up our handlers
+        this.handleClose();
+    }
+    /**
+     * Check if transport is connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Handle connection close
+     */
+    handleClose() {
+        if (!this.connected) {
+            return;
+        }
+        this.connected = false;
+        this.closeHandlers.forEach((handler) => {
+            try {
+                handler();
+            }
+            catch (error) {
+                console.error('Error in close handler:', error);
+            }
+        });
+        // Clear all handlers
+        this.messageHandlers.clear();
+        this.errorHandlers.clear();
+        this.closeHandlers.clear();
+    }
+}
+//# sourceMappingURL=stdio.js.map

package/dist/transport/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["../../src/transport/stdio.ts"],"names":[],"mappings":"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"}

package/dist/transport/transport.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Transport interface for pluggable communication layers
+ */
+import type { Message } from '../jsonrpc/messages.js';
+import type { Disposable } from '../utils/disposable.js';
+/**
+ * Transport interface for sending/receiving JSON-RPC messages
+ */
+export interface Transport {
+    /**
+     * Send a message to the remote peer
+     */
+    send(message: Message): Promise<void>;
+    /**
+     * Subscribe to incoming messages
+     * @returns Disposable to unsubscribe
+     */
+    onMessage(handler: (message: Message) => void): Disposable;
+    /**
+     * Subscribe to transport errors
+     * @returns Disposable to unsubscribe
+     */
+    onError(handler: (error: Error) => void): Disposable;
+    /**
+     * Subscribe to connection close
+     * @returns Disposable to unsubscribe
+     */
+    onClose(handler: () => void): Disposable;
+    /**
+     * Close the transport connection
+     */
+    close(): Promise<void>;
+    /**
+     * Check if transport is connected
+     */
+    isConnected(): boolean;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/transport/transport.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtC;;;OAGG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,UAAU,CAAC;IAE3D;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,UAAU,CAAC;IAErD;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,UAAU,CAAC;IAEzC;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;OAEG;IACH,WAAW,IAAI,OAAO,CAAC;CACxB"}

package/dist/transport/transport.js

@@ -0,0 +1,5 @@
+/**
+ * Transport interface for pluggable communication layers
+ */
+export {};
+//# sourceMappingURL=transport.js.map

package/dist/transport/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport/transport.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/transport/websocket.d.ts

@@ -0,0 +1,142 @@
+/**
+ * WebSocket Transport implementation for LSP
+ */
+import type { Transport } from './transport.js';
+import type { Message } from '../jsonrpc/messages.js';
+import type { Disposable } from '../utils/disposable.js';
+type CloseLikeEvent = {
+    type: 'close';
+};
+type ErrorLikeEvent = {
+    error?: unknown;
+};
+type MessageLikeEvent = {
+    data: unknown;
+};
+type WebSocketLike = {
+    readonly readyState: number;
+    send(data: string, callback?: (error?: Error) => void): void;
+    close(): void;
+    on?(event: 'open', handler: () => void): void;
+    on?(event: 'message', handler: (data: Buffer | string) => void): void;
+    on?(event: 'error', handler: (error: Error) => void): void;
+    on?(event: 'close', handler: () => void): void;
+    once?(event: 'close', handler: () => void): void;
+    addEventListener?(event: 'open', handler: () => void): void;
+    addEventListener?(event: 'message', handler: (event: MessageLikeEvent) => void): void;
+    addEventListener?(event: 'error', handler: (event: ErrorLikeEvent) => void): void;
+    addEventListener?(event: 'close', handler: (event: CloseLikeEvent) => void): void;
+};
+export interface WebSocketTransportOptions {
+    /**
+     * WebSocket URL for client mode (e.g., 'ws://localhost:3000')
+     */
+    url?: string;
+    /**
+     * Existing WebSocket instance for server mode
+     */
+    socket?: WebSocketLike;
+    /**
+     * Enable automatic reconnection (client mode only)
+     */
+    enableReconnect?: boolean;
+    /**
+     * Maximum number of reconnection attempts
+     * @default 5
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Initial delay between reconnection attempts in milliseconds
+     * @default 1000
+     */
+    reconnectDelay?: number;
+    /**
+     * Maximum delay between reconnection attempts in milliseconds
+     * @default 30000
+     */
+    maxReconnectDelay?: number;
+    /**
+     * Multiplier for exponential backoff
+     * @default 2
+     */
+    reconnectBackoffMultiplier?: number;
+}
+export declare function createWebSocketClient(url: string): WebSocketLike;
+/**
+ * WebSocket-based transport for LSP communication
+ *
+ * Supports both client and server modes:
+ * - Client mode: Connects to a WebSocket server URL
+ * - Server mode: Wraps an existing WebSocket connection
+ */
+export declare class WebSocketTransport implements Transport {
+    private socket;
+    private connected;
+    private messageHandlers;
+    private errorHandlers;
+    private closeHandlers;
+    private readonly mode;
+    private readonly url;
+    private readonly enableReconnect;
+    private readonly maxReconnectAttempts;
+    private readonly reconnectDelay;
+    private readonly maxReconnectDelay;
+    private readonly reconnectBackoffMultiplier;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private intentionallyClosed;
+    constructor(options: WebSocketTransportOptions);
+    /**
+     * Setup event handlers for the WebSocket
+     */
+    private setupSocket;
+    private handleOpen;
+    private handleMessageData;
+    private handleClose;
+    /**
+     * Schedule a reconnection attempt with exponential backoff
+     */
+    private scheduleReconnect;
+    /**
+     * Attempt to reconnect to the server
+     */
+    private attemptReconnect;
+    /**
+     * Notify all error handlers
+     */
+    private notifyError;
+    /**
+     * Send a message through the WebSocket
+     */
+    send(message: Message): Promise<void>;
+    /**
+     * Register a handler for incoming messages
+     */
+    onMessage(handler: (message: Message) => void): Disposable;
+    /**
+     * Register a handler for transport errors
+     */
+    onError(handler: (error: Error) => void): Disposable;
+    /**
+     * Register a handler for transport closure
+     */
+    onClose(handler: () => void): Disposable;
+    /**
+     * Close the WebSocket connection
+     */
+    close(): Promise<void>;
+    /**
+     * Check if the transport is currently connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get the current reconnection attempt count
+     */
+    getReconnectAttempts(): number;
+    /**
+     * Check if reconnection is enabled
+     */
+    isReconnectEnabled(): boolean;
+}
+export {};
+//# sourceMappingURL=websocket.d.ts.map

package/dist/transport/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../src/transport/websocket.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD,KAAK,cAAc,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AACxC,KAAK,cAAc,GAAG;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAC1C,KAAK,gBAAgB,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAE1C,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IAC7D,KAAK,IAAI,IAAI,CAAC;IACd,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC9C,EAAE,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IACtE,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IAC3D,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC/C,IAAI,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IACjD,gBAAgB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC5D,gBAAgB,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,GAAG,IAAI,CAAC;IACtF,gBAAgB,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,IAAI,CAAC;IAClF,gBAAgB,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,IAAI,CAAC;CACnF,CAAC;AAKF,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;IAEvB;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,0BAA0B,CAAC,EAAE,MAAM,CAAC;CACrC;AAoCD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAchE;AAsBD;;;;;;GAMG;AACH,qBAAa,kBAAmB,YAAW,SAAS;IAClD,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,eAAe,CAA8C;IACrE,OAAO,CAAC,aAAa,CAA0C;IAC/D,OAAO,CAAC,aAAa,CAA8B;IAGnD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAS;IACpD,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,mBAAmB,CAAkB;IAE7C,YAAY,OAAO,EAAE,yBAAyB,EAwB7C;IAED;;OAEG;IACH,OAAO,CAAC,WAAW;IAoBnB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,WAAW;IAuBnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;OAEG;IACH,OAAO,CAAC,WAAW;IAUnB;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B1C;IAED;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,UAAU,CAQzD;IAED;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,UAAU,CAQnD;IAED;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,UAAU,CAQvC;IAED;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CA4B3B;IAED;;OAEG;IACH,WAAW,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,oBAAoB,IAAI,MAAM,CAE7B;IAED;;OAEG;IACH,kBAAkB,IAAI,OAAO,CAE5B;CACF"}

package/dist/transport/websocket.js

@@ -0,0 +1,324 @@
+/**
+ * WebSocket Transport implementation for LSP
+ */
+import { createRequire } from 'node:module';
+const READY_STATE_CONNECTING = 0;
+const READY_STATE_OPEN = 1;
+function hasEventEmitterAPI(socket) {
+    return typeof socket.on === 'function';
+}
+function getNativeWebSocketCtor() {
+    if (typeof globalThis.WebSocket === 'undefined') {
+        return undefined;
+    }
+    const ctor = globalThis.WebSocket;
+    return (url) => new ctor(url);
+}
+function getWsWebSocketCtor() {
+    try {
+        const require = createRequire(import.meta.url);
+        const moduleValue = require('ws');
+        if (typeof moduleValue === 'function') {
+            return (url) => new moduleValue(url);
+        }
+        if (moduleValue.WebSocket) {
+            return (url) => new moduleValue.WebSocket(url);
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createWebSocketClient(url) {
+    const nativeCtor = getNativeWebSocketCtor();
+    if (nativeCtor) {
+        return nativeCtor(url);
+    }
+    const wsCtor = getWsWebSocketCtor();
+    if (wsCtor) {
+        return wsCtor(url);
+    }
+    throw new Error('WebSocket client unavailable. Use Node.js >= 22.4 for native globalThis.WebSocket, or install "ws" as an optional peer dependency.');
+}
+function parseIncomingMessage(data) {
+    if (typeof data === 'string') {
+        return JSON.parse(data);
+    }
+    if (data instanceof Uint8Array) {
+        return JSON.parse(Buffer.from(data).toString('utf8'));
+    }
+    if (data instanceof ArrayBuffer) {
+        return JSON.parse(Buffer.from(data).toString('utf8'));
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) {
+        return JSON.parse(data.toString('utf8'));
+    }
+    throw new Error('Unsupported WebSocket message payload type');
+}
+/**
+ * WebSocket-based transport for LSP communication
+ *
+ * Supports both client and server modes:
+ * - Client mode: Connects to a WebSocket server URL
+ * - Server mode: Wraps an existing WebSocket connection
+ */
+export class WebSocketTransport {
+    socket;
+    connected = false;
+    messageHandlers = new Set();
+    errorHandlers = new Set();
+    closeHandlers = new Set();
+    // Reconnection state
+    mode;
+    url;
+    enableReconnect;
+    maxReconnectAttempts;
+    reconnectDelay;
+    maxReconnectDelay;
+    reconnectBackoffMultiplier;
+    reconnectAttempts = 0;
+    reconnectTimer;
+    intentionallyClosed = false;
+    constructor(options) {
+        if (!options.url && !options.socket) {
+            throw new Error('Either url or socket must be provided');
+        }
+        if (options.url && options.socket) {
+            throw new Error('Cannot provide both url and socket');
+        }
+        this.mode = options.socket ? 'server' : 'client';
+        this.url = options.url;
+        this.enableReconnect = options.enableReconnect ?? false;
+        this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+        this.reconnectDelay = options.reconnectDelay ?? 1000;
+        this.maxReconnectDelay = options.maxReconnectDelay ?? 30000;
+        this.reconnectBackoffMultiplier = options.reconnectBackoffMultiplier ?? 2;
+        if (options.socket) {
+            this.socket = options.socket;
+        }
+        else {
+            this.socket = createWebSocketClient(this.url);
+        }
+        this.setupSocket();
+    }
+    /**
+     * Setup event handlers for the WebSocket
+     */
+    setupSocket() {
+        if (hasEventEmitterAPI(this.socket)) {
+            this.socket.on('open', () => this.handleOpen());
+            this.socket.on('message', (data) => this.handleMessageData(data));
+            this.socket.on('error', (error) => this.notifyError(error));
+            this.socket.on('close', () => this.handleClose());
+            return;
+        }
+        this.socket.addEventListener?.('open', () => this.handleOpen());
+        this.socket.addEventListener?.('message', (event) => {
+            this.handleMessageData(event.data);
+        });
+        this.socket.addEventListener?.('error', (event) => {
+            const error = event.error instanceof Error ? event.error : new Error('WebSocket error');
+            this.notifyError(error);
+        });
+        this.socket.addEventListener?.('close', () => this.handleClose());
+    }
+    handleOpen() {
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+    }
+    handleMessageData(data) {
+        try {
+            const message = parseIncomingMessage(data);
+            for (const handler of this.messageHandlers) {
+                try {
+                    handler(message);
+                }
+                catch {
+                    // Ignore message-handler failures to avoid breaking the transport loop.
+                }
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.notifyError(new Error(`Failed to parse message: ${err.message}`));
+        }
+    }
+    handleClose() {
+        const wasConnected = this.connected;
+        this.connected = false;
+        for (const handler of this.closeHandlers) {
+            try {
+                handler();
+            }
+            catch {
+                // Ignore close-handler failures.
+            }
+        }
+        if (this.mode === 'client' &&
+            this.enableReconnect &&
+            !this.intentionallyClosed &&
+            wasConnected &&
+            this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.scheduleReconnect();
+        }
+    }
+    /**
+     * Schedule a reconnection attempt with exponential backoff
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            return;
+        }
+        this.reconnectAttempts++;
+        const baseDelay = this.reconnectDelay * Math.pow(this.reconnectBackoffMultiplier, this.reconnectAttempts - 1);
+        const delay = Math.min(baseDelay, this.maxReconnectDelay);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.attemptReconnect();
+        }, delay);
+    }
+    /**
+     * Attempt to reconnect to the server
+     */
+    attemptReconnect() {
+        if (this.intentionallyClosed || !this.url) {
+            return;
+        }
+        try {
+            this.socket = createWebSocketClient(this.url);
+            this.setupSocket();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.notifyError(new Error(`Reconnection attempt ${this.reconnectAttempts} failed: ${err.message}`));
+            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                this.scheduleReconnect();
+            }
+        }
+    }
+    /**
+     * Notify all error handlers
+     */
+    notifyError(error) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error);
+            }
+            catch {
+                // Ignore error-handler failures.
+            }
+        }
+    }
+    /**
+     * Send a message through the WebSocket
+     */
+    async send(message) {
+        if (!this.connected || this.socket.readyState !== READY_STATE_OPEN) {
+            throw new Error('WebSocket is not connected');
+        }
+        return new Promise((resolve, reject) => {
+            const data = JSON.stringify(message);
+            if (hasEventEmitterAPI(this.socket)) {
+                this.socket.send(data, (error) => {
+                    if (error) {
+                        reject(new Error(`Failed to send message: ${error.message}`));
+                        return;
+                    }
+                    resolve();
+                });
+                return;
+            }
+            try {
+                this.socket.send(data);
+                resolve();
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                reject(new Error(`Failed to send message: ${err.message}`));
+            }
+        });
+    }
+    /**
+     * Register a handler for incoming messages
+     */
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return {
+            dispose: () => {
+                this.messageHandlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Register a handler for transport errors
+     */
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return {
+            dispose: () => {
+                this.errorHandlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Register a handler for transport closure
+     */
+    onClose(handler) {
+        this.closeHandlers.add(handler);
+        return {
+            dispose: () => {
+                this.closeHandlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Close the WebSocket connection
+     */
+    async close() {
+        this.intentionallyClosed = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        if (this.socket.readyState === READY_STATE_OPEN ||
+            this.socket.readyState === READY_STATE_CONNECTING) {
+            return new Promise((resolve) => {
+                const cleanup = () => {
+                    resolve();
+                };
+                if (hasEventEmitterAPI(this.socket) && this.socket.once) {
+                    this.socket.once('close', cleanup);
+                }
+                else {
+                    this.socket.addEventListener?.('close', cleanup);
+                }
+                setTimeout(cleanup, 5000);
+                this.socket.close();
+            });
+        }
+    }
+    /**
+     * Check if the transport is currently connected
+     */
+    isConnected() {
+        return this.connected && this.socket.readyState === READY_STATE_OPEN;
+    }
+    /**
+     * Get the current reconnection attempt count
+     */
+    getReconnectAttempts() {
+        return this.reconnectAttempts;
+    }
+    /**
+     * Check if reconnection is enabled
+     */
+    isReconnectEnabled() {
+        return this.enableReconnect;
+    }
+}
+//# sourceMappingURL=websocket.js.map