@luxonis/visualizer-protobuf 1.9.0 → 2.0.0

package/dist/{index-GbwWdY6w.js → index-DpXY8ing.js}

@@ -1,13 +1,15 @@
-import { aq as styleTags, ar as tags, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aB as foldInside, aH as defineCSSCompletionSource, at as LanguageSupport, av as LRParser, au as ExternalTokenizer } from './index-CNWGMhCW.js';
-import './worker-utils-Jii8lIsy.js';
+import { aq as styleTags, ar as tags, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aB as foldInside, aH as defineCSSCompletionSource, at as LanguageSupport, av as LRParser, au as ExternalTokenizer } from './index-DQCAxiet.js';
+import './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
+import './worker-utils-BbyBpOVt.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-otpYhpPx.js → index-DudYiuIt.js}

@@ -1,13 +1,15 @@
-import { aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport } from './index-CNWGMhCW.js';
-import './worker-utils-Jii8lIsy.js';
+import { aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport } from './index-DQCAxiet.js';
+import './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
+import './worker-utils-BbyBpOVt.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-B8t-Gi4x.js → index-FOw7-sDA.js}

@@ -1,13 +1,15 @@
-import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, ay as syntaxTree, aw as ifNotIn, as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport, aF as IterMode, ax as completeFromList, aG as NodeWeakMap, aE as snippetCompletion } from './index-CNWGMhCW.js';
-import './worker-utils-Jii8lIsy.js';
+import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, ay as syntaxTree, aw as ifNotIn, as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, at as LanguageSupport, aF as IterMode, ax as completeFromList, aG as NodeWeakMap, aE as snippetCompletion } from './index-DQCAxiet.js';
+import './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
+import './worker-utils-BbyBpOVt.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-Cp3omW6p.js → index-IoSJKto7.js}

@@ -1,15 +1,17 @@
-import { ImagePanel } from './index-BEcWpcB1.js';
+import { ImagePanel } from './index-CgoOLCnB.js';
 import 'react';
 import 'react-dom';
-import './index-CNWGMhCW.js';
-import './worker-utils-Jii8lIsy.js';
+import './index-DQCAxiet.js';
+import './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
+import './worker-utils-BbyBpOVt.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-Dn-E1-20.js → index-M-zdB4A1.js}

@@ -1,13 +1,15 @@
-import { an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aq as styleTags, ar as tags, as as LRLanguage, at as LanguageSupport, au as ExternalTokenizer, av as LRParser, aw as ifNotIn, ax as completeFromList, ay as syntaxTree } from './index-CNWGMhCW.js';
-import './worker-utils-Jii8lIsy.js';
+import { an as indentNodeProp, ao as continuedIndent, ap as foldNodeProp, aq as styleTags, ar as tags, as as LRLanguage, at as LanguageSupport, au as ExternalTokenizer, av as LRParser, aw as ifNotIn, ax as completeFromList, ay as syntaxTree } from './index-DQCAxiet.js';
+import './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
+import './worker-utils-BbyBpOVt.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-Bk6p8-al.js → index-QNisWGZ4.js}

@@ -1,13 +1,15 @@
-import { as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, aq as styleTags, ar as tags, at as LanguageSupport, av as LRParser } from './index-CNWGMhCW.js';
-import './worker-utils-Jii8lIsy.js';
+import { as as LRLanguage, an as indentNodeProp, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, aq as styleTags, ar as tags, at as LanguageSupport, av as LRParser } from './index-DQCAxiet.js';
+import './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
+import './worker-utils-BbyBpOVt.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-txFQeh8N.js → index-doJtQKmP.js}

@@ -1,13 +1,15 @@
-import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, ap as foldNodeProp, aB as foldInside, an as indentNodeProp, ao as continuedIndent, aH as defineCSSCompletionSource, at as LanguageSupport } from './index-CNWGMhCW.js';
-import './worker-utils-Jii8lIsy.js';
+import { au as ExternalTokenizer, aC as ContextTracker, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, ap as foldNodeProp, aB as foldInside, an as indentNodeProp, ao as continuedIndent, aH as defineCSSCompletionSource, at as LanguageSupport } from './index-DQCAxiet.js';
+import './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
+import './worker-utils-BbyBpOVt.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/{index-ChQWCJEj.js → index-r1jTO4Ay.js}

