@luxonis/depthai-viewer-common 3.7.4 → 3.7.6

package/dist/visualizer/connection/foxglove-protocol.js

@@ -0,0 +1,63 @@
+// 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/
+import { BinaryOpcode, ClientBinaryOpcode } from "./foxglove-ws-types.js";
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+export function makeServiceCallRequest(request) {
+    const encoding = textEncoder.encode(request.encoding);
+    const payload = new Uint8Array(1 + 4 + 4 + 4 + encoding.length + request.data.byteLength);
+    const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    let offset = 0;
+    view.setUint8(offset, ClientBinaryOpcode.SERVICE_CALL_REQUEST);
+    offset += 1;
+    view.setUint32(offset, request.serviceId, true);
+    offset += 4;
+    view.setUint32(offset, request.callId, true);
+    offset += 4;
+    view.setUint32(offset, request.encoding.length, true);
+    offset += 4;
+    payload.set(encoding, offset);
+    offset += encoding.length;
+    const data = new Uint8Array(request.data.buffer, request.data.byteOffset, request.data.byteLength);
+    payload.set(data, offset);
+    return new DataView(payload.buffer);
+}
+export function parseMessage(view) {
+    let offset = 0;
+    const op = view.getUint8(offset);
+    offset += 1;
+    const subscriptionId = view.getUint32(offset, true);
+    offset += 4;
+    const timestamp = view.getBigUint64(offset, true);
+    offset += 8;
+    const data = new DataView(view.buffer, offset);
+    return { op, subscriptionId, timestamp, data };
+}
+export function parseServiceCallResponse(view) {
+    let offset = 0;
+    const op = view.getUint8(offset);
+    offset += 1;
+    const serviceId = view.getUint32(offset, true);
+    offset += 4;
+    const callId = view.getUint32(offset, true);
+    offset += 4;
+    const encodingLength = view.getUint32(offset, true);
+    offset += 4;
+    const encodingBytes = new DataView(view.buffer, offset, encodingLength);
+    const encoding = textDecoder.decode(encodingBytes);
+    offset += encodingLength;
+    const data = new DataView(view.buffer, offset, view.buffer.byteLength - offset);
+    return { op, serviceId, callId, encoding, data };
+}
+export function parseFoxgloveMessage(view) {
+    const op = view.getUint8(0);
+    if (op === BinaryOpcode.MESSAGE_DATA) {
+        return parseMessage(view);
+    }
+    else if (op === BinaryOpcode.SERVICE_CALL_RESPONSE) {
+        return parseServiceCallResponse(view);
+    }
+    return null;
+}
+//# sourceMappingURL=foxglove-protocol.js.map

package/dist/visualizer/connection/foxglove-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foxglove-protocol.js","sourceRoot":"","sources":["../../../src/visualizer/connection/foxglove-protocol.ts"],"names":[],"mappings":"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"}

package/dist/visualizer/connection/foxglove-ws-types.d.ts

@@ -0,0 +1,80 @@
+export declare enum BinaryOpcode {
+    MESSAGE_DATA = 1,
+    TIME = 2,
+    SERVICE_CALL_RESPONSE = 3,
+    FETCH_ASSET_RESPONSE = 4
+}
+export declare enum ClientBinaryOpcode {
+    MESSAGE_DATA = 1,
+    SERVICE_CALL_REQUEST = 2
+}
+export type ChannelId = number;
+export type SubscriptionId = number;
+export type ServiceId = number;
+export type Channel = {
+    id: ChannelId;
+    topic: string;
+    encoding: string;
+    schemaName: string;
+    schema: string;
+    schemaEncoding?: string;
+};
+type ServiceRequestDefinition = {
+    encoding: string;
+    schemaName: string;
+    schemaEncoding: string;
+    schema: string;
+};
+export type Service = {
+    id: number;
+    name: string;
+    type: string;
+    request?: ServiceRequestDefinition;
+    response?: ServiceRequestDefinition;
+    requestSchema?: string;
+    responseSchema?: string;
+};
+export type Subscribe = {
+    op: "subscribe";
+    subscriptions: Array<{
+        id: SubscriptionId;
+        channelId: ChannelId;
+    }>;
+};
+export type Unsubscribe = {
+    op: "unsubscribe";
+    subscriptionIds: SubscriptionId[];
+};
+export type ServiceCallPayload = {
+    serviceId: ServiceId;
+    callId: number;
+    encoding: string;
+    data: DataView;
+};
+export type Advertise = {
+    op: "advertise";
+    channels: Channel[];
+};
+export type Unadvertise = {
+    op: "unadvertise";
+    channelIds: ChannelId[];
+};
+export type AdvertiseServices = {
+    op: "advertiseServices";
+    services: Service[];
+};
+export type UnadvertiseServices = {
+    op: "unadvertiseServices";
+    serviceIds: ServiceId[];
+};
+export type MessageData = {
+    op: BinaryOpcode.MESSAGE_DATA;
+    subscriptionId: SubscriptionId;
+    timestamp: bigint;
+    data: DataView;
+};
+export type ServiceCallResponse = ServiceCallPayload & {
+    op: BinaryOpcode.SERVICE_CALL_RESPONSE;
+};
+export {};
+//# sourceMappingURL=foxglove-ws-types.d.ts.map

