@leofcoin/chain 1.9.10 → 1.9.12

package/exports/browser/client-B5W9RVIn-DHAPaCMU.js

@@ -0,0 +1,1047 @@
+import { i as inflate_1, c as createDebugger, d as deflate_1, L as LittlePubSub } from './node-browser-Oq89xLSU.js';
+import './identity-B8_RBemH-Dq17MYzU.js';
+import './constants-V2VjIc2r.js';
+
+class Api {
+    _pubsub;
+    constructor(_pubsub) {
+        this._pubsub = _pubsub;
+    }
+    subscribe(topic, cb) {
+        this._pubsub.subscribe(topic, cb);
+    }
+    unsubscribe(topic, cb) {
+        this._pubsub.unsubscribe(topic, cb);
+    }
+    publish(topic, value) {
+        this._pubsub.publish(topic, value);
+    }
+    subscribers() {
+        this._pubsub.subscribers;
+    }
+    connectionState(state) {
+        switch (state) {
+            case 0:
+                return 'connecting';
+            case 1:
+                return 'open';
+            case 2:
+                return 'closing';
+            case 3:
+                return 'closed';
+        }
+    }
+    /**
+     * @param {string} type
+     * @param {string} name
+     * @param {object} params
+     */
+    request(client, request) {
+        return new Promise((resolve, reject) => {
+            const state = this.connectionState(client.readyState);
+            if (state !== 'open')
+                return reject(`coudn't send request to ${client.id}, no open connection found.`);
+            request.id = Math.random().toString(36).slice(-12);
+            const handler = (result) => {
+                if (result && result.error)
+                    return reject(result.error);
+                resolve({ result, id: request.id, handler });
+                this.unsubscribe(request.id, handler);
+            };
+            this.subscribe(request.id, handler);
+            this.send(client, request);
+        });
+    }
+    async send(client, request) {
+        return client.send(JSON.stringify(request));
+    }
+    pubsub(client) {
+        return {
+            publish: (topic = 'pubsub', value) => {
+                return this.send(client, { url: 'pubsub', params: { topic, value } });
+            },
+            subscribe: (topic = 'pubsub', cb) => {
+                this.subscribe(topic, cb);
+                return this.send(client, {
+                    url: 'pubsub',
+                    params: { topic, subscribe: true }
+                });
+            },
+            unsubscribe: (topic = 'pubsub', cb) => {
+                this.unsubscribe(topic, cb);
+                return this.send(client, {
+                    url: 'pubsub',
+                    params: { topic, unsubscribe: true }
+                });
+            },
+            subscribers: this._pubsub.subscribers
+        };
+    }
+    server(client) {
+        return {
+            uptime: async () => {
+                try {
+                    const { result, id, handler } = await this.request(client, {
+                        url: 'uptime'
+                    });
+                    this.unsubscribe(id, handler);
+                    return result;
+                }
+                catch (e) {
+                    throw e;
+                }
+            },
+            ping: async () => {
+                try {
+                    const now = new Date().getTime();
+                    const { result, id, handler } = await this.request(client, {
+                        url: 'ping'
+                    });
+                    this.unsubscribe(id, handler);
+                    return Number(result) - now;
+                }
+                catch (e) {
+                    throw e;
+                }
+            }
+        };
+    }
+    peernet(client) {
+        return {
+            join: async (params) => {
+                try {
+                    params.join = true;
+                    const requested = { url: 'peernet', params };
+                    const { result, id, handler } = await this.request(client, requested);
+                    this.unsubscribe(id, handler);
+                    return result;
+                }
+                catch (e) {
+                    throw e;
+                }
+            },
+            leave: async (params) => {
+                try {
+                    params.join = false;
+                    const requested = { url: 'peernet', params };
+                    const { result, id, handler } = await this.request(client, requested);
+                    this.unsubscribe(id, handler);
+                    return result;
+                }
+                catch (e) {
+                    throw e;
+                }
+            },
+            peers: async () => {
+                try {
+                    const requested = { url: 'peernet', params: { peers: true } };
+                    const { result, id, handler } = await this.request(client, requested);
+                    this.unsubscribe(id, handler);
+                    return result;
+                }
+                catch (e) {
+                    throw e;
+                }
+            }
+        };
+    }
+}
+
+class ClientConnection {
+    client;
+    api;
+    #startTime;
+    constructor(client, api) {
+        this.#startTime = new Date().getTime();
+        this.client = client;
+        this.api = api;
+    }
+    request = async (req) => {
+        const { result, id, handler } = await this.api.request(this.client, req);
+        globalThis.pubsub.unsubscribe(id, handler);
+        return result;
+    };
+    send = (req) => this.api.send(this.client, req);
+    get subscribe() {
+        return this.api.subscribe;
+    }
+    get unsubscribe() {
+        return this.api.unsubscribe;
+    }
+    get subscribers() {
+        return this.api.subscribers;
+    }
+    get publish() {
+        return this.api.publish;
+    }
+    get pubsub() {
+        return this.api.pubsub(this.client);
+    }
+    uptime = () => {
+        const now = new Date().getTime();
+        return (now - this.#startTime);
+    };
+    get peernet() {
+        return this.api.peernet(this.client);
+    }
+    get server() {
+        return this.api.server(this.client);
+    }
+    connectionState = () => this.api.connectionState(this.client.readyState);
+    close = exit => {
+        // client.onclose = message => {
+        //   if (exit) process.exit()
+        // }
+        this.client.close();
+    };
+}
+
+if (!globalThis.PubSub)
+    globalThis.PubSub = LittlePubSub;
+if (!globalThis.pubsub)
+    globalThis.pubsub = new LittlePubSub(false);
+class SocketRequestClient {
+    api;
+    clientConnection;
+    #tries = 0;
+    #retry = false;
+    #timeout = 10_000;
+    #times = 10;
+    #options;
+    #protocol;
+    #url;
+    #experimentalWebsocket = false;
+    constructor(url, protocol, options) {
+        let { retry, timeout, times, experimentalWebsocket } = options || {};
+        if (retry !== undefined)
+            this.#retry = retry;
+        if (timeout !== undefined)
+            this.#timeout = timeout;
+        if (times !== undefined)
+            this.#times = times;
+        if (experimentalWebsocket !== undefined)
+            this.#experimentalWebsocket = experimentalWebsocket;
+        this.#url = url;
+        this.#protocol = protocol;
+        this.#options = options;
+        this.api = new Api(globalThis.pubsub);
+    }
+    init() {
+        return new Promise(async (resolve, reject) => {
+            const init = async () => {
+                // @ts-ignore
+                if (!globalThis.WebSocket && !this.#experimentalWebsocket)
+                    globalThis.WebSocket = (await import('./browser-DTwbEd2v-BvEtTVTB.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                const client = new WebSocket(this.#url, this.#protocol);
+                if (this.#experimentalWebsocket) {
+                    client.addEventListener('error', this.onerror);
+                    client.addEventListener('message', this.onmessage);
+                    client.addEventListener('open', () => {
+                        this.#tries = 0;
+                        resolve(new ClientConnection(client, this.api));
+                    });
+                    client.addEventListener('close', (client.onclose = (message) => {
+                        this.#tries++;
+                        if (!this.#retry)
+                            return reject(this.#options);
+                        if (this.#tries > this.#times) {
+                            console.log(`${this.#options.protocol} Client Closed`);
+                            console.error(`could not connect to - ${this.#url}/`);
+                            return resolve(new ClientConnection(client, this.api));
+                        }
+                        if (message.code === 1006) {
+                            console.log(`Retrying in ${this.#timeout} ms`);
+                            setTimeout(() => {
+                                return init();
+                            }, this.#timeout);
+                        }
+                    }));
+                }
+                else {
+                    client.onmessage = this.onmessage;
+                    client.onerror = this.onerror;
+                    client.onopen = () => {
+                        this.#tries = 0;
+                        resolve(new ClientConnection(client, this.api));
+                    };
+                    client.onclose = (message) => {
+                        this.#tries++;
+                        if (!this.#retry)
+                            return reject(this.#options);
+                        if (this.#tries > this.#times) {
+                            console.log(`${this.#options.protocol} Client Closed`);
+                            console.error(`could not connect to - ${this.#url}/`);
+                            return resolve(new ClientConnection(client, this.api));
+                        }
+                        if (message.code === 1006) {
+                            console.log(`Retrying in ${this.#timeout} ms`);
+                            setTimeout(() => {
+                                return init();
+                            }, this.#timeout);
+                        }
+                    };
+                }
+            };
+            return init();
+        });
+    }
+    onerror = (error) => {
+        if (globalThis.pubsub.hasSubscribers('error')) {
+            globalThis.pubsub.publish('error', error);
+        }
+        else {
+            console.error(error);
+        }
+    };
+    onmessage(message) {
+        if (!message.data) {
+            console.warn(`message ignored because it contained no data`);
+            return;
+        }
+        const { value, url, status, id } = JSON.parse(message.data.toString());
+        const publisher = id ? id : url;
+        if (status === 200) {
+            globalThis.pubsub.publish(publisher, value);
+        }
+        else {
+            globalThis.pubsub.publish(publisher, { error: value });
+        }
+    }
+}
+
+const MAX_MESSAGE_SIZE = 16000;
+const defaultOptions = {
+    networkVersion: 'peach',
+    version: 'v1',
+    stars: ['wss://star.leofcoin.org'],
+    connectEvent: 'peer:connected'
+};
+
+// Simple CRC32 implementation
+const crc32$1 = (data) => {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+};
+const iceServers = [
+    {
+        urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
+    },
+    {
+        urls: 'stun:openrelay.metered.ca:80'
+    },
+    {
+        urls: 'turn:openrelay.metered.ca:443',
+        username: 'openrelayproject',
+        credential: 'openrelayproject'
+    },
+    {
+        urls: 'turn:openrelay.metered.ca:443?transport=tcp',
+        username: 'openrelayproject',
+        credential: 'openrelayproject'
+    }
+];
+const SimplePeer = (await import('./index-avzvc6cK-CDbEoIOc.js').then(function (n) { return n.i; })).default;
+class Peer extends SimplePeer {
+    peerId;
+    channelName;
+    version;
+    compressionThreshold = 0.98;
+    bw = { up: 0, down: 0 };
+    get connected() {
+        return super.connected;
+    }
+    constructor(options) {
+        const { from, to, initiator, trickle, config, version, wrtc, compressionThreshold } = options;
+        const channelName = initiator ? `${from}:${to}` : `${to}:${from}`;
+        super({
+            channelName,
+            initiator,
+            trickle: trickle ?? true,
+            config: { iceServers, ...config },
+            wrtc: wrtc ?? globalThis.wrtc
+        });
+        this.version = String(version);
+        this.peerId = to;
+        this.channelName = channelName;
+        if (compressionThreshold !== undefined)
+            this.compressionThreshold = compressionThreshold;
+    }
+    async #chunkit(data, id) {
+        this.bw.up = data.length;
+        // attempt compression; use compressed only if beneficial
+        let sendData = data;
+        try {
+            const c = deflate_1(data);
+            if (c?.length && c.length < data.length * this.compressionThreshold)
+                sendData = c;
+        }
+        catch (e) {
+            // ignore
+        }
+        const size = sendData.length;
+        const encodeFrame = (idStr, totalSize, index, count, payload, flags) => {
+            const te = new TextEncoder();
+            const idBytes = te.encode(idStr);
+            const crc = crc32$1(payload);
+            const headerLen = 1 + 1 + 4 + 4 + 4 + 4 + 2 + idBytes.length;
+            const buffer = new ArrayBuffer(headerLen + payload.length);
+            const view = new DataView(buffer);
+            const out = new Uint8Array(buffer);
+            let offset = 0;
+            view.setUint8(offset, 1); // version
+            offset += 1;
+            view.setUint8(offset, flags); // flags: bit0 chunked, bit1 compressed
+            offset += 1;
+            view.setUint32(offset, totalSize, true);
+            offset += 4;
+            view.setUint32(offset, index, true);
+            offset += 4;
+            view.setUint32(offset, count, true);
+            offset += 4;
+            view.setUint32(offset, crc, true); // CRC32
+            offset += 4;
+            view.setUint16(offset, idBytes.length, true);
+            offset += 2;
+            out.set(idBytes, offset);
+            offset += idBytes.length;
+            out.set(payload, offset);
+            return out;
+        };
+        // no needles chunking, keep it simple, if data is smaller then max size just send it
+        if (size <= MAX_MESSAGE_SIZE) {
+            const flags = ((size > MAX_MESSAGE_SIZE ? 1 : 0) << 0) |
+                ((sendData !== data ? 1 : 0) << 1);
+            super.send(encodeFrame(id, size, 0, 1, sendData, flags));
+            return;
+        }
+        function* chunks(data) {
+            while (data.length !== 0) {
+                const amountToSlice = data.length >= MAX_MESSAGE_SIZE ? MAX_MESSAGE_SIZE : data.length;
+                const subArray = data.subarray(0, amountToSlice);
+                data = data.subarray(amountToSlice, data.length);
+                yield subArray;
+                // super.send(JSON.stringify({ chunk: subArray, id, size }))
+            }
+        }
+        // while (data.length !== 0) {
+        //   const amountToSlice =
+        //     data.length >= MAX_MESSAGE_SIZE ? MAX_MESSAGE_SIZE : data.length
+        //   const subArray = data.subarray(0, amountToSlice)
+        //   data = data.subarray(amountToSlice, data.length)
+        //   super.send(JSON.stringify({ chunk: subArray, id, size }))
+        // }
+        // backpressure-aware send loop with indexed chunks
+        const count = Math.ceil(size / MAX_MESSAGE_SIZE);
+        let index = 0;
+        const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+        const threshold = 4 * 1024 * 1024; // 4MB bufferedAmount threshold
+        const flags = (1 << 0) | ((sendData !== data ? 1 : 0) << 1);
+        for (const chunk of chunks(sendData)) {
+            // wait while channel is congested
+            // eslint-disable-next-line no-await-in-loop
+            while (
+            // @ts-ignore underlying channel is not part of public types
+            this._channel?.bufferedAmount > threshold) {
+                // if connection closed, abort
+                // eslint-disable-next-line no-await-in-loop
+                if (!this.connected)
+                    return;
+                // eslint-disable-next-line no-await-in-loop
+                await sleep(10);
+            }
+            super.send(encodeFrame(id, size, index, count, chunk, flags));
+            index += 1;
+        }
+    }
+    /**
+     * send to peer
+     * @param data ArrayLike
+     * @param id custom id to listen to
+     */
+    send(data, id = crypto.randomUUID()) {
+        // send chuncks till ndata support for SCTP is added
+        // wraps data
+        this.#chunkit(data, id);
+    }
+    /**
+     * send to peer & wait for response
+     * @param data ArrayLike
+     * @param id custom id to listen to
+     */
+    request(data, id = crypto.randomUUID()) {
+        return new Promise((resolve, reject) => {
+            let timeout;
+            const onrequest = ({ data }) => {
+                clearTimeout(timeout);
+                resolve(data);
+                globalThis.pubsub.unsubscribe(id, onrequest);
+            };
+            timeout = setTimeout(() => {
+                globalThis.pubsub.unsubscribe(id, onrequest);
+                reject(`request for ${id} timed out`);
+            }, 30_000);
+            globalThis.pubsub.subscribe(id, onrequest);
+            this.send(data, id);
+        });
+    }
+    /**
+     * Get comprehensive network statistics from WebRTC
+     * @returns NetworkStats object with detailed metrics
+     */
+    async getNetworkStats() {
+        try {
+            const pc = this._pc;
+            if (!pc)
+                return null;
+            const stats = await pc.getStats();
+            const result = {
+                latency: null,
+                jitter: null,
+                bytesReceived: 0,
+                bytesSent: 0,
+                packetsLost: 0,
+                fractionLost: null,
+                inboundBitrate: null,
+                outboundBitrate: null,
+                availableOutgoingBitrate: null,
+                timestamp: Date.now()
+            };
+            let prevBytesReceived = 0;
+            let prevBytesSent = 0;
+            let prevTimestamp = 0;
+            stats.forEach((report) => {
+                // Latency from candidate pair
+                if (report.type === 'candidate-pair' && report.currentRoundTripTime) {
+                    result.latency = Math.round(report.currentRoundTripTime * 1000);
+                }
+                // Inbound RTP stats
+                if (report.type === 'inbound-rtp') {
+                    result.bytesReceived += report.bytesReceived || 0;
+                    result.packetsLost += report.packetsLost || 0;
+                    if (report.jitter) {
+                        result.jitter = Math.round(report.jitter * 1000);
+                    }
+                    if (report.fractionLost) {
+                        result.fractionLost = report.fractionLost;
+                    }
+                }
+                // Outbound RTP stats
+                if (report.type === 'outbound-rtp') {
+                    result.bytesSent += report.bytesSent || 0;
+                }
+                // Available bandwidth
+                if (report.type === 'remote-candidate' &&
+                    report.availableOutgoingBitrate) {
+                    result.availableOutgoingBitrate = Math.round(report.availableOutgoingBitrate);
+                }
+            });
+            return result;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    toJSON() {
+        return {
+            peerId: this.peerId,
+            channelName: this.channelName,
+            version: this.version,
+            bw: this.bw
+        };
+    }
+}
+
+// Simple CRC32 implementation
+const crc32 = (data) => {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+};
+const debug = createDebugger('@netpeer/swarm/client');
+class Client {
+    #peerId;
+    #connections = {};
+    #stars = {};
+    #starListeners = {};
+    #reinitLock = null;
+    #connectEvent = 'peer:connected';
+    #retryOptions = { retries: 5, factor: 2, minTimeout: 1000, maxTimeout: 30000 };
+    id;
+    networkVersion;
+    starsConfig;
+    socketClient;
+    messageSize = 262144;
+    version;
+    #messagesToHandle = {};
+    get peerId() {
+        return this.#peerId;
+    }
+    get connections() {
+        return { ...this.#connections };
+    }
+    get peers() {
+        return Object.entries(this.#connections);
+    }
+    getPeer(peerId) {
+        return this.#connections[peerId];
+    }
+    constructor(options) {
+        const { peerId, networkVersion, version, connectEvent, stars } = {
+            ...defaultOptions,
+            ...options
+        };
+        this.#peerId = peerId;
+        this.networkVersion = networkVersion;
+        this.version = version;
+        this.#connectEvent = connectEvent;
+        this.starsConfig = stars;
+        if (options?.retry)
+            this.#retryOptions = { ...this.#retryOptions, ...options.retry };
+        this._init();
+    }
+    /**
+     * Safely reinitialize the client (used after system resume/sleep).
+     * It closes existing connections and reconnects to configured stars.
+     */
+    async reinit() {
+        // avoid concurrent reinit runs
+        if (this.#reinitLock)
+            return this.#reinitLock;
+        this.#reinitLock = (async () => {
+            debug('reinit: start');
+            try {
+                await this.close();
+                this.#stars = {};
+                this.#connections = {};
+                for (const star of this.starsConfig) {
+                    try {
+                        await this.setupStar(star);
+                    }
+                    catch (e) {
+                        // If last star fails and none connected, surface error
+                        if (Object.keys(this.#stars).length === 0)
+                            throw new Error(`No star available to connect`);
+                    }
+                }
+            }
+            finally {
+                debug('reinit: done');
+                this.#reinitLock = null;
+            }
+        })();
+        return this.#reinitLock;
+    }
+    async setupStar(star) {
+        const { retries, factor, minTimeout, maxTimeout } = this.#retryOptions;
+        const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+        let attempt = 0;
+        let lastErr;
+        while (attempt <= retries) {
+            try {
+                const client = new SocketRequestClient(star, this.networkVersion);
+                this.#stars[star] = await client.init();
+                this.setupStarListeners(this.#stars[star], star);
+                this.#stars[star].send({
+                    url: 'join',
+                    params: { version: this.version, peerId: this.peerId }
+                });
+                globalThis.pubsub.publishVerbose('star:connected', star);
+                debug(`setupStar ${star} succeeded`);
+                return this.#stars[star];
+            }
+            catch (e) {
+                lastErr = e;
+                attempt += 1;
+                if (attempt > retries)
+                    break;
+                const delay = Math.min(maxTimeout, Math.round(minTimeout * Math.pow(factor, attempt - 1)));
+                debug(`setupStar ${star} failed, retrying in ${delay}ms (attempt ${attempt})`);
+                // eslint-disable-next-line no-await-in-loop
+                await sleep(delay);
+            }
+        }
+        throw lastErr;
+    }
+    async _init() {
+        if (!globalThis.RTCPeerConnection)
+            globalThis.wrtc = (await import('./browser-AkMNdace-11JEjCcV.js').then(function (n) { return n.b; })).default;
+        for (const star of this.starsConfig) {
+            try {
+                await this.setupStar(star);
+            }
+            catch (e) {
+                if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 &&
+                    !this.socketClient)
+                    throw new Error(`No star available to connect`);
+            }
+        }
+        if (globalThis.process?.versions?.node) {
+            process.on('SIGINT', async () => {
+                process.stdin.resume();
+                await this.close();
+                process.exit();
+            });
+        }
+        else {
+            globalThis.addEventListener('beforeunload', this.close.bind(this));
+        }
+    }
+    setupStarListeners(starConnection, starId) {
+        // create stable references to handlers so we can unsubscribe later
+        const onPeerJoined = (id) => this.#peerJoined(id, starConnection);
+        const onPeerLeft = (id) => this.#peerLeft(id, starConnection);
+        const onStarJoined = this.#starJoined;
+        const onStarLeft = this.#starLeft;
+        const onSignal = (message) => this.#inComingSignal(message, starConnection);
+        starConnection.pubsub.subscribe('peer:joined', onPeerJoined);
+        starConnection.pubsub.subscribe('peer:left', onPeerLeft);
+        starConnection.pubsub.subscribe('star:joined', onStarJoined);
+        starConnection.pubsub.subscribe('star:left', onStarLeft);
+        starConnection.pubsub.subscribe('signal', onSignal);
+        this.#starListeners[starId] = [
+            { topic: 'peer:joined', handler: onPeerJoined },
+            { topic: 'peer:left', handler: onPeerLeft },
+            { topic: 'star:joined', handler: onStarJoined },
+            { topic: 'star:left', handler: onStarLeft },
+            { topic: 'signal', handler: onSignal }
+        ];
+    }
+    #starJoined = (id) => {
+        if (this.#stars[id]) {
+            this.#stars[id].close(0);
+            delete this.#stars[id];
+        }
+        console.log(`star ${id} joined`);
+    };
+    #starLeft = async (id) => {
+        if (this.#stars[id]) {
+            this.#stars[id].close(0);
+            delete this.#stars[id];
+        }
+        // if we lost all stars, try to reconnect to configured stars with backoff
+        if (Object.keys(this.#stars).length === 0) {
+            for (const star of this.starsConfig) {
+                try {
+                    await this.setupStar(star);
+                    // stop at first success
+                    return;
+                }
+                catch (e) {
+                    debug(`reconnect star ${star} failed: ${e.message || e}`);
+                    if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1)
+                        throw new Error(`No star available to connect`);
+                }
+            }
+        }
+        debug(`star ${id} left`);
+    };
+    #peerLeft = (peer, star) => {
+        const id = peer.peerId || peer;
+        if (this.#connections[id]) {
+            this.#connections[id].destroy();
+            delete this.#connections[id];
+        }
+        debug(`peer ${id} left`);
+    };
+    connect(peerId, star, initiator = true) {
+        if (this.#connections[peerId]) {
+            debug(`peer ${peerId} already connected`);
+            return;
+        }
+        if (this.#stars[star]?.connectionState() !== 'open') {
+            console.warn(`Star ${star} is not connected, cannot reconnect to peer ${peerId}`);
+            return;
+        }
+        this.#createRTCPeerConnection(peerId, star, this.version, initiator);
+    }
+    reconnect(peerId, star, initiator = false) {
+        delete this.#connections[peerId];
+        debug(`reconnecting to peer ${peerId}`);
+        return this.connect(peerId, star, initiator);
+    }
+    #createRTCPeerConnection = (peerId, star, version, initiator = false) => {
+        const peer = new Peer({
+            initiator: initiator,
+            from: this.peerId,
+            to: peerId,
+            version
+        });
+        peer.on('signal', (signal) => this.#peerSignal(peer, signal, star, this.version));
+        peer.on('connect', () => this.#peerConnect(peer));
+        peer.on('close', () => this.#peerClose(peer));
+        peer.on('data', (data) => this.#peerData(peer, data));
+        peer.on('error', (error) => this.#peerError(peer, error));
+        this.#connections[peerId] = peer;
+    };
+    #peerJoined = async ({ peerId, version }, star) => {
+        // check if peer rejoined before the previous connection closed
+        if (this.#connections[peerId]) {
+            this.#connections[peerId].destroy();
+            delete this.#connections[peerId];
+        }
+        if (this.peerId !== peerId)
+            this.#createRTCPeerConnection(peerId, star, version, true);
+        debug(`peer ${peerId} joined`);
+    };
+    #inComingSignal = async ({ from, signal, channelName, version }, star) => {
+        if (version !== this.version) {
+            console.warn(`${from} joined using the wrong version.\nexpected: ${this.version} but got:${version}`);
+            return;
+        }
+        if (from === this.peerId) {
+            console.warn(`${from} tried to connect to itself.`);
+            return;
+        }
+        let peer = this.#connections[from];
+        if (!peer) {
+            this.#createRTCPeerConnection(from, star, version);
+            peer = this.#connections[from];
+        }
+        if (peer.connected) {
+            debug(`peer ${from} already connected`);
+            return;
+        }
+        // peer.channels[channelName]
+        if (String(peer.channelName) !== String(channelName)) {
+            console.warn(`channelNames don't match: got ${peer.channelName}, expected: ${channelName}.`);
+            // Destroy the existing peer connection
+            // peer.destroy()
+            // delete this.#connections[from]
+            // // // Create a new peer connection with the correct configuration
+            // this.#createRTCPeerConnection(from, star, version, false)
+            // peer = this.#connections[from]
+            return;
+        }
+        peer.signal(signal);
+    };
+    #peerSignal = (peer, signal, star, version) => {
+        let client = this.#stars[star];
+        if (!client)
+            client = this.#stars[Object.keys(this.#stars)[0]];
+        client.send({
+            url: 'signal',
+            params: {
+                from: this.peerId,
+                to: peer.peerId,
+                channelName: peer.channelName,
+                version,
+                signal,
+                initiator: peer.initiator
+            }
+        });
+    };
+    #peerClose = (peer) => {
+        if (this.#connections[peer.peerId]) {
+            peer.destroy();
+            delete this.#connections[peer.peerId];
+        }
+        debug(`closed ${peer.peerId}'s connection`);
+    };
+    #peerConnect = (peer) => {
+        debug(`${peer.peerId} connected`);
+        globalThis.pubsub.publishVerbose(this.#connectEvent, peer.peerId);
+    };
+    #noticeMessage = (message, id, from, peer) => {
+        const dataOut = message instanceof Uint8Array
+            ? message
+            : new Uint8Array(Object.values(message));
+        if (globalThis.pubsub.hasSubscribers(id)) {
+            globalThis.pubsub.publish(id, {
+                data: dataOut,
+                id,
+                from,
+                peer
+            });
+        }
+        else {
+            globalThis.pubsub.publish('peer:data', {
+                data: dataOut,
+                id,
+                from,
+                peer
+            });
+        }
+    };
+    #peerData = (peer, data) => {
+        const tryJson = () => {
+            const parsed = JSON.parse(new TextDecoder().decode(data));
+            const { id, size, chunk, index, count } = parsed;
+            chunk ? Object.values(chunk).length : size;
+            return {
+                id,
+                size: Number(size),
+                index: Number(index ?? 0),
+                count: Number(count ?? 1),
+                chunk: new Uint8Array(Object.values(chunk)),
+                flags: 0,
+                crc: 0
+            };
+        };
+        const decodeBinary = () => {
+            let u8;
+            if (typeof data === 'string') {
+                // should not happen when sending binary, fallback to JSON
+                return tryJson();
+            }
+            else if (data instanceof ArrayBuffer) {
+                u8 = new Uint8Array(data);
+            }
+            else if (ArrayBuffer.isView(data)) {
+                const view = data;
+                const byteOffset = view.byteOffset || 0;
+                const byteLength = view.byteLength || data.length;
+                u8 = new Uint8Array(view.buffer, byteOffset, byteLength);
+            }
+            else if (data?.buffer) {
+                u8 = new Uint8Array(data.buffer);
+            }
+            else {
+                // last resort: attempt JSON
+                return tryJson();
+            }
+            const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+            let offset = 0;
+            dv.getUint8(offset);
+            offset += 1;
+            const flags = dv.getUint8(offset);
+            offset += 1;
+            const size = dv.getUint32(offset, true);
+            offset += 4;
+            const index = dv.getUint32(offset, true);
+            offset += 4;
+            const count = dv.getUint32(offset, true);
+            offset += 4;
+            const expectedCrc = dv.getUint32(offset, true);
+            offset += 4;
+            const idLen = dv.getUint16(offset, true);
+            offset += 2;
+            const idBytes = u8.subarray(offset, offset + idLen);
+            offset += idLen;
+            const id = new TextDecoder().decode(idBytes);
+            const chunk = u8.subarray(offset);
+            return { id, size, index, count, chunk, flags, crc: expectedCrc };
+        };
+        const frame = decodeBinary();
+        peer.bw.down += frame.chunk.length;
+        // Single frame path: if compressed, inflate before publish
+        if (frame.count === 1) {
+            let payload = frame.chunk;
+            const compressed = Boolean(frame.flags & (1 << 1));
+            if (compressed) {
+                const actualCrc = crc32(payload);
+                if (actualCrc !== frame.crc) {
+                    console.warn(`CRC mismatch: expected ${frame.crc}, got ${actualCrc}`);
+                }
+                try {
+                    payload = inflate_1(payload);
+                }
+                catch (e) {
+                    console.warn('inflate failed, passing compressed payload');
+                }
+            }
+            this.#noticeMessage(payload, frame.id, peer.peerId, peer);
+            return;
+        }
+        // Chunked message handling with indexed reassembly
+        if (!this.#messagesToHandle[frame.id] ||
+            Array.isArray(this.#messagesToHandle[frame.id])) {
+            this.#messagesToHandle[frame.id] = {
+                chunks: new Array(frame.count),
+                receivedBytes: 0,
+                expectedSize: Number(frame.size),
+                expectedCount: Number(frame.count)
+            };
+        }
+        const state = this.#messagesToHandle[frame.id];
+        // Verify CRC for this chunk
+        const actualCrc = crc32(frame.chunk);
+        if (actualCrc !== frame.crc) {
+            console.warn(`Chunk CRC mismatch for ${frame.id}[${frame.index}]: expected ${frame.crc}, got ${actualCrc}`);
+        }
+        state.chunks[frame.index] = frame.chunk;
+        state.receivedBytes += frame.chunk.length;
+        // If all chunks present and total size matches, reassemble
+        const allPresent = state.chunks.every((c) => c instanceof Uint8Array);
+        if (allPresent && state.receivedBytes === state.expectedSize) {
+            const result = new Uint8Array(state.expectedSize);
+            let offset2 = 0;
+            for (const c of state.chunks) {
+                result.set(c, offset2);
+                offset2 += c.length;
+            }
+            let payload = result;
+            const compressed = Boolean(frame.flags & (1 << 1));
+            if (compressed) {
+                try {
+                    payload = inflate_1(result);
+                }
+                catch (e) {
+                    console.warn('inflate failed, passing compressed payload');
+                }
+            }
+            this.#noticeMessage(payload, frame.id, peer.peerId, peer);
+            delete this.#messagesToHandle[frame.id];
+        }
+    };
+    #peerError = (peer, error) => {
+        console.warn(`Connection error: ${error.message}`);
+        peer.destroy();
+    };
+    async close() {
+        for (const peerId in this.#connections) {
+            const peer = this.#connections[peerId];
+            if (peer) {
+                peer.destroy();
+                delete this.#connections[peerId];
+            }
+        }
+        for (const star in this.#stars) {
+            // unsubscribe handlers we registered earlier
+            const listeners = this.#starListeners[star];
+            if (listeners && listeners.length) {
+                for (const { topic, handler } of listeners) {
+                    try {
+                        this.#stars[star].pubsub.unsubscribe(topic, handler);
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                }
+            }
+            if (this.#stars[star].connectionState() === 'open') {
+                await this.#stars[star].send({ url: 'leave', params: this.peerId });
+            }
+        }
+        const peerClosers = Object.values(this.#connections).map((connection) => {
+            try {
+                // destroy() may be sync or return a promise
+                return connection.destroy();
+            }
+            catch (e) {
+                return undefined;
+            }
+        });
+        const starClosers = Object.values(this.#stars).map((connection) => {
+            try {
+                return connection.close(0);
+            }
+            catch (e) {
+                return undefined;
+            }
+        });
+        return Promise.allSettled([...peerClosers, ...starClosers]);
+    }
+}
+
+export { Client as default };