@@ -1,13 +1,15 @@
-import { au as ExternalTokenizer, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, aK as html, at as LanguageSupport, aL as parseMixed } from './index-CNWGMhCW.js';
-import './worker-utils-Jii8lIsy.js';
+import { au as ExternalTokenizer, aq as styleTags, ar as tags, av as LRParser, as as LRLanguage, an as indentNodeProp, ao as continuedIndent, aA as delimitedIndent, ap as foldNodeProp, aB as foldInside, aK as html, at as LanguageSupport, aL as parseMixed } from './index-DQCAxiet.js';
+import './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
 import '@mui/material';
 import './i18next-C5Qe4-E1.js';
+import './worker-utils-BbyBpOVt.js';
 import 'react-dnd';
 import 'react-dnd-html5-backend';
 import '@emotion/react';

package/dist/index.js

@@ -1,5 +1,8 @@
-export { aR as ImagePanel, aQ as PanelLayout, aS as PointCloudPanel, aP as VisualizerContext, aO as WebSocketConnection } from './index-CNWGMhCW.js';
-export { d as createWsWorkerMessageListener } from './worker-utils-Jii8lIsy.js';
+export { aR as ImagePanel, aQ as PanelLayout, aS as PointCloudPanel, aO as VisualizerConnection, aP as VisualizerContext } from './index-DQCAxiet.js';
+export { b as createWsWorkerMessageListener } from './worker-utils-DfViKOHw.js';
+export { c as createWebRtcWorkerMessageListener } from './worker-utils-BbyBpOVt.js';
+import './communicator-D_EeiIbd.js';
+import 'protobufjs/minimal';
 import 'react';
 import 'zustand';
 import 'react-mosaic-component';
@@ -18,4 +21,3 @@ import 'react-icons';
 import '@pandacss/dev';
 import 'hydrated-ws';
 import 'ms';
-import 'protobufjs/minimal';

package/dist/{worker-D2k1TTky.js → worker-1z9jlpUn.js}

@@ -1,6 +1,7 @@
-import { d as createWsWorkerMessageListener } from './worker-utils-Jii8lIsy.js';
+import { b as createWsWorkerMessageListener } from './worker-utils-DfViKOHw.js';
 import 'hydrated-ws';
 import 'ms';
+import './communicator-D_EeiIbd.js';
 import 'protobufjs/minimal';
 
 // This Source Code Form is subject to the terms of the Mozilla Public

package/dist/worker-DNYPTnyn.js

@@ -0,0 +1,9 @@
+import { c as createWebRtcWorkerMessageListener } from './worker-utils-BbyBpOVt.js';
+import './communicator-D_EeiIbd.js';
+import 'protobufjs/minimal';
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+self.addEventListener("message", createWebRtcWorkerMessageListener(self.postMessage.bind(self), self.postMessage.bind(self)));

package/dist/worker-utils-BbyBpOVt.js

