@phystack/hub-client 4.5.19-dev → 4.5.20-dev

package/src/twin-messaging.ts

@@ -0,0 +1,184 @@
+/**
+ * Twin Messaging Factory
+ *
+ * Creates emit/on/to methods for any twin type.
+ * Provides a consistent messaging API across all instance types.
+ *
+ * API Design:
+ * - emit(type, payload): Fire-and-forget broadcast to subscribers
+ * - to(targetId).emit(type, payload): Fire-and-forget to specific twin
+ * - to(targetId).emit(type, payload, callback): Request-response to specific twin
+ * - on(type, callback): Listen for messages, with optional respond callback
+ *
+ * Backwards Compatibility:
+ * - Message format: `${typePrefix}:${eventType}` is unchanged from pre-PR 144
+ * - Old callback signature (data) => {...} works - the respond parameter is optional
+ */
+
+import { TwinMessageResult, TwinMessageResultStatus } from './types/twin.types';
+
+export interface TwinMessagingContext {
+  /** Function to send events via the hub */
+  sendEvent: (targetTwinId: string, payload: any) => void;
+  /** Function to register message listeners */
+  onTwinMessage: (twinId: string, callback: (payload: any) => void) => void;
+  /** The twin ID for this instance */
+  twinId: string;
+  /** Source device ID for message metadata */
+  deviceId: string;
+  /** Type prefix for message routing (e.g., 'edgeInstance', 'peripheralInstance') */
+  typePrefix: string;
+}
+
+export interface TwinMessagingMethods {
+  /** Send a fire-and-forget event to subscribers */
+  emit: (type: string, payload: any) => void;
+  /** Listen for events, with optional respond callback for request-response */
+  on: (type: string, callback: (message: any, respond?: (result: TwinMessageResult) => void) => void) => void;
+  /** Target a specific twin for messaging */
+  to: (targetTwinId: string) => {
+    /** Send event or action to the targeted twin */
+    emit: {
+      (type: string, payload: any): void;
+      (type: string, payload: any, callback: (response: TwinMessageResult) => void): Promise<TwinMessageResult>;
+    };
+  };
+}
+
+const REQUEST_TIMEOUT = 10000;
+
+/**
+ * Creates messaging methods (emit, on, to) for a twin instance.
+ * This provides a consistent API across all instance types (Edge, Screen, Peripheral, etc.)
+ */
+export function createTwinMessaging(context: TwinMessagingContext): TwinMessagingMethods {
+  const { sendEvent, onTwinMessage, twinId, deviceId, typePrefix } = context;
+
+  // Registry for pending requests - enables request-response pattern
+  const pendingRequests = new Map<string, {
+    resolve: (value: TwinMessageResult) => void;
+    reject: (reason: TwinMessageResult) => void;
+    timeoutId: ReturnType<typeof setTimeout>;
+  }>();
+
+  const generateRequestId = () => `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+  // Build message payload with metadata
+  const buildMessage = (type: string, data: any) => ({
+    type: `${typePrefix}:${type}`,
+    sourceTwinId: twinId,
+    sourceDeviceId: deviceId,
+    data,
+  });
+
+  // Send fire-and-forget event
+  const sendMessage = (targetTwinId: string, type: string, payload: any): void => {
+    sendEvent(targetTwinId, buildMessage(type, payload));
+  };
+
+  // Send request and wait for response (used by to().emit() with callback)
+  const sendRequest = (
+    targetTwinId: string,
+    type: string,
+    payload: any,
+    callback: (response: TwinMessageResult) => void
+  ): Promise<TwinMessageResult> => {
+    const requestId = generateRequestId();
+
+    return new Promise<TwinMessageResult>((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        pendingRequests.delete(requestId);
+        const error: TwinMessageResult = {
+          status: TwinMessageResultStatus.Error,
+          message: `Request timed out after ${REQUEST_TIMEOUT}ms`,
+        };
+        reject(error);
+      }, REQUEST_TIMEOUT);
+
+      pendingRequests.set(requestId, { resolve, reject, timeoutId });
+
+      // Send with requestId embedded
+      sendEvent(targetTwinId, buildMessage(type, { ...payload, requestId }));
+    }).then(result => {
+      callback(result);
+      return result;
+    }).catch(error => {
+      callback(error);
+      throw error;
+    });
+  };
+
+  // Set up response listener - handles all incoming responses for this twin
+  onTwinMessage(twinId, (payload: any) => {
+    const messageType = payload.data?.type || payload.type;
+    if (messageType === `${typePrefix}:response`) {
+      const responseData = payload.data?.data || payload.data;
+      const requestId = responseData?.requestId;
+      const pending = pendingRequests.get(requestId);
+      if (pending) {
+        clearTimeout(pending.timeoutId);
+        pendingRequests.delete(requestId);
+        // Extract result without requestId
+        const { requestId: _, ...result } = responseData;
+        pending.resolve(result as TwinMessageResult);
+      }
+    }
+  });
+
+  // emit: Fire-and-forget broadcast to subscribers
+  const emit = (type: string, payload: any): void => {
+    sendMessage(twinId, type, payload);
+  };
+
+  // on: Listen for events, with respond callback for request-response
+  const on = (
+    type: string,
+    callback: (message: any, respond?: (result: TwinMessageResult) => void) => void
+  ) => {
+    onTwinMessage(twinId, (payload: any) => {
+      const messageType = payload.data?.type || payload.type;
+      if (messageType === `${typePrefix}:${type}`) {
+        const messageData = payload.data?.data || payload.data;
+        const requestId = messageData?.requestId;
+        const sourceTwinId = payload.sourceTwinId;
+
+        // Create respond callback if this is a request (has requestId and source)
+        const respond = (requestId && sourceTwinId)
+          ? (result: TwinMessageResult) => {
+              sendEvent(sourceTwinId, buildMessage('response', { ...result, requestId }));
+            }
+          : undefined;
+
+        // Pass message without requestId (strip it from the payload)
+        // Preserve null/undefined if original messageData was falsy
+        if (!messageData) {
+          callback(messageData, respond);
+        } else {
+          const { requestId: _, ...cleanData } = messageData;
+          callback(cleanData, respond);
+        }
+      }
+    });
+  };
+
+  // to: Target a specific twin for messaging
+  const to = (targetTwinId: string) => {
+    function emit(type: string, payload: any): void;
+    function emit(type: string, payload: any, callback: (response: TwinMessageResult) => void): Promise<TwinMessageResult>;
+    function emit(
+      type: string,
+      payload: any,
+      callback?: (response: TwinMessageResult) => void
+    ): void | Promise<TwinMessageResult> {
+      if (callback) {
+        return sendRequest(targetTwinId, type, payload, callback);
+      } else {
+        sendMessage(targetTwinId, type, payload);
+      }
+    }
+
+    return { emit };
+  };
+
+  return { emit, on, to };
+}

package/src/twin-registry.ts

@@ -0,0 +1,39 @@
+import { PhyHubClient } from ".";
+import { PeripheralTwinInstance } from "./peripheral-twin";
+import { IPeripheralTwinInstance } from "./types/twin.types";
+
+/**
+ * registry to create, store and retrieve instances of different types of twins e.g. Device, Screen, Peripheral
+ */
+
+export class TwinRegistry {
+  private peripheralInstances: Map<string, IPeripheralTwinInstance> = new Map();
+
+  constructor(private phyHubClient: PhyHubClient) {
+  }
+
+  // create an instance of PeripheralTwinInstance class
+  async getPeripheralInstance(twinId: string) : Promise<IPeripheralTwinInstance | null> {
+    try {
+
+      // check whether we've already created instance for this twinId
+      if (this.peripheralInstances.has(twinId)) {
+        return this.peripheralInstances.get(twinId)!;
+      }
+
+      // create an object of PeripheralTwinInstance class
+      const peripheralTwinInstance = new PeripheralTwinInstance(this.phyHubClient, twinId);
+
+      // class object is created, but perform sanity checks such as whether PhyHubClient is valid, twinId is valid etc.
+      // to make sure we are able to correct and return a valid instance
+      await peripheralTwinInstance.initialize();
+
+      // set the newly created instance in the map for future use
+      this.peripheralInstances.set(twinId, peripheralTwinInstance);
+
+      return peripheralTwinInstance;
+    } catch(error) {
+      throw error;
+    }
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './signal.types';
+export * from './twin.types';
+export * from './webrtc.types';

package/src/types/twin.types.ts

@@ -1,4 +1,5 @@
-import { PhygridDataChannel, PhygridMediaStream } from './webrtc.types';
+import { PhyHubClient } from '..';
+import { PhygridDataChannel, PhygridMediaStream } from '../services/webrtc/types';
 
 export enum TwinTypeEnum {
   Device = 'Device',
@@ -626,30 +627,50 @@ export interface PeripheralTwinResponse extends TwinResponseBase {
 }
 
 export interface PeripheralInstance extends PeripheralTwinResponse {
-  emit: (type: string, payload: any) => void;
-  on: (type: string, callback: (message: any) => void) => void;
+  /**
+   * Send a message to this peripheral.
+   * - Without callback: Fire-and-forget (returns void)
+   * - With callback: Request-response pattern (returns Promise)
+   */
+  emit: {
+    (type: string, payload: any): void;
+    (type: string, payload: any, callback: (response: TwinMessageResult) => void): Promise<TwinMessageResult>;
+  };
+  /** Listen for events/actions of a given type */
+  on: (type: string, callback: (message: any, respond?: (result: TwinMessageResult) => void) => void) => void;
+  /** Target a different twin for messaging */
   to: (targetTwinId: string) => {
-    emit: (type: string, payload: any) => void;
+    emit: {
+      (type: string, payload: any): void;
+      (type: string, payload: any, callback: (response: TwinMessageResult) => void): Promise<TwinMessageResult>;
+    };
   };
   updateReported: (properties: Record<string, any>) => Promise<TwinResponse>;
   updateDesired: (properties: Record<string, any>) => Promise<TwinResponse>;
   onUpdateReported: (callback: (reportedProperties: Record<string, any>) => void) => void;
   onUpdateDesired: (callback: (desiredProperties: Record<string, any>) => void) => void;
   remove: () => Promise<TwinResponse | void>;
-  getDataChannel: () => Promise<PhygridDataChannel>;
-  onDataChannel: (callback: (dc: PhygridDataChannel) => void) => void;
-  getMediaStream: () => Promise<{
+  getDataChannel: (channelName?: string) => Promise<PhygridDataChannel>;
+  onDataChannel: (callback: (dc: PhygridDataChannel) => void, channelName?: string) => void;
+  getMediaStream: (channelName?: string) => Promise<{
     stream: PhygridMediaStream;
     close: () => void;
   }>;
-  onMediaStream: (callback: (stream: PhygridMediaStream) => void) => Promise<void>;
+  onMediaStream: (callback: (stream: PhygridMediaStream) => void, channelName?: string) => Promise<void>;
 }
 
 export interface Instance {
+  /** Send a fire-and-forget event to subscribers (broadcast) */
   emit: (type: string, payload: any) => void;
-  on: (type: string, callback: (message: any) => void) => void;
+  /** Listen for events/actions of a given type */
+  on: (type: string, callback: (message: any, respond?: (result: TwinMessageResult) => void) => void) => void;
+  /** Target a specific twin for messaging */
   to: (twinId: string) => {
-    emit: (type: string, payload: any) => void;
+    /** Send event or action to the targeted twin */
+    emit: {
+      (type: string, payload: any): void;
+      (type: string, payload: any, callback: (response: TwinMessageResult) => void): Promise<TwinMessageResult>;
+    };
   };
   createPeripheralTwin: (
     peripheralName: string,
@@ -658,11 +679,11 @@ export interface Instance {
     descriptors?: Record<string, string>
   ) => Promise<TwinResponse>;
   getPeripheralTwins: (twinId?: string) => Promise<PeripheralTwinResponse[]>;
-  getDataChannel: () => Promise<PhygridDataChannel>;
-  onDataChannel: (callback: (dc: PhygridDataChannel) => void) => void;
+  getDataChannel: (channelName?: string) => Promise<PhygridDataChannel>;
+  onDataChannel: (callback: (dc: PhygridDataChannel) => void, channelName?: string) => void;
   updateReported: (properties: Record<string, any>) => Promise<TwinResponse>;
-  getMediaStream: () => Promise<{ stream: PhygridMediaStream; close: () => void }>;
-  onMediaStream: (callback: (stream: PhygridMediaStream) => void) => Promise<void>;
+  getMediaStream: (channelName?: string) => Promise<{ stream: PhygridMediaStream; close: () => void }>;
+  onMediaStream: (callback: (stream: PhygridMediaStream) => void, channelName?: string) => Promise<void>;
   [key: string]: any; // Allow any additional properties
 }
 
@@ -801,3 +822,48 @@ export interface MediaOptions {
   isMediaConnection?: boolean;
   mediaDirection?: string;
 }
+
+export enum TwinMessageResultStatus {
+  Success = 'success',
+  Error = 'error',
+  Warning = 'warning',
+};
+
+export interface TwinMessageResult {
+  status: TwinMessageResultStatus;
+  message: string;
+}
+
+export interface IPeripheralTwinInstance {
+  phyHubClient: PhyHubClient;
+  twinId: string;
+  edgeInstance: Instance | null;
+  peripheralTwinResponse: TwinResponse | null;
+  /**
+   * Send a message to this peripheral.
+   * - Without callback: Fire-and-forget (returns void)
+   * - With callback: Request-response pattern (returns Promise)
+   */
+  emit: {
+    (eventType: string, payload: any): void;
+    (eventType: string, payload: any, callback: (response: TwinMessageResult) => void): Promise<TwinMessageResult>;
+  };
+  /** Listen for events/actions, with optional respond callback for request-response */
+  on: (eventType: string, callback: (message: any, respond?: (result: TwinMessageResult) => void) => void) => void;
+  /** Target a different twin for messaging */
+  to: (targetTwinId: string) => {
+    emit: {
+      (eventType: string, payload: any): void;
+      (eventType: string, payload: any, callback: (response: TwinMessageResult) => void): Promise<TwinMessageResult>;
+    };
+  };
+  getDataChannel: () => Promise<PhygridDataChannel | undefined>;
+  onDataChannel: (callback: (dc: PhygridDataChannel) => void) => Promise<void>;
+  getMediaStream: () => Promise<{stream: PhygridMediaStream; close: () => void} | undefined>;
+  onMediaStream: (callback: (stream: PhygridMediaStream) => void) => Promise<void>;
+  updateReported: (properties: Record<string, any>) => Promise<TwinResponse>;
+  onUpdateReported: (callback: (reportedProperties: Record<string, any>) => void) => void;
+  updateDesired: (properties: Record<string, any>) => Promise<TwinResponse>;
+  onUpdateDesired: (callback: (reportedProperties: Record<string, any>) => void) => void;
+  remove : () => Promise<TwinResponse | void>;
+}

package/dist/services/webrtc/datachannel.d.ts

@@ -1,10 +0,0 @@
-import { PhygridDataChannel, WebRTCConnectionOptions } from '../../types/webrtc.types';
-export interface WebRTCDataChannelResult {
-    dataChannel: PhygridDataChannel;
-    close: () => void;
-    _rawPeerConnection?: RTCPeerConnection;
-    _rawDataChannel?: RTCDataChannel;
-}
-export type WebRTCDataChannelConnectionResult = WebRTCDataChannelResult;
-export declare function createWebRTCDataChannelConnection(options: WebRTCConnectionOptions): Promise<WebRTCDataChannelConnectionResult>;
-//# sourceMappingURL=datachannel.d.ts.map

package/dist/services/webrtc/datachannel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"datachannel.d.ts","sourceRoot":"","sources":["../../../src/services/webrtc/datachannel.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AA4CvF,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,kBAAkB,CAAC;IAChC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,kBAAkB,CAAC,EAAE,iBAAiB,CAAC;IACvC,eAAe,CAAC,EAAE,cAAc,CAAC;CAClC;AAED,MAAM,MAAM,iCAAiC,GAAG,uBAAuB,CAAC;AAOxE,wBAAsB,iCAAiC,CACrD,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,iCAAiC,CAAC,CAyK5C"}

package/dist/services/webrtc/datachannel.js

@@ -1,290 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWebRTCDataChannelConnection = createWebRTCDataChannelConnection;
-(async function initializeWebRTCGlobals() {
-    if (typeof window !== 'undefined')
-        return;
-    try {
-        const wrtc = require('@roamhq/wrtc');
-        if (typeof global.MediaStream === 'undefined' && wrtc.MediaStream) {
-            global.MediaStream = wrtc.MediaStream;
-            console.log('Global MediaStream initialized');
-        }
-        if (typeof global.RTCDataChannel === 'undefined' && wrtc.RTCDataChannel) {
-            global.RTCDataChannel = wrtc.RTCDataChannel;
-            console.log('Global RTCDataChannel initialized');
-        }
-        if (typeof global.RTCPeerConnection === 'undefined' && wrtc.RTCPeerConnection) {
-            global.RTCPeerConnection = wrtc.RTCPeerConnection;
-            console.log('Global RTCPeerConnection initialized');
-        }
-        if (typeof global.RTCSessionDescription === 'undefined' && wrtc.RTCSessionDescription) {
-            global.RTCSessionDescription = wrtc.RTCSessionDescription;
-            console.log('Global RTCSessionDescription initialized');
-        }
-        if (typeof global.RTCIceCandidate === 'undefined' && wrtc.RTCIceCandidate) {
-            global.RTCIceCandidate = wrtc.RTCIceCandidate;
-            console.log('Global RTCIceCandidate initialized');
-        }
-        console.log('WebRTC globals successfully initialized');
-    }
-    catch (error) {
-        console.error('Failed to initialize WebRTC globals:', error);
-    }
-})().catch(err => console.error('Error in WebRTC globals initialization:', err));
-const peer_connection_ice_1 = require("./peer-connection-ice");
-(async function initializeWebRTCGlobals() {
-    if (typeof window !== 'undefined')
-        return;
-    try {
-        const wrtc = require('@roamhq/wrtc');
-        if (typeof global.MediaStream === 'undefined' && wrtc.MediaStream) {
-            global.MediaStream = wrtc.MediaStream;
-            console.log('Global MediaStream initialized');
-        }
-        if (typeof global.RTCPeerConnection === 'undefined' && wrtc.RTCPeerConnection) {
-            global.RTCPeerConnection = wrtc.RTCPeerConnection;
-            console.log('Global RTCPeerConnection initialized');
-        }
-        if (typeof global.RTCSessionDescription === 'undefined' && wrtc.RTCSessionDescription) {
-            global.RTCSessionDescription = wrtc.RTCSessionDescription;
-            console.log('Global RTCSessionDescription initialized');
-        }
-        if (typeof global.RTCIceCandidate === 'undefined' && wrtc.RTCIceCandidate) {
-            global.RTCIceCandidate = wrtc.RTCIceCandidate;
-            console.log('Global RTCIceCandidate initialized');
-        }
-        console.log('WebRTC globals successfully initialized');
-    }
-    catch (error) {
-        console.error('Failed to initialize WebRTC globals:', error);
-    }
-})().catch(err => console.error('Error in WebRTC globals initialization:', err));
-const CONNECTION_TIMEOUT = 15000;
-const RECONNECT_DELAY = 1000;
-const INITIAL_RETRY_DELAY = 1000;
-const MAX_RETRY_DELAY = 30000;
-async function createWebRTCDataChannelConnection(options) {
-    let pc = null;
-    let isShuttingDown = false;
-    let isReconnecting = false;
-    let currentConnectionId = 0;
-    let pendingCandidates = [];
-    let activeDataChannel = null;
-    const { targetTwinId, sendTwinMessage, subscribeTwin, onTwinMessage, offTwinMessage, useStun = true, isInitiator = true, channelPrefix = 'channel', mediaOptions = { isMediaConnection: false }, } = options;
-    const { persistentChannel, setupDataChannel, setCleanupFn } = createPersistentDataChannel();
-    setCleanupFn(() => {
-        if (mediaOptions.isMediaConnection && mediaOptions.localStream) {
-            mediaOptions.localStream.getTracks().forEach(track => track.stop());
-        }
-    });
-    const callbacks = {
-        async onCreateConnection(pcInstance, connectionId, localInitiator) {
-            console.log(`Creating data channel for connection ID: ${connectionId} ${JSON.stringify(localInitiator)}`);
-            const channelId = `${channelPrefix}-${targetTwinId}`;
-            return new Promise(resolve => {
-                if (isInitiator) {
-                    const dataChannel = pcInstance.createDataChannel(channelId);
-                    dataChannel.binaryType = 'arraybuffer';
-                    setupDataChannel(dataChannel, isReconnecting, isShuttingDown, triggerReconnect);
-                    resolve(dataChannel);
-                }
-                else {
-                    pcInstance.ondatachannel = event => {
-                        console.log('Data channel received in hub-client');
-                        const dataChannel = event.channel;
-                        dataChannel.binaryType = 'arraybuffer';
-                        setupDataChannel(dataChannel, isReconnecting, isShuttingDown, triggerReconnect);
-                    };
-                    resolve(null);
-                }
-            });
-        },
-        onCloseCleanup() {
-            if (mediaOptions.isMediaConnection && mediaOptions.localStream) {
-                mediaOptions.localStream.getTracks().forEach(track => track.stop());
-            }
-        },
-        async onSubscribe() {
-            await subscribeTwin(targetTwinId);
-        },
-        async sendSignalingMessage(type, data) {
-            await sendTwinMessage(targetTwinId, {
-                type: `${channelPrefix}-${targetTwinId}:${type}`,
-                data,
-            });
-        },
-        setupMessageHandling(messageHandler) {
-            onTwinMessage(targetTwinId, messageHandler);
-        },
-        removeMessageHandling(messageHandler) {
-            console.log(`Removing message listener for twin ${targetTwinId}`);
-            offTwinMessage(targetTwinId, messageHandler);
-        },
-        reportConnectionState(info) {
-            console.log(info);
-        },
-        reportError(info, error) {
-            console.error(info, error || '');
-        },
-        async retryConnection(retries, toggledUseStun, nextDelay) {
-            isReconnecting = false;
-            return (0, peer_connection_ice_1.attemptConnection)(state, { ...options, useStun: toggledUseStun !== null && toggledUseStun !== void 0 ? toggledUseStun : useStun }, retries, toggledUseStun !== null && toggledUseStun !== void 0 ? toggledUseStun : useStun, nextDelay !== null && nextDelay !== void 0 ? nextDelay : INITIAL_RETRY_DELAY, INITIAL_RETRY_DELAY, CONNECTION_TIMEOUT, MAX_RETRY_DELAY, callbacks);
-        },
-        safeReject(error) {
-            throw error;
-        },
-    };
-    const state = {
-        pc,
-        isShuttingDown,
-        isReconnecting,
-        currentConnectionId,
-        pendingCandidates,
-        activeDataChannel,
-        useStun,
-        channelPrefix,
-        targetTwinId,
-        isInitiator,
-        connectionType: 'datachannel',
-    };
-    function triggerReconnect(attempt) {
-        if (isReconnecting || isShuttingDown) {
-            console.log(`triggerReconnect() called but already reconnecting or shutting down (attempt ${attempt})`);
-            return;
-        }
-        isReconnecting = true;
-        (0, peer_connection_ice_1.triggerReconnect)(state, attempt, RECONNECT_DELAY, callbacks);
-    }
-    const result = await (0, peer_connection_ice_1.attemptConnection)(state, { ...options }, 0, useStun, INITIAL_RETRY_DELAY, INITIAL_RETRY_DELAY, CONNECTION_TIMEOUT, MAX_RETRY_DELAY, callbacks);
-    return {
-        dataChannel: persistentChannel,
-        _rawPeerConnection: result._rawPeerConnection,
-        _rawDataChannel: result._rawDataChannel,
-        close: () => {
-            isShuttingDown = true;
-            if (result.close) {
-                result.close();
-            }
-        },
-    };
-}
-const createPersistentDataChannel = () => {
-    const messageListeners = [];
-    const closeListeners = [];
-    let currentDataChannel = null;
-    let activeDataChannel = null;
-    let reconnectAttempts = 0;
-    let cleanupFn = null;
-    const setCleanupFn = (fn) => {
-        cleanupFn = fn;
-    };
-    const persistentChannel = {
-        send: (data) => {
-            if (activeDataChannel && activeDataChannel.readyState === 'open') {
-                try {
-                    if (typeof data === 'object' && data !== null) {
-                        activeDataChannel.send(JSON.stringify(data));
-                    }
-                    else {
-                        activeDataChannel.send(data);
-                    }
-                }
-                catch (error) {
-                    console.error('Error sending data:', error);
-                }
-            }
-            else {
-                console.warn('Channel not ready, dropping message. State:', activeDataChannel ? activeDataChannel.readyState : 'no channel');
-            }
-        },
-        onMessage: (callback) => {
-            console.log('Adding message listener to persistent channel');
-            messageListeners.push(callback);
-        },
-        offMessage: (callback) => {
-            const index = messageListeners.indexOf(callback);
-            if (index !== -1) {
-                messageListeners.splice(index, 1);
-            }
-        },
-        onClose: (callback) => {
-            closeListeners.push(callback);
-        },
-        offClose: (callback) => {
-            const index = closeListeners.indexOf(callback);
-            if (index !== -1) {
-                closeListeners.splice(index, 1);
-            }
-        },
-        close: () => {
-            if (currentDataChannel && currentDataChannel.readyState !== 'closed') {
-                currentDataChannel.close();
-            }
-            if (cleanupFn)
-                cleanupFn();
-        },
-    };
-    const setupDataChannel = (dc, isReconnecting, isShuttingDown, triggerReconnect) => {
-        console.log('Setting up data channel with listeners');
-        currentDataChannel = dc;
-        activeDataChannel = dc;
-        dc.onopen = () => {
-            console.log('Data channel opened in setupDataChannel, readyState:', dc.readyState);
-            currentDataChannel = dc;
-            activeDataChannel = dc;
-        };
-        dc.onmessage = event => {
-            console.log('Received message in data channel:', typeof event.data);
-            let parsedData = event.data;
-            if (typeof event.data === 'string') {
-                try {
-                    parsedData = JSON.parse(event.data);
-                }
-                catch (e) {
-                    parsedData = event.data;
-                }
-            }
-            if (messageListeners.length === 0) {
-                console.warn('No message listeners registered for data channel');
-            }
-            messageListeners.forEach(listener => {
-                try {
-                    listener(parsedData);
-                }
-                catch (error) {
-                    console.error('Error handling message:', error);
-                }
-            });
-        };
-        dc.onclose = () => {
-            console.log('Data channel closed');
-            closeListeners.forEach(listener => {
-                try {
-                    listener();
-                }
-                catch (error) {
-                    console.error('Error in close listener:', error);
-                }
-            });
-            if (!isShuttingDown && !isReconnecting) {
-                console.log('Data channel closed unexpectedly, triggering reconnect');
-                triggerReconnect(reconnectAttempts++);
-            }
-            activeDataChannel = null;
-        };
-        dc.onerror = error => {
-            console.error('Data channel error:', error);
-            if (!isShuttingDown && !isReconnecting) {
-                console.log('Data channel error, triggering reconnect');
-                triggerReconnect(reconnectAttempts++);
-            }
-        };
-    };
-    return {
-        persistentChannel,
-        setupDataChannel,
-        setCleanupFn,
-    };
-};
-//# sourceMappingURL=datachannel.js.map