package/dist/visualizer/connection/foxglove-ws-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foxglove-ws-types.d.ts","sourceRoot":"","sources":["../../../src/visualizer/connection/foxglove-ws-types.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY;IACtB,YAAY,IAAI;IAChB,IAAI,IAAI;IACR,qBAAqB,IAAI;IACzB,oBAAoB,IAAI;CACzB;AAED,oBAAY,kBAAkB;IAC5B,YAAY,IAAI;IAChB,oBAAoB,IAAI;CACzB;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAC/B,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AACpC,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B,MAAM,MAAM,OAAO,GAAG;IACpB,EAAE,EAAE,SAAS,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,wBAAwB,CAAC;IACnC,QAAQ,CAAC,EAAE,wBAAwB,CAAC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,WAAW,CAAC;IAChB,aAAa,EAAE,KAAK,CAAC;QACnB,EAAE,EAAE,cAAc,CAAC;QACnB,SAAS,EAAE,SAAS,CAAC;KACtB,CAAC,CAAC;CACJ,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,aAAa,CAAC;IAClB,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,WAAW,CAAC;IAChB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,aAAa,CAAC;IAClB,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,mBAAmB,CAAC;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,qBAAqB,CAAC;IAC1B,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,YAAY,CAAC,YAAY,CAAC;IAC9B,cAAc,EAAE,cAAc,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,GAAG;IACrD,EAAE,EAAE,YAAY,CAAC,qBAAqB,CAAC;CACxC,CAAC"}

package/dist/visualizer/connection/foxglove-ws-types.js

@@ -0,0 +1,13 @@
+export var BinaryOpcode;
+(function (BinaryOpcode) {
+    BinaryOpcode[BinaryOpcode["MESSAGE_DATA"] = 1] = "MESSAGE_DATA";
+    BinaryOpcode[BinaryOpcode["TIME"] = 2] = "TIME";
+    BinaryOpcode[BinaryOpcode["SERVICE_CALL_RESPONSE"] = 3] = "SERVICE_CALL_RESPONSE";
+    BinaryOpcode[BinaryOpcode["FETCH_ASSET_RESPONSE"] = 4] = "FETCH_ASSET_RESPONSE";
+})(BinaryOpcode || (BinaryOpcode = {}));
+export var ClientBinaryOpcode;
+(function (ClientBinaryOpcode) {
+    ClientBinaryOpcode[ClientBinaryOpcode["MESSAGE_DATA"] = 1] = "MESSAGE_DATA";
+    ClientBinaryOpcode[ClientBinaryOpcode["SERVICE_CALL_REQUEST"] = 2] = "SERVICE_CALL_REQUEST";
+})(ClientBinaryOpcode || (ClientBinaryOpcode = {}));
+//# sourceMappingURL=foxglove-ws-types.js.map

package/dist/visualizer/connection/foxglove-ws-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foxglove-ws-types.js","sourceRoot":"","sources":["../../../src/visualizer/connection/foxglove-ws-types.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,YAKX;AALD,WAAY,YAAY;IACtB,+DAAgB,CAAA;IAChB,+CAAQ,CAAA;IACR,iFAAyB,CAAA;IACzB,+EAAwB,CAAA;AAC1B,CAAC,EALW,YAAY,KAAZ,YAAY,QAKvB;AAED,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,2EAAgB,CAAA;IAChB,2FAAwB,CAAA;AAC1B,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B"}

package/dist/visualizer/connection/webrtc/bridge.d.ts

