@leofcoin/chain 1.10.21 → 1.11.0

package/exports/browser/client-DKKzPSlb-C_1ug6ux.js

@@ -1,2401 +0,0 @@
-import { i as inflate_1, c as createDebugger, d as deflate_1, L as LittlePubSub } from './node-browser-Ha4Lvntj.js';
-import './browser-crypto-CH0ua22L.js';
-import './connection-monitor-D-krNiRH.js';
-import './index-CvKt4UDE.js';
-import './sha2-BKcEJzgd.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-CCfR9KOM-BGMMnVsR.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'
-};
-
-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;
-};
-class PeerCore {
-    transport;
-    options;
-    constructor(transport, options) {
-        this.transport = transport;
-        this.options = options;
-    }
-    #createMessageId() {
-        const randomUUID = globalThis.crypto?.randomUUID;
-        if (typeof randomUUID === 'function')
-            return randomUUID.call(globalThis.crypto);
-        return `msg-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    }
-    #encodeFrame(id, totalSize, index, count, payload, flags) {
-        const te = new TextEncoder();
-        const idBytes = te.encode(id);
-        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);
-        offset += 1;
-        view.setUint8(offset, flags);
-        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);
-        offset += 4;
-        view.setUint16(offset, idBytes.length, true);
-        offset += 2;
-        out.set(idBytes, offset);
-        offset += idBytes.length;
-        out.set(payload, offset);
-        return out;
-    }
-    async #chunkAndSend(data, id) {
-        if (!this.transport.isConnected())
-            return;
-        this.options.onPayloadSend?.(data.length);
-        let sendData = data;
-        try {
-            const compressed = deflate_1(data);
-            if (compressed?.length &&
-                compressed.length < data.length * this.options.compressionThreshold) {
-                sendData = compressed;
-            }
-        }
-        catch (e) { }
-        const size = sendData.length;
-        if (size <= this.options.maxMessageSize) {
-            if (!this.transport.isConnected())
-                return;
-            const flags = (sendData !== data ? 1 : 0) << 1;
-            this.transport.sendRaw(this.#encodeFrame(id, size, 0, 1, sendData, flags));
-            return;
-        }
-        const threshold = 4 * 1024 * 1024;
-        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-        const count = Math.ceil(size / this.options.maxMessageSize);
-        const flags = (1 << 0) | ((sendData !== data ? 1 : 0) << 1);
-        let index = 0;
-        let remaining = sendData;
-        while (remaining.length !== 0) {
-            const amountToSlice = remaining.length >= this.options.maxMessageSize
-                ? this.options.maxMessageSize
-                : remaining.length;
-            const chunk = remaining.subarray(0, amountToSlice);
-            remaining = remaining.subarray(amountToSlice);
-            while ((this.options.getBufferedAmount?.() || 0) > threshold) {
-                if (!this.transport.isConnected())
-                    return;
-                // eslint-disable-next-line no-await-in-loop
-                await sleep(10);
-            }
-            if (!this.transport.isConnected())
-                return;
-            this.transport.sendRaw(this.#encodeFrame(id, size, index, count, chunk, flags));
-            index += 1;
-        }
-    }
-    send(data, id = this.#createMessageId()) {
-        void this.#chunkAndSend(data, id).catch(() => { });
-    }
-    request(data, id = this.#createMessageId()) {
-        return new Promise((resolve, reject) => {
-            if (!this.transport.isConnected()) {
-                reject(new Error('peer is not connected'));
-                return;
-            }
-            const pubsub = this.options.getPubSub();
-            if (!pubsub) {
-                reject(new Error('globalThis.pubsub is not available'));
-                return;
-            }
-            let timeout;
-            let settled = false;
-            const finish = (fn) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timeout);
-                try {
-                    pubsub.unsubscribe(id, onrequest);
-                }
-                catch (e) { }
-                fn();
-            };
-            const onrequest = ({ data }) => {
-                finish(() => resolve(data));
-            };
-            timeout = setTimeout(() => {
-                finish(() => reject(new Error(`request for ${id} timed out`)));
-            }, 30_000);
-            try {
-                pubsub.subscribe(id, onrequest);
-            }
-            catch (error) {
-                finish(() => {
-                    reject(error instanceof Error ? error : new Error(String(error)));
-                });
-                return;
-            }
-            if (!this.transport.isConnected()) {
-                finish(() => reject(new Error('peer disconnected before request send')));
-                return;
-            }
-            void this.#chunkAndSend(data, id).catch((error) => {
-                finish(() => {
-                    reject(error instanceof Error ? error : new Error(String(error)));
-                });
-            });
-        });
-    }
-}
-
-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'
-    }
-];
-class WebRTCPeer {
-    #pc;
-    #listeners = new Map();
-    #pendingCandidates = [];
-    #connected = false;
-    #destroyed = false;
-    #trickle = true;
-    #core;
-    _pc;
-    _channel = null;
-    initiator;
-    peerId;
-    channelName;
-    version;
-    compressionThreshold = 0.98;
-    bw = { up: 0, down: 0 };
-    get connected() {
-        return this.#connected;
-    }
-    constructor(options) {
-        const { from, to, initiator, trickle, config, version, wrtc, compressionThreshold } = options;
-        const rtc = this.#resolveRtc(wrtc);
-        const channelName = initiator ? `${from}:${to}` : `${to}:${from}`;
-        const pc = new rtc.RTCPeerConnection({ iceServers, ...config });
-        this.#pc = pc;
-        this._pc = pc;
-        this.initiator = Boolean(initiator);
-        this.#trickle = trickle ?? true;
-        this.version = String(version);
-        this.peerId = to;
-        this.channelName = channelName;
-        if (compressionThreshold !== undefined)
-            this.compressionThreshold = compressionThreshold;
-        this.#setupPeerConnectionHandlers(rtc);
-        if (this.initiator) {
-            this.#attachDataChannel(this.#pc.createDataChannel(channelName));
-            void this.#createOffer();
-        }
-        this.#core = new PeerCore({
-            kind: 'webrtc-datachannel',
-            isConnected: () => this.connected,
-            sendRaw: (payload) => this.#sendRaw(payload)
-        }, {
-            maxMessageSize: MAX_MESSAGE_SIZE,
-            compressionThreshold: this.compressionThreshold,
-            getBufferedAmount: () => this._channel?.bufferedAmount || 0,
-            getPubSub: this.#getPubSub,
-            onPayloadSend: (payloadBytes) => {
-                this.bw.up += payloadBytes;
-            }
-        });
-    }
-    #createMessageId() {
-        const randomUUID = globalThis.crypto?.randomUUID;
-        if (typeof randomUUID === 'function')
-            return randomUUID.call(globalThis.crypto);
-        return `msg-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    }
-    #resolveRtc(wrtc) {
-        if (wrtc)
-            return wrtc;
-        const globalCandidate = globalThis;
-        if (globalCandidate.RTCPeerConnection) {
-            return {
-                RTCPeerConnection: globalCandidate.RTCPeerConnection,
-                RTCSessionDescription: globalCandidate.RTCSessionDescription,
-                RTCIceCandidate: globalCandidate.RTCIceCandidate
-            };
-        }
-        if (globalCandidate.wrtc?.RTCPeerConnection)
-            return globalCandidate.wrtc;
-        throw new Error('No WebRTC implementation available');
-    }
-    #setupPeerConnectionHandlers(rtc) {
-        this.#pc.onicecandidate = (event) => {
-            if (this.#destroyed)
-                return;
-            if (event.candidate && this.#trickle) {
-                const payload = event.candidate.toJSON
-                    ? event.candidate.toJSON()
-                    : {
-                        candidate: event.candidate.candidate,
-                        sdpMLineIndex: event.candidate.sdpMLineIndex,
-                        sdpMid: event.candidate.sdpMid,
-                        usernameFragment: event.candidate.usernameFragment
-                    };
-                this.#emit('signal', payload);
-            }
-            if (!event.candidate && !this.#trickle && this.#pc.localDescription) {
-                this.#emit('signal', this.#serializeDescription(this.#pc.localDescription));
-            }
-        };
-        this.#pc.onconnectionstatechange = () => {
-            const state = this.#pc.connectionState;
-            if (state === 'failed' || state === 'closed')
-                this.destroy();
-        };
-        this.#pc.ondatachannel = (event) => {
-            if (!this._channel)
-                this.#attachDataChannel(event.channel);
-        };
-    }
-    #attachDataChannel(channel) {
-        this._channel = channel;
-        channel.binaryType = 'arraybuffer';
-        channel.onopen = () => {
-            if (this.#destroyed || this.#connected)
-                return;
-            this.#connected = true;
-            this.#emit('connect');
-        };
-        channel.onclose = () => {
-            if (this.#destroyed)
-                return;
-            this.destroy();
-        };
-        channel.onerror = () => {
-            this.#emit('error', new Error('DataChannel error'));
-        };
-        channel.onmessage = (event) => {
-            this.#emit('data', event.data);
-        };
-    }
-    async #createOffer() {
-        try {
-            const offer = await this.#pc.createOffer();
-            await this.#pc.setLocalDescription(offer);
-            if (this.#trickle && this.#pc.localDescription) {
-                this.#emit('signal', this.#serializeDescription(this.#pc.localDescription));
-            }
-        }
-        catch (error) {
-            this.#emit('error', error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    async #applyRemoteDescription(rtc, description) {
-        const sessionDescription = rtc.RTCSessionDescription
-            ? new rtc.RTCSessionDescription(description)
-            : description;
-        await this.#pc.setRemoteDescription(sessionDescription);
-        if (description.type === 'offer') {
-            const answer = await this.#pc.createAnswer();
-            await this.#pc.setLocalDescription(answer);
-            if (this.#pc.localDescription) {
-                this.#emit('signal', this.#serializeDescription(this.#pc.localDescription));
-            }
-        }
-        const pending = [...this.#pendingCandidates];
-        this.#pendingCandidates = [];
-        for (const candidate of pending) {
-            // eslint-disable-next-line no-await-in-loop
-            await this.#addIceCandidate(rtc, candidate);
-        }
-    }
-    async #addIceCandidate(rtc, candidate) {
-        if (!this.#pc.remoteDescription) {
-            this.#pendingCandidates.push(candidate);
-            return;
-        }
-        const iceCandidate = rtc.RTCIceCandidate
-            ? new rtc.RTCIceCandidate(candidate)
-            : candidate;
-        await this.#pc.addIceCandidate(iceCandidate);
-    }
-    #serializeDescription(description) {
-        return {
-            type: description.type,
-            sdp: description.sdp || ''
-        };
-    }
-    #sendRaw(payload) {
-        if (!this._channel || this._channel.readyState !== 'open') {
-            throw new Error('datachannel is not open');
-        }
-        this._channel.send(payload);
-    }
-    on(event, handler) {
-        const listeners = this.#listeners.get(event) ?? new Set();
-        listeners.add(handler);
-        this.#listeners.set(event, listeners);
-        return this;
-    }
-    off(event, handler) {
-        this.#listeners.get(event)?.delete(handler);
-        return this;
-    }
-    #emit(event, ...args) {
-        const listeners = this.#listeners.get(event);
-        if (!listeners)
-            return;
-        for (const handler of listeners)
-            handler(...args);
-    }
-    signal(signalData) {
-        const rtc = this.#resolveRtc();
-        void (async () => {
-            try {
-                const signalCandidate = signalData;
-                if (typeof signalCandidate.candidate === 'string') {
-                    await this.#addIceCandidate(rtc, signalCandidate);
-                    return;
-                }
-                const signalDescription = signalData;
-                if (typeof signalDescription.type === 'string' &&
-                    typeof signalDescription.sdp === 'string') {
-                    await this.#applyRemoteDescription(rtc, signalDescription);
-                    return;
-                }
-                throw new Error('invalid signal payload');
-            }
-            catch (error) {
-                this.#emit('error', error instanceof Error ? error : new Error(String(error)));
-            }
-        })();
-    }
-    destroy() {
-        if (this.#destroyed)
-            return;
-        this.#destroyed = true;
-        this.#connected = false;
-        if (this._channel) {
-            this._channel.onopen = null;
-            this._channel.onclose = null;
-            this._channel.onmessage = null;
-            this._channel.onerror = null;
-            try {
-                this._channel.close();
-            }
-            catch (e) { }
-            this._channel = null;
-        }
-        this.#pc.onicecandidate = null;
-        this.#pc.onconnectionstatechange = null;
-        this.#pc.ondatachannel = null;
-        try {
-            this.#pc.close();
-        }
-        catch (e) { }
-        this.#emit('close');
-    }
-    #getPubSub() {
-        const pubsubCandidate = globalThis
-            .pubsub;
-        if (pubsubCandidate &&
-            typeof pubsubCandidate.subscribe === 'function' &&
-            typeof pubsubCandidate.unsubscribe === 'function') {
-            return pubsubCandidate;
-        }
-        return null;
-    }
-    /**
-     * send to peer
-     * @param data Uint8Array
-     * @param id custom id to listen to
-     */
-    send(data, id = this.#createMessageId()) {
-        this.#core.send(data, id);
-    }
-    /**
-     * send to peer & wait for response
-     * @param data Uint8Array
-     * @param id custom id to listen to
-     */
-    request(data, id = this.#createMessageId()) {
-        return this.#core.request(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()
-            };
-            stats.forEach((report) => {
-                const typedReport = report;
-                // Latency from candidate pair
-                if (typedReport.type === 'candidate-pair' &&
-                    typeof typedReport.currentRoundTripTime === 'number') {
-                    result.latency = Math.round(typedReport.currentRoundTripTime * 1000);
-                }
-                // Inbound RTP stats
-                if (typedReport.type === 'inbound-rtp') {
-                    result.bytesReceived += Number(typedReport.bytesReceived || 0);
-                    result.packetsLost += Number(typedReport.packetsLost || 0);
-                    if (typeof typedReport.jitter === 'number') {
-                        result.jitter = Math.round(typedReport.jitter * 1000);
-                    }
-                    if (typeof typedReport.fractionLost === 'number') {
-                        result.fractionLost = typedReport.fractionLost;
-                    }
-                }
-                // Outbound RTP stats
-                if (typedReport.type === 'outbound-rtp') {
-                    result.bytesSent += Number(typedReport.bytesSent || 0);
-                }
-                // Available bandwidth
-                if (typedReport.type === 'remote-candidate' &&
-                    typeof typedReport.availableOutgoingBitrate === 'number') {
-                    result.availableOutgoingBitrate = Math.round(typedReport.availableOutgoingBitrate);
-                }
-            });
-            return result;
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    toJSON() {
-        return {
-            peerId: this.peerId,
-            channelName: this.channelName,
-            version: this.version,
-            bw: this.bw
-        };
-    }
-}
-
-// WebTransport streams carry bytes, not application message boundaries.
-const MAX_FRAME_BYTES = 64 * 1024;
-const encodeFrame = (payload) => {
-    if (!(payload instanceof Uint8Array) || !payload.length || payload.length > MAX_FRAME_BYTES) {
-        throw new Error('invalid transport frame length');
-    }
-    const frame = new Uint8Array(payload.length + 4);
-    new DataView(frame.buffer).setUint32(0, payload.length);
-    frame.set(payload, 4);
-    return frame;
-};
-class FrameReader {
-    constructor(reader) { this.reader = reader; this.chunk = new Uint8Array(); this.offset = 0; }
-    async exact(length, allowEnd = false) {
-        const result = new Uint8Array(length);
-        let written = 0;
-        while (written < length) {
-            if (this.offset === this.chunk.length) {
-                const { done, value } = await this.reader.read();
-                if (done) {
-                    if (allowEnd && written === 0)
-                        return null;
-                    throw new Error('truncated transport frame');
-                }
-                this.chunk = value;
-                this.offset = 0;
-                if (!value?.length)
-                    continue;
-            }
-            const count = Math.min(length - written, this.chunk.length - this.offset);
-            result.set(this.chunk.subarray(this.offset, this.offset + count), written);
-            this.offset += count;
-            written += count;
-        }
-        return result;
-    }
-    async read() {
-        const header = await this.exact(4, true);
-        if (!header)
-            return null;
-        const length = new DataView(header.buffer).getUint32(0);
-        if (!length || length > MAX_FRAME_BYTES)
-            throw new Error('invalid transport frame length');
-        return this.exact(length);
-    }
-}
-const jsonBytes = (value) => new TextEncoder().encode(JSON.stringify(value));
-const parseJson = (bytes) => JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
-
-const getWebTransportCtor = async () => {
-    const candidate = globalThis;
-    if (!candidate.WebTransport && candidate.process?.versions?.node) {
-        const { WebTransport } = await import('./index.browser-CFfJpgKV.js');
-        return WebTransport;
-    }
-    if (!candidate.WebTransport) {
-        throw new Error('WebTransport is not available in this runtime');
-    }
-    return candidate.WebTransport;
-};
-class WebTransportPeer {
-    #session = null;
-    #reader = null;
-    #writer = null;
-    #listeners = new Map();
-    #destroyed = false;
-    #connected = false;
-    #core;
-    initiator = true;
-    peerId;
-    channelName;
-    version;
-    compressionThreshold = 0.98;
-    bw = { up: 0, down: 0 };
-    get connected() {
-        return this.#connected;
-    }
-    constructor(options) {
-        this.peerId = options.to;
-        this.channelName = `webtransport:${options.from}:${options.to}`;
-        this.version = String(options.version);
-        if (options.compressionThreshold !== undefined) {
-            this.compressionThreshold = options.compressionThreshold;
-        }
-        this.#core = new PeerCore({
-            kind: 'webtransport-bidi',
-            isConnected: () => this.connected,
-            sendRaw: (payload) => {
-                void this.#sendRaw(payload).catch(error => {
-                    if (!this.#destroyed) {
-                        this.#emit('error', error);
-                        this.destroy();
-                    }
-                });
-            }
-        }, {
-            maxMessageSize: MAX_MESSAGE_SIZE,
-            compressionThreshold: this.compressionThreshold,
-            getPubSub: this.#getPubSub,
-            onPayloadSend: (payloadBytes) => {
-                this.bw.up += payloadBytes;
-            }
-        });
-        queueMicrotask(() => {
-            void this.#open(options);
-        });
-    }
-    #createMessageId() {
-        const randomUUID = globalThis.crypto?.randomUUID;
-        if (typeof randomUUID === 'function') {
-            return randomUUID.call(globalThis.crypto);
-        }
-        return `msg-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    }
-    #getPubSub() {
-        const pubsubCandidate = globalThis
-            .pubsub;
-        if (pubsubCandidate &&
-            typeof pubsubCandidate.subscribe === 'function' &&
-            typeof pubsubCandidate.unsubscribe === 'function') {
-            return pubsubCandidate;
-        }
-        return null;
-    }
-    #emit(event, ...args) {
-        const listeners = this.#listeners.get(event);
-        if (!listeners)
-            return;
-        for (const handler of listeners)
-            handler(...args);
-    }
-    async #open(options) {
-        try {
-            const ticket = await options.getTicket();
-            if (this.#destroyed)
-                return;
-            const WebTransportCtor = await getWebTransportCtor();
-            const session = new WebTransportCtor(options.url);
-            this.#session = session;
-            void session.closed.then(() => this.destroy(), error => {
-                if (!this.#destroyed) {
-                    this.#emit('error', error);
-                    this.destroy();
-                }
-            });
-            await session.ready;
-            if (this.#destroyed)
-                return;
-            const stream = (await session.createBidirectionalStream());
-            if (this.#destroyed)
-                return;
-            this.#reader = stream.readable.getReader();
-            this.#writer = stream.writable.getWriter();
-            const frames = new FrameReader(this.#reader);
-            await this.#writer.write(encodeFrame(jsonBytes({ protocol: 'swarm-relay/1', ticket })));
-            const ready = parseJson(await frames.read());
-            if (ready.protocol !== 'swarm-relay/1' || ready.peerId !== this.peerId || String(ready.version) !== this.version) {
-                throw new Error('invalid WebTransport relay handshake');
-            }
-            if (this.#destroyed)
-                return;
-            this.#connected = true;
-            this.#emit('connect');
-            void this.#readLoop(frames);
-        }
-        catch (error) {
-            this.#emit('error', error instanceof Error ? error : new Error(String(error)));
-            this.destroy();
-        }
-    }
-    async #readLoop(frames) {
-        const reader = this.#reader;
-        if (!reader)
-            return;
-        try {
-            while (!this.#destroyed) {
-                // eslint-disable-next-line no-await-in-loop
-                const value = await frames.read();
-                if (!value)
-                    break;
-                this.bw.down += value.length;
-                this.#emit('data', value);
-            }
-        }
-        catch (error) {
-            if (!this.#destroyed) {
-                this.#emit('error', error instanceof Error ? error : new Error(String(error)));
-            }
-        }
-        if (!this.#destroyed)
-            this.destroy();
-    }
-    async #sendRaw(payload) {
-        if (!this.#writer)
-            throw new Error('WebTransport writer is not ready');
-        await this.#writer.write(encodeFrame(payload));
-    }
-    on(event, handler) {
-        const listeners = this.#listeners.get(event) ?? new Set();
-        listeners.add(handler);
-        this.#listeners.set(event, listeners);
-        return this;
-    }
-    off(event, handler) {
-        this.#listeners.get(event)?.delete(handler);
-        return this;
-    }
-    signal(_signalData) {
-        // WebTransport does not use SDP/ICE signaling in this peer implementation.
-    }
-    send(data, id = this.#createMessageId()) {
-        this.#core.send(data, id);
-    }
-    request(data, id = this.#createMessageId()) {
-        return this.#core.request(data, id);
-    }
-    async getNetworkStats() {
-        return null;
-    }
-    destroy() {
-        if (this.#destroyed)
-            return;
-        this.#destroyed = true;
-        this.#connected = false;
-        try {
-            void this.#reader?.cancel?.().catch(() => { });
-        }
-        catch (e) { }
-        this.#reader?.releaseLock?.();
-        this.#reader = null;
-        try {
-            void this.#writer?.close?.().catch(() => { });
-        }
-        catch (e) { }
-        this.#writer?.releaseLock?.();
-        this.#writer = null;
-        try {
-            this.#session?.close?.();
-        }
-        catch (e) { }
-        this.#session = null;
-        this.#emit('close');
-    }
-}
-
-const getPubSub = () => {
-    const candidate = globalThis.pubsub;
-    if (candidate &&
-        typeof candidate.subscribe === 'function' &&
-        typeof candidate.unsubscribe === 'function') {
-        return candidate;
-    }
-    return null;
-};
-class CircuitPeer {
-    #listeners = new Map();
-    #destroyed = false;
-    #connected = false;
-    #sendViaCircuit;
-    #core;
-    initiator = true;
-    peerId;
-    channelName;
-    version;
-    bw = { up: 0, down: 0 };
-    get connected() {
-        return this.#connected;
-    }
-    constructor(options) {
-        this.peerId = options.to;
-        this.channelName = `circuit:${options.from}:${options.to}`;
-        this.version = String(options.version);
-        this.#sendViaCircuit = options.sendViaCircuit;
-        this.#core = new PeerCore({
-            kind: 'circuit',
-            isConnected: () => this.connected,
-            sendRaw: data => {
-                void this.#sendViaCircuit({ id: this.#createMessageId(), data: Array.from(data) }).catch(error => {
-                    if (this.#destroyed)
-                        return;
-                    this.#emit('error', error);
-                    this.destroy();
-                });
-            }
-        }, {
-            // JSON byte arrays expand up to four characters per byte. Keep the whole
-            // WebSocket frame below its default 64 KiB limit, including wrapper/ID.
-            maxMessageSize: 14_000,
-            compressionThreshold: 0.98,
-            getPubSub,
-            onPayloadSend: bytes => { this.bw.up += bytes; }
-        });
-        queueMicrotask(async () => {
-            try {
-                await options.handshake();
-                if (this.#destroyed)
-                    return;
-                this.#connected = true;
-                this.#emit('connect');
-            }
-            catch (error) {
-                if (this.#destroyed)
-                    return;
-                this.#emit('error', error);
-                this.destroy();
-            }
-        });
-    }
-    #createMessageId() {
-        const randomUUID = globalThis.crypto?.randomUUID;
-        if (typeof randomUUID === 'function') {
-            return randomUUID.call(globalThis.crypto);
-        }
-        return `msg-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    }
-    #emit(event, ...args) {
-        const listeners = this.#listeners.get(event);
-        if (!listeners)
-            return;
-        for (const handler of listeners)
-            handler(...args);
-    }
-    on(event, handler) {
-        const listeners = this.#listeners.get(event) ?? new Set();
-        listeners.add(handler);
-        this.#listeners.set(event, listeners);
-        return this;
-    }
-    off(event, handler) {
-        this.#listeners.get(event)?.delete(handler);
-        return this;
-    }
-    signal(_signalData) {
-        // Circuit transport does not use SDP/ICE signaling.
-    }
-    send(data, id = this.#createMessageId()) {
-        if (new TextEncoder().encode(id).length > 1024) {
-            this.#emit('error', new Error('circuit message id exceeds 1024 bytes'));
-            return;
-        }
-        if (this.#destroyed) {
-            this.#emit('error', new Error('circuit peer is destroyed'));
-            return;
-        }
-        this.#core.send(data, id);
-    }
-    request(data, id = this.#createMessageId()) {
-        if (new TextEncoder().encode(id).length > 1024) {
-            return Promise.reject(new Error('circuit message id exceeds 1024 bytes'));
-        }
-        return this.#core.request(data, id);
-    }
-    async getNetworkStats() {
-        return null;
-    }
-    destroy() {
-        if (this.#destroyed)
-            return;
-        this.#destroyed = true;
-        this.#connected = false;
-        this.#emit('close');
-    }
-}
-
-/** Normalize current star announcements and the legacy peer-id-only format. */
-const normalizePeerAnnouncement = (value) => {
-    if (typeof value === 'string') {
-        const peerId = value.trim();
-        return peerId && peerId !== 'undefined' ? { peerId } : null;
-    }
-    if (!value || typeof value !== 'object')
-        return null;
-    const candidate = value;
-    if (typeof candidate.peerId !== 'string')
-        return null;
-    const peerId = candidate.peerId.trim();
-    if (!peerId || peerId === 'undefined')
-        return null;
-    return {
-        peerId,
-        version: typeof candidate.version === 'string' ? candidate.version : undefined,
-        transport: candidate.transport
-    };
-};
-
-// 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');
-const isWrtcImplementation = (candidate) => {
-    if (!candidate || typeof candidate !== 'object')
-        return false;
-    const wrtcCandidate = candidate;
-    return (typeof wrtcCandidate.RTCPeerConnection === 'function' &&
-        typeof wrtcCandidate.RTCSessionDescription === 'function' &&
-        typeof wrtcCandidate.RTCIceCandidate === 'function');
-};
-class Client {
-    #peerId;
-    #connections = {};
-    #stars = {};
-    #starListeners = {};
-    #reinitLock = null;
-    #connectEvent = 'peer:connected';
-    #supportedTransports = new Set(['webrtc']);
-    #preferredTransportKind = 'webrtc';
-    #wrtcBackend = 'vandeurenglenn';
-    #fallbackTransportOrder = [];
-    #enableCircuitFallback = true;
-    #transportConnectTimeoutMs = 10_000;
-    #peerTransportAttempts = new Map();
-    #peerTransportKinds = new Map();
-    #fallbackCircuitMethod = 'swarm:fallback:send';
-    #testHooks;
-    #webTransportUrlTemplate;
-    #discoverWebTransport = true;
-    #relayUrls = new WeakMap();
-    #circuitHandlers = new Map();
-    #pendingCircuitRequests = new Map();
-    #circuitRequestTimeoutMs = 30_000;
-    #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.#testHooks = options.testHooks;
-        this.#connectEvent = connectEvent;
-        this.starsConfig = stars;
-        const configuredKinds = options.transport?.kinds
-            ? options.transport.kinds
-            : options.transport?.kind
-                ? [options.transport.kind]
-                : (options.transport?.webtransport?.urlTemplate
-                    ? ['webrtc', 'webtransport']
-                    : ['webrtc']);
-        this.#supportedTransports = new Set(this.#normalizeTransportKinds(configuredKinds));
-        if (!this.#supportedTransports.size)
-            this.#supportedTransports.add('webrtc');
-        const configuredPreferred = options.transport?.preferredKind || options.transport?.kind || 'webrtc';
-        this.#preferredTransportKind = this.#supportedTransports.has(configuredPreferred)
-            ? configuredPreferred
-            : this.#supportedTransports.has('webrtc')
-                ? 'webrtc'
-                : 'webtransport';
-        this.#webTransportUrlTemplate = options.transport?.webtransport?.urlTemplate;
-        this.#discoverWebTransport = !options.transport?.kind && !options.transport?.kinds ||
-            !!options.transport?.kinds?.includes('webtransport') || options.transport?.kind === 'webtransport';
-        if (this.#discoverWebTransport && (typeof globalThis.WebTransport === 'function' || globalThis.process?.versions?.node)) {
-            this.#supportedTransports.add('webtransport');
-        }
-        const wrtcBackend = options.transport?.webrtc?.backend ||
-            globalThis.process?.env?.NETPEER_SWARM_WRTC_BACKEND ||
-            'vandeurenglenn';
-        if (wrtcBackend !== 'vandeurenglenn' && wrtcBackend !== 'koush') {
-            throw new Error(`Unsupported WebRTC backend: ${wrtcBackend}`);
-        }
-        this.#wrtcBackend = wrtcBackend;
-        this.#enableCircuitFallback = options.transport?.fallback?.enabled ?? true;
-        if (typeof options.transport?.fallback?.connectTimeoutMs === 'number' &&
-            options.transport.fallback.connectTimeoutMs > 0) {
-            this.#transportConnectTimeoutMs =
-                options.transport.fallback.connectTimeoutMs;
-        }
-        this.#fallbackTransportOrder = this.#normalizeFallbackOrder(options.transport?.fallback?.order);
-        if (options?.retry)
-            this.#retryOptions = { ...this.#retryOptions, ...options.retry };
-        this.#circuitHandlers.set(this.#fallbackCircuitMethod, (payload, context) => this.#handleFallbackCircuitPayload(payload, context));
-        this.#circuitHandlers.set('swarm:fallback:hello', () => ({
-            peerId: this.peerId, version: this.version, encoding: 'peer-core/1'
-        }));
-        if (!this.#testHooks?.skipInit) {
-            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,
-                        transport: {
-                            kind: this.#preferredTransportKind,
-                            kinds: [...this.#supportedTransports]
-                        }
-                    }
-                });
-                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 (this.#supportedTransports.has('webrtc') &&
-            !globalThis.RTCPeerConnection &&
-            !globalThis.wrtc) {
-            const { backend, implementation } = await this.#loadNodeWebrtcImplementation();
-            globalThis.wrtc = implementation;
-            globalThis.__swarmWrtcImpl = backend;
-        }
-        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));
-        }
-    }
-    async #loadNodeWebrtcImplementation() {
-        let wrtcModule;
-        if (this.#wrtcBackend === 'koush') {
-            try {
-                wrtcModule = await import('@koush/wrtc');
-            }
-            catch (error) {
-                throw new Error('The koush WebRTC backend is opt-in; install @koush/wrtc to use it', { cause: error });
-            }
-        }
-        else {
-            wrtcModule = await import('@vandeurenglenn/wrtc');
-        }
-        const moduleCandidate = wrtcModule;
-        const implementation = isWrtcImplementation(moduleCandidate.default)
-            ? moduleCandidate.default
-            : wrtcModule;
-        if (!isWrtcImplementation(implementation)) {
-            const packageName = this.#wrtcBackend === 'koush' ? '@koush/wrtc' : '@vandeurenglenn/wrtc';
-            throw new Error(`${packageName} does not match required wrtc contract`);
-        }
-        debug(`using ${this.#wrtcBackend} as wrtc implementation`);
-        return { backend: this.#wrtcBackend, implementation };
-    }
-    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);
-        const onCircuit = (message) => this.#inComingCircuit(message, starConnection);
-        const onServerData = (message) => {
-            globalThis.pubsub.publish('server:data', message);
-        };
-        const onRelayReady = (message) => {
-            if (!this.#discoverWebTransport || message?.protocol !== 'swarm-relay/1' || typeof message.url !== 'string')
-                return;
-            let url;
-            try {
-                url = new URL(message.url);
-            }
-            catch {
-                return;
-            }
-            if (url.protocol !== 'https:' || url.username || url.password || url.hash)
-                return;
-            if (this.#relayUrls.get(starConnection) === url.href)
-                return;
-            this.#relayUrls.set(starConnection, url.href);
-            this.#supportedTransports.add('webtransport');
-            // Update capabilities on this same authenticated star connection. The
-            // server sends relay metadata before its peer snapshot, so fallback can
-            // resolve a real endpoint without users configuring transport URLs.
-            starConnection.send({ url: 'join', params: {
-                    version: this.version, peerId: this.peerId,
-                    transport: { kind: this.#preferredTransportKind, kinds: [...this.#supportedTransports] }
-                } });
-        };
-        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);
-        starConnection.pubsub.subscribe('circuit', onCircuit);
-        starConnection.pubsub.subscribe('server:data', onServerData);
-        starConnection.pubsub.subscribe('relay:ready', onRelayReady);
-        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 },
-            { topic: 'circuit', handler: onCircuit },
-            { topic: 'server:data', handler: onServerData },
-            { topic: 'relay:ready', handler: onRelayReady }
-        ];
-    }
-    #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`);
-    };
-    #normalizeTransportKinds(kinds) {
-        if (!Array.isArray(kinds))
-            return [];
-        const normalized = new Set();
-        for (const kind of kinds) {
-            if (kind === 'webrtc' || kind === 'webtransport')
-                normalized.add(kind);
-        }
-        return [...normalized];
-    }
-    #normalizeFallbackOrder(kinds) {
-        if (!Array.isArray(kinds))
-            return [];
-        const normalized = new Set();
-        for (const kind of kinds) {
-            if (kind === 'webrtc' || kind === 'webtransport' || kind === 'circuit') {
-                normalized.add(kind);
-            }
-        }
-        return [...normalized];
-    }
-    #supportsTransport(kind) {
-        return this.#supportedTransports.has(kind);
-    }
-    #getRemoteTransportKinds(transport) {
-        const fromKinds = this.#normalizeTransportKinds(transport?.kinds);
-        if (fromKinds.length)
-            return fromKinds;
-        if (transport?.kind === 'webrtc' || transport?.kind === 'webtransport') {
-            return [transport.kind];
-        }
-        return ['webrtc'];
-    }
-    #selectTransportForPeer(peerId, transport) {
-        const remoteKinds = this.#getRemoteTransportKinds(transport);
-        const commonKinds = remoteKinds.filter((kind) => this.#supportsTransport(kind));
-        if (!commonKinds.length) {
-            debug(`peer ${peerId} has no compatible transport with local capabilities`);
-            return null;
-        }
-        if (transport?.kind && commonKinds.includes(transport.kind)) {
-            return transport.kind;
-        }
-        if (commonKinds.includes(this.#preferredTransportKind)) {
-            return this.#preferredTransportKind;
-        }
-        if (commonKinds.includes('webrtc'))
-            return 'webrtc';
-        return 'webtransport';
-    }
-    #buildTransportOrder(peerId, transport) {
-        const remoteKinds = this.#getRemoteTransportKinds(transport);
-        const commonKinds = remoteKinds.filter((kind) => this.#supportsTransport(kind));
-        if (!commonKinds.length) {
-            if (this.#enableCircuitFallback) {
-                debug(`peer ${peerId} has no direct transport overlap, using circuit`);
-                return ['circuit'];
-            }
-            return [];
-        }
-        const order = [];
-        if (transport?.kind && commonKinds.includes(transport.kind)) {
-            order.push(transport.kind);
-        }
-        if (commonKinds.includes(this.#preferredTransportKind) &&
-            !order.includes(this.#preferredTransportKind)) {
-            order.push(this.#preferredTransportKind);
-        }
-        for (const kind of this.#fallbackTransportOrder) {
-            if (kind !== 'circuit' &&
-                commonKinds.includes(kind) &&
-                !order.includes(kind)) {
-                order.push(kind);
-            }
-        }
-        if (commonKinds.includes('webrtc') && !order.includes('webrtc')) {
-            order.push('webrtc');
-        }
-        if (commonKinds.includes('webtransport') &&
-            !order.includes('webtransport')) {
-            order.push('webtransport');
-        }
-        if (this.#enableCircuitFallback && !order.includes('circuit')) {
-            order.push('circuit');
-        }
-        debug(`peer ${peerId} transport order: ${order.join(' -> ')}`);
-        return order;
-    }
-    #clearTransportAttempt(peerId) {
-        const attempt = this.#peerTransportAttempts.get(peerId);
-        if (attempt?.timeout)
-            clearTimeout(attempt.timeout);
-        this.#peerTransportAttempts.delete(peerId);
-    }
-    #emitTransportEvent(event) {
-        this.#testHooks?.onTransportEvent?.(event);
-    }
-    #advanceTransportAttempt(peerId) {
-        const attempt = this.#peerTransportAttempts.get(peerId);
-        if (!attempt)
-            return;
-        const previousIndex = attempt.index;
-        const previousTransport = attempt.order[previousIndex];
-        if (attempt.timeout)
-            clearTimeout(attempt.timeout);
-        this.#emitTransportEvent({
-            type: 'attempt-advanced',
-            peerId,
-            transport: previousTransport,
-            attemptIndex: previousIndex,
-            order: [...attempt.order]
-        });
-        attempt.index += 1;
-        this.#attemptPeerTransport(peerId);
-    }
-    #startPeerTransportAttempt(peerId, star, version, initiator, transport) {
-        if (this.#connections[peerId])
-            return;
-        if (this.#peerTransportAttempts.has(peerId))
-            return;
-        const order = this.#buildTransportOrder(peerId, transport);
-        if (!order.length) {
-            debug(`peer ${peerId} has no available transport to attempt`);
-            return;
-        }
-        this.#peerTransportAttempts.set(peerId, {
-            order,
-            index: 0,
-            star,
-            version,
-            initiator
-        });
-        this.#attemptPeerTransport(peerId);
-    }
-    #attemptPeerTransport(peerId) {
-        const attempt = this.#peerTransportAttempts.get(peerId);
-        if (!attempt)
-            return;
-        if (attempt.index >= attempt.order.length) {
-            const exhaustedTransport = attempt.order[attempt.order.length - 1] ?? 'circuit';
-            this.#emitTransportEvent({
-                type: 'attempts-exhausted',
-                peerId,
-                transport: exhaustedTransport,
-                attemptIndex: attempt.index,
-                order: [...attempt.order]
-            });
-            debug(`peer ${peerId} transport attempts exhausted`);
-            this.#clearTransportAttempt(peerId);
-            return;
-        }
-        if (this.#connections[peerId])
-            return;
-        const transportKind = attempt.order[attempt.index];
-        this.#emitTransportEvent({
-            type: 'attempt-started',
-            peerId,
-            transport: transportKind,
-            attemptIndex: attempt.index,
-            order: [...attempt.order]
-        });
-        let peer = null;
-        if (transportKind === 'webrtc') {
-            peer = this.#createRTCPeerConnection(peerId, attempt.star, attempt.version, attempt.initiator);
-        }
-        else if (transportKind === 'webtransport') {
-            const url = this.#resolveWebTransportUrl(peerId, attempt.star);
-            if (!url) {
-                this.#advanceTransportAttempt(peerId);
-                return;
-            }
-            peer = this.#createWebTransportConnection(peerId, url, attempt.version, attempt.star);
-        }
-        else {
-            peer = this.#createCircuitConnection(peerId, attempt.version);
-        }
-        if (!peer) {
-            this.#advanceTransportAttempt(peerId);
-            return;
-        }
-        attempt.timeout = setTimeout(() => {
-            const current = this.#connections[peerId];
-            if (!current || current.connected)
-                return;
-            this.#emitTransportEvent({
-                type: 'attempt-timeout',
-                peerId,
-                transport: transportKind,
-                attemptIndex: attempt.index,
-                order: [...attempt.order]
-            });
-            debug(`peer ${peerId} ${transportKind} connect timeout`);
-            current.destroy();
-        }, this.#transportConnectTimeoutMs);
-    }
-    #decodeCircuitFallbackPayload(payload) {
-        if (!payload || typeof payload !== 'object')
-            return null;
-        const candidate = payload;
-        if (!Array.isArray(candidate.data))
-            return null;
-        const id = typeof candidate.id === 'string' && candidate.id.length
-            ? candidate.id
-            : this.#createCircuitId();
-        return {
-            id,
-            data: new Uint8Array(candidate.data.map((byte) => Number(byte) & 255))
-        };
-    }
-    async #handleFallbackCircuitPayload(payload, context) {
-        const decoded = this.#decodeCircuitFallbackPayload(payload);
-        if (!decoded) {
-            throw new Error('invalid circuit fallback payload');
-        }
-        let peer = this.#connections[context.from];
-        if (!peer) {
-            peer = this.#createCircuitConnection(context.from, this.version);
-        }
-        if (!peer)
-            throw new Error('circuit peer unavailable');
-        if (!peer.connected) {
-            const waitingPeer = peer;
-            await new Promise((resolve, reject) => {
-                const finish = (error) => {
-                    clearTimeout(timer);
-                    waitingPeer.off('connect', onConnect);
-                    waitingPeer.off('close', onClose);
-                    error ? reject(error) : resolve();
-                };
-                const onConnect = () => finish();
-                const onClose = () => finish(new Error('circuit peer closed during handshake'));
-                const timer = setTimeout(() => finish(new Error('circuit handshake timed out')), this.#transportConnectTimeoutMs);
-                waitingPeer.on('connect', onConnect);
-                waitingPeer.on('close', onClose);
-            });
-        }
-        this.#peerData(peer, decoded.data);
-        return { ok: true };
-    }
-    #createCircuitId() {
-        const randomUUID = globalThis.crypto?.randomUUID;
-        if (typeof randomUUID === 'function') {
-            return randomUUID.call(globalThis.crypto);
-        }
-        return `circuit-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    }
-    #encodeCircuitData(data) {
-        if (data instanceof Uint8Array) {
-            return { __swarmType: 'u8', data: Array.from(data) };
-        }
-        return data;
-    }
-    #decodeCircuitData(data) {
-        if (data &&
-            typeof data === 'object' &&
-            data.__swarmType === 'u8' &&
-            Array.isArray(data.data)) {
-            return new Uint8Array(data.data.map((item) => Number(item) & 255));
-        }
-        return data;
-    }
-    #pickStarConnection() {
-        const entries = Object.values(this.#stars);
-        return entries.find((client) => client?.connectionState?.() === 'open');
-    }
-    #sendCircuit(starConnection, payload) {
-        starConnection.send({
-            url: 'circuit',
-            params: payload
-        });
-    }
-    onCircuit(method, handler) {
-        this.#circuitHandlers.set(method, handler);
-    }
-    offCircuit(method) {
-        this.#circuitHandlers.delete(method);
-    }
-    onServerData(handler) {
-        globalThis.pubsub.subscribe('server:data', handler);
-    }
-    offServerData(handler) {
-        globalThis.pubsub.unsubscribe('server:data', handler);
-    }
-    circuitRequest(peerId, method, data, timeoutMs = this.#circuitRequestTimeoutMs) {
-        const starConnection = this.#pickStarConnection();
-        if (!starConnection) {
-            return Promise.reject(new Error('no connected star available for circuit request'));
-        }
-        const id = this.#createCircuitId();
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.#pendingCircuitRequests.delete(id);
-                reject(new Error(`circuit request for ${id} timed out`));
-            }, timeoutMs);
-            this.#pendingCircuitRequests.set(id, { resolve, reject, timeout, peerId, starConnection });
-            try {
-                this.#sendCircuit(starConnection, {
-                    to: peerId,
-                    from: this.peerId,
-                    id,
-                    phase: 'request',
-                    method,
-                    data: this.#encodeCircuitData(data)
-                });
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                this.#pendingCircuitRequests.delete(id);
-                reject(error);
-            }
-        });
-    }
-    #inComingCircuit = async ({ from, to, id, phase, method, data, error }, starConnection) => {
-        if (to !== this.peerId)
-            return;
-        if (phase === 'response') {
-            const pending = this.#pendingCircuitRequests.get(id);
-            if (!pending)
-                return;
-            if (pending.starConnection !== starConnection)
-                return;
-            if (from !== pending.peerId && !(from === 'server' && error))
-                return;
-            clearTimeout(pending.timeout);
-            this.#pendingCircuitRequests.delete(id);
-            if (error) {
-                pending.reject(new Error(String(error)));
-                return;
-            }
-            pending.resolve(this.#decodeCircuitData(data));
-            return;
-        }
-        if (phase !== 'request')
-            return;
-        if (typeof method !== 'string' || !method.length)
-            return;
-        const handler = this.#circuitHandlers.get(method);
-        if (!handler) {
-            this.#sendCircuit(starConnection, {
-                to: from,
-                from: this.peerId,
-                id,
-                phase: 'response',
-                error: `no circuit handler registered for method ${method}`
-            });
-            return;
-        }
-        try {
-            const response = await handler(this.#decodeCircuitData(data), {
-                from,
-                method,
-                id
-            });
-            this.#sendCircuit(starConnection, {
-                to: from,
-                from: this.peerId,
-                id,
-                phase: 'response',
-                data: this.#encodeCircuitData(response)
-            });
-        }
-        catch (handlerError) {
-            this.#sendCircuit(starConnection, {
-                to: from,
-                from: this.peerId,
-                id,
-                phase: 'response',
-                error: handlerError instanceof Error
-                    ? handlerError.message
-                    : String(handlerError)
-            });
-        }
-    };
-    connect(peerId, star, initiator = true) {
-        if (this.#connections[peerId]) {
-            debug(`peer ${peerId} already connected`);
-            return;
-        }
-        if (!this.#testHooks?.allowConnectWithoutStar &&
-            this.#stars[star]?.connectionState() !== 'open') {
-            console.warn(`Star ${star} is not connected, cannot reconnect to peer ${peerId}`);
-            return;
-        }
-        this.#startPeerTransportAttempt(peerId, star, this.version, initiator, {
-            kind: this.#preferredTransportKind,
-            kinds: [...this.#supportedTransports]
-        });
-    }
-    reconnect(peerId, star, initiator = false) {
-        delete this.#connections[peerId];
-        debug(`reconnecting to peer ${peerId}`);
-        return this.connect(peerId, star, initiator);
-    }
-    connectWebTransport(peerId, url) {
-        this.#createWebTransportConnection(peerId, url, this.version);
-    }
-    #resolveWebTransportUrl(peerId, starConnection) {
-        const urlTemplate = this.#webTransportUrlTemplate || (starConnection && this.#relayUrls.get(starConnection));
-        if (!urlTemplate) {
-            return null;
-        }
-        return urlTemplate
-            .replace('{peerId}', encodeURIComponent(peerId))
-            .replace('{selfId}', encodeURIComponent(this.peerId));
-    }
-    #createWebTransportConnection(peerId, url, version, starConnection) {
-        if (this.#connections[peerId]) {
-            debug(`peer ${peerId} already connected`);
-            return null;
-        }
-        const testPeer = this.#testHooks?.createPeer?.({
-            kind: 'webtransport',
-            peerId,
-            version,
-            initiator: true,
-            url
-        });
-        if (testPeer) {
-            testPeer.on('connect', () => this.#peerConnect(testPeer));
-            testPeer.on('close', () => this.#peerClose(testPeer));
-            testPeer.on('data', (data) => this.#peerData(testPeer, data));
-            testPeer.on('error', (error) => this.#peerError(testPeer, error));
-            this.#connections[peerId] = testPeer;
-            this.#peerTransportKinds.set(peerId, 'webtransport');
-            return testPeer;
-        }
-        const peer = new WebTransportPeer({
-            from: this.peerId,
-            to: peerId,
-            version,
-            url,
-            getTicket: async () => {
-                const star = starConnection || this.#pickStarConnection();
-                if (!star)
-                    throw new Error('no connected star available for WebTransport ticket');
-                let timer;
-                try {
-                    const response = await Promise.race([
-                        star.request({ url: 'webtransport-ticket', params: { from: this.peerId, to: peerId } }),
-                        new Promise((_, reject) => {
-                            timer = setTimeout(() => reject(new Error('WebTransport ticket request timed out')), this.#transportConnectTimeoutMs);
-                        })
-                    ]);
-                    if (typeof response?.ticket !== 'string')
-                        throw new Error('star did not authorize WebTransport relay');
-                    return response.ticket;
-                }
-                finally {
-                    clearTimeout(timer);
-                }
-            }
-        });
-        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;
-        this.#peerTransportKinds.set(peerId, 'webtransport');
-        return peer;
-    }
-    #createCircuitConnection(peerId, version) {
-        if (this.#connections[peerId]) {
-            debug(`peer ${peerId} already connected`);
-            return null;
-        }
-        const testPeer = this.#testHooks?.createPeer?.({
-            kind: 'circuit',
-            peerId,
-            version,
-            initiator: true
-        });
-        if (testPeer) {
-            testPeer.on('connect', () => this.#peerConnect(testPeer));
-            testPeer.on('close', () => this.#peerClose(testPeer));
-            testPeer.on('data', (data) => this.#peerData(testPeer, data));
-            testPeer.on('error', (error) => this.#peerError(testPeer, error));
-            this.#connections[peerId] = testPeer;
-            this.#peerTransportKinds.set(peerId, 'circuit');
-            return testPeer;
-        }
-        const peer = new CircuitPeer({
-            from: this.peerId,
-            to: peerId,
-            version,
-            handshake: async () => {
-                const response = await this.circuitRequest(peerId, 'swarm:fallback:hello', undefined, this.#transportConnectTimeoutMs);
-                if (response?.peerId !== peerId || String(response?.version) !== String(version) || response.encoding !== 'peer-core/1') {
-                    throw new Error('invalid circuit handshake response');
-                }
-            },
-            sendViaCircuit: (payload) => this.circuitRequest(peerId, this.#fallbackCircuitMethod, payload)
-        });
-        peer.on('connect', () => this.#peerConnect(peer));
-        peer.on('close', () => this.#peerClose(peer));
-        peer.on('error', (error) => this.#peerError(peer, error));
-        this.#connections[peerId] = peer;
-        this.#peerTransportKinds.set(peerId, 'circuit');
-        return peer;
-    }
-    #createRTCPeerConnection = (peerId, star, version, initiator = false) => {
-        const testPeer = this.#testHooks?.createPeer?.({
-            kind: 'webrtc',
-            peerId,
-            version,
-            initiator,
-            star
-        });
-        if (testPeer) {
-            testPeer.on('connect', () => this.#peerConnect(testPeer));
-            testPeer.on('close', () => this.#peerClose(testPeer));
-            testPeer.on('data', (data) => this.#peerData(testPeer, data));
-            testPeer.on('error', (error) => this.#peerError(testPeer, error));
-            this.#connections[peerId] = testPeer;
-            this.#peerTransportKinds.set(peerId, 'webrtc');
-            return testPeer;
-        }
-        const peer = new WebRTCPeer({
-            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;
-        this.#peerTransportKinds.set(peerId, 'webrtc');
-        return peer;
-    };
-    #peerJoined = async (announcement, star) => {
-        const normalized = normalizePeerAnnouncement(announcement);
-        if (!normalized) {
-            debug('ignored malformed peer announcement');
-            return;
-        }
-        const { peerId, transport } = normalized;
-        // Legacy stars announce only the peer id. This value is used for transport
-        // negotiation; applications still perform their own version handshake.
-        const version = normalized.version ?? this.version;
-        if (this.peerId === peerId)
-            return;
-        // Stars can announce the same peer more than once while its transport is
-        // still negotiating. Keep that connection/attempt alive; destroying it
-        // here makes simultaneous joins continually reset each other.
-        // Both sides receive the discovery event. Elect exactly one offerer so
-        // simultaneous joins do not create competing channels/SDP negotiations.
-        const initiator = String(this.peerId) < String(peerId);
-        this.#startPeerTransportAttempt(peerId, star, version, initiator, transport);
-        debug(`peer ${peerId} joined`);
-    };
-    #inComingSignal = async ({ from, signal, channelName, version }, star) => {
-        if (!this.#supportsTransport('webrtc')) {
-            debug(`ignoring webrtc signal for ${from} because local client does not support webrtc`);
-            return;
-        }
-        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 && String(peer.channelName).startsWith('webtransport:')) {
-            if (peer.connected) {
-                debug(`ignoring webrtc signal for ${from} because peer uses webtransport`);
-                return;
-            }
-            peer.destroy();
-            delete this.#connections[from];
-            this.#clearTransportAttempt(from);
-            peer = undefined;
-        }
-        if (!peer) {
-            this.#clearTransportAttempt(from);
-            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}.`);
-            peer.destroy();
-            delete this.#connections[from];
-            this.#clearTransportAttempt(from);
-            this.#createRTCPeerConnection(from, star, version, false);
-            peer = this.#connections[from];
-            if (!peer)
-                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) => {
-        // A failed transport can finish closing after fallback has already placed a
-        // replacement in the connection map. Never let that stale close delete or
-        // advance the replacement's active attempt.
-        if (this.#connections[peer.peerId] !== peer) {
-            debug(`ignored stale close for ${peer.peerId}`);
-            return;
-        }
-        const wasConnected = peer.connected;
-        this.#peerTransportKinds.delete(peer.peerId);
-        delete this.#connections[peer.peerId];
-        if (!wasConnected && this.#peerTransportAttempts.has(peer.peerId)) {
-            this.#advanceTransportAttempt(peer.peerId);
-        }
-        debug(`closed ${peer.peerId}'s connection`);
-    };
-    #peerConnect = (peer) => {
-        const attempt = this.#peerTransportAttempts.get(peer.peerId);
-        const transport = this.#peerTransportKinds.get(peer.peerId) ||
-            attempt?.order[attempt.index] ||
-            'webrtc';
-        this.#emitTransportEvent({
-            type: 'connected',
-            peerId: peer.peerId,
-            transport,
-            attemptIndex: attempt?.index ?? 0,
-            order: attempt ? [...attempt.order] : [transport]
-        });
-        this.#clearTransportAttempt(peer.peerId);
-        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) => {
-        const message = error instanceof Error ? error.message : `unknown error: ${String(error)}`;
-        const attempt = this.#peerTransportAttempts.get(peer.peerId);
-        const transport = this.#peerTransportKinds.get(peer.peerId) ||
-            attempt?.order[attempt.index] ||
-            'webrtc';
-        this.#emitTransportEvent({
-            type: 'attempt-error',
-            peerId: peer.peerId,
-            transport,
-            attemptIndex: attempt?.index ?? 0,
-            order: attempt ? [...attempt.order] : [transport],
-            reason: message
-        });
-        console.warn(`Connection error: ${message}`);
-        peer.destroy();
-    };
-    async close() {
-        for (const pending of this.#pendingCircuitRequests.values()) {
-            clearTimeout(pending.timeout);
-            pending.reject(new Error('client closed'));
-        }
-        this.#pendingCircuitRequests.clear();
-        for (const peerId of this.#peerTransportAttempts.keys()) {
-            this.#clearTransportAttempt(peerId);
-        }
-        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 };