sealbridge 0.0.1 → 0.1.0

package/dist/packages/relay/dist/index.js

@@ -0,0 +1,707 @@
+// SPDX-License-Identifier: Apache-2.0
+import { createServer } from 'node:http';
+import { WebSocketServer, WebSocket } from 'ws';
+import { verifyEnvelope, createRelayAuthToken, normalizeRelayOrigin, validateRelayEndpointUrl, } from '../../core/dist/index.js';
+import { DEFAULT_MAX_ENVELOPE_BYTES, InMemoryRelay, createRelayFetchHandler, mapRelayError, normalizeReceiveFilter, relayHttpHeaders, sanitizeRelayErrorCode, } from './fetch.js';
+import { createPinnedRelayFetch, resolveAndValidateRelayEndpoint } from './ssrf.js';
+export * from './fetch.js';
+export * from './retry.js';
+import { isTransientRelayError, relayRetryDelay, waitForRelayRetry, relayDeadline } from './retry.js';
+export { createPinnedRelayFetch, resolveAndValidateRelayEndpoint } from './ssrf.js';
+export { createSignedAgentCard, verifySignedAgentCard, findDiscoveredAgentCard, toA2AAgentCard, createInviteToken, parseAndVerifyInviteToken, } from '../../core/dist/index.js';
+export async function startLocalRelay(options = {}) {
+    const relay = new InMemoryRelay({
+        tamper: options.tamper,
+        allowUnboundRelayAuth: options.allowUnboundRelayAuth,
+    });
+    const handler = createRelayFetchHandler({
+        relay,
+        allowQueryAuth: options.allowQueryAuth,
+        allowUnboundRelayAuth: options.allowUnboundRelayAuth,
+    });
+    let boundOrigin = 'http://127.0.0.1';
+    const server = createServer(async (request, response) => {
+        const controller = new AbortController();
+        response.once('close', () => controller.abort());
+        try {
+            const chunks = [];
+            let size = 0;
+            for await (const chunk of request) {
+                size += chunk.length;
+                if (size > DEFAULT_MAX_ENVELOPE_BYTES)
+                    throw new Error('BODY_TOO_LARGE');
+                chunks.push(chunk);
+            }
+            const result = await handler(new Request(new URL(request.url ?? '/', boundOrigin), {
+                method: request.method,
+                headers: Object.entries(request.headers).flatMap(([name, value]) => value === undefined
+                    ? []
+                    : (Array.isArray(value) ? value : [value]).map((v) => [name, v])),
+                ...(chunks.length ? { body: Buffer.concat(chunks) } : {}),
+                signal: controller.signal,
+            }));
+            const kind = result.headers.get('content-type')?.startsWith('text/event-stream')
+                ? 'sse'
+                : result.body == null
+                    ? 'empty'
+                    : 'json';
+            response.writeHead(result.status, {
+                ...Object.fromEntries(result.headers),
+                ...relayHttpHeaders(kind),
+            });
+            if (!result.body) {
+                response.end();
+                return;
+            }
+            const reader = result.body.getReader();
+            try {
+                while (!response.destroyed && !response.writableEnded) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    if (!response.write(value)) {
+                        // A disconnected client never emits drain. Close and error must unblock the write.
+                        if (response.destroyed || response.writableEnded)
+                            break;
+                        await new Promise((resolve) => {
+                            const doneWriting = () => {
+                                response.off('drain', doneWriting);
+                                response.off('close', doneWriting);
+                                response.off('error', doneWriting);
+                                resolve();
+                            };
+                            response.once('drain', doneWriting);
+                            response.once('close', doneWriting);
+                            response.once('error', doneWriting);
+                            if (response.destroyed || response.writableEnded)
+                                doneWriting();
+                        });
+                        if (response.destroyed || response.writableEnded)
+                            break;
+                    }
+                }
+            }
+            finally {
+                await reader.cancel();
+                if (!response.destroyed && !response.writableEnded)
+                    response.end();
+            }
+        }
+        catch (e) {
+            const mapped = mapRelayError(e);
+            if (!response.headersSent)
+                response.writeHead(mapped.status, relayHttpHeaders('json'));
+            if (!response.destroyed)
+                response.end(JSON.stringify({ error: mapped.error }));
+        }
+    });
+    server.requestTimeout = 10000;
+    const wsServer = new WebSocketServer({ server, path: '/ws', maxPayload: 1048576 });
+    const wsAuth = () => ({
+        expectedOrigin: boundOrigin,
+        requireOrigin: options.allowUnboundRelayAuth !== true,
+    });
+    wsServer.on('connection', (socket) => {
+        let subscription = { disposed: true, stop: () => { } };
+        const disposeSubscription = () => {
+            subscription.disposed = true;
+            if (subscription.timer !== undefined) {
+                clearTimeout(subscription.timer);
+                subscription.timer = undefined;
+            }
+            subscription.stop();
+            subscription.stop = () => { };
+        };
+        socket.once('close', () => disposeSubscription());
+        socket.on('message', (raw) => {
+            try {
+                const request = JSON.parse(raw.toString());
+                if (request.method === 'send' && request.envelope) {
+                    relay.send(request.envelope);
+                    socket.send(JSON.stringify({ ok: true }));
+                }
+                else if (request.method === 'receive' && request.recipientDid) {
+                    const receive = relay.openInbox(request.recipientDid, request.authToken ?? request.auth, 'receive', wsAuth(), { role: request.role, taskId: request.taskId, peek: request.peek });
+                    socket.send(JSON.stringify({ envelope: receive() ?? null }));
+                }
+                else if (request.method === 'subscribe' && request.recipientDid) {
+                    const did = request.recipientDid, receive = relay.openInbox(did, request.authToken ?? request.auth, 'subscribe', wsAuth(), { role: request.role, taskId: request.taskId });
+                    disposeSubscription();
+                    const current = { disposed: false, stop: () => { } };
+                    subscription = current;
+                    const flush = () => {
+                        if (current.disposed)
+                            return;
+                        let envelope;
+                        // A slow socket must not pull the recipient queue ahead of maxQueueSize.
+                        while (!current.disposed &&
+                            socket.readyState === WebSocket.OPEN &&
+                            socket.bufferedAmount < 1048576 &&
+                            (envelope = receive()))
+                            socket.send(JSON.stringify({ envelope }));
+                        if (!current.disposed &&
+                            socket.readyState === WebSocket.OPEN &&
+                            socket.bufferedAmount >= 1048576) {
+                            if (current.timer !== undefined)
+                                clearTimeout(current.timer);
+                            current.timer = setTimeout(() => {
+                                current.timer = undefined;
+                                flush();
+                            }, 20);
+                        }
+                    };
+                    current.stop = relay.subscribe(did, flush);
+                    flush();
+                }
+                else if (request.method === 'unsubscribe') {
+                    disposeSubscription();
+                }
+                else
+                    throw new Error('INVALID_REQUEST');
+            }
+            catch (e) {
+                socket.send(JSON.stringify({ ok: false, error: sanitizeRelayErrorCode(e) }));
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(options.port ?? 0, options.host ?? '127.0.0.1', () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                reject(new Error('RELAY_BIND'));
+                return;
+            }
+            const hostname = address.address.includes(':')
+                ? '[' + address.address + ']'
+                : address.address;
+            boundOrigin = 'http://' + hostname + ':' + address.port;
+            resolve();
+        });
+    });
+    return {
+        relay,
+        url: boundOrigin,
+        wsUrl: boundOrigin.replace(/^http:/, 'ws:') + '/ws',
+        close: async () => {
+            for (const client of wsServer.clients)
+                client.terminate();
+            await new Promise((resolve) => wsServer.close(() => resolve()));
+            server.closeAllConnections();
+            await new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
+        },
+    };
+}
+class RelayCredentials {
+    authSource;
+    relayUrl;
+    recipientKeys = new Map();
+    constructor(authSource, relayUrl) {
+        this.authSource = authSource;
+        this.relayUrl = relayUrl;
+    }
+    setRecipientKey(key) {
+        this.recipientKeys.set(key.did, key);
+        return this;
+    }
+    async authToken(did, action) {
+        const origin = normalizeRelayOrigin(this.relayUrl);
+        const key = this.recipientKeys.get(did);
+        if (key)
+            return createRelayAuthToken(key, { action, origin });
+        if (typeof this.authSource === 'function')
+            return this.authSource(did, action, origin);
+        if (this.authSource?.did === did)
+            return createRelayAuthToken(this.authSource, { action, origin });
+        throw new Error('RELAY_AUTH_REQUIRED');
+    }
+}
+const nativeFetch = globalThis.fetch;
+function isKeyPair(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'did' in value &&
+        'privateKey' in value &&
+        typeof value.did === 'string' &&
+        typeof value.privateKey === 'string');
+}
+function splitRelayArgs(second, third, fourth) {
+    let fetcher = fetch;
+    let auth;
+    let security = {};
+    if (typeof second === 'function')
+        fetcher = second;
+    else if (isKeyPair(second))
+        auth = second;
+    else if (second)
+        security = { ...second };
+    if (typeof third === 'function' || isKeyPair(third))
+        auth = third;
+    else if (third)
+        security = { ...security, ...third };
+    if (fourth)
+        security = { ...security, ...fourth };
+    return { fetcher, auth, security };
+}
+export class HttpRelayClient extends RelayCredentials {
+    url;
+    buffered = new Map();
+    delivered = new Map();
+    baseFetcher;
+    security;
+    transportPromise;
+    fetcher;
+    constructor(url, fetcherOrKey = fetch, authOrOptions, options) {
+        const parsed = splitRelayArgs(fetcherOrKey, authOrOptions, options);
+        super(parsed.auth, url);
+        this.url = url;
+        this.baseFetcher = parsed.fetcher;
+        this.security = parsed.security;
+        this.fetcher = ((input, init) => this.dispatch(input, init));
+    }
+    async dispatch(input, init) {
+        const transport = await this.prepare();
+        return transport(input, init);
+    }
+    prepare() {
+        // Cache successful pins and security failures; transient DNS failures can be retried.
+        this.transportPromise ??= this.buildTransport().catch((error) => {
+            if (isTransientRelayError(error))
+                this.transportPromise = undefined;
+            throw error;
+        });
+        return this.transportPromise;
+    }
+    async buildTransport() {
+        const custom = this.baseFetcher !== nativeFetch;
+        if (custom && !this.security.lookup) {
+            validateRelayEndpointUrl(this.url, { allowPrivateRelay: this.security.allowPrivateRelay });
+            return this.baseFetcher;
+        }
+        const resolved = await resolveAndValidateRelayEndpoint(this.url, this.security);
+        if (custom)
+            return this.baseFetcher;
+        return createPinnedRelayFetch(resolved, this.security);
+    }
+    async send(envelope) {
+        const result = await this.fetcher(this.url + '/envelopes', {
+            method: 'POST',
+            body: JSON.stringify(envelope),
+            headers: { 'content-type': 'application/json' },
+        });
+        if (!result.ok)
+            throw new Error('RELAY_REJECTED: ' + (await result.text()));
+    }
+    async register(card) {
+        for (let attempt = 0;; attempt++) {
+            try {
+                const timeout = this.security.requestTimeoutMs ?? 45_000;
+                await relayDeadline((async () => {
+                    const r = await this.fetcher(this.url + '/agents', {
+                        method: 'POST', body: JSON.stringify(card),
+                        headers: { 'content-type': 'application/json' },
+                        signal: AbortSignal.timeout(timeout),
+                    });
+                    if (!r.ok) {
+                        await r.body?.cancel();
+                        throw new Error('RELAY_REGISTRATION_REJECTED: ' + r.status);
+                    }
+                    await r.arrayBuffer();
+                })(), timeout);
+                return;
+            }
+            catch (error) {
+                if (attempt >= 4 || !isTransientRelayError(error))
+                    throw error;
+                console.warn('Relay registration retry ' + (attempt + 1));
+                await waitForRelayRetry(relayRetryDelay(attempt));
+            }
+        }
+    }
+    async discover() {
+        const r = await this.fetcher(this.url + '/agents');
+        if (!r.ok)
+            throw new Error('DISCOVERY_FAILED');
+        const cards = (await r.json());
+        if (!Array.isArray(cards))
+            throw new Error('INVALID_AGENT_CARD');
+        const { verifySignedAgentCard } = await import('../../core/dist/index.js');
+        const now = Date.now();
+        return cards.filter((c) => verifySignedAgentCard(c, now));
+    }
+    async receive(recipientDid, waitMs, signal, filter) {
+        const normalized = normalizeReceiveFilter(filter);
+        const bufferKey = recipientDid +
+            '\0' +
+            (normalized.lease ? 'lease:' : '') + (normalized.role ?? '') +
+            '\0' +
+            (normalized.taskIds ? [...normalized.taskIds].sort().join(',') : '');
+        if (!normalized.peek) {
+            const queue = this.buffered.get(bufferKey) ?? [];
+            if (queue.length)
+                return queue.shift();
+        }
+        const params = new URLSearchParams({ recipient: recipientDid });
+        if (waitMs !== undefined)
+            params.set('waitMs', String(waitMs));
+        if (normalized.role)
+            params.set('role', normalized.role);
+        if (normalized.taskIds) {
+            for (const id of normalized.taskIds)
+                params.append('taskId', id);
+        }
+        if (normalized.peek)
+            params.set('peek', 'true');
+        else if (normalized.lease)
+            params.set('lease', 'true');
+        const r = await this.fetcher(this.url + '/envelopes?' + params.toString(), {
+            signal,
+            headers: { authorization: 'Bearer ' + (await this.authToken(recipientDid, 'receive')) },
+        });
+        if (r.status === 204)
+            return;
+        if (!r.ok) {
+            await r.body?.cancel();
+            throw new Error('RELAY_REJECTED: ' + r.status);
+        }
+        const body = (await r.json());
+        let values = 'envelopes' in body ? body.envelopes : [body];
+        if (!Array.isArray(values) || values.some((e) => !verifyEnvelope(e, recipientDid)))
+            throw new Error('RELAY_TAMPERING_DETECTED');
+        if (normalized.peek)
+            return values[0];
+        if (normalized.lease) {
+            const now = Date.now();
+            for (const [id, entry] of this.delivered)
+                if (entry.expires <= now)
+                    this.delivered.delete(id);
+            const fresh = [];
+            for (const envelope of values) {
+                const id = recipientDid + ':' + envelope.payload.envelopeId;
+                const prior = this.delivered.get(id);
+                if (prior) {
+                    if (prior.acknowledged) {
+                        try {
+                            await this.acknowledgeDelivery(recipientDid, envelope.payload.envelopeId);
+                        }
+                        catch (error) {
+                            if (!isTransientRelayError(error))
+                                throw error;
+                        }
+                    }
+                    continue;
+                }
+                if (this.delivered.size >= 16384)
+                    throw new Error('RELAY_DEDUPE_CAPACITY');
+                this.delivered.set(id, { expires: now + 10 * 60_000, acknowledged: false });
+                fresh.push(envelope);
+            }
+            values = fresh;
+        }
+        this.buffered.set(bufferKey, values);
+        return values.shift();
+    }
+    async acknowledgeDelivery(recipientDid, envelopeId) {
+        const entry = this.delivered.get(recipientDid + ':' + envelopeId);
+        if (!entry)
+            return;
+        // Processing has completed even if the DELETE response is lost. Redelivery retries the ack.
+        entry.acknowledged = true;
+        const r = await this.fetcher(this.url + '/envelopes/' + encodeURIComponent(envelopeId) +
+            '?recipient=' + encodeURIComponent(recipientDid), {
+            method: 'DELETE',
+            headers: { authorization: 'Bearer ' + await this.authToken(recipientDid, 'receive') },
+        });
+        await r.arrayBuffer();
+        if (!r.ok && r.status !== 404)
+            throw new Error('RELAY_REJECTED: ' + r.status);
+    }
+    async peek(recipientDid, filter) {
+        return this.receive(recipientDid, undefined, undefined, { ...filter, peek: true });
+    }
+    async pollInbox(recipientDid, filter) {
+        return this.receive(recipientDid, filter?.waitMs, filter?.signal, filter);
+    }
+}
+/** Persistent SSE transport with a bounded per-recipient inbox. */
+export class SseRelayClient extends HttpRelayClient {
+    maxBufferBytes = 2 * 1024 * 1024;
+    streams = new Map();
+    async receive(recipientDid, waitMs = 30000, signal) {
+        signal?.throwIfAborted();
+        let state = this.streams.get(recipientDid);
+        if (!state) {
+            state = { controller: new AbortController(), queue: [], notify: new Set() };
+            this.streams.set(recipientDid, state);
+            const current = state;
+            current.pump = (async () => {
+                try {
+                    for await (const e of this.stream(recipientDid, current.controller.signal)) {
+                        if (current.queue.length >= 1000)
+                            throw new Error('SSE_CAPACITY');
+                        current.queue.push(e);
+                        for (const notify of [...current.notify])
+                            notify();
+                    }
+                    if (!current.controller.signal.aborted)
+                        throw new Error('SSE_CLOSED');
+                }
+                catch (error) {
+                    current.error = error;
+                    for (const notify of [...current.notify])
+                        notify();
+                }
+            })();
+        }
+        if (state.queue.length)
+            return state.queue.shift();
+        if (state.error)
+            throw state.error;
+        const current = state;
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timer);
+                current.notify.delete(wake);
+                signal?.removeEventListener('abort', abort);
+            };
+            const wake = () => {
+                cleanup();
+                resolve();
+            }, abort = () => {
+                cleanup();
+                reject(new Error('SSE_ABORTED'));
+            };
+            const timer = setTimeout(wake, Math.max(0, Math.min(waitMs, 30000)));
+            current.notify.add(wake);
+            signal?.addEventListener('abort', abort, { once: true });
+            if (signal?.aborted)
+                abort();
+        });
+        if (current.error)
+            throw current.error;
+        return current.queue.shift();
+    }
+    async close() {
+        const states = [...this.streams.values()];
+        this.streams.clear();
+        for (const state of states)
+            state.controller.abort();
+        await Promise.all(states.map((s) => s.pump));
+    }
+    async *stream(recipientDid, signal) {
+        const r = await this.fetcher(this.url + '/stream?recipient=' + encodeURIComponent(recipientDid), {
+            signal,
+            headers: { authorization: 'Bearer ' + (await this.authToken(recipientDid, 'stream')) },
+        });
+        if (!r.ok || !r.body)
+            throw new Error('SSE_FAILED');
+        const reader = r.body.getReader(), decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                if (Buffer.byteLength(buffer, 'utf8') > this.maxBufferBytes)
+                    throw new Error('SSE_BUFFER_OVERFLOW');
+                let index;
+                while ((index = buffer.indexOf('\n\n')) >= 0) {
+                    const frame = buffer.slice(0, index);
+                    buffer = buffer.slice(index + 2);
+                    for (const line of frame.split('\n'))
+                        if (line.startsWith('data: ')) {
+                            const e = JSON.parse(line.slice(6));
+                            if (!verifyEnvelope(e, recipientDid))
+                                throw new Error('RELAY_TAMPERING_DETECTED');
+                            yield e;
+                        }
+                }
+            }
+        }
+        finally {
+            await reader.cancel();
+        }
+    }
+}
+function socketIsOpen(socket) {
+    return socket?.readyState === WebSocket.OPEN;
+}
+export class WebSocketRelayClient extends RelayCredentials {
+    url;
+    socket;
+    pending = false;
+    stopped = false;
+    opening;
+    security;
+    constructor(url, authOrOptions, options) {
+        const parsed = splitRelayArgs(undefined, authOrOptions, options);
+        super(parsed.auth, url);
+        this.url = url;
+        this.security = parsed.security;
+    }
+    requireSocket() {
+        if (!this.socket)
+            throw new Error('RELAY_CLOSED');
+        return this.socket;
+    }
+    async open() {
+        const resolved = await resolveAndValidateRelayEndpoint(this.url, this.security);
+        if (this.stopped)
+            return;
+        const hostname = resolved.url.hostname.replace(/^\[|\]$/g, '');
+        const secure = resolved.url.protocol === 'wss:';
+        const wsOptions = {
+            lookup: resolved.lookup,
+            ...(secure ? { servername: hostname } : {}),
+        };
+        const socket = new WebSocket(this.url, wsOptions);
+        this.socket = socket;
+        if (this.stopped) {
+            socket.close();
+            return;
+        }
+        if (socket.readyState === WebSocket.OPEN)
+            return;
+        await new Promise((resolve, reject) => {
+            const fail = (error) => reject(error);
+            socket.once('open', () => {
+                socket.off('error', fail);
+                resolve();
+            });
+            socket.once('error', fail);
+        });
+    }
+    async ready() {
+        if (this.stopped)
+            throw new Error('RELAY_CLOSED');
+        // Read readyState through a helper so the early check does not exclude OPEN later.
+        if (!socketIsOpen(this.socket)) {
+            this.opening ??= this.open();
+            await this.opening;
+        }
+        if (this.stopped || !socketIsOpen(this.socket))
+            throw new Error('RELAY_CLOSED');
+    }
+    async request(body) {
+        await this.ready();
+        if (this.pending)
+            throw new Error('CONCURRENT_RELAY_REQUEST');
+        this.pending = true;
+        try {
+            const socket = this.requireSocket();
+            return await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    socket.removeListener('message', receive);
+                    reject(new Error('RELAY_TIMEOUT'));
+                }, 5000);
+                const receive = (raw) => {
+                    clearTimeout(timer);
+                    try {
+                        const r = JSON.parse(raw.toString());
+                        r.error ? reject(new Error(r.error)) : resolve(r);
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                };
+                socket.once('message', receive);
+                socket.send(JSON.stringify(body));
+            });
+        }
+        finally {
+            this.pending = false;
+        }
+    }
+    async send(envelope) {
+        await this.request({ method: 'send', envelope });
+    }
+    async receive(recipientDid, _waitMs, _signal, filter) {
+        const r = await this.request({
+            method: 'receive',
+            recipientDid,
+            authToken: await this.authToken(recipientDid, 'receive'),
+            ...(filter?.role ? { role: filter.role } : {}),
+            ...(filter?.taskId ? { taskId: filter.taskId } : {}),
+            ...(filter?.peek ? { peek: true } : {}),
+        });
+        if (r.envelope && !verifyEnvelope(r.envelope, recipientDid))
+            throw new Error('RELAY_TAMPERING_DETECTED');
+        return r.envelope ?? undefined;
+    }
+    async *subscribe(recipientDid, signal) {
+        signal?.throwIfAborted();
+        await this.ready();
+        const authToken = await this.authToken(recipientDid, 'subscribe');
+        if (this.pending)
+            throw new Error('CONCURRENT_RELAY_REQUEST');
+        this.pending = true;
+        const queue = [];
+        let failure, wake = () => { };
+        const receive = (raw) => {
+            try {
+                const r = JSON.parse(raw.toString());
+                if (r.error)
+                    throw new Error(r.error);
+                if (!r.envelope || !verifyEnvelope(r.envelope, recipientDid))
+                    throw new Error('RELAY_TAMPERING_DETECTED');
+                if (queue.length >= 1000)
+                    throw new Error('RELAY_CAPACITY');
+                queue.push(r.envelope);
+            }
+            catch (e) {
+                failure = e;
+            }
+            wake();
+        };
+        const close = () => {
+            failure = new Error('RELAY_CLOSED');
+            wake();
+        }, error = (e) => {
+            failure = e;
+            wake();
+        };
+        const abort = () => wake();
+        const socket = this.requireSocket();
+        socket.on('message', receive);
+        socket.once('close', close);
+        socket.once('error', error);
+        signal?.addEventListener('abort', abort, { once: true });
+        try {
+            socket.send(JSON.stringify({ method: 'subscribe', recipientDid, authToken }));
+            while (!signal?.aborted) {
+                if (failure)
+                    throw failure;
+                if (queue.length) {
+                    yield queue.shift();
+                    continue;
+                }
+                await new Promise((resolve) => {
+                    wake = resolve;
+                    if (queue.length || failure || signal?.aborted)
+                        resolve();
+                });
+            }
+        }
+        finally {
+            socket.off('message', receive);
+            socket.off('close', close);
+            socket.off('error', error);
+            signal?.removeEventListener('abort', abort);
+            if (socket.readyState === WebSocket.OPEN)
+                socket.send(JSON.stringify({ method: 'unsubscribe' }));
+            this.pending = false;
+        }
+    }
+    async close() {
+        this.stopped = true;
+        const socket = this.socket;
+        if (!socket || socket.readyState === WebSocket.CLOSED)
+            return;
+        await new Promise((resolve) => {
+            socket.once('close', resolve);
+            socket.close();
+        });
+    }
+}
+//# sourceMappingURL=index.js.map