@@ -0,0 +1,11 @@
+import { ArtificialWorker } from "../../utils/artificial-worker.js";
+import type { WorkerInputMessage, WorkerOutputMessage } from "../communicator.js";
+import { WebRtcCommsProxy } from "./comms-proxy.js";
+export declare class WebRtcBridge extends ArtificialWorker<WorkerInputMessage, WorkerOutputMessage> {
+    #private;
+    private readonly automaticTokenRefresh?;
+    commsProxy: WebRtcCommsProxy | null;
+    constructor(automaticTokenRefresh?: ((token: string) => void) | undefined);
+    terminate(): void;
+}
+//# sourceMappingURL=bridge.d.ts.map

package/dist/visualizer/connection/webrtc/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../../src/visualizer/connection/webrtc/bridge.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAEpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAGlF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAoGpD,qBAAa,YAAa,SAAQ,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC;;IAgBtE,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAC;IAL1D,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAQ;gBAKP,qBAAqB,CAAC,GAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,aAAA;IAQnE,SAAS,IAAI,IAAI;CA+clC"}

package/dist/visualizer/connection/webrtc/bridge.js

@@ -0,0 +1,453 @@
+// 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/
+import { WebRtcClient, } from "@luxonis/remote-connection";
+import { ArtificialWorker } from "../../utils/artificial-worker.js";
+import { Logger } from "../../utils/logger.js";
+import { parseFoxgloveMessage } from "../foxglove-protocol.js";
+import { BinaryOpcode } from "../foxglove-ws-types.js";
+import { WebRtcCommsProxy } from "./comms-proxy.js";
+const logger = Logger.getLogger();
+const MESSAGE_CHANNEL_NAME = "message";
+const SYSTEM_CHANNEL_NAME = "system";
+const COMMS_CHANNEL_NAME = "comms";
+const REASSEMBLY_SUMMARY_INTERVAL_MS = 2_000;
+function createReassemblyDiagnostics() {
+    return {
+        completed: 0,
+        completedBytes: 0,
+        gaps: 0,
+        missingSequences: 0n,
+        expired: 0,
+        evicted: 0,
+        malformed: 0,
+        late: 0,
+        duplicates: 0,
+        lastSummaryAt: performance.now(),
+    };
+}
+function summarizeReassemblyDiagnostics(diagnostics) {
+    const now = performance.now();
+    if (now - diagnostics.lastSummaryAt < REASSEMBLY_SUMMARY_INTERVAL_MS) {
+        return;
+    }
+    logger.debug("[webrtc-reassembly] message", {
+        completed: diagnostics.completed,
+        completedBytes: diagnostics.completedBytes,
+        gaps: diagnostics.gaps,
+        missingSequences: diagnostics.missingSequences.toString(),
+        expired: diagnostics.expired,
+        evicted: diagnostics.evicted,
+        malformed: diagnostics.malformed,
+        late: diagnostics.late,
+        duplicates: diagnostics.duplicates,
+    });
+    Object.assign(diagnostics, createReassemblyDiagnostics());
+}
+function withLossyMediaFraming(config) {
+    const remoteDataChannelOptions = config.remoteDataChannelOptions;
+    return {
+        ...config,
+        remoteDataChannelOptions: (label, channel) => {
+            const configuredOptions = remoteDataChannelOptions?.(label, channel) ?? {};
+            if (label === MESSAGE_CHANNEL_NAME) {
+                return {
+                    ...configuredOptions,
+                    // v1 applies the SDK's local 64 KiB admission default unless an
+                    // application deliberately supplies an outbound override here.
+                    framing: "v1",
+                };
+            }
+            // Control and auxiliary channels retain the native, unframed protocol.
+            return { ...configuredOptions, framing: "none" };
+        },
+    };
+}
+function isInternalChannel(channelName) {
+    return (channelName === MESSAGE_CHANNEL_NAME ||
+        channelName === SYSTEM_CHANNEL_NAME ||
+        channelName === COMMS_CHANNEL_NAME);
+}
+export class WebRtcBridge extends ArtificialWorker {
+    automaticTokenRefresh;
+    #worker;
+    #webrtc = null;
+    #webrtcGeneration = 0;
+    #connectionGeneration = 0;
+    #recoverableCloseGeneration = null;
+    #terminalCloseGeneration = null;
+    #recoverableSession = false;
+    #messageChannel = null;
+    #systemChannel = null;
+    commsProxy = null;
+    #activeConnectionGeneration = null;
+    #workerMessageListener = null;
+    #mainMessageListener = null;
+    constructor(automaticTokenRefresh) {
+        super();
+        this.automaticTokenRefresh = automaticTokenRefresh;
+        this.#worker = new Worker(new URL("./worker.js", import.meta.url), {
+            type: "module",
+        });
+        this.#setupArtificialWorker();
+    }
+    terminate() {
+        this.#cleanupWorkerListeners();
+        this.#cleanupMainListeners();
+        this.#retireConnectionGeneration();
+        this.#worker.terminate();
+        this.#webrtc?.dispose("Connection terminated");
+        this.#webrtc = null;
+    }
+    #cleanupWorkerListeners() {
+        if (this.#workerMessageListener) {
+            this.#worker.removeEventListener("message", this.#workerMessageListener);
+            this.#workerMessageListener = null;
+        }
+    }
+    #cleanupMainListeners() {
+        if (this.#mainMessageListener) {
+            this.removeEventListenerFromMain("message", this.#mainMessageListener);
+            this.#mainMessageListener = null;
+        }
+    }
+    #setupArtificialWorker() {
+        this.#mainMessageListener = (event) => {
+            switch (event.data.type) {
+                case "open": {
+                    if ("config" in event.data.data) {
+                        this.#createWebRtc(withLossyMediaFraming(event.data.data.config));
+                    }
+                    break;
+                }
+                case "close": {
+                    this.#webrtc?.dispose("Client requested connection close");
+                    this.terminate();
+                    break;
+                }
+                case "call_service": {
+                    this.#worker.postMessage({
+                        kind: "serviceCall",
+                        data: {
+                            message: event.data.data,
+                        },
+                    });
+                    break;
+                }
+                case "unsubscribe":
+                case "subscribe": {
+                    this.#worker.postMessage({
+                        kind: event.data.type,
+                        data: { message: { topics: event.data.data } },
+                    });
+                    break;
+                }
+            }
+        };
+        this.addEventListenerFromMain("message", this.#mainMessageListener);
+    }
+    #createWebRtc(config) {
+        if (this.#webrtc) {
+            logger.warn("[webrtc-session] ignoring duplicate open request", {
+                generation: this.#webrtcGeneration,
+            });
+            return;
+        }
+        const generation = ++this.#webrtcGeneration;
+        this.#recoverableCloseGeneration = null;
+        this.#terminalCloseGeneration = null;
+        this.#recoverableSession = config.sessionRecovery !== undefined;
+        logger.warn("[webrtc-session] creating WebRTC client", {
+            generation,
+            recoveryEnabled: this.#recoverableSession,
+        });
+        const client = new WebRtcClient(config);
+        this.#webrtc = client;
+        this.#handleWebRtc(client, generation);
+        if (!this.#workerMessageListener) {
+            this.#handleMessages();
+        }
+    }
+    #handleWebRtc(client, generation) {
+        client.on("error", (error) => {
+            logger.error("WebRtc Client Failed", error);
+            if (error === "signaling_rejected" || error === "session_recovery_exhausted") {
+                this.#worker.postMessage({ kind: "disconnect", error });
+                this.#handleConnectionClosed(null, generation, true);
+            }
+        });
+        client.on("session_recovery_started", (attempt, reason) => {
+            logger.info("[webrtc-session] recovery started", {
+                generation,
+                attempt,
+                reason,
+            });
+            this.#retireConnectionGeneration(true);
+        });
+        client.on("session_recovery_succeeded", (attempt, previousClientId, clientId) => {
+            logger.info("[webrtc-session] recovery resolved", {
+                generation,
+                attempt,
+                previousClientId,
+                clientId,
+            });
+        });
+        client.on("session_recovery_failed", (attempt, error) => {
+            logger.warn("[webrtc-session] recovery failed", {
+                generation,
+                attempt,
+                error,
+            });
+        });
+        client.on("connection_closed", () => {
+            logger.warn("[webrtc-session] client reported peer connection closed", {
+                generation,
+            });
+        });
+        client.on("connection_established", (connection) => {
+            if (generation !== this.#webrtcGeneration) {
+                connection.close();
+                return;
+            }
+            this.#retireConnectionGeneration();
+            const connectionGeneration = ++this.#connectionGeneration;
+            this.#recoverableCloseGeneration = null;
+            const current = {
+                id: connectionGeneration,
+                connection,
+                unsubscribers: [],
+                peerListeners: [],
+                openNotified: false,
+                retired: false,
+            };
+            this.#activeConnectionGeneration = current;
+            const peerConnection = connection.peerConnection;
+            const observe = (event) => {
+                const listener = (() => {
+                    if (!this.#isCurrentConnectionGeneration(current))
+                        return;
+                    logger.warn("[webrtc-session] peer connection state changed", {
+                        generation,
+                        connectionGeneration,
+                        connectionState: peerConnection.connectionState,
+                        iceConnectionState: peerConnection.iceConnectionState,
+                    });
+                });
+                peerConnection.addEventListener(event, listener);
+                current.peerListeners.push([event, listener]);
+            };
+            observe("connectionstatechange");
+            observe("iceconnectionstatechange");
+            current.unsubscribers.push(connection.on("data_channel", (channel) => {
+                if (!this.#isCurrentConnectionGeneration(current))
+                    return;
+                this.#attachChannel(channel, current, generation);
+            }));
+            current.unsubscribers.push(connection.on("connection_closed", () => {
+                if (!this.#isCurrentConnectionGeneration(current))
+                    return;
+                this.#handleConnectionClosed(null, generation, false, current.id);
+            }));
+        });
+    }
+    #handleConnectionClosed(channel, generation, terminal = false, connectionGeneration) {
+        if (generation !== this.#webrtcGeneration ||
+            (connectionGeneration !== undefined &&
+                this.#activeConnectionGeneration?.id !== connectionGeneration)) {
+            return;
+        }
+        if (this.#recoverableSession && !terminal) {
+            if (this.#recoverableCloseGeneration === generation)
+                return;
+            this.#recoverableCloseGeneration = generation;
+            this.#retireConnectionGeneration();
+            logger.warn("[webrtc-session] retaining Viewer while session recovers", {
+                generation,
+                channel,
+            });
+            this.#worker.postMessage({
+                kind: "connection",
+                data: { channel: null, ready: false },
+            });
+            return;
+        }
+        if (this.#terminalCloseGeneration === generation)
+            return;
+        this.#terminalCloseGeneration = generation;
+        logger.warn("[webrtc-session] bridge closing connection", {
+            generation,
+            channel,
+        });
+        this.#worker.postMessage({
+            kind: "connection",
+            data: { channel, ready: false },
+        });
+        this.postMessageToMain({ type: "close" });
+        this.#retireConnectionGeneration();
+        this.#webrtc = null;
+    }
+    #isCurrentConnectionGeneration(generation) {
+        return this.#activeConnectionGeneration === generation && !generation.retired;
+    }
+    #retireConnectionGeneration(notifyNotReady = false) {
+        const generation = this.#activeConnectionGeneration;
+        if (!generation || generation.retired)
+            return;
+        generation.retired = true;
+        for (const unsubscribe of generation.unsubscribers.splice(0))
+            unsubscribe();
+        for (const [event, listener] of generation.peerListeners.splice(0))
+            generation.connection.peerConnection.removeEventListener(event, listener);
+        if (this.commsProxy) {
+            this.commsProxy.handleClose();
+            this.commsProxy = null;
+        }
+        this.#messageChannel = null;
+        this.#systemChannel = null;
+        this.#activeConnectionGeneration = null;
+        if (notifyNotReady)
+            this.#worker.postMessage({ kind: "connection", data: { channel: null, ready: false } });
+    }
+    #attachChannel(channel, current, generation) {
+        const guard = (callback) => (...args) => {
+            if (this.#isCurrentConnectionGeneration(current))
+                callback(...args);
+        };
+        if (isInternalChannel(channel.label)) {
+            current.unsubscribers.push(channel.on("close", guard(() => this.#handleConnectionClosed(channel.label, generation, false, current.id))));
+        }
+        switch (channel.label) {
+            case MESSAGE_CHANNEL_NAME:
+                this.#handleWebRtcMessageChannel(channel, current, guard);
+                break;
+            case SYSTEM_CHANNEL_NAME:
+                this.#handleWebRtcSystemChannel(channel, current, guard);
+                break;
+            case COMMS_CHANNEL_NAME:
+                this.#handleWebRtcCommsChannel(channel, current);
+                break;
+        }
+        this.#handleWebRtcDataChannelOpenNotification(channel);
+        if (!current.openNotified &&
+            this.#systemChannel?.raw.readyState === "open" &&
+            this.#messageChannel?.raw.readyState === "open") {
+            current.openNotified = true;
+            this.postMessageToMain({ type: "open" });
+        }
+    }
+    #handleWebRtcMessageChannel(channel, current, guard) {
+        logger.debug("[DEBUG] Message channel opened!");
+        this.#messageChannel = channel;
+        const reassemblyDiagnostics = createReassemblyDiagnostics();
+        current.unsubscribers.push(channel.on("reassembly:complete", guard(({ bytes }) => {
+            reassemblyDiagnostics.completed += 1;
+            reassemblyDiagnostics.completedBytes += bytes;
+            summarizeReassemblyDiagnostics(reassemblyDiagnostics);
+        })));
+        current.unsubscribers.push(channel.on("reassembly:gap", guard(({ missingCount }) => {
+            reassemblyDiagnostics.gaps += 1;
+            reassemblyDiagnostics.missingSequences += BigInt(missingCount);
+            summarizeReassemblyDiagnostics(reassemblyDiagnostics);
+        })));
+        current.unsubscribers.push(channel.on("reassembly:expired", guard(() => {
+            reassemblyDiagnostics.expired += 1;
+            summarizeReassemblyDiagnostics(reassemblyDiagnostics);
+        })));
+        current.unsubscribers.push(channel.on("reassembly:evicted", guard(() => {
+            reassemblyDiagnostics.evicted += 1;
+            summarizeReassemblyDiagnostics(reassemblyDiagnostics);
+        })));
+        current.unsubscribers.push(channel.on("reassembly:malformed", guard(() => {
+            reassemblyDiagnostics.malformed += 1;
+            summarizeReassemblyDiagnostics(reassemblyDiagnostics);
+        })));
+        current.unsubscribers.push(channel.on("reassembly:late", guard(() => {
+            reassemblyDiagnostics.late += 1;
+            summarizeReassemblyDiagnostics(reassemblyDiagnostics);
+        })));
+        current.unsubscribers.push(channel.on("reassembly:duplicate", guard(() => {
+            reassemblyDiagnostics.duplicates += 1;
+            summarizeReassemblyDiagnostics(reassemblyDiagnostics);
+        })));
+        current.unsubscribers.push(channel.on("message:binary", guard(async (view) => {
+            const message = parseFoxgloveMessage(view);
+            if (!message) {
+                return;
+            }
+            if (message.op === BinaryOpcode.MESSAGE_DATA) {
+                this.#worker.postMessage({
+                    kind: "genericMessage",
+                    data: { message },
+                }, [message.data.buffer]);
+            }
+            else {
+                this.#worker.postMessage({
+                    kind: "systemMessage",
+                    data: {
+                        message: {
+                            op: "serviceResponse",
+                            callId: message.callId,
+                            data: message.data,
+                        },
+                    },
+                }, [message.data.buffer]);
+            }
+        })));
+    }
+    #handleWebRtcSystemChannel(channel, current, guard) {
+        logger.debug("[DEBUG] System channel opened!");
+        this.#systemChannel = channel;
+        current.unsubscribers.push(channel.on("message:json", guard(async (data) => {
+            this.#worker.postMessage({
+                kind: "systemMessage",
+                data: { message: data },
+            });
+        })));
+    }
+    #handleWebRtcCommsChannel(channel, _current) {
+        logger.debug("[DEBUG] Comms channel opened!");
+        this.commsProxy = new WebRtcCommsProxy(channel, this.automaticTokenRefresh);
+    }
+    #handleWebRtcDataChannelOpenNotification(channel) {
+        if (!isInternalChannel(channel.label)) {
+            return;
+        }
+        this.#worker.postMessage({
+            kind: "connection",
+            data: {
+                channel: channel.label,
+                ready: true,
+            },
+        });
+    }
+    #handleMessages() {
+        this.#workerMessageListener = ((event) => {
+            switch (event.data.type) {
+                case "send": {
+                    const channel = event.data.data.channel === "message" ? this.#messageChannel : this.#systemChannel;
+                    if (!channel)
+                        break;
+                    if (event.data.data.channel === MESSAGE_CHANNEL_NAME) {
+                        const outcome = channel.trySendMessage(event.data.data.data);
+                        if (outcome.status === "dropped") {
+                            logger.debug("[webrtc-outbound] lossy message dropped", {
+                                reason: outcome.reason,
+                                bytes: outcome.bytes,
+                                chunks: outcome.chunks,
+                            });
+                        }
+                    }
+                    else {
+                        channel.sendMessage(event.data.data.data);
+                    }
+                    break;
+                }
+                default: {
+                    this.postMessageToMain(event.data);
+                }
+            }
+        });
+        this.#worker.addEventListener("message", this.#workerMessageListener);
+    }
+}
+//# sourceMappingURL=bridge.js.map