@phystack/hub-client 4.4.29

package/src/index.ts

@@ -0,0 +1,1429 @@
+import { Socket, SocketOptions, ManagerOptions } from 'socket.io-client';
+import {
+  TwinStatusEnum,
+  ScreenTwinReportedProperties,
+  TwinResponse,
+  DeviceStatus,
+  EdgeTwinResponse,
+  EdgeTwinDesiredPropertiesResponse,
+  PeripheralTwinResponse,
+  TwinTypeEnum,
+  Instance,
+  PeripheralInstance,
+} from './types/twin.types';
+import {
+  PhygridDataChannel,
+  PhygridMediaStream,
+  WebRTCConnectionOptions,
+} from './types/webrtc.types';
+import { PhyHubConnection } from './services/phyhub-connection.service';
+import { SignalsService } from './services/signals.service';
+import { DataRequestTypeEnum, InitSignalPayload } from './types/signal.types';
+import {
+  createWebRTCDataChannelConnection,
+  WebRTCDataChannelResult,
+} from './services/webrtc/datachannel';
+import {
+  createWebRTCMediaStreamConnection,
+  WebRTCMediaStreamResult,
+} from './services/webrtc/mediastream';
+// import { createWebRTCMediaStreamConnection, WebRTCMediaStreamResult } from './helpers/webrtc-mediastream';
+
+// Define WebRTC types that might not be available in all environments
+declare global {
+  // In browsers, these are standard WebRTC interfaces
+  // In Node.js, we polyfill them from @roamhq/wrtc
+  interface Window {
+    RTCVideoSource?: any;
+  }
+
+  namespace NodeJS {
+    interface Global {
+      MediaStream?: any;
+      RTCPeerConnection?: any;
+      RTCSessionDescription?: any;
+      RTCIceCandidate?: any;
+      RTCVideoSource?: any;
+    }
+  }
+
+  // Make RTCVideoSource available in function scope when used
+  var RTCVideoSource: any;
+}
+
+(async function initializeWebRTCGlobals() {
+  // Only run in Node environment
+  if (typeof window !== 'undefined') return;
+
+  try {
+    // Dynamically import wrtc
+    const wrtc = require('@roamhq/wrtc');
+
+    // Set all WebRTC globals
+    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');
+    }
+
+    if (typeof (global as any).RTCVideoSource === 'undefined' && wrtc.nonstandard.RTCVideoSource) {
+      (global as any).RTCVideoSource = wrtc.nonstandard.RTCVideoSource;
+      console.log('Global RTCVideoSource 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));
+
+interface EventPayload<T = any> {
+  twinId?: string;
+  sourceTwinId?: string;
+  sourceDeviceId?: string;
+  deviceId?: string;
+  status?: TwinStatusEnum;
+  data?: T;
+}
+
+export type MyIoOptions = Partial<ManagerOptions & SocketOptions>;
+
+export class PhyHubClient {
+  private static instance: PhyHubClient | null = null;
+  private instanceId: string | undefined = undefined;
+  private moduleName: string | undefined = undefined;
+  private socket: Socket | null = null;
+  private socketConnected = false;
+  private emitQueue: any[] = [];
+  private lastDeviceStatusCheck: number = 0;
+  private lastDeviceStatusResponse: DeviceStatus | undefined = undefined;
+  private signals: SignalsService | undefined;
+  private subscribedTwins: Set<string> = new Set();
+  private twinMessageListeners: { [key: string]: Set<(message: any) => void> } = {};
+  private instances: Map<string, Instance> = new Map();
+  private peripheralInstances: Map<string, PeripheralInstance> = new Map();
+  private twinUpdateListeners: { [key: string]: Set<(twin: TwinResponse) => void> } = {};
+
+  private readonly EVENTS = {
+    PING: 'ping',
+    PONG: 'pong',
+    CONNECT: 'connect',
+    RECONNECT: 'reconnect',
+    RECONNECT_ERROR: 'reconnect_error',
+    RECONNECT_FAILED: 'reconnect_failed',
+    DISCONNECT: 'disconnect',
+    REPORT_SCREEN_INSTANCE_PROPERTIES: 'setScreenInstanceReportedProperties',
+    GET_DEVICE_STATUS: 'getDeviceStatus',
+    GET_DEVICE_NETWORKS: 'getDeviceNetworks',
+    GET_DEVICE_INSTANCE: 'getDeviceInstance',
+    GET_INSTANCE: 'getInstance',
+    SIGNAL_EVENT: 'sendEventSignal',
+    SIGNAL_CHECKOUT: 'sendEventSignal',
+    SIGNAL_PURCHASE: 'sendEventSignal',
+    SIGNAL_SESSION: 'sendSessionSignal',
+    SIGNAL_CLIENT: 'sendClientSignal',
+    TWIN_MESSAGE: 'twinMessage',
+    TWIN_SUBSCRIBE: 'twinSubscribe',
+    TWIN_UNSUBSCRIBE: 'twinUnsubscribe',
+    GET_TWIN_BY_ID: 'getTwinById',
+  } as const;
+
+  constructor(params: { instanceId?: string; moduleName?: string; dataResidency?: string } = {}) {
+    this.instanceId = params.instanceId;
+    if (!this.instanceId) {
+      if (typeof window !== 'undefined') {
+        console.log('Running in browser, looking for instanceId in URL hash', window.location.hash);
+        this.instanceId =
+          new URLSearchParams(window.location.hash.slice(1)).get('instanceId') || undefined;
+        console.log('Found instanceId in URL hash', this.instanceId);
+      } else {
+        this.instanceId = process.env.TWIN_ID;
+      }
+    }
+    this.moduleName = params.moduleName;
+  }
+
+  private async initializeConnection(): Promise<this> {
+    if (this.socket && this.socketConnected) {
+      return this;
+    }
+
+    try {
+      console.log(
+        'initializeConnection()',
+        JSON.stringify(
+          {
+            instanceId: this.instanceId,
+            moduleName: this.moduleName,
+          },
+          null,
+          2
+        )
+      );
+      const phyHubConnection = PhyHubConnection.getInstance({
+        instanceId: this.instanceId,
+        moduleName: this.moduleName,
+      });
+
+      this.socket = await phyHubConnection.getPhyHubSocket();
+
+      // Wait for socket to be connected
+      await new Promise<void>((resolve, reject) => {
+        if (this.socket?.connected) {
+          this.socketConnected = true;
+          resolve();
+        } else {
+          this.socket?.once('connect', () => {
+            this.socketConnected = true;
+            resolve();
+          });
+          this.socket?.once('connect_error', error => {
+            reject(error);
+          });
+        }
+      });
+
+      // Now that socket is connected, set up the listeners
+      this.setupSocketListeners(
+        (value: this) => value,
+        (reason?: any) => {
+          throw reason;
+        }
+      );
+
+      return this;
+    } catch (err) {
+      this.socket = null;
+      this.socketConnected = false;
+      throw err;
+    }
+  }
+
+  private setupSocketListeners(
+    resolve: (value: this) => void,
+    _reject: (reason?: any) => void
+  ): void {
+    if (!this.socket) return;
+
+    this.socket.on(this.EVENTS.PONG, (data: any) => {
+      setTimeout(() => {
+        this.emit('ping', { count: data.data.count + 1 });
+      }, 30000);
+    });
+
+    this.socket.on(this.EVENTS.CONNECT, () => {
+      this.socketConnected = true;
+      this.emit(this.EVENTS.PING, { count: 1 });
+      this.processEmitQueue();
+      // Re-subscribe to twins after reconnection
+      this.subscribedTwins.forEach(twinId => {
+        this.subscribeTwin(twinId).catch(error => {
+          console.error(`Failed to re-subscribe to twin ${twinId}:`, error);
+        });
+      });
+      resolve(this);
+    });
+
+    this.socket.io.on(this.EVENTS.RECONNECT, () => {
+      this.socketConnected = true;
+      this.processEmitQueue();
+
+      // Re-subscribe to twins after reconnection
+      this.subscribedTwins.forEach(twinId => {
+        this.subscribeTwin(twinId).catch(error => {
+          console.error(`Failed to re-subscribe to twin ${twinId}:`, error);
+        });
+      });
+    });
+
+    this.socket.io.on(this.EVENTS.RECONNECT_ERROR, () => {
+      this.socketConnected = false;
+    });
+
+    this.socket.io.on(this.EVENTS.RECONNECT_FAILED, () => {
+      this.socketConnected = false;
+    });
+
+    this.socket.on(this.EVENTS.DISCONNECT, () => {
+      this.socketConnected = false;
+    });
+
+    this.socket.on(this.EVENTS.TWIN_MESSAGE, (payload: EventPayload) => {
+      // console.log('Received TWIN_MESSAGE payload:', {
+      //   JSON: JSON.stringify(payload, null, 2),
+      // });
+
+      if (payload.twinId && payload.data) {
+        // console.log('Received TWIN_MESSAGE event:', {
+        //   hasListeners: !!this.twinMessageListeners[payload.twinId],
+        //   listenerCount: this.twinMessageListeners[payload.twinId]?.size
+        // });
+        const listeners = this.twinMessageListeners[payload.twinId];
+        if (listeners) {
+          // console.log(`Executing ${listeners.size} listeners for twin ${payload.twinId}`);
+          listeners.forEach(callback => {
+            // console.log('Executing listener for twin:', callback);
+            try {
+              callback(payload);
+            } catch (error) {
+              console.error(`Error in twin message listener for ${payload.twinId}:`, error);
+            }
+          });
+        } else {
+          // console.log(`No listeners found for twin ${payload.twinId}`, JSON.stringify(payload, null, 2));
+        }
+      } else {
+        // console.log('Invalid twin message payload:', payload);
+      }
+    });
+
+    // Add global listener for twin updates
+    this.socket.on('twinUpdated', (payload: EventPayload<TwinResponse>) => {
+      console.log('twinUpdated event received', JSON.stringify(payload, null, 2));
+      if (payload.data) {
+        const twinId = payload.twinId || payload.data.id;
+        if (twinId && this.twinUpdateListeners[twinId]) {
+          // Invoke all callbacks registered for this twin
+          this.twinUpdateListeners[twinId].forEach(cb => {
+            try {
+              cb(payload.data!);
+              console.log(
+                'twinUpdateListeners[twinId].forEach() callback executed',
+                JSON.stringify(payload.data, null, 2)
+              );
+            } catch (error) {
+              console.error(`Error in twin update listener for ${twinId}:`, error);
+            }
+          });
+        }
+      }
+    });
+  }
+
+  private async assureSocketConnection(): Promise<void> {
+    if (!this.socket || !this.socketConnected) {
+      await this.initializeConnection();
+    }
+    if (!this.socket) {
+      throw new Error('Socket not initialized');
+    }
+  }
+
+  public static async connect(
+    params: {
+      instanceId?: string;
+      moduleName?: string;
+      dataResidency?: string;
+    } = {}
+  ): Promise<PhyHubClient> {
+    console.info(`connect(): Connecting to phyhub`);
+    // TODO handle deviceId and accessKey for screen instance scenarios
+
+    if (!PhyHubClient.instance) {
+      PhyHubClient.instance = new PhyHubClient(params);
+      await PhyHubClient.instance.initializeConnection();
+      console.info(`connect(): Connection to phyhub initialized`);
+    }
+    return PhyHubClient.instance;
+  }
+
+  public getSocket = () => {
+    return this.socket;
+  };
+
+  public initializeSignals = async (initParams?: InitSignalPayload) => {
+    let edgeTwin;
+    if (!initParams) {
+      await this.getDeviceStatus();
+      if (!this.lastDeviceStatusResponse) {
+        throw new Error('Failed to fetch device settings');
+      }
+
+      edgeTwin = (await this.getInstance()) as Instance;
+      if (!edgeTwin) {
+        throw new Error('Unable to determine app settings');
+      }
+    }
+
+    const initSignalsPayload: InitSignalPayload = {
+      deviceId:
+        initParams?.deviceId ?? edgeTwin?.deviceId ?? this.lastDeviceStatusResponse?.deviceId ?? '',
+      installationId:
+        initParams?.installationId ?? edgeTwin?.properties.desired.installationId ?? '',
+      spaceId: initParams?.spaceId ?? this.lastDeviceStatusResponse?.spaceId ?? '',
+      tenantId: initParams?.tenantId ?? this.lastDeviceStatusResponse?.tenantId ?? '',
+      appVersion: initParams?.appVersion ?? 'XXXXXXXXXXXXXXXXXXXXXXXX',
+      appId: initParams?.appId ?? 'XXXXXXXXXXXXXXXXXXXXXXXX',
+      environment: initParams?.environment ?? this.lastDeviceStatusResponse?.gridEnv ?? '',
+      dataResidency: (
+        initParams?.dataResidency ??
+        this.lastDeviceStatusResponse?.dataResidency ??
+        ''
+      ).toUpperCase(),
+      country: initParams?.country ?? 'SE',
+      installationVersion: initParams?.installationVersion ?? 'XXXXXXXXXXXXXXXXXXXXXXXX',
+      accessToken: initParams?.accessToken ?? this.lastDeviceStatusResponse?.accessKey,
+      clientUserAgent: initParams?.clientUserAgent ?? undefined,
+      ip: initParams?.ip ?? this.lastDeviceStatusResponse?.ip?.[0]?.ipv4 ?? 'N/A',
+    };
+
+    this.signals = new SignalsService(this, initSignalsPayload);
+    return this.signals;
+  };
+
+  public isConnected(): boolean {
+    return this.socketConnected;
+  }
+
+  public async sendSignal(type: DataRequestTypeEnum, data: Record<string, any>) {
+    let eventToEmit = undefined;
+    switch (type) {
+      case DataRequestTypeEnum.EVENT:
+        eventToEmit = this.EVENTS.SIGNAL_EVENT;
+        break;
+      case DataRequestTypeEnum.CHECKOUT:
+        eventToEmit = this.EVENTS.SIGNAL_CHECKOUT;
+        break;
+      case DataRequestTypeEnum.PURCHASE:
+        eventToEmit = this.EVENTS.SIGNAL_PURCHASE;
+        break;
+      case DataRequestTypeEnum.SESSION:
+        eventToEmit = this.EVENTS.SIGNAL_SESSION;
+        break;
+      case DataRequestTypeEnum.CLIENT:
+        eventToEmit = this.EVENTS.SIGNAL_CLIENT;
+        break;
+      default:
+        throw new Error(`Unsupported type ${type}`);
+    }
+
+    if (!eventToEmit) {
+      throw new Error(`Unsupported type ${type}`);
+    }
+
+    const payload: EventPayload<Record<string, any>> = {
+      data,
+    };
+
+    this.emit(eventToEmit, payload);
+  }
+
+  public async getDeviceStatus(): Promise<any> {
+    await this.assureSocketConnection();
+
+    const now = Date.now();
+    const tenSeconds = 10 * 1000;
+    if (now - this.lastDeviceStatusCheck < tenSeconds) {
+      // console.info('getDeviceStatus(): Skipping emit - returning last known status');
+      return Promise.resolve(this.lastDeviceStatusResponse);
+    }
+
+    return new Promise((resolve, reject) => {
+      this.lastDeviceStatusCheck = now;
+      this.emit(this.EVENTS.GET_DEVICE_STATUS, (response: any) => {
+        this.lastDeviceStatusResponse = response;
+        resolve(response);
+      });
+
+      this.socket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  }
+
+  public getDataChannel = async (targetTwinId: string): Promise<PhygridDataChannel> => {
+    const options: WebRTCConnectionOptions = {
+      targetTwinId,
+      sendTwinMessage: this.sendTwinMessage.bind(this),
+      subscribeTwin: this.subscribeTwin.bind(this),
+      onTwinMessage: this.onTwinMessage.bind(this),
+      offTwinMessage: this.offTwinMessage.bind(this),
+      useStun: true,
+      isInitiator: true,
+      channelPrefix: 'channel',
+      mediaOptions: { isMediaConnection: false },
+    };
+
+    const result = (await createWebRTCDataChannelConnection(options)) as WebRTCDataChannelResult;
+    return result.dataChannel;
+  };
+
+  public onDataChannel = async (
+    sourceTwinId: string,
+    callback: (dc: PhygridDataChannel) => void
+  ) => {
+    const options: WebRTCConnectionOptions = {
+      targetTwinId: sourceTwinId,
+      sendTwinMessage: this.sendTwinMessage.bind(this),
+      subscribeTwin: this.subscribeTwin.bind(this),
+      onTwinMessage: this.onTwinMessage.bind(this),
+      offTwinMessage: this.offTwinMessage.bind(this),
+      useStun: true,
+      isInitiator: false,
+      channelPrefix: 'channel',
+      mediaOptions: { isMediaConnection: false },
+    };
+
+    const result = (await createWebRTCDataChannelConnection(options)) as WebRTCDataChannelResult;
+    callback(result.dataChannel);
+  };
+
+  public async getMediaStream(targetTwinId: string): Promise<{
+    stream: PhygridMediaStream;
+    close: () => void;
+  }> {
+    const options: WebRTCConnectionOptions = {
+      targetTwinId,
+      sendTwinMessage: this.sendTwinMessage.bind(this),
+      subscribeTwin: this.subscribeTwin.bind(this),
+      onTwinMessage: this.onTwinMessage.bind(this),
+      offTwinMessage: this.offTwinMessage.bind(this),
+      isInitiator: true,
+      channelPrefix: 'media',
+      mediaOptions: {
+        isMediaConnection: true,
+        mediaDirection: 'recvonly',
+      },
+    };
+    const result: WebRTCMediaStreamResult = await createWebRTCMediaStreamConnection(options);
+    return {
+      stream: result.mediaStream,
+      close: result.close,
+    };
+  }
+
+  public onMediaStream = async (
+    sourceTwinId: string,
+    callback: (stream: PhygridMediaStream) => void
+  ): Promise<void> => {
+    const options: WebRTCConnectionOptions = {
+      targetTwinId: sourceTwinId,
+      sendTwinMessage: this.sendTwinMessage.bind(this),
+      subscribeTwin: this.subscribeTwin.bind(this),
+      onTwinMessage: this.onTwinMessage.bind(this),
+      offTwinMessage: this.offTwinMessage.bind(this),
+      isInitiator: false,
+      channelPrefix: 'media',
+      mediaOptions: {
+        isMediaConnection: true,
+      },
+    };
+
+    const result: WebRTCMediaStreamResult = await createWebRTCMediaStreamConnection(options);
+    callback(result.mediaStream);
+  };
+
+  // TODO properties should automatically be updated when the edge twin is updated
+  // We could do a refresh method and call that on reconnect like we handle the resubscribes for peripherals
+  public async getInstance(): Promise<Instance> {
+    // TODO support multiple instances of different twin ids
+    if (!this.instanceId) {
+      throw new Error('Instance ID not set');
+    }
+    if (this.instances.has(this.instanceId)) {
+      return this.instances.get(this.instanceId)!;
+    }
+
+    await this.assureSocketConnection();
+
+    let instance: Instance | undefined;
+
+    let instanceTwin = await this.getTwinById(this.instanceId);
+    // console.log('getTwinById response', instanceTwin);
+
+    const edgeInstanceTypePrefix = 'edgeInstance';
+
+    const edgeTwinEmit = (type: string, payload: any) => {
+      // console.log('edgeTwinEmit', type, payload);
+      const { id: twinId } = instanceTwin;
+      const edgeTwinMessagePayload = {
+        type: `${edgeInstanceTypePrefix}:${type}`,
+        sourceTwinId: twinId,
+        sourceDeviceId: instanceTwin.deviceId,
+        data: payload,
+      };
+      // console.log('edgeTwinEmit', edgeTwinMessagePayload);
+      this.sendTwinMessage(twinId, edgeTwinMessagePayload);
+    };
+
+    const edgeTwinOn = (type: string, callback: (message: any) => void) => {
+      const { id: twinId } = instanceTwin;
+      const onEdgeTwinMessage = (payload: any) => {
+        // console.log('onEdgeTwinMessage callback', payload);
+        const messageType = payload.data?.type || payload.type;
+        if (messageType === `${edgeInstanceTypePrefix}:${type}`) {
+          // console.log('onEdgeTwinMessage', payload.data?.data || payload.data);
+          callback(payload.data?.data || payload.data);
+        } else {
+          // console.log('onEdgeTwinMessage', 'ignoring', messageType);
+        }
+      };
+      this.onTwinMessage(twinId, onEdgeTwinMessage);
+    };
+
+    const edgeTwinTo = (targetTwinId: string) => ({
+      emit: (type: string, payload: any) => {
+        // console.log('edgeTwinEmit', type, payload);
+        const edgeTwinMessagePayload = {
+          type: `${edgeInstanceTypePrefix}:${type}`,
+          sourceTwinId: instanceTwin.id,
+          sourceDeviceId: instanceTwin.deviceId,
+          data: payload,
+        };
+        // console.log('edgeTwinEmit', edgeTwinMessagePayload);
+        this.sendTwinMessage(targetTwinId, edgeTwinMessagePayload);
+      },
+    });
+
+    const getPeripheralTwins = async (): Promise<PeripheralTwinResponse[]> => {
+      const payload: EventPayload = {
+        data: {
+          instanceId: instanceTwin.id,
+        },
+      };
+
+      return new Promise((resolve, reject) => {
+        this.emit('getPeripheralTwins', payload, (response: any) => {
+          const { twins } = response;
+          resolve(twins || []);
+        });
+
+        this.socket?.on('error', (error: any) => {
+          reject(error);
+        });
+      });
+    };
+
+    const createPeripheralTwin = async (
+      peripheralName: string,
+      hardwareId: string,
+      desiredProperties?: Record<string, any>,
+      descriptors?: Record<string, string>
+    ): Promise<PeripheralTwinResponse> => {
+      const existingTwins = (await getPeripheralTwins()) as PeripheralTwinResponse[];
+      const existingTwin = existingTwins.find(
+        (twin: PeripheralTwinResponse) => twin.properties.desired.hardwareId === hardwareId
+      );
+
+      if (existingTwin) {
+        throw new Error(`Peripheral twin with hardwareId ${hardwareId} already exists`);
+      }
+
+      const payload: EventPayload = {
+        data: {
+          deviceId: instanceTwin.deviceId,
+          tenantId: instanceTwin.tenantId,
+          instanceId: instanceTwin.id,
+          peripheralName,
+          hardwareId,
+          desiredProperties,
+          descriptors,
+        },
+      };
+
+      return new Promise((resolve, reject) => {
+        this.emit('createPeripheralTwin', payload, (response: any) => {
+          const { twin } = response;
+          if (!twin) throw new Error('Failed to create peripheral twin');
+          resolve(twin);
+        });
+
+        this.socket?.on('error', (error: any) => {
+          reject(error);
+        });
+      });
+    };
+
+    const getDataChannel = async () => {
+      return await this.getDataChannel(instanceTwin.id);
+    };
+
+    const onDataChannel = async (callback: (dc: PhygridDataChannel) => void) => {
+      return await this.onDataChannel(instanceTwin.id, callback);
+    };
+
+    const getMediaStream = async () => {
+      if (!instance) {
+        throw new Error('Instance not initialized');
+      }
+      return await this.getMediaStream(instance.id);
+    };
+
+    const onMediaStream = async (callback: (stream: PhygridMediaStream) => void): Promise<void> => {
+      if (!instance) {
+        throw new Error('Instance not initialized');
+      }
+      await this.onMediaStream(instance.id, callback);
+      // Return void to match the expected return type
+    };
+
+    const updateReported = async (properties: Record<string, any>) => {
+      const newReported = {
+        ...properties,
+      };
+      const result = await this.updateReportedProperties(instanceTwin.id, newReported);
+      Object.assign(instance!, result);
+      return result;
+    };
+
+    instance = {
+      ...instanceTwin,
+      emit: edgeTwinEmit,
+      on: edgeTwinOn,
+      to: edgeTwinTo,
+      createPeripheralTwin,
+      updateReported,
+      getPeripheralTwins,
+      getDataChannel,
+      onDataChannel,
+      getMediaStream,
+      onMediaStream,
+    };
+
+    this.instances.set(this.instanceId, instance);
+    return instance;
+  }
+
+  public async getEdgeInstance(): Promise<Instance> {
+    return this.getInstance();
+  }
+
+  public async getScreenInstance(): Promise<Instance> {
+    return this.getInstance();
+  }
+
+  // TODO properties should automatically be updated when the edge twin is updated
+  public async getPeripheralInstance(peripheralTwinId: string): Promise<PeripheralInstance> {
+    if (this.peripheralInstances.has(peripheralTwinId)) {
+      return this.peripheralInstances.get(peripheralTwinId)!;
+    }
+    // console.log(`Getting peripheral instance for twin ID: ${peripheralTwinId}`);
+    let peripheralInstance: PeripheralInstance | undefined;
+    const edgeInstance = await this.getInstance();
+    if (!edgeInstance) {
+      console.error('Edge instance not found');
+      throw new Error('Edge instance not found');
+    }
+
+    // console.log('getting peripheral twin', peripheralTwinId);
+
+    const peripheralTwin = await this.getTwinById(peripheralTwinId);
+    // console.log('peripheralTwinp', peripheralTwin);
+    if (!peripheralTwin) {
+      console.error(`Peripheral twin with id ${peripheralTwinId} not found`);
+      throw new Error(`Peripheral twin with id ${peripheralTwinId} not found`);
+    }
+
+    if (peripheralTwin.type !== TwinTypeEnum.Peripheral) {
+      throw new Error(`Twin ${peripheralTwinId} is not a peripheral twin`);
+    }
+
+    // Auto-subscribe if peripheral belongs to a different device
+    // if (peripheralTwin.deviceId !== edgeInstance.deviceId) {
+    // console.log('Auto-subscribing to peripheral twin', peripheralTwinId);
+    // const response =
+    await this.subscribeTwin(peripheralTwinId);
+    // console.log('subscribeTwin response', response);
+    // }
+
+    const instanceTypePrefix = 'peripheralInstance';
+
+    const peripheralTwinEmit = (type: string, payload: any) => {
+      // console.log(`Peripheral ${peripheralTwinId} emitting event:`, {
+      //   type,
+      //   payload
+      // });
+
+      const messagePayload = {
+        type: `${instanceTypePrefix}:${peripheralTwin.id}:${type}`,
+        sourceTwinId: peripheralTwin.id,
+        sourceDeviceId: edgeInstance.deviceId,
+        data: payload,
+      };
+
+      // console.log('Sending twin message:', JSON.stringify(messagePayload, null, 2));
+      this.sendTwinMessage(peripheralTwin.id, messagePayload);
+    };
+
+    const peripheralTwinOn = (type: string, callback: (message: any) => void) => {
+      console.log(`Setting up listener for peripheral ${peripheralTwinId} event: ${type}`);
+
+      const onMessage = (payload: any) => {
+        // console.log(`Received message for peripheral ${peripheralTwinId}:`, payload);
+        const messageType = payload.data?.type || payload.type;
+        if (messageType === `${instanceTypePrefix}:${peripheralTwin.id}:${type}`) {
+          // console.log('Processing matching message type');
+          callback(payload.data?.data || payload.data);
+        } else {
+          // console.log('Ignoring non-matching message type:', messageType);
+        }
+      };
+
+      this.onTwinMessage(peripheralTwin.id, onMessage);
+    };
+
+    const peripheralTwinTo = (targetTwinId: string) => ({
+      emit: (type: string, payload: any) => {
+        const messagePayload = {
+          type: `${instanceTypePrefix}:${peripheralTwin.id}:${type}`,
+          sourceTwinId: edgeInstance.id,
+          sourceDeviceId: edgeInstance.deviceId,
+          data: payload,
+        };
+        this.sendTwinMessage(targetTwinId, messagePayload);
+      },
+    });
+
+    const getDataChannel = async () => {
+      return await this.getDataChannel(peripheralTwin.id);
+    };
+
+    const onDataChannel = async (callback: (dc: PhygridDataChannel) => void) => {
+      return await this.onDataChannel(peripheralTwin.id, callback);
+    };
+
+    const getMediaStream = async () => {
+      if (!peripheralInstance) {
+        throw new Error('Peripheral instance not initialized');
+      }
+      return await this.getMediaStream(peripheralInstance.id);
+    };
+
+    const onMediaStream = async (callback: (stream: PhygridMediaStream) => void): Promise<void> => {
+      if (!peripheralInstance) {
+        throw new Error('Peripheral instance not initialized');
+      }
+      await this.onMediaStream(peripheralInstance.id, callback);
+      // Return void to match the expected return type
+    };
+
+    const updateReported = async (properties: Record<string, any>) => {
+      const newReported = {
+        ...properties,
+      };
+      const result = await this.updateReportedProperties(peripheralTwin.id, newReported);
+      // console.log('hub-client updateReported result', result);
+      Object.assign(peripheralInstance!, result);
+      return result;
+    };
+
+    const onUpdateReported = (callback: (reportedProperties: Record<string, any>) => void) => {
+      let previousProperties: Record<string, any> | undefined = undefined;
+
+      console.log(`[onUpdateReported] Registering handler for all reported properties`);
+
+      this.onTwinUpdate(peripheralTwin.id, (twin: TwinResponse) => {
+        console.log(`[onUpdateReported] Twin update received for ${peripheralTwin.id}`);
+
+        // Only process updates for this specific peripheral
+        if (twin.id !== peripheralTwin.id) {
+          console.log(`[onUpdateReported] Twin ID mismatch: ${twin.id} !== ${peripheralTwin.id}`);
+          return;
+        }
+
+        const reported = twin.properties.reported as Record<string, any>;
+
+        // Check if reported properties exist
+        if (reported) {
+          // If this is the first update, always trigger
+          if (previousProperties === undefined) {
+            console.log(`[onUpdateReported] First update - calling callback`);
+            previousProperties = JSON.parse(JSON.stringify(reported)); // Deep copy
+            callback(reported);
+            return;
+          }
+
+          const currentPropertiesStr = JSON.stringify(reported);
+          const previousPropertiesStr = JSON.stringify(previousProperties);
+
+          // Debug by printing parts of the strings - last 100 chars to avoid excessive logs
+          console.log(
+            `[onUpdateReported] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`
+          );
+          console.log(
+            `[onUpdateReported] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`
+          );
+
+          // Additional check - compare string lengths first
+          if (currentPropertiesStr.length !== previousPropertiesStr.length) {
+            console.log(
+              `[onUpdateReported] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`
+            );
+          }
+
+          const hasChanged = currentPropertiesStr !== previousPropertiesStr;
+
+          console.log(
+            `[onUpdateReported] Properties comparison:`,
+            hasChanged ? 'CHANGED' : 'UNCHANGED'
+          );
+
+          if (hasChanged) {
+            previousProperties = JSON.parse(currentPropertiesStr); // Deep copy
+            console.log(`[onUpdateReported] Calling callback with updated reported properties`);
+            callback(reported);
+          } else {
+            // Force a callback call at least every 5 updates to ensure clients get updates
+            // This is a safety mechanism
+            console.log(`[onUpdateReported] No change detected in properties`);
+          }
+        } else {
+          console.log(`[onUpdateReported] No reported properties found`);
+        }
+      });
+    };
+
+    const onUpdateDesired = (callback: (desiredProperties: Record<string, any>) => void) => {
+      let previousProperties: Record<string, any> | undefined = undefined;
+
+      console.log(`[onUpdateDesired] Registering handler for all desired properties`);
+
+      this.onTwinUpdate(peripheralTwin.id, (twin: TwinResponse) => {
+        console.log(`[onUpdateDesired] Twin update received for ${peripheralTwin.id}`);
+
+        // Only process updates for this specific peripheral
+        if (twin.id !== peripheralTwin.id) {
+          console.log(`[onUpdateDesired] Twin ID mismatch: ${twin.id} !== ${peripheralTwin.id}`);
+          return;
+        }
+
+        const desired = twin.properties.desired as Record<string, any>;
+
+        // Check if desired properties exist
+        if (desired) {
+          // If this is the first update, always trigger
+          if (previousProperties === undefined) {
+            console.log(`[onUpdateDesired] First update - calling callback`);
+            previousProperties = JSON.parse(JSON.stringify(desired)); // Deep copy
+            callback(desired);
+            return;
+          }
+
+          const currentPropertiesStr = JSON.stringify(desired);
+          const previousPropertiesStr = JSON.stringify(previousProperties);
+
+          // Debug by printing parts of the strings - last 100 chars to avoid excessive logs
+          console.log(
+            `[onUpdateDesired] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`
+          );
+          console.log(
+            `[onUpdateDesired] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`
+          );
+
+          // Additional check - compare string lengths first
+          if (currentPropertiesStr.length !== previousPropertiesStr.length) {
+            console.log(
+              `[onUpdateDesired] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`
+            );
+          }
+
+          const hasChanged = currentPropertiesStr !== previousPropertiesStr;
+
+          console.log(
+            `[onUpdateDesired] Properties comparison:`,
+            hasChanged ? 'CHANGED' : 'UNCHANGED'
+          );
+
+          if (hasChanged) {
+            previousProperties = JSON.parse(currentPropertiesStr); // Deep copy
+            console.log(`[onUpdateDesired] Calling callback with updated desired properties`);
+            callback(desired);
+          } else {
+            // Force a callback call at least every 5 updates to ensure clients get updates
+            // This is a safety mechanism
+            console.log(`[onUpdateDesired] No change detected in properties`);
+          }
+        } else {
+          console.log(`[onUpdateDesired] No desired properties found`);
+        }
+      });
+    };
+
+    const remove = async (): Promise<TwinResponse | void> => {
+      const payload: EventPayload = {
+        data: { twinId: peripheralTwin.id },
+      };
+
+      return new Promise((resolve, reject) => {
+        this.emit('deletePeripheralTwin', payload, (response: any) => {
+          const { twin } = response;
+          resolve(twin);
+        });
+
+        this.socket?.on('error', (error: any) => {
+          reject(error);
+        });
+      });
+    };
+
+    const updateDesired = async (properties: Record<string, any>): Promise<TwinResponse> => {
+      const payload: EventPayload = {
+        twinId: peripheralTwin.id,
+        data: properties,
+      };
+
+      return new Promise((resolve, reject) => {
+        this.emit('updatePeripheralTwinDesired', payload, (response: any) => {
+          const { twin } = response;
+          resolve(twin || {});
+        });
+
+        this.socket?.on('error', (error: any) => {
+          reject(error);
+        });
+      });
+    };
+
+    peripheralInstance = {
+      ...peripheralTwin,
+      emit: peripheralTwinEmit,
+      on: peripheralTwinOn,
+      to: peripheralTwinTo,
+      updateReported,
+      updateDesired,
+      onUpdateReported,
+      onUpdateDesired,
+      remove,
+      getDataChannel,
+      onDataChannel,
+      getMediaStream,
+      onMediaStream,
+    };
+    this.peripheralInstances.set(peripheralTwinId, peripheralInstance);
+    return peripheralInstance;
+  }
+
+  private getGridApp() {
+    let currentWindow: Window & typeof globalThis = window;
+    while (currentWindow) {
+      try {
+        if (
+          (currentWindow as any).gridapp &&
+          typeof (currentWindow as any).gridapp.getSettings === 'function'
+        ) {
+          return (currentWindow as any).gridapp;
+        }
+        if (currentWindow.parent === currentWindow) break;
+        currentWindow = currentWindow.parent as Window & typeof globalThis;
+      } catch (e) {
+        break;
+      }
+    }
+    return null;
+  }
+
+  public async getSettings(): Promise<Partial<EdgeTwinDesiredPropertiesResponse>> {
+    if (typeof window !== 'undefined') {
+      const gridapp = this.getGridApp();
+      if (gridapp) {
+        return gridapp.getSettings() as Partial<EdgeTwinDesiredPropertiesResponse>;
+      }
+    }
+
+    // Existing fallback logic
+    const edgeInstance = await this.getInstance();
+    if (!edgeInstance) {
+      throw new Error('Edge instance not found');
+    }
+    return (edgeInstance.properties.desired as EdgeTwinDesiredPropertiesResponse).settings;
+  }
+
+  public async getEdgeSettings(): Promise<Partial<EdgeTwinDesiredPropertiesResponse>> {
+    return this.getSettings();
+  }
+
+  public async getScreenSettings(): Promise<Partial<EdgeTwinDesiredPropertiesResponse>> {
+    return this.getSettings();
+  }
+
+  // todo: fix return type, remove any
+  public async getDeviceInstance(): Promise<any> {
+    await this.assureSocketConnection();
+
+    return new Promise((resolve, reject) => {
+      this.emit(this.EVENTS.GET_DEVICE_INSTANCE, (response: any) => {
+        resolve(response);
+      });
+
+      this.socket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  }
+
+  // todo: fix return type, remove any
+  public async getDeviceNetworks(): Promise<any> {
+    await this.assureSocketConnection();
+
+    return new Promise((resolve, reject) => {
+      this.emit(this.EVENTS.GET_DEVICE_NETWORKS, (response: any) => {
+        resolve(response);
+      });
+
+      this.socket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  }
+
+  // todo: fix return type, remove any
+  public async setScreenInstanceReportedProperties(
+    payload: EventPayload<ScreenTwinReportedProperties>
+  ): Promise<any> {
+    await this.assureSocketConnection();
+
+    console.info(`setScreenInstanceReportedProperties(): payload ${JSON.stringify(payload)}`);
+
+    return new Promise((resolve, reject) => {
+      this.emit(this.EVENTS.REPORT_SCREEN_INSTANCE_PROPERTIES, payload, (response: any) => {
+        resolve(response);
+      });
+
+      this.socket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  }
+
+  // todo: fix return type, remove any for clarity
+  public emit(method: string, ...args: any[]): void {
+    if (!this.socket) {
+      console.error('emit(): Socket not created');
+      return;
+    }
+
+    const event = this.instanceId;
+    const callback = typeof args[args.length - 1] === 'function' ? args.pop() : undefined;
+    const payload = { method, ...args[0] };
+
+    const emitArgs = [event, payload];
+
+    if (callback) {
+      emitArgs.push(callback);
+    }
+
+    if (!this.socketConnected) {
+      console.info('emit(): Socket not connected, adding to emitQueue', emitArgs);
+      this.emitQueue.push(emitArgs);
+      return;
+    }
+
+    // console.info('hub-client is connected, emit(): Emitting', emitArgs);
+    // TODO: fix ts-ignore
+    // @ts-ignore
+    this.socket.emit(...emitArgs);
+  }
+
+  // todo: fix return type, remove any
+  private processEmitQueue(): void {
+    if (!this.socket || !this.socketConnected) {
+      return;
+    }
+
+    while (this.emitQueue.length > 0) {
+      const args = this.emitQueue.shift();
+      if (args) {
+        this.socket.emit.apply(this.socket, args);
+      }
+    }
+  }
+
+  public onTwinUpdate(targetTwinId: string, callback: (twin: TwinResponse) => void) {
+    console.log(`onTwinUpdate() called for twin ${targetTwinId}`);
+    this.assureSocketConnection();
+
+    // Initialize the set of listeners for this twin if it doesn't exist
+    if (!this.twinUpdateListeners[targetTwinId]) {
+      this.twinUpdateListeners[targetTwinId] = new Set();
+    }
+
+    // Add the callback to the set of listeners
+    this.twinUpdateListeners[targetTwinId].add(callback);
+    console.log(
+      `Added twin update listener for ${targetTwinId}. Total listeners: ${this.twinUpdateListeners[targetTwinId].size}`
+    );
+
+    // Make sure we're subscribed to this twin
+    if (!this.subscribedTwins.has(targetTwinId)) {
+      this.subscribeTwin(targetTwinId).catch(error => {
+        console.error(`Failed to subscribe to twin ${targetTwinId} for updates:`, error);
+      });
+    }
+  }
+
+  public offTwinUpdate(targetTwinId: string, callback: (twin: TwinResponse) => void): boolean {
+    console.log(`Removing update listener for twin ${targetTwinId}`);
+
+    if (!this.twinUpdateListeners[targetTwinId]) {
+      console.log(`No update listeners found for twin ${targetTwinId}`);
+      return false;
+    }
+
+    const result = this.twinUpdateListeners[targetTwinId].delete(callback);
+
+    if (this.twinUpdateListeners[targetTwinId].size === 0) {
+      delete this.twinUpdateListeners[targetTwinId];
+      console.log(`Removed last update listener for twin ${targetTwinId}, cleaning up`);
+    } else {
+      console.log(
+        `Removed update listener. Remaining listeners: ${this.twinUpdateListeners[targetTwinId].size}`
+      );
+    }
+
+    return result;
+  }
+
+  public async sendTwinMessage(
+    targetTwinId: string,
+    data: any,
+    callback?: (response: any) => void
+  ) {
+    // console.log('sendTwinMessage called with:', {
+    //   targetTwinId,
+    //   data,
+    //   hasCallback: !!callback
+    // });
+
+    const edgeInstance = await this.getInstance();
+    if (!edgeInstance) {
+      console.error('sendTwinMessage failed: Edge instance not found');
+      throw new Error('Edge instance not found');
+    }
+
+    const { id: edgeTwinId, deviceId } = edgeInstance;
+
+    if (!deviceId) {
+      console.error('sendTwinMessage failed: Device ID not available');
+      throw new Error('Device ID not available - ensure device is connected');
+    }
+
+    const payload: EventPayload = {
+      twinId: targetTwinId,
+      sourceTwinId: edgeTwinId,
+      sourceDeviceId: deviceId,
+      data,
+    };
+
+    // console.log('sendTwinMessage prepared payload:', JSON.stringify(payload, null, 2));
+
+    if (callback) {
+      // console.log('sendTwinMessage emitting with callback');
+      this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response: any) => {
+        // console.log('sendTwinMessage callback received response:', response);
+        callback(response);
+      });
+    } else {
+      // console.log('sendTwinMessage emitting with promise');
+      return new Promise((resolve, reject) => {
+        this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response: any) => {
+          // console.log('sendTwinMessage promise received response:', response);
+          resolve(response);
+        });
+
+        this.socket?.on('error', (error: any) => {
+          console.error('sendTwinMessage socket error:', error);
+          reject(error);
+        });
+      });
+    }
+  }
+
+  public async onTwinMessage(
+    targetTwinId: string,
+    callback: (message: any) => void
+  ): Promise<void> {
+    console.log('onTwinMessage called for twin:', {
+      targetTwinId,
+      existingListeners: this.twinMessageListeners[targetTwinId]?.size || 0,
+    });
+
+    if (!this.twinMessageListeners[targetTwinId]) {
+      // console.log(`Creating new listener set for twin ${targetTwinId}`);
+      this.twinMessageListeners[targetTwinId] = new Set();
+    }
+
+    this.twinMessageListeners[targetTwinId].add(callback);
+    console.log(
+      `Added new callback. Total listeners: ${this.twinMessageListeners[targetTwinId].size}`
+    );
+
+    // console.log(`Adding callback to listeners for twin ${targetTwinId}`);
+    this.twinMessageListeners[targetTwinId].add(callback);
+
+    // console.log('Current listener count:', {
+    //   targetTwinId,
+    //   listenerCount: this.twinMessageListeners[targetTwinId].size,
+    //   allListeners: Object.keys(this.twinMessageListeners).map(id => ({
+    //     twinId: id,
+    //     count: this.twinMessageListeners[id].size
+    //   }))
+    // });
+  }
+
+  public offTwinMessage(targetTwinId: string, callback: (message: any) => void): boolean {
+    console.log(`Removing message listener for twin ${targetTwinId}`);
+
+    if (!this.twinMessageListeners[targetTwinId]) {
+      console.log(`No listeners found for twin ${targetTwinId}`);
+      return false;
+    }
+
+    const result = this.twinMessageListeners[targetTwinId].delete(callback);
+
+    if (this.twinMessageListeners[targetTwinId].size === 0) {
+      delete this.twinMessageListeners[targetTwinId];
+      console.log(`Removed last listener for twin ${targetTwinId}, cleaning up`);
+    } else {
+      console.log(
+        `Removed listener. Remaining listeners: ${this.twinMessageListeners[targetTwinId].size}`
+      );
+    }
+
+    return result;
+  }
+
+  public removeMessageListener(twinId: string, callback: (message: any) => void): void {
+    const listeners = this.twinMessageListeners[twinId];
+    if (listeners) {
+      listeners.delete(callback);
+      if (listeners.size === 0) {
+        delete this.twinMessageListeners[twinId];
+      }
+    }
+  }
+
+  public async subscribeTwin(targetTwinId: string, callback?: (response: any) => void) {
+    console.log(`[subscribeTwin] Starting subscription to twin ${targetTwinId}`);
+    console.log(`[subscribeTwin] Current subscribed twins:`, Array.from(this.subscribedTwins));
+    console.log(`[subscribeTwin] Current listeners:`, Object.keys(this.twinMessageListeners));
+
+    this.subscribedTwins.add(targetTwinId);
+    const edgeInstance = await this.getInstance();
+    if (!edgeInstance) {
+      throw new Error('Edge instance not found');
+    }
+
+    const { id: edgeTwinId, deviceId } = edgeInstance;
+
+    const payload: EventPayload = {
+      twinId: targetTwinId,
+      sourceTwinId: edgeTwinId,
+      sourceDeviceId: deviceId,
+    };
+
+    console.log(`[subscribeTwin] Emitting TWIN_SUBSCRIBE with payload:`, payload);
+
+    if (callback) {
+      this.emit(this.EVENTS.TWIN_SUBSCRIBE, payload, (response: any) => {
+        console.log(`[subscribeTwin] Subscription callback response:`, response);
+        callback(response);
+      });
+    } else {
+      return new Promise((resolve, reject) => {
+        this.emit(this.EVENTS.TWIN_SUBSCRIBE, payload, (response: any) => {
+          console.log(`[subscribeTwin] Subscription promise response:`, response);
+          resolve(response);
+        });
+
+        this.socket?.on('error', (error: any) => {
+          console.error(`[subscribeTwin] Socket error:`, error);
+          reject(error);
+        });
+      });
+    }
+  }
+
+  public async getTwinById(twinId: string): Promise<TwinResponse> {
+    const payload: EventPayload<{ twinId: string }> = {
+      data: { twinId },
+    };
+
+    return new Promise((resolve, reject) => {
+      this.emit(this.EVENTS.GET_TWIN_BY_ID, payload, (response: any) => {
+        const { twin } = response;
+        if (!twin) {
+          reject(new Error(`Twin with id ${twinId} not found`));
+          return;
+        }
+        resolve(twin);
+      });
+
+      this.socket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  }
+
+  // private async updateTwinById(twinId: string, newTwin: Partial<TwinResponse>): Promise<TwinResponse> {
+  //   const payload: EventPayload = {
+  //     twinId,
+  //     data: newTwin
+  //   };
+
+  //   return new Promise((resolve, reject) => {
+  //     this.emit('updateTwin', payload, (response: any) => {
+  //       const { twin } = response;
+  //       if (!twin) {
+  //         reject(new Error(`Failed to update twin ${twinId}`));
+  //         return;
+  //       }
+  //       resolve(twin);
+  //     });
+
+  //     this.socket?.on('error', (error: any) => {
+  //       reject(error);
+  //     });
+  //   });
+  // }
+
+  private async updateReportedProperties(
+    twinId: string,
+    reportedProperties: Record<string, any>
+  ): Promise<TwinResponse> {
+    const payload: EventPayload = {
+      twinId,
+      data: reportedProperties,
+    };
+
+    return new Promise((resolve, reject) => {
+      this.emit('reportPeripheralTwinProperties', payload, (response: any) => {
+        const { twin } = response;
+        if (!twin) {
+          reject(new Error(`Failed to update reported properties for twin ${twinId}`));
+          return;
+        }
+        resolve(twin);
+      });
+
+      this.socket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  }
+}
+
+export const connectPhyClient = (
+  params: { instanceId?: string; moduleName?: string; dataResidency?: string } = {}
+) => PhyHubClient.connect(params);
+
+export type { EdgeTwinResponse, Instance, PeripheralInstance };
+
+export default {
+  connectPhyClient,
+};
+
+export type { PhygridDataChannel, PhygridMediaStream };