@leofcoin/peernet 1.2.19 → 1.2.21

package/exports/browser/client-lPe0SUWx.js

@@ -0,0 +1,2165 @@
+import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-DFiLLjUD.js';
+import './identity-BeVZQ2Dp.js';
+import 'crypto';
+import './value-C3vAp-wb.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-8BFql6K9.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
+        };
+    }
+}
+
+const getWebTransportCtor = () => {
+    const candidate = globalThis;
+    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);
+            }
+        }, {
+            maxMessageSize: MAX_MESSAGE_SIZE,
+            compressionThreshold: this.compressionThreshold,
+            getPubSub: this.#getPubSub,
+            onPayloadSend: (payloadBytes) => {
+                this.bw.up += payloadBytes;
+            }
+        });
+        queueMicrotask(() => {
+            void this.#open(options.url);
+        });
+    }
+    #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(url) {
+        try {
+            const WebTransportCtor = getWebTransportCtor();
+            const session = new WebTransportCtor(url);
+            this.#session = session;
+            await session.ready;
+            const stream = (await session.createBidirectionalStream());
+            this.#reader = stream.readable.getReader();
+            this.#writer = stream.writable.getWriter();
+            this.#connected = true;
+            this.#emit('connect');
+            void this.#readLoop();
+            void session.closed.catch((error) => {
+                if (this.#destroyed)
+                    return;
+                this.#emit('error', error instanceof Error ? error : new Error(String(error)));
+            });
+        }
+        catch (error) {
+            this.#emit('error', error instanceof Error ? error : new Error(String(error)));
+            this.destroy();
+        }
+    }
+    async #readLoop() {
+        const reader = this.#reader;
+        if (!reader)
+            return;
+        try {
+            while (!this.#destroyed) {
+                // eslint-disable-next-line no-await-in-loop
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (!value)
+                    continue;
+                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(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 (e) { }
+        this.#reader?.releaseLock?.();
+        this.#reader = null;
+        try {
+            void this.#writer?.close?.();
+        }
+        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;
+    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;
+        setTimeout(() => {
+            if (this.#destroyed)
+                return;
+            this.#connected = true;
+            this.#emit('connect');
+        }, 0);
+    }
+    #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 (this.#destroyed) {
+            this.#emit('error', new Error('circuit peer is destroyed'));
+            return;
+        }
+        this.bw.up += data.length;
+        void this.#sendViaCircuit({ id, data: Array.from(data) }).catch((error) => {
+            this.#emit('error', error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    request(data, id = this.#createMessageId()) {
+        const pubsub = getPubSub();
+        if (!pubsub) {
+            return Promise.reject(new Error('globalThis.pubsub is not available'));
+        }
+        return new Promise((resolve, reject) => {
+            let timeout;
+            let settled = false;
+            const finish = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                try {
+                    pubsub.unsubscribe(id, onResponse);
+                }
+                catch (e) { }
+                fn();
+            };
+            const onResponse = ({ data: response }) => {
+                finish(() => resolve(response));
+            };
+            timeout = setTimeout(() => {
+                finish(() => reject(new Error(`request for ${id} timed out`)));
+            }, 30_000);
+            pubsub.subscribe(id, onResponse);
+            this.send(data, id);
+        });
+    }
+    async getNetworkStats() {
+        return null;
+    }
+    destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        this.#connected = false;
+        this.#emit('close');
+    }
+}
+
+// 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';
+    #fallbackTransportOrder = [];
+    #enableCircuitFallback = true;
+    #transportConnectTimeoutMs = 10_000;
+    #peerTransportAttempts = new Map();
+    #peerTransportKinds = new Map();
+    #fallbackCircuitMethod = 'swarm:fallback:send';
+    #testHooks;
+    #webTransportUrlTemplate;
+    #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]
+                : ['webrtc', 'webtransport'];
+        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.#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));
+        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 (!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() {
+        const koushWrtcModule = await import('./browser-FVp_QbaL.js').then(function (n) { return n.b; });
+        const koushWrtc = koushWrtcModule.default;
+        if (!isWrtcImplementation(koushWrtc)) {
+            throw new Error('@koush/wrtc does not match required wrtc contract');
+        }
+        debug('using @koush/wrtc as wrtc implementation');
+        return { backend: 'koush', implementation: koushWrtc };
+    }
+    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);
+        };
+        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);
+        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 }
+        ];
+    }
+    #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);
+            if (!url) {
+                this.#advanceTransportAttempt(peerId);
+                return;
+            }
+            peer = this.#createWebTransportConnection(peerId, url, attempt.version);
+        }
+        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);
+        }
+        this.#noticeMessage(decoded.data, decoded.id, context.from, peer);
+        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 });
+            this.#sendCircuit(starConnection, {
+                to: peerId,
+                from: this.peerId,
+                id,
+                phase: 'request',
+                method,
+                data: this.#encodeCircuitData(data)
+            });
+        });
+    }
+    #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;
+            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) {
+        const urlTemplate = this.#webTransportUrlTemplate;
+        if (!urlTemplate) {
+            console.warn('WebTransport requires transport.webtransport.urlTemplate in client options');
+            return null;
+        }
+        return urlTemplate
+            .replace('{peerId}', encodeURIComponent(peerId))
+            .replace('{selfId}', encodeURIComponent(this.peerId));
+    }
+    #createWebTransportConnection(peerId, url, version) {
+        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
+        });
+        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,
+            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 ({ peerId, version, transport }, 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)
+            return;
+        this.#startPeerTransportAttempt(peerId, star, version, true, 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) => {
+        const wasConnected = peer.connected;
+        this.#peerTransportKinds.delete(peer.peerId);
+        if (this.#connections[peer.peerId]) {
+            peer.destroy();
+            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 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 };