@@ -0,0 +1,453 @@
+import { F as FoxgloveCommunicator } from './communicator-D_EeiIbd.js';
+
+class EventEmitter {
+    id = 0;
+    handlers = {};
+    emit(event, data) {
+        const handlers = this.handlers[event] ?? [];
+        for (const { handler } of handlers) {
+            handler(...data);
+        }
+    }
+    on(event, handler) {
+        const key = event;
+        const id = this.id + 1;
+        if (!this.handlers[key]) {
+            this.handlers[key] = [];
+        }
+        this.handlers[key].push({ id, handler });
+        return this.off(event, id);
+    }
+    off(event, id) {
+        const key = event;
+        if (!this.handlers[key]) {
+            return;
+        }
+        const index = this.handlers[key].findIndex(handler => handler.id === id);
+        if (index > 0) {
+            this.handlers[key].splice(index, 1);
+        }
+    }
+    isEventHandled(event) {
+        const eventHandlers = this.handlers[event];
+        return !!eventHandlers && Object.values(eventHandlers).length > 0;
+    }
+}
+
+class WebRtcDataChannel {
+    channel;
+    events = new EventEmitter();
+    oldMessages = [];
+    constructor(channel) {
+        this.channel = channel;
+        this.channel.onerror = event => this.events.emit('error', [event]);
+        this.channel.onmessage = event => this.events.emit('message', [event]);
+        this.channel.onclose = event => this.events.emit('close', [event]);
+        this.channel.onopen = event => {
+            this.events.emit('open', [event]);
+            for (const message of this.oldMessages) {
+                this.sendMessage(message);
+            }
+            this.oldMessages = [];
+        };
+    }
+    get raw() {
+        return this.channel;
+    }
+    get label() {
+        return this.channel.label;
+    }
+    sendMessage(message) {
+        if (this.channel.readyState === 'open') {
+            this.channel.send(message);
+        }
+        else {
+            this.oldMessages.push(message);
+        }
+    }
+    /**
+     * This method does **not** filter messages. Use this method only intead of {@link on}
+     * if you are sure all messages sent over this channel will contain text.
+     */
+    onTextMessage(callback) {
+        return this.events.on('message', async (event) => {
+            const buffer = await event.data.arrayBuffer();
+            const message = new TextDecoder('utf-8').decode(buffer);
+            callback(message);
+        });
+    }
+    on = this.events.on.bind(this.events);
+}
+
+class WebRtcConnection {
+    iceServers;
+    #peerConnection;
+    connected = false;
+    events = new EventEmitter();
+    onIceCandidate;
+    onConnectionEstablished;
+    constructor(props) {
+        this.iceServers = props.iceServers;
+        this.onIceCandidate = props.onCandidate;
+        this.onConnectionEstablished = props.onConnectionEstablished;
+        this.#peerConnection = this.createPeerConnection();
+    }
+    createPeerConnection() {
+        const config = {
+            iceServers: this.iceServers ?? [],
+        };
+        const connection = new RTCPeerConnection(config);
+        connection.addEventListener('connectionstatechange', () => {
+            if (connection.connectionState === 'disconnected' ||
+                connection.connectionState === 'failed' ||
+                connection.connectionState === 'closed') {
+                this.events.emit('connection_closed', []);
+                this.connected = false;
+            }
+        });
+        connection.addEventListener('iceconnectionstatechange', () => {
+            if (connection.connectionState === 'connected') {
+                this.onConnectionEstablished();
+                this.connected = true;
+            }
+            else if (this.connected) {
+                this.events.emit('connection_closed', []);
+                this.connected = false;
+            }
+        });
+        connection.onicecandidate = event => {
+            if (event.candidate) {
+                this.onIceCandidate(event.candidate);
+            }
+        };
+        connection.ondatachannel = event => {
+            const channel = new WebRtcDataChannel(event.channel);
+            if (channel.label === 'ping-pong') {
+                channel.on('message', () => channel.sendMessage('pong'));
+            }
+            this.events.emit('data_channel', [channel]);
+        };
+        return connection;
+    }
+    get peerConnection() {
+        return this.#peerConnection;
+    }
+    createDataChannel(label, options) {
+        const channel = this.#peerConnection.createDataChannel(label, options);
+        return new WebRtcDataChannel(channel);
+    }
+    setRemoteDescription(type, sdp) {
+        return this.#peerConnection.setRemoteDescription({ type, sdp });
+    }
+    async createDescription(type) {
+        const description = await this.#peerConnection[type === 'offer' ? 'createOffer' : 'createAnswer']();
+        await this.#peerConnection.setLocalDescription(description);
+        return description;
+    }
+    addIceCandidate(candidate) {
+        return this.#peerConnection.addIceCandidate(new RTCIceCandidate(candidate));
+    }
+    close() {
+        return this.#peerConnection.close();
+    }
+    on = this.events.on.bind(this.events);
+}
+
+const DEFAULT_SIGNALING_SERVER_URL = 'wss://signal.cloud.luxonis.com/session/';
+class WebRtcClient {
+    config;
+    socket;
+    connection = null;
+    signalingConnectionRetries;
+    events = new EventEmitter();
+    iceCandidates = [];
+    constructor(config) {
+        this.config = config;
+        this.signalingConnectionRetries = (config.signalingConnectionRetries ?? 3) || 0;
+        this.connectSignalingServer();
+    }
+    get signalingServerConnected() {
+        return this.socket.readyState === WebSocket.OPEN;
+    }
+    disconnect(reason) {
+        this.connection?.close();
+        this.sendMessage({
+            Disconnect: {
+                type: 'normal',
+                reason,
+            },
+        });
+    }
+    connect() {
+        this.sendMessage({
+            ConnectSession: {
+                client_id: this.config.clientId,
+                application_identifier: this.config.applicationIdentifier,
+                auth_payload: this.config.authPayload,
+            },
+        });
+    }
+    connectSignalingServer() {
+        this.socket = new WebSocket(this.config.signalingServerUrl ?? DEFAULT_SIGNALING_SERVER_URL);
+        this.socket.onopen = () => {
+            this.connect();
+        };
+        // this.socket.onclose = () => console.debug('[WebRTC] Disconnected from signaling server');
+        this.socket.onerror = error => {
+            this.events.emit('error', ['signaling_connection_error', error]);
+            if (!this.events.isEventHandled('error')) {
+                console.error('[WebRTC] Signaling connection error:', error);
+            }
+            setTimeout(() => {
+                if (this.signalingConnectionRetries) {
+                    this.signalingConnectionRetries -= 1;
+                    if (this.socket.readyState === WebSocket.CLOSED || this.socket.readyState === WebSocket.CLOSING) {
+                        // console.debug('[WebRTC] Reconnecting to signaling server');
+                        this.connectSignalingServer();
+                    }
+                }
+            }, 3_000);
+        };
+        this.socket.onmessage = event => {
+            const message = JSON.parse(event.data);
+            this.handleSignalingMessage(message);
+        };
+    }
+    disconnectSignalingServer(reason) {
+        if (this.signalingServerConnected) {
+            this.sendMessage({
+                Disconnect: {
+                    type: 'normal',
+                    reason,
+                },
+            });
+            this.socket.close();
+        }
+    }
+    handleSignalingMessage(message) {
+        if ('AcknowledgeSession' in message) {
+            if (message.AcknowledgeSession.acknowledge) {
+                this.createConnection();
+            }
+            else {
+                if (!this.events.isEventHandled('error')) {
+                    console.error('[WebRTC] Connection refused:', message.AcknowledgeSession.reason);
+                }
+                this.events.emit('error', ['signaling_rejected', message.AcknowledgeSession.reason]);
+                this.dispose('Connection refused');
+            }
+        }
+        else if ('Candidate' in message) {
+            void this.handleCandidateMessage(message);
+        }
+        else if ('Disconnect' in message) {
+            this.dispose('Targed disconnected');
+        }
+    }
+    async handleCandidateMessage({ Candidate: { type: kind, candidate } }) {
+        if (!this.connection) {
+            // console.error('[WebRTC] Candidate message dropped: conenction not established');
+            return;
+        }
+        // console.debug('[WebRTC] Processing candidate message', kind);
+        switch (kind) {
+            case 'answer':
+            case 'offer': {
+                const data = `${candidate}`;
+                if (data === 'null' || data === '') {
+                    console.error('[WebRTC] Offer refused: remote description cannot be null');
+                    this.reconnect('Error: received invalid candidate');
+                    return;
+                }
+                // console.debug('[WebRTC] Offer accepted. Setting remote description..');
+                await this.connection.setRemoteDescription(kind, candidate);
+                // console.debug('[WebRTC] Set remote description');
+                for (const candidate of this.iceCandidates) {
+                    // console.debug('[WebRTC] Adding stored ICE candidate');
+                    this.connection.addIceCandidate(JSON.parse(candidate));
+                }
+                this.iceCandidates = [];
+                if (kind === 'offer') {
+                    const answer = await this.connection.createDescription('answer');
+                    // console.debug('[WebRTC] Answer created (set local description)');
+                    this.sendMessage({
+                        Candidate: {
+                            type: 'answer',
+                            candidate: answer.sdp ?? '',
+                        },
+                    });
+                }
+                return;
+            }
+            case 'candidate': {
+                if (this.connection.peerConnection.remoteDescription === null) {
+                    // console.debug('[WebRTC] Storing ICE candidate (remote description is not set yet)');
+                    this.iceCandidates.push(candidate);
+                }
+                else {
+                    // console.debug('[WebRTC] Adding ICE candidate');
+                    return this.connection.addIceCandidate(JSON.parse(candidate));
+                }
+            }
+        }
+    }
+    reconnect(reason) {
+        // console.debug(`[WebRTC] Reconnecting: ${reason}`);
+        this.disconnect(reason);
+        this.connect();
+    }
+    sendMessage(message) {
+        // console.debug('[WebRTC] Sending message', message);
+        if (this.socket.readyState === WebSocket.OPEN) {
+            this.socket.send(JSON.stringify(message));
+        }
+    }
+    createConnection() {
+        this.connection = new WebRtcConnection({
+            iceServers: this.config.iceServers,
+            onCandidate: candidate => {
+                this.sendMessage({
+                    Candidate: {
+                        type: 'candidate',
+                        candidate: JSON.stringify(candidate),
+                    },
+                });
+            },
+            onConnectionEstablished: () => this.disconnectSignalingServer('P2P connection established'),
+        });
+        this.events.emit('connection_established', [this.connection]);
+    }
+    dispose(reason) {
+        this.disconnect(reason);
+        this.disconnectSignalingServer(reason);
+    }
+    on = this.events.on.bind(this.events);
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+const MESSAGE_CHANNEL_NAME = "message";
+const SYSTEM_CHANNEL_NAME = "system";
+class WebRtcWorker extends FoxgloveCommunicator {
+  #webrtc;
+  #messageChannel = null;
+  #systemChannel = null;
+  #isReady = false;
+  #subscriptionId = 0;
+  #createWebRtc(config) {
+    this.#webrtc = new WebRtcClient(config);
+  }
+  #handleMessages() {
+    this.#webrtc.on("connection_established", connection => {
+      connection.on("data_channel", channel => {
+        // this.#onOpen(); // TODO:
+
+        if (channel.label === MESSAGE_CHANNEL_NAME) {
+          this.#messageChannel = channel;
+          channel.on("message", async ({
+            data: {
+              subscriptionId,
+              data
+            }
+          }) => {
+            this.handleGenericMessage(subscriptionId, data);
+          });
+        } else if (channel.label === SYSTEM_CHANNEL_NAME) {
+          this.#systemChannel = channel;
+          channel.on("message", async event => {
+            // TODO: Handle service call responses
+            const message = JSON.parse(event.data);
+            if (message.op === "advertise") {
+              this.handleChannelsAdvertisement(message.channels);
+            } else if (message.op === 'unadvertise') {
+              this.handleChannelsUnadvertisement(message.channelIds);
+            } else if (message.op === 'advertiseServices') {
+              this.handleServicesAdvertisement(message.services);
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            } else if (message.op === 'unadvertiseServices') {
+              this.handleServicesUnadvertisement(message.serviceIds);
+            }
+          });
+        }
+      });
+      connection.on("connection_closed", () => {
+        // this.#onClose(); // TODO:
+      });
+    });
+  }
+  isReady() {
+    return this.#isReady;
+  }
+  sendServiceCallRequest(request) {
+    // TODO: Should be binary
+    // https://github.com/foxglove/ws-protocol/blob/main/docs/spec.md#service-call-request
+    this.#messageChannel?.sendMessage(JSON.stringify(request));
+  }
+  subscribe(channel) {
+    this.#subscriptionId += 1;
+    this.#systemChannel?.sendMessage(JSON.stringify({
+      op: 'subscribe',
+      subscriptions: [{
+        id: this.#subscriptionId,
+        channelId: channel
+      }]
+    }));
+    return this.#subscriptionId;
+  }
+  constructor(config, send, sendWithTransfer) {
+    super();
+    this.send = send;
+    this.sendWithTransfer = sendWithTransfer;
+    this.#createWebRtc(config);
+    this.#handleMessages();
+  }
+
+  // TODO: binary support
+  rawSend(channel, data) {
+    if (this.isReady()) {
+      const target = channel === 'message' ? this.#messageChannel : this.#systemChannel;
+      target?.sendMessage(data);
+    }
+  }
+  close() {
+    this.#webrtc.dispose("Connection closed");
+  }
+  callService({
+    name,
+    serviceCallId,
+    body = {}
+  }) {
+    super.callService({
+      name,
+      serviceCallId,
+      body
+    });
+  }
+}
+function createWebRtcWorkerMessageListener(send, sendWithTransfer) {
+  let webrtcWorker = null;
+  return async event => {
+    const {
+      type,
+      data
+    } = event.data;
+    switch (type) {
+      case "open":
+        webrtcWorker = new WebRtcWorker(data.config, send, sendWithTransfer);
+        break;
+      case "close":
+        webrtcWorker?.close();
+        break;
+      case "send":
+        webrtcWorker?.rawSend(data.channel, data.message);
+        break;
+      case "call_service":
+        webrtcWorker?.callService(data);
+        break;
+    }
+  };
+}
+
+export { createWebRtcWorkerMessageListener as c };