@antseed/node 0.1.0

package/dist/p2p/connection-manager.js

@@ -0,0 +1,726 @@
+import { EventEmitter } from "node:events";
+import net from "node:net";
+import { ConnectionState } from "../types/connection.js";
+import { getDefaultIceConfig } from "./ice-config.js";
+import { NonceReplayGuard, buildConnectionAuthEnvelope, verifyConnectionAuthEnvelope, } from "./connection-auth.js";
+let _nodeDatachannel = null;
+async function loadNodeDatachannel() {
+    if (_nodeDatachannel)
+        return _nodeDatachannel;
+    _nodeDatachannel = await import("node-datachannel");
+    return _nodeDatachannel;
+}
+function getNodeDatachannel() {
+    if (!_nodeDatachannel)
+        throw new Error("node-datachannel not loaded");
+    return _nodeDatachannel;
+}
+const DATA_CHANNEL_LABEL = "antseed-data";
+const LINE_SEPARATOR = "\n";
+const INITIAL_LINE_TIMEOUT_MS = 10_000;
+const MAX_INITIAL_LINE_BYTES = 8 * 1024;
+/** Represents a single P2P connection. */
+export class PeerConnection extends EventEmitter {
+    remotePeerId;
+    isInitiator;
+    _state = ConnectionState.Connecting;
+    _timeoutMs;
+    _timeoutHandle = null;
+    _rtc = null;
+    _dataChannel = null;
+    _rawSocket = null;
+    _signalingSocket = null;
+    constructor(config) {
+        super();
+        this.remotePeerId = config.remotePeerId;
+        this.isInitiator = config.isInitiator;
+        this._timeoutMs = config.timeoutMs ?? 30_000;
+    }
+    get state() {
+        return this._state;
+    }
+    attachRtcPeer(rtc) {
+        this._rtc = rtc;
+    }
+    attachSignalingSocket(socket) {
+        this._signalingSocket = socket;
+    }
+    attachDataChannel(channel) {
+        this._dataChannel = channel;
+        channel.onOpen(() => {
+            this.clearTimeout();
+            if (this._state === ConnectionState.Connecting) {
+                this.setState(ConnectionState.Open);
+            }
+        });
+        channel.onClosed(() => {
+            if (this._state !== ConnectionState.Closed && this._state !== ConnectionState.Failed) {
+                this.setState(ConnectionState.Closed);
+            }
+        });
+        channel.onError((err) => {
+            this.fail(new Error(`DataChannel error: ${err}`));
+        });
+        channel.onMessage((msg) => {
+            if (typeof msg === "string") {
+                this.emit("message", new TextEncoder().encode(msg));
+            }
+            else {
+                this.emit("message", new Uint8Array(msg));
+            }
+        });
+    }
+    attachRawSocket(socket, initialData) {
+        this._rawSocket = socket;
+        socket.on("data", (chunk) => {
+            this.emit("message", new Uint8Array(chunk));
+        });
+        socket.on("error", (err) => {
+            this.fail(err);
+        });
+        socket.on("close", () => {
+            if (this._state !== ConnectionState.Closed && this._state !== ConnectionState.Failed) {
+                this.setState(ConnectionState.Closed);
+            }
+        });
+        this.clearTimeout();
+        if (this._state === ConnectionState.Connecting) {
+            this.setState(ConnectionState.Open);
+        }
+        if (initialData && initialData.length > 0) {
+            queueMicrotask(() => {
+                this.emit("message", initialData);
+            });
+        }
+    }
+    fail(err) {
+        if (this._state !== ConnectionState.Failed && this._state !== ConnectionState.Closed) {
+            this.setState(ConnectionState.Failed);
+        }
+        this._teardownTransports();
+        this._emitError(err);
+    }
+    /** Transition to a new state and emit event. */
+    setState(newState) {
+        if (this._state === newState)
+            return;
+        this._state = newState;
+        this.emit("stateChange", newState);
+    }
+    /** Start the connection timeout. */
+    startTimeout() {
+        this._timeoutHandle = setTimeout(() => {
+            if (this._state === ConnectionState.Connecting) {
+                this.fail(new Error(`Connection to ${this.remotePeerId} timed out`));
+            }
+        }, this._timeoutMs);
+    }
+    /** Clear the connection timeout. */
+    clearTimeout() {
+        if (this._timeoutHandle) {
+            clearTimeout(this._timeoutHandle);
+            this._timeoutHandle = null;
+        }
+    }
+    /** Send a message through the active transport. */
+    send(data) {
+        if (this._state !== ConnectionState.Open && this._state !== ConnectionState.Authenticated) {
+            throw new Error(`Cannot send in state ${this._state}`);
+        }
+        if (this._dataChannel && this._dataChannel.isOpen()) {
+            const ok = this._dataChannel.sendMessageBinary(data);
+            if (!ok) {
+                throw new Error(`Failed to send data to ${this.remotePeerId}`);
+            }
+            return;
+        }
+        if (!this._rawSocket || this._rawSocket.destroyed || !this._rawSocket.writable) {
+            throw new Error(`Cannot send to ${this.remotePeerId}: no writable transport`);
+        }
+        this._rawSocket.write(Buffer.from(data));
+    }
+    /** Close the connection gracefully. */
+    close() {
+        if (this._state === ConnectionState.Closed) {
+            return;
+        }
+        this.clearTimeout();
+        this.setState(ConnectionState.Closing);
+        this._teardownTransports();
+        this.setState(ConnectionState.Closed);
+        this.removeAllListeners();
+    }
+    _teardownTransports() {
+        if (this._dataChannel) {
+            try {
+                this._dataChannel.close();
+            }
+            catch {
+                // best effort close
+            }
+            this._dataChannel = null;
+        }
+        if (this._rtc) {
+            try {
+                this._rtc.close();
+            }
+            catch {
+                // best effort close
+            }
+            this._rtc = null;
+        }
+        if (this._rawSocket && !this._rawSocket.destroyed) {
+            this._rawSocket.destroy();
+        }
+        this._rawSocket = null;
+        if (this._signalingSocket && !this._signalingSocket.destroyed) {
+            this._signalingSocket.destroy();
+        }
+        this._signalingSocket = null;
+    }
+    _emitError(err) {
+        if (this.listenerCount("error") > 0) {
+            this.emit("error", err);
+        }
+    }
+}
+/** Manages all peer connections and optional inbound listening. */
+export class ConnectionManager extends EventEmitter {
+    _connections = new Map();
+    _iceConfig;
+    _localPeerId = null;
+    _localPrivateKey = null;
+    _listenHost = "127.0.0.1";
+    _listenPort = null;
+    _server = null;
+    _transportMode;
+    _metadataProvider = null;
+    _ipConnectionCounts = new Map();
+    _introReplayGuard = new NonceReplayGuard();
+    static _knownEndpoints = new Map();
+    static _detectedTransportMode = null;
+    constructor(iceConfig) {
+        super();
+        this._iceConfig = iceConfig ?? getDefaultIceConfig();
+        this._transportMode = ConnectionManager._detectTransportMode();
+    }
+    static async init(iceConfig) {
+        try {
+            await loadNodeDatachannel();
+        }
+        catch {
+            // node-datachannel not available — TCP fallback will be used
+        }
+        return new ConnectionManager(iceConfig);
+    }
+    get iceConfig() {
+        return this._iceConfig;
+    }
+    get connections() {
+        return this._connections;
+    }
+    getListeningPort() {
+        return this._listenPort;
+    }
+    setMetadataProvider(provider) {
+        this._metadataProvider = provider;
+    }
+    setLocalPeerId(peerId) {
+        this._localPeerId = peerId;
+    }
+    setLocalIdentity(identity) {
+        this._localPeerId = identity.peerId;
+        this._localPrivateKey = identity.privateKey;
+    }
+    static registerPeerEndpoint(peerId, endpoint) {
+        this._knownEndpoints.set(peerId, endpoint);
+    }
+    static resolvePeerEndpoint(peerId) {
+        return this._knownEndpoints.get(peerId);
+    }
+    registerPeerEndpoint(peerId, endpoint) {
+        ConnectionManager.registerPeerEndpoint(peerId, endpoint);
+    }
+    async startListening(config) {
+        this._localPeerId = config.peerId;
+        this._listenHost = config.host ?? "127.0.0.1";
+        this._listenPort = config.port;
+        if (this._server) {
+            return;
+        }
+        this._server = net.createServer((socket) => {
+            const ip = socket.remoteAddress ?? 'unknown';
+            const current = this._ipConnectionCounts.get(ip) ?? 0;
+            if (current >= 10) {
+                socket.destroy();
+                return;
+            }
+            this._ipConnectionCounts.set(ip, current + 1);
+            socket.once('close', () => {
+                const count = this._ipConnectionCounts.get(ip) ?? 1;
+                if (count <= 1) {
+                    this._ipConnectionCounts.delete(ip);
+                }
+                else {
+                    this._ipConnectionCounts.set(ip, count - 1);
+                }
+            });
+            this._handleInboundSocket(socket);
+        });
+        this._server.maxConnections = 256;
+        await new Promise((resolve, reject) => {
+            this._server.once("error", reject);
+            this._server.listen(this._listenPort, this._listenHost, () => resolve());
+        });
+        // Resolve actual bound port (important when port 0 is used for OS-assigned)
+        const addr = this._server.address();
+        if (addr && typeof addr !== 'string') {
+            this._listenPort = addr.port;
+        }
+        ConnectionManager.registerPeerEndpoint(config.peerId, {
+            host: this._listenHost,
+            port: this._listenPort,
+        });
+    }
+    async stopListening() {
+        if (!this._server) {
+            return;
+        }
+        const server = this._server;
+        this._server = null;
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+        if (this._localPeerId) {
+            ConnectionManager._knownEndpoints.delete(this._localPeerId);
+        }
+    }
+    /** Create a new outbound connection. */
+    createConnection(config) {
+        const existing = this._connections.get(config.remotePeerId);
+        if (existing && existing.state !== ConnectionState.Closed && existing.state !== ConnectionState.Failed) {
+            throw new Error(`Connection to ${config.remotePeerId} already exists`);
+        }
+        const conn = new PeerConnection(config);
+        this._registerConnection(config.remotePeerId, conn);
+        conn.startTimeout();
+        if (!this._localPeerId) {
+            queueMicrotask(() => {
+                conn.fail(new Error("Local peer id is not configured"));
+            });
+            return conn;
+        }
+        if (!this._localPrivateKey) {
+            queueMicrotask(() => {
+                conn.fail(new Error("Local private key is not configured"));
+            });
+            return conn;
+        }
+        const endpoint = config.endpoint ?? ConnectionManager.resolvePeerEndpoint(config.remotePeerId);
+        if (!endpoint) {
+            queueMicrotask(() => {
+                conn.fail(new Error(`No endpoint registered for peer ${config.remotePeerId}`));
+            });
+            return conn;
+        }
+        ConnectionManager.registerPeerEndpoint(config.remotePeerId, endpoint);
+        if (this._transportMode === "webrtc") {
+            this._createWebRtcConnection(config, conn, endpoint);
+        }
+        else {
+            this._createTcpConnection(config, conn, endpoint);
+        }
+        return conn;
+    }
+    /** Get an existing connection by peer ID. */
+    getConnection(peerId) {
+        return this._connections.get(peerId);
+    }
+    /** Close a specific connection. */
+    closeConnection(peerId) {
+        const conn = this._connections.get(peerId);
+        if (conn) {
+            conn.close();
+        }
+    }
+    /** Close all connections and clean up. */
+    closeAll() {
+        for (const conn of this._connections.values()) {
+            conn.close();
+        }
+        this._connections.clear();
+        if (this._server) {
+            void this.stopListening();
+        }
+    }
+    _createWebRtcConnection(config, conn, endpoint) {
+        const signalingSocket = net.connect({ host: endpoint.host, port: endpoint.port });
+        conn.attachSignalingSocket(signalingSocket);
+        let rtc = null;
+        const pendingSignals = [];
+        this._attachSignalingParser(signalingSocket, (msg) => {
+            if (!rtc) {
+                pendingSignals.push(msg);
+                return;
+            }
+            this._applySignalToRtc(rtc, msg, conn);
+        }, (err) => conn.fail(err), "");
+        signalingSocket.once("connect", () => {
+            this._sendLine(signalingSocket, {
+                type: "hello",
+                auth: buildConnectionAuthEnvelope("hello", this._localPeerId, this._localPrivateKey),
+            });
+            rtc = this._createRtcPeer(config.remotePeerId);
+            conn.attachRtcPeer(rtc);
+            this._wireRtcPeer(conn, rtc, signalingSocket, true);
+            for (const signal of pendingSignals) {
+                this._applySignalToRtc(rtc, signal, conn);
+            }
+            pendingSignals.length = 0;
+        });
+        signalingSocket.on("error", (err) => {
+            if (conn.state === ConnectionState.Connecting) {
+                conn.fail(err);
+            }
+        });
+        signalingSocket.on("close", () => {
+            if (conn.state === ConnectionState.Connecting) {
+                conn.fail(new Error(`Signaling socket closed before connection to ${config.remotePeerId} opened`));
+            }
+        });
+    }
+    _createTcpConnection(config, conn, endpoint) {
+        const socket = net.connect({ host: endpoint.host, port: endpoint.port });
+        socket.once("connect", () => {
+            this._sendLine(socket, {
+                type: "intro",
+                auth: buildConnectionAuthEnvelope("intro", this._localPeerId, this._localPrivateKey),
+            });
+            conn.attachRawSocket(socket);
+        });
+        socket.on("error", (err) => {
+            if (conn.state === ConnectionState.Connecting) {
+                conn.fail(err);
+            }
+        });
+        socket.on("close", () => {
+            if (conn.state === ConnectionState.Connecting) {
+                conn.fail(new Error(`TCP socket closed before connection to ${config.remotePeerId} opened`));
+            }
+        });
+    }
+    _handleInboundSocket(socket) {
+        let buffer = Buffer.alloc(0);
+        const timeout = setTimeout(() => {
+            socket.destroy(new Error("Inbound socket intro timeout"));
+        }, INITIAL_LINE_TIMEOUT_MS);
+        const onData = (chunk) => {
+            if (buffer.length + chunk.length > MAX_INITIAL_LINE_BYTES) {
+                socket.off("data", onData);
+                clearTimeout(timeout);
+                socket.destroy(new Error("Inbound socket intro exceeded 8KB limit"));
+                return;
+            }
+            buffer = Buffer.concat([buffer, chunk]);
+            const lineBreak = buffer.indexOf(0x0a); // '\n'
+            if (lineBreak < 0) {
+                return;
+            }
+            socket.off("data", onData);
+            clearTimeout(timeout);
+            const line = buffer.subarray(0, lineBreak).toString("utf8").trim();
+            const remaining = buffer.subarray(lineBreak + 1);
+            // Detect HTTP requests (metadata endpoint served on signaling port)
+            if (line.startsWith("GET ") || line.startsWith("HEAD ")) {
+                this._serveHttpMetadata(socket, line);
+                return;
+            }
+            let intro;
+            try {
+                intro = JSON.parse(line);
+            }
+            catch {
+                socket.destroy(new Error("Failed to parse initial socket message"));
+                return;
+            }
+            if (intro.type !== "intro" && intro.type !== "hello") {
+                socket.destroy(new Error("Unsupported initial socket message type"));
+                return;
+            }
+            const verified = verifyConnectionAuthEnvelope({
+                type: intro.type,
+                auth: intro.auth,
+                replayGuard: this._introReplayGuard,
+            });
+            if (!verified.ok || !verified.peerId) {
+                socket.destroy(new Error(`Inbound auth failed: ${verified.reason ?? "unknown reason"}`));
+                return;
+            }
+            if (intro.type === "intro") {
+                this._acceptTcpInbound(socket, verified.peerId, remaining);
+                return;
+            }
+            if (intro.type === "hello") {
+                this._acceptWebRtcInbound(socket, verified.peerId, remaining.toString("utf8"));
+                return;
+            }
+            socket.destroy(new Error("Unsupported initial socket message type"));
+        };
+        socket.on("data", onData);
+        socket.on("error", (err) => {
+            clearTimeout(timeout);
+            this._emitError(err);
+        });
+        socket.on("close", () => {
+            clearTimeout(timeout);
+        });
+    }
+    _serveHttpMetadata(socket, requestLine) {
+        const MAX_HEADER_SIZE = 8 * 1024; // 8KB
+        let headerBytes = 0;
+        const headerTimeout = setTimeout(() => {
+            socket.destroy(new Error("HTTP header read timeout"));
+        }, 5_000);
+        const onData = (chunk) => {
+            headerBytes += chunk.length;
+            if (headerBytes > MAX_HEADER_SIZE) {
+                clearTimeout(headerTimeout);
+                socket.off("data", onData);
+                socket.destroy(new Error("HTTP headers exceeded 8KB limit"));
+                return;
+            }
+            if (chunk.includes(Buffer.from("\r\n\r\n")) || chunk.includes(Buffer.from("\n\n"))) {
+                clearTimeout(headerTimeout);
+                socket.off("data", onData);
+            }
+        };
+        socket.on("data", onData);
+        const url = requestLine.split(" ")[1] ?? "";
+        let statusLine;
+        let body;
+        if (url !== "/metadata") {
+            statusLine = "404 Not Found";
+            body = JSON.stringify({ error: "not found" });
+        }
+        else if (!this._metadataProvider) {
+            statusLine = "503 Service Unavailable";
+            body = JSON.stringify({ error: "metadata not available" });
+        }
+        else {
+            const metadata = this._metadataProvider();
+            if (!metadata) {
+                statusLine = "503 Service Unavailable";
+                body = JSON.stringify({ error: "metadata not available" });
+            }
+            else {
+                statusLine = "200 OK";
+                body = JSON.stringify(metadata);
+            }
+        }
+        socket.end(`HTTP/1.1 ${statusLine}\r\n` +
+            `Content-Type: application/json\r\n` +
+            `Content-Length: ${Buffer.byteLength(body)}\r\n` +
+            `Connection: close\r\n` +
+            `\r\n` +
+            body);
+    }
+    _acceptTcpInbound(socket, remotePeerId, remainingData) {
+        const existing = this._connections.get(remotePeerId);
+        if (existing && existing.state !== ConnectionState.Closed && existing.state !== ConnectionState.Failed) {
+            socket.destroy(new Error(`Connection from ${remotePeerId} already exists`));
+            return;
+        }
+        const conn = new PeerConnection({
+            remotePeerId,
+            isInitiator: false,
+        });
+        this._registerConnection(remotePeerId, conn);
+        conn.attachRawSocket(socket, remainingData.length > 0 ? new Uint8Array(remainingData) : undefined);
+        this.emit("connection", conn);
+    }
+    _acceptWebRtcInbound(socket, remotePeerId, initialSignalingBuffer) {
+        const existing = this._connections.get(remotePeerId);
+        if (existing && existing.state !== ConnectionState.Closed && existing.state !== ConnectionState.Failed) {
+            socket.destroy(new Error(`Connection from ${remotePeerId} already exists`));
+            return;
+        }
+        const conn = new PeerConnection({
+            remotePeerId,
+            isInitiator: false,
+        });
+        conn.attachSignalingSocket(socket);
+        this._registerConnection(remotePeerId, conn);
+        const rtc = this._createRtcPeer(remotePeerId);
+        conn.attachRtcPeer(rtc);
+        this._wireRtcPeer(conn, rtc, socket, false);
+        this._attachSignalingParser(socket, (msg) => {
+            this._applySignalToRtc(rtc, msg, conn);
+        }, (err) => conn.fail(err), initialSignalingBuffer);
+        socket.on("close", () => {
+            if (conn.state === ConnectionState.Connecting) {
+                conn.fail(new Error(`Inbound signaling from ${remotePeerId} closed before connection opened`));
+            }
+        });
+        socket.on("error", (err) => {
+            conn.fail(err);
+        });
+        this.emit("connection", conn);
+    }
+    _wireRtcPeer(conn, rtc, signalingSocket, isInitiator) {
+        rtc.onLocalDescription((sdp, descriptionType) => {
+            this._sendLine(signalingSocket, {
+                type: "sdp",
+                sdp,
+                descriptionType: this._normalizeDescriptionType(descriptionType),
+            });
+        });
+        rtc.onLocalCandidate((candidate, mid) => {
+            this._sendLine(signalingSocket, {
+                type: "candidate",
+                candidate,
+                mid,
+            });
+        });
+        rtc.onStateChange((state) => {
+            const lower = state.toLowerCase();
+            if (lower === "failed" || lower === "disconnected" || lower === "closed") {
+                if (conn.state === ConnectionState.Connecting || conn.state === ConnectionState.Open) {
+                    conn.fail(new Error(`WebRTC state is ${state}`));
+                }
+                else if (conn.state === ConnectionState.Authenticated) {
+                    conn.close();
+                }
+            }
+        });
+        if (isInitiator) {
+            const channel = rtc.createDataChannel(DATA_CHANNEL_LABEL, { ordered: true });
+            conn.attachDataChannel(channel);
+            rtc.setLocalDescription();
+        }
+        else {
+            rtc.onDataChannel((channel) => {
+                conn.attachDataChannel(channel);
+            });
+        }
+    }
+    _createRtcPeer(remotePeerId) {
+        const ndc = getNodeDatachannel();
+        const iceServers = this._iceConfig.iceServers.flatMap((server) => {
+            return Array.isArray(server.urls) ? server.urls : [server.urls];
+        });
+        return new ndc.PeerConnection(`idleai-${remotePeerId.slice(0, 12)}`, {
+            iceServers,
+            iceTransportPolicy: this._iceConfig.iceTransportPolicy ?? "all",
+        });
+    }
+    _applySignalToRtc(rtc, signal, conn) {
+        try {
+            if (signal.type === "sdp") {
+                rtc.setRemoteDescription(signal.sdp, signal.descriptionType);
+            }
+            else {
+                rtc.addRemoteCandidate(signal.candidate, signal.mid);
+            }
+        }
+        catch (err) {
+            conn.fail(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    _attachSignalingParser(socket, onMessage, onError, initialBuffer) {
+        const MAX_BUFFER_SIZE = 64 * 1024; // 64KB
+        let buffer = initialBuffer;
+        const processBuffer = () => {
+            while (true) {
+                const lineBreak = buffer.indexOf(LINE_SEPARATOR);
+                if (lineBreak < 0) {
+                    break;
+                }
+                const line = buffer.slice(0, lineBreak).trim();
+                buffer = buffer.slice(lineBreak + LINE_SEPARATOR.length);
+                if (line.length === 0) {
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    onMessage(parsed);
+                }
+                catch (err) {
+                    onError(err instanceof Error ? err : new Error(String(err)));
+                    return;
+                }
+            }
+        };
+        if (buffer.length > 0) {
+            processBuffer();
+        }
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            if (buffer.length > MAX_BUFFER_SIZE) {
+                socket.destroy(new Error("Signaling buffer exceeded 64KB limit"));
+                return;
+            }
+            processBuffer();
+        });
+    }
+    _sendLine(socket, payload) {
+        if (socket.destroyed) {
+            throw new Error("Cannot send message on destroyed socket");
+        }
+        socket.write(JSON.stringify(payload) + LINE_SEPARATOR);
+    }
+    _registerConnection(peerId, conn) {
+        this._connections.set(peerId, conn);
+        conn.on("stateChange", (state) => {
+            this.emit("connectionStateChange", peerId, state);
+            if (state === ConnectionState.Closed || state === ConnectionState.Failed) {
+                this._connections.delete(peerId);
+            }
+        });
+        conn.on("error", (err) => {
+            this._emitError(err);
+        });
+    }
+    static _detectTransportMode() {
+        if (this._detectedTransportMode) {
+            return this._detectedTransportMode;
+        }
+        try {
+            const ndc = _nodeDatachannel;
+            if (!ndc) {
+                this._detectedTransportMode = "tcp";
+                return this._detectedTransportMode;
+            }
+            const probe = new ndc.PeerConnection("idleai-transport-probe", { iceServers: [] });
+            try {
+                const channel = probe.createDataChannel("probe", { ordered: true });
+                channel.close();
+            }
+            finally {
+                probe.close();
+            }
+            this._detectedTransportMode = "webrtc";
+        }
+        catch {
+            this._detectedTransportMode = "tcp";
+        }
+        return this._detectedTransportMode;
+    }
+    _normalizeDescriptionType(type) {
+        switch (type) {
+            case "offer":
+            case "answer":
+            case "pranswer":
+            case "rollback":
+            case "unspec":
+                return type;
+            default:
+                return "unspec";
+        }
+    }
+    _emitError(err) {
+        if (this.listenerCount("error") > 0) {
+            this.emit("error", err);
+        }
+    }
+}
+//# sourceMappingURL=connection-manager.js.map