@leofcoin/chain 1.8.8 → 1.8.11

package/exports/browser/client-CWkdUcxK-BEmg-tGc.js

@@ -1,989 +0,0 @@
-import { c as createDebugger, i as inflate_1, d as deflate_1, L as LittlePubSub } from './node-browser-A1KVCavN.js';
-import './identity-nIyW_Xm8-BU8xakCv.js';
-import './flags-wmeqg14g.js';
-import './networks-F1y7bMrB.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;
-        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-CfYI-6aD-DHRKebpJ.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.subscribers['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-DTbjK0sK-BK_5FT46.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);
-        });
-    }
-    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 }
-                });
-                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-Qcpp3EKK-DOtgsScX.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.subscribers